Deploy 69184b3

Make the compiler design guides instead of describing the idea of guides

Source: https://github.com/WINTER4000/turingDNA/commit/69184b3031eab40cc6197d4e5820af5f5780d9b1

dee/core/compiler.py

@@ -393,6 +393,7 @@ class CompileReport:
     lesion: Optional[LesionCall]
     passes: List[Pass]
     scope: Dict[str, str]
+    strategies: List["Strategy"] = field(default_factory=list)
 
     @property
     def compiled(self) -> bool:
@@ -442,7 +443,8 @@ SCOPE = {
 def compile_report(wt_allele: str, patient_allele: str, *,
                    window: str = "", offset: int = -1,
                    germline: bool = False,
-                   can_enumerate: bool = True,
+                   strategies: Optional[List["Strategy"]] = None,
+                   enumerate_diags: Optional[List[Diagnostic]] = None,
                    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.
@@ -483,7 +485,7 @@ def compile_report(wt_allele: str, patient_allele: str, *,
             f"{lesion.kind} — no route.", lesion.diagnostics)
         for name, _ in PASS_ORDER[2:]:
             add(name, "skipped", "An earlier pass refused.")
-        return CompileReport(lesion, passes, dict(SCOPE))
+        return CompileReport(lesion, passes, dict(SCOPE), strategies or [])
 
     corr = lesion.correction
     add("classify", "warn" if any(d.level == "warning" for d in lesion.diagnostics) else "ok",
@@ -500,7 +502,7 @@ def compile_report(wt_allele: str, patient_allele: str, *,
             add("verify", "error", "Reference disagrees with the alleles.", new)
             for name, _ in PASS_ORDER[3:]:
                 add(name, "skipped", "An earlier pass refused.")
-            return CompileReport(verified, passes, dict(SCOPE))
+            return CompileReport(verified, passes, dict(SCOPE), strategies or [])
         add("verify", "ok",
             f"Reference has {corr.wt_base} at offset {offset}; the correction "
             "reproduces it exactly.", new)
@@ -511,12 +513,26 @@ def compile_report(wt_allele: str, patient_allele: str, *,
             "off-by-one still type-checks at the allele level.")
 
     # ── enumerate ───────────────────────────────────────────────────────
-    if can_enumerate:
-        add("enumerate", "ok",
-            f"Base-editing guides can be enumerated for a {corr.editor_family} "
-            f"edit on the {corr.strand} strand.")
+    # Reports on GUIDES, not on the ability to look for them. The first
+    # version said "guides can be enumerated" and enumerated none, which made
+    # this a classifier wearing a compiler's clothes.
+    ediags = list(enumerate_diags or [])
+    if strategies is None:
+        add("enumerate", "unavailable", CAPABILITY_NOTES["enumerate"], ediags)
+    elif not strategies:
+        add("enumerate", "error",
+            "No guide places this base inside an editing window.", ediags)
+        for name, _ in PASS_ORDER[4:]:
+            add(name, "skipped", "No strategy to assess.")
+        return CompileReport(lesion, passes, dict(SCOPE), strategies or [])
     else:
-        add("enumerate", "unavailable", CAPABILITY_NOTES["enumerate"])
+        n_by = sum(len(s.bystanders) for s in strategies)
+        clean = sum(1 for s in strategies if s.clean)
+        add("enumerate",
+            "warn" if clean == 0 else "ok",
+            f"{len(strategies)} {corr.editor_family} guide(s) reach this base "
+            f"on the {corr.strand} strand; {clean} with no bystander, "
+            f"{n_by} bystander edit(s) across the set.", ediags)
 
     # ── consequence ─────────────────────────────────────────────────────
     # Reports on the RESULT, never on the ability to have produced one.
@@ -555,7 +571,7 @@ def compile_report(wt_allele: str, patient_allele: str, *,
         "Design record assembled with every pass, its status, and the "
         "reasons for anything not run.")
 
-    return CompileReport(lesion, passes, dict(SCOPE))
+    return CompileReport(lesion, passes, dict(SCOPE), strategies or [])
 
 
 def report_to_dict(report: CompileReport) -> Dict[str, object]:
@@ -568,6 +584,21 @@ def report_to_dict(report: CompileReport) -> Dict[str, object]:
     lesion = report.lesion
     corr = lesion.correction if lesion else None
     return {
+        "strategies": [
+            {"rank": s.rank, "editor_id": s.editor_id,
+             "editor_family": s.editor_family, "strand": s.strand,
+             "position": s.position, "spacer": s.spacer, "pam": s.pam,
+             "target_spacer_pos": s.target_spacer_pos,
+             "target_activity": s.target_activity,
+             "on_target_score": s.on_target_score,
+             "composite_score": s.composite_score,
+             "clean": s.clean,
+             "bystanders": [
+                 {"spacer_pos": b.spacer_pos, "offset": b.offset,
+                  "from_base": b.from_base, "to_base": b.to_base,
+                  "activity": b.activity} for b in s.bystanders]}
+            for s in (report.strategies or [])
+        ],
         "compiled": report.compiled,
         "incomplete_because": report.incomplete_because,
         "scope": report.scope,
@@ -591,3 +622,202 @@ def report_to_dict(report: CompileReport) -> Dict[str, object]:
             for p in report.passes
         ],
     }
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Enumerate: actual guides, not a promise of guides
+# ═══════════════════════════════════════════════════════════════════════
+# The first version of the enumerate pass reported "base-editing guides CAN
+# be enumerated" and enumerated none, which made the whole compiler a
+# classifier with ceremony. This composes crispr.find_guides and
+# base_editor.predict_base_edits into real strategies.
+#
+# Still deterministic — no network, no GPU, no model — but no longer
+# dependency-free, hence the lazy imports.
+#
+# The coordinate convention was established EMPIRICALLY, not assumed: the
+# spacer footprint is always window[position-1 : position-1+len] on the
+# forward strand, read directly for a '+' guide and reverse-complemented for
+# a '-' guide. Verified over 160 spacer positions across both strands with
+# zero mismatches before anything was built on it, because guessing here
+# designs a guide against the wrong strand.
+
+@dataclass
+class Bystander:
+    """A base the editor will also change, because it sits in the window."""
+    spacer_pos: int       # 1-based, 5'->3' along the spacer
+    offset: int           # 0-based on the forward strand — what Evo 2 needs
+    from_base: str        # on the EDITED strand
+    to_base: str
+    activity: float
+
+
+@dataclass
+class Strategy:
+    rank: int
+    editor_id: str
+    editor_family: str
+    strand: str           # '+' sense | '-' antisense
+    position: int         # 1-based forward start of the spacer footprint
+    spacer: str
+    pam: str
+    target_spacer_pos: int
+    target_activity: float
+    on_target_score: float
+    composite_score: float
+    bystanders: List[Bystander] = field(default_factory=list)
+
+    @property
+    def clean(self) -> bool:
+        return not self.bystanders
+
+
+def spacer_pos_to_offset(position: int, strand: str, spacer_len: int,
+                         spacer_pos: int) -> int:
+    """1-based spacer index -> 0-based forward-strand offset.
+
+    Separate and named because it is the single most dangerous line here.
+    A '-' guide's spacer runs antiparallel: its 5' base is the LAST base of
+    the forward footprint, so the index has to be mirrored.
+    """
+    start = position - 1
+    if strand == "+":
+        return start + (spacer_pos - 1)
+    return start + (spacer_len - spacer_pos)
+
+
+def plan_base_edit_strategies(window: str, target_offset: int,
+                              corr: Correction, *, editor_id: str = "",
+                              max_results: int = 6
+                              ) -> Tuple[List[Strategy], List[Diagnostic]]:
+    """Guides that put the target base in the editing window, right strand.
+
+    `window` is WILD-TYPE reference. Guides are designed against the
+    PATIENT'S sequence, which this function derives — and that distinction is
+    the whole ballgame. An ABE has to find an A to convert; if you search the
+    wild-type reference for an ABE correction you are looking at the G that is
+    already correct, and every search returns nothing. The first version of
+    this function did exactly that and reported "no guide places this base in
+    an editing window" for lesions that are perfectly editable.
+
+    Returns (strategies, diagnostics). An empty list with a diagnostic is a
+    real answer — "no guide places this base in any editing window" is the
+    single most common reason a base-editable lesion is still not treatable,
+    and it is caused by PAM availability, which nothing can argue with.
+    """
+    from dee.core import base_editor as _be
+    from dee.core import crispr as _crispr
+
+    diags: List[Diagnostic] = []
+    want_strand = "+" if corr.strand == "sense" else "-"
+
+    if not window or not (0 <= target_offset < len(window)):
+        diags.append(Diagnostic(
+            "error", "target_outside_window",
+            f"Target offset {target_offset} is outside the "
+            f"{len(window)}-base window.", "Check the coordinate."))
+        return [], diags
+    if window[target_offset].upper() != corr.wt_base:
+        diags.append(Diagnostic(
+            "error", "window_is_not_wildtype",
+            f"The window has {window[target_offset]!r} at the target, but the "
+            f"wild-type allele is {corr.wt_base!r}.",
+            "Pass the WILD-TYPE reference; the patient sequence is derived "
+            "from it here."))
+        return [], diags
+
+    # The sequence the editor actually sees.
+    patient_seq = (window[:target_offset] + corr.patient_base
+                   + window[target_offset + 1:])
+
+    if not editor_id:
+        # Default to the first editor of the required family. Not an
+        # allow-list: the caller can name any editor the catalogue knows.
+        fam = [e for e in _be.list_base_editors(corr.editor_family)]
+        if not fam:
+            diags.append(Diagnostic(
+                "error", "no_editor_for_family",
+                f"No {corr.editor_family} is registered in the editor catalogue.",
+                "Add one to dee/core/base_editor.py."))
+            return [], diags
+        editor_id = fam[0].id
+
+    ed = _be.get_base_editor(editor_id)
+    if ed is None:
+        diags.append(Diagnostic("error", "unknown_editor",
+                                f"Unknown base editor {editor_id!r}.",
+                                "Pick one from the catalogue."))
+        return [], diags
+    if ed.kind != corr.editor_family:
+        diags.append(Diagnostic(
+            "error", "editor_family_mismatch",
+            f"{editor_id} is a {ed.kind}; this correction needs a "
+            f"{corr.editor_family}.",
+            f"{ed.kind} writes {ed.target_base}>{ed.result_base}, which does "
+            "not make this change."))
+        return [], diags
+
+    try:
+        guides = _crispr.find_guides(patient_seq, mode="base_edit",
+                                     base_editor=editor_id, max_results=200)
+    except ValueError as exc:
+        diags.append(Diagnostic(
+            "error", "no_guides_possible", str(exc),
+            "A base editor needs a PAM at a fixed distance from the target. "
+            "Supply a longer reference window so more PAMs are in range."))
+        return [], diags
+
+    out: List[Strategy] = []
+    for g in guides:
+        if g.strand != want_strand:
+            continue
+        pred = _be.predict_base_edits(g.spacer, editor_id)
+        if not pred.edits:
+            continue
+        hit = None
+        rest: List[Bystander] = []
+        for p, fb, tb, act in pred.edits:
+            off = spacer_pos_to_offset(g.position, g.strand, len(g.spacer), p)
+            if off == target_offset:
+                hit = (p, act)
+            else:
+                rest.append(Bystander(p, off, fb, tb, round(act, 3)))
+        if hit is None:
+            continue        # this guide edits, but not the base we care about
+        out.append(Strategy(
+            rank=0, editor_id=editor_id, editor_family=ed.kind,
+            strand=g.strand, position=g.position, spacer=g.spacer, pam=g.pam,
+            target_spacer_pos=hit[0], target_activity=round(hit[1], 3),
+            on_target_score=round(g.on_target_score, 3),
+            composite_score=round(g.composite_score, 3),
+            bystanders=rest))
+
+    if not out:
+        diags.append(Diagnostic(
+            "error", "no_guide_places_target_in_window",
+            f"No {editor_id} guide on the {corr.strand} strand puts this base "
+            f"inside the editing window (positions {ed.window[0]}-{ed.window[1]}).",
+            "This is a PAM-availability limit, not a scoring threshold: a base "
+            "editor can only reach bases at a fixed distance from an NGG. Try "
+            "another editor whose window sits differently, a wider reference "
+            "window, or a different Cas variant."))
+        return [], diags
+
+    # Rank by the editor's activity at the TARGET base first. A guide that
+    # edits the right base weakly is worse than one that edits it strongly,
+    # regardless of how the generic on-target heuristic scores the spacer.
+    out.sort(key=lambda s: (-s.target_activity, len(s.bystanders),
+                            -s.composite_score))
+    for i, s in enumerate(out[:max_results], 1):
+        s.rank = i
+
+    n_clean = sum(1 for s in out[:max_results] if s.clean)
+    if n_clean == 0:
+        diags.append(Diagnostic(
+            "warning", "every_guide_has_bystanders",
+            "Every guide that reaches this base also edits at least one other "
+            "base in its window.",
+            "Bystanders are not automatically benign. Score them before "
+            "choosing — a silent or intronic bystander in a regulatory "
+            "element is exactly the case nothing else checks."))
+    return out[:max_results], diags

dee/server.py

@@ -3484,11 +3484,23 @@ def create_app() -> Flask:
         if body.get("score_consequence"):
             consequence = _score_variant_consequence(wt, patient, window, offset)
 
+        # Actually design guides. Cheap, deterministic, no network.
+        strategies, enum_diags = None, None
+        call = _compiler.classify_lesion(wt, patient)
+        if call.correction is not None and window and 0 <= offset < len(window):
+            try:
+                strategies, enum_diags = _compiler.plan_base_edit_strategies(
+                    window, offset, call.correction,
+                    editor_id=str(body.get("editor") or ""))
+            except Exception:  # noqa: BLE001
+                app.logger.exception("guide enumeration failed")
+                strategies, enum_diags = None, None
+
         try:
             report = _compiler.compile_report(
                 wt, patient, window=window, offset=offset,
                 germline=bool(body.get("germline")),
-                can_enumerate=True,
+                strategies=strategies, enumerate_diags=enum_diags,
                 consequence=consequence,
                 can_check_specificity=False,
             )

dee/static/app.css

@@ -9961,3 +9961,37 @@ body.de-agent-run .dna-edit-actions { display: none; }
     .tc-scope p, .tc-pass-detail, .tc-diag-msg, .tc-diag-remedy,
     .tc-locus-note, .tc-chip { font-size: 12px; }
 }
+
+/* Guides the compiler actually designed — the difference between a
+   classifier and a compiler. */
+.tc-strats { margin-top: 20px; }
+.tc-strat {
+    padding: 12px 14px; border-radius: var(--r-2); margin-bottom: 9px;
+    border: 1px solid var(--line); background: var(--gray-1);
+}
+.tc-strat.is-clean { border-color: color-mix(in srgb, var(--success) 45%, var(--line)); }
+.tc-strat-top { display: flex; align-items: center; gap: 9px; flex-wrap: wrap; }
+.tc-strat-rank {
+    width: 19px; height: 19px; border-radius: 50%; flex-shrink: 0;
+    display: inline-flex; align-items: center; justify-content: center;
+    font-size: 11px; background: var(--ink-strong); color: var(--on-ink);
+}
+.tc-strat-spacer { font-size: 13px; letter-spacing: .04em; color: var(--ink-strong); }
+.tc-strat-pam {
+    font-size: 12px; padding: 1px 6px; border-radius: 3px;
+    background: color-mix(in srgb, var(--warning) 18%, transparent); color: var(--warning);
+}
+.tc-strat-meta { font-size: 11.5px; color: var(--ink-faint); margin-top: 6px; }
+.tc-bys { margin-top: 9px; display: flex; gap: 7px; flex-wrap: wrap; align-items: baseline; }
+.tc-bys--none { font-size: 12px; color: var(--success); }
+.tc-bys-hd { font-size: 10.5px; text-transform: uppercase; letter-spacing: .07em; color: var(--warning); }
+.tc-by {
+    font-size: 11.5px; font-family: var(--font-mono);
+    padding: 2px 7px; border-radius: 3px;
+    background: color-mix(in srgb, var(--warning) 12%, transparent); color: var(--ink);
+}
+.tc-by-off { color: var(--ink-faint); }
+.tc-bys-note { flex-basis: 100%; margin: 4px 0 0; font-size: 11.5px; color: var(--ink-faint); line-height: 1.5; }
+@media (max-width: 720px) {
+    .tc-strat-meta, .tc-by, .tc-bys-note, .tc-bys--none { font-size: 12px; }
+}

dee/static/app.js

@@ -12411,7 +12411,36 @@ if (document.readyState === 'loading') {
         });
     }
 
