correct: Preserve mixed-case preflight seeds

After both mixed-case interpretations complete their required preflight, the CLI competitor scheduler must not rerun that same required work under the already-consumed shared deadline. Restrict only the executed follow-up work to optional character classes while retaining the full admitted frontier for cumulative disclosure accounting.

This preserves a required-pass candidate if optional work reaches the deadline and keeps the public capture-mass calculation unchanged. The regression asserts that both full mixed-case follow-up searches enter optional-only mode.

Refs #37.

Author: BenWestgate

src/codex32/_cli_input.py

@@ -456,6 +456,7 @@ def _correction_candidates(
     fingerprint_match: Callable[[CorrectionCandidate], bool | None] | None = None,
     seed_candidates: Sequence[CorrectionCandidate] = (),
     required_only: bool = False,
+    optional_only: bool = False,
 ) -> tuple[tuple[CorrectionCandidate, ...], bool, float]:
     count = len(value.replace(" ", ""))
     targets, primary, reduced, _timed = _correction_plan(profile, byte_length, count, target)
@@ -474,6 +475,7 @@ def _correction_candidates(
         capture_layers=capture_layers,
         seed_candidates=seed_candidates,
         required_only=required_only,
+        optional_only=optional_only,
     )
     if allowed is not None:
         candidates = tuple(candidate for candidate in candidates if allowed(candidate))
@@ -525,13 +527,12 @@ def _scheduled_candidates(
             if not complete:
                 return (), False
     capture_layers: list[tuple[int, int]] = []
-    candidates, complete, deadline = search(
-        first, deadline=deadline, capture_layers=capture_layers, seed_candidates=seeded
-    )
+    full_search = partial(search, capture_layers=capture_layers, optional_only=retry is not None)
+    candidates, complete, deadline = full_search(first, deadline=deadline, seed_candidates=seeded)
     if retry is None:
         return candidates, complete
-    retry_candidates, retry_complete, _deadline = search(
-        retry, deadline=deadline, capture_layers=capture_layers, seed_candidates=(*seeded, *candidates)
+    retry_candidates, retry_complete, _deadline = full_search(
+        retry, deadline=deadline, seed_candidates=(*seeded, *candidates)
     )
     complete = complete and retry_complete
     annotated = []

src/codex32/_competitors.py

@@ -175,18 +175,23 @@ def _search_competitors(
     allowed: Callable[[CorrectionCandidate], bool] | None,
     *,
     seed_candidates: Sequence[CorrectionCandidate] = (),
+    optional_only: bool = False,
 ) -> tuple[tuple[CorrectionCandidate, ...], bool]:
     results = {candidate.artifact.text.lower(): candidate for candidate in seed_candidates}
     fixed: dict[int, CorrectionCandidate | None] = {}
     completed: set[_Layer] = set()
     try:
         for state in states:
-            if _FIXED in state.counts:
+            if not optional_only and _FIXED in state.counts:
                 _check_deadline(deadline)
                 fixed[state.target] = _search_fixed(state, frontier, results, allowed)
         targets = {state.target: state for state in states}
         layers = sorted(
-            (key for key in frontier if key[1] != _FIXED),
+            (
+                key
+                for key in frontier
+                if key[1] != _FIXED and (not optional_only or key[1].unit != 4 and key[1].distance > 2)
+            ),
             key=lambda key: (_tier(key[1]), frontier[key]),
         )
         for key in layers:

src/codex32/indel.py

@@ -606,16 +606,13 @@ def finish(
     if competitors:
         from codex32._competitors import _search_competitors
 
-        result = (
-            _search_competitors(
-                states,
-                frontier,
-                deadline,
-                allowed,
-                seed_candidates=seed_candidates,
-            )
-            if seed_candidates
-            else _search_competitors(states, frontier, deadline, allowed)
+        result = _search_competitors(
+            states,
+            frontier,
+            deadline,
+            allowed,
+            seed_candidates=seed_candidates,
+            optional_only=optional_only,
         )
         return finish(*result)
     results = {candidate.artifact.text.lower(): candidate for candidate in seed_candidates}

tests/test_correction_disclosure.py

@@ -60,7 +60,9 @@ def test_scheduler_annotates_from_admission_even_when_no_work_finished(monkeypat
         (48, indel._StructuralClass(0, 0, adjacent=2), 0, 0): rank + 1,
     }
     monkeypatch.setattr(indel, "_frontier", lambda *args: frontier)
-    monkeypatch.setattr("codex32._competitors._search_competitors", lambda *args: ((candidate,), complete))
+    monkeypatch.setattr(
+        "codex32._competitors._search_competitors", lambda *args, **kwargs: ((candidate,), complete)
+    )
     result, finished = indel._search_many(
         (CorrectionContext("ms", 48),),
         source,
@@ -309,7 +311,9 @@ def test_residue_exactly_five_bits_is_not_gated_even_with_zero_addends(residue):
 def test_previous_case_interpretation_search_is_charged_even_without_a_candidate(monkeypatch):
     candidate = replace(_candidate(), capture_volume=(1 << 60) + 1)
     monkeypatch.setattr(indel, "_frontier", lambda *args: {(48, indel._FIXED, 0, 0): 1})
-    monkeypatch.setattr("codex32._competitors._search_competitors", lambda *args: ((candidate,), True))
+    monkeypatch.setattr(
+        "codex32._competitors._search_competitors", lambda *args, **kwargs: ((candidate,), True)
+    )
     previous = [(1 << 60, 65)]
     result, _ = indel._search_many(
         (CorrectionContext("ms", 48),),

tests/test_mixed_case_deadline.py

@@ -66,6 +66,7 @@ def test_scheduled_truncation_survives_a_complete_later_pass(monkeypatch: pytest
     def truncated_first(value: str, *_args: object, **kwargs: object) -> tuple[object, bool, float]:
         if kwargs.get("required_only"):
             return (), True, 0.0
+        assert kwargs.get("optional_only") is True
         full_searches.append(value)
         if len(full_searches) == 1:
             return (replace(found[0], search_complete=False),), False, 0.0