-    function renderDiags(passes) {
+    function renderStrategies(list) {
+    const host = $('tcStrategies');
+    if (!host) return;
+    if (!list || !list.length) { host.hidden = true; host.innerHTML = ''; return; }
+    host.hidden = false;
+    host.innerHTML = '<h3 class="tc-diags-hd">Guides that reach this base</h3>'
+      + list.map((s) => {
+        const by = (s.bystanders || []).map((b) =>
+          `<span class="tc-by">pos ${b.spacer_pos} &middot; ${esc(b.from_base)}&rarr;${esc(b.to_base)}`
+          + ` <span class="tc-by-off">offset ${b.offset}</span></span>`).join('');
+        return `<div class="tc-strat${s.clean ? ' is-clean' : ''}">`
+          + `<div class="tc-strat-top">`
+          + `<span class="tc-strat-rank">${s.rank}</span>`
+          + `<code class="tc-strat-spacer mono">${esc(s.spacer)}</code>`
+          + `<span class="tc-strat-pam mono">${esc(s.pam)}</span>`
+          + `<span class="tc-chip">${esc(s.editor_id)}</span>`
+          + `<span class="tc-chip">${s.strand === '+' ? 'sense' : 'antisense'}</span>`
+          + `</div>`
+          + `<div class="tc-strat-meta">target at spacer position ${s.target_spacer_pos}`
+          + ` &middot; activity ${s.target_activity} &middot; on-target ${s.on_target_score}</div>`
+          + (by
+              ? `<div class="tc-bys"><span class="tc-bys-hd">Bystander edits</span>${by}`
+                + `<p class="tc-bys-note">Also changed by this guide. Not automatically benign &mdash; `
+                + `a bystander in a regulatory element is exactly the case nothing else checks.</p></div>`
+              : `<div class="tc-bys tc-bys--none">No bystander edits in this guide's window.</div>`)
+          + `</div>`;
+      }).join('');
+  }
+
+  function renderDiags(passes) {
         const host = $('tcDiags');
         if (!host) return;
         const all = [];
@@ -12464,6 +12493,7 @@ if (document.readyState === 'loading') {
             renderVerdict(data);
             renderLocus(win, isNaN(offset) ? -1 : offset, data.correction);
             renderPasses(data.passes || []);
+            renderStrategies(data.strategies || []);
             renderDiags(data.passes || []);
             $('tcResultCard').hidden = false;
         } catch (err) {

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-tc2" />
+    <link rel="stylesheet" href="/static/app.css?v=20260812-tc3" />
     <!-- 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. -->
@@ -1353,6 +1353,7 @@
                       <div class="tc-verdict" id="tcVerdict"></div>
                       <div class="tc-locus" id="tcLocus" hidden></div>
                       <ol class="tc-passes" id="tcPasses"></ol>
+                      <div class="tc-strats" id="tcStrategies" hidden></div>
                       <div class="tc-diags" id="tcDiags"></div>
                   </section>
               </section>
@@ -2843,7 +2844,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-tc2" defer></script>
+    <script src="/static/app.js?v=20260812-tc3" 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

@@ -315,3 +315,119 @@ def test_scope_travels_with_every_report():
 def test_compile_report_refuses_germline_before_running_any_pass():
     with pytest.raises(C.GermlineRefused):
         C.compile_report("G", "A", window=WINDOW, offset=0, germline=True)
+
+
+# ═══════════════════════════════════════════════════════════════════════
+# Enumerate: real guides. The pass used to promise guides and produce none.
+# ═══════════════════════════════════════════════════════════════════════
+HBB = ("CCTGAGGAGAAGGCTGCCGTCACCGCCCTGTGGGGCAAGGTGAACGTGGATGAAGTTGGTGGTGAGG"
+       "CCCTGGGCAGGCTGCTGGTGGTCTACCCTTGGACCCAGAGGTTCTTTGAGTCC")
+COMPL = {"A": "T", "T": "A", "C": "G", "G": "C"}
+
+
+def test_spacer_index_maps_to_the_forward_strand_on_both_strands():
+    """The single most dangerous line in the planner. A '-' guide's spacer runs
+    antiparallel, so its 5' base is the LAST base of the forward footprint."""
+    from dee.core import crispr
+    guides = crispr.find_guides(HBB, mode="base_edit", base_editor="be4max",
+                                max_results=8)
+    checked = 0
+    for g in guides:
+        for pos in range(1, len(g.spacer) + 1):
+            off = C.spacer_pos_to_offset(g.position, g.strand, len(g.spacer), pos)
+            got = HBB[off] if g.strand == "+" else COMPL[HBB[off]]
+            assert got == g.spacer[pos - 1], (
+                f"{g.strand} guide at {g.position}, spacer pos {pos}")
+            checked += 1
+    assert checked > 100, "should have exercised both strands thoroughly"
+
+
+def test_guides_are_designed_against_the_patient_sequence_not_the_reference():
+    """The bug that made enumerate return nothing for every lesion: an ABE has
+    to find an A to convert, and the wild-type reference has the correct G
+    there. Searching the reference finds nothing, forever."""
+    corr = C.classify_lesion("G", "A").correction        # ABE, sense
+    found = [off for off in range(len(HBB))
+             if HBB[off] == "G"
+             and C.plan_base_edit_strategies(HBB, off, corr)[0]]
+    assert found, "at least one G must be reachable by an ABE guide"
+
+
+def test_a_strategy_carries_a_real_spacer_pam_and_editor():
+    corr = C.classify_lesion("G", "A").correction
+    off = next(o for o in range(len(HBB))
+               if HBB[o] == "G" and C.plan_base_edit_strategies(HBB, o, corr)[0])
+    strategies, _ = C.plan_base_edit_strategies(HBB, off, corr)
+    s = strategies[0]
+    assert len(s.spacer) == 20 and set(s.spacer) <= set("ACGT")
+    assert s.pam and s.editor_family == "ABE"
+    assert s.strand == "+", "sense correction must engage the sense strand"
+    assert 1 <= s.target_spacer_pos <= 20
+
+
+def test_bystanders_carry_forward_strand_offsets_so_they_can_be_scored():
+    """A bystander without a genomic coordinate cannot be handed to Evo 2,
+    which is the entire point of collecting them."""
+    corr = C.classify_lesion("G", "A").correction
+    for off in range(len(HBB)):
+        if HBB[off] != "G":
+            continue
+        strategies, _ = C.plan_base_edit_strategies(HBB, off, corr)
+        for s in strategies:
+            for b in s.bystanders:
+                assert 0 <= b.offset < len(HBB)
+                assert b.offset != off, "the target is not a bystander"
+                assert b.from_base == "A" and b.to_base == "G"
+
+
+def test_an_editor_of_the_wrong_family_is_refused():
+    corr = C.classify_lesion("G", "A").correction        # needs ABE
+    strategies, diags = C.plan_base_edit_strategies(HBB, 12, corr,
+                                                    editor_id="be4max")
+    assert not strategies
+    assert diags[0].code == "editor_family_mismatch"
+    assert "C>T" in diags[0].remedy
+
+
+def test_a_window_that_is_not_wildtype_is_refused():
+    corr = C.classify_lesion("G", "A").correction
+    off = HBB.index("A")
+    strategies, diags = C.plan_base_edit_strategies(HBB, off, corr)
+    assert not strategies
+    assert diags[0].code == "window_is_not_wildtype"
+
+
+def test_unreachable_target_says_it_is_a_pam_limit_not_a_score_threshold():
+    corr = C.classify_lesion("G", "A").correction
+    for off in range(len(HBB)):
+        if HBB[off] != "G":
+            continue
+        strategies, diags = C.plan_base_edit_strategies(HBB, off, corr)
+        if not strategies and diags:
+            assert diags[0].code == "no_guide_places_target_in_window"
+            assert "PAM-availability" in diags[0].remedy
+            return
+    pytest.skip("every G in this fixture happens to be reachable")
+
+
+def test_the_enumerate_pass_reports_guides_not_a_promise_of_guides():
+    corr = C.classify_lesion("G", "A").correction
+    off = next(o for o in range(len(HBB))
+               if HBB[o] == "G" and C.plan_base_edit_strategies(HBB, o, corr)[0])
+    st, dg = C.plan_base_edit_strategies(HBB, off, corr)
+    r = C.compile_report("G", "A", window=HBB, offset=off,
+                         strategies=st, enumerate_diags=dg)
+    p = _by_name(r)["enumerate"]
+    assert p.status in ("ok", "warn")
+    assert "guide(s) reach this base" in p.detail
+    assert r.strategies, "the report carries the actual designs"
+
+
+def test_no_reachable_guide_stops_the_build_rather_than_emitting_a_record():
+    # A real G, so `verify` passes and `enumerate` is the pass that refuses.
+    off = HBB.index("G")
+    r = C.compile_report("G", "A", window=HBB, offset=off, strategies=[])
+    p = _by_name(r)
+    assert p["enumerate"].status == "error"
+    assert p["emit"].status == "skipped"
+    assert not r.compiled