correct: Report mixed-case truncation

Replace the assert-complete deadline test with two counter-examples:
five minority-case P that only the erasure reading corrects, and
fifteen minority-case X with one mistyped that only case
normalization corrects. Each case checks that its other reading alone
finds nothing and that the shared schedule still returns the backup
within the ten-second deadline. On the first case the normalized
reading's exhaustive optional search takes minutes, so the test cannot
require a complete search; it requires the truncation to be reported.

Make _scheduled_candidates report that truncation. Combine both full
passes' completeness instead of keeping only the later pass, and mark
returned candidates search_complete=False when either pass truncated,
so a copy from a completed earlier pass cannot hide the later timeout.

refs #37

Claude-Session: https://claude.ai/code/session_013gZvwvuocM7a7Ut4kiBFHw

Author: claude

src/codex32/_cli_input.py

@@ -530,16 +530,20 @@ def _scheduled_candidates(
     )
     if retry is None:
         return candidates, complete
-    retry_candidates, complete, _deadline = search(
+    retry_candidates, retry_complete, _deadline = search(
         retry, deadline=deadline, capture_layers=capture_layers, seed_candidates=(*seeded, *candidates)
     )
+    complete = complete and retry_complete
     annotated = []
     for item in (*candidates, *retry_candidates):
         volume, bits = _capture_mass(capture_layers, item.capture_volume)
         annotated.append(replace(item, cumulative_capture_volume=volume, capture_space_bits=bits))
     unique: dict[str, CorrectionCandidate] = {}
     for item in _best(annotated, prefer_common=byte_length == "?", fingerprint_match=fingerprint_match):
-        unique.setdefault(item.artifact.text.lower(), item)
+        # A copy from a completed earlier pass must not hide later truncation.
+        unique.setdefault(
+            item.artifact.text.lower(), item if complete else replace(item, search_complete=False)
+        )
     return tuple(unique.values()), complete
 
 

tests/test_mixed_case_deadline.py

@@ -1,31 +1,82 @@
 """Deadline regression for mixed-case embedded recovery."""
 
+from dataclasses import replace
 from time import monotonic
 
+import pytest
+
 from codex32 import Profile
-from codex32._cli_input import _case_interpretation, _scheduled_candidates
+from codex32._cli_input import _case_interpretation, _correction_candidates, _scheduled_candidates
 
+SOURCE = "ms10testsxxxxxxxxxxxxxxxxxxxxxxxxxx4nzvca9cmczlw"
 
-def test_embedded_mixed_case_completes_both_interpretations_within_deadline() -> None:
-    source = "ms10testsxxxxxxxxxxxxxxxxxxxxxxxxxx4nzvca9cmczlw"
-    damaged = "ms10testsxPxxxxxPxxxxxPxxxxxPxxxxxP4nzvca9cmczlw"
+
+@pytest.mark.parametrize(
+    ("damaged", "erasure_fixes", "normalized_fixes"),
+    [
+        # Five minority-case P: five erasures are correctable, five substitutions are not.
+        ("ms10testsxPxxxxxPxxxxxPxxxxxPxxxxxP4nzvca9cmczlw", True, False),
+        # Fifteen minority-case X, one mistyped: fifteen erasures are not correctable,
+        # one substitution after case normalization is.
+        ("ms10testsXXXXXXXPXXXXXXXxxxxxxxxxxx4nzvca9cmczlw", False, True),
+    ],
+)
+def test_embedded_mixed_case_recovers_either_sole_interpretation_within_deadline(
+    damaged: str, erasure_fixes: bool, normalized_fixes: bool
+) -> None:
     interpretation = _case_interpretation(damaged, "", (Profile.MS,), None)
 
     assert interpretation is not None
     direct, normalized, erased, _prefix = interpretation
     assert direct is None
-    separator = normalized.rfind("1")
-    deadline = monotonic() + 10
+    immutable = normalized[: normalized.rfind("1") + 1]
+    for value, fixes in ((erased, erasure_fixes), (normalized, normalized_fixes)):
+        alone, alone_complete, _deadline = _correction_candidates(
+            value, Profile.MS, None, immutable, deadline=monotonic() + 10, required_only=True
+        )
+        assert alone_complete
+        assert [candidate.artifact.text for candidate in alone] == ([SOURCE] if fixes else [])
 
     candidates, complete = _scheduled_candidates(
         normalized,
         erased,
         Profile.MS,
         None,
-        normalized[: separator + 1],
-        deadline=deadline,
+        immutable,
+        deadline=monotonic() + 10,
     )
 
-    assert complete
-    assert len(candidates) == 1
-    assert candidates[0].artifact.text == source
+    # The exhaustive optional search may truncate at the deadline; the
+    # candidate must still be found and must report that truncation.
+    assert [candidate.artifact.text for candidate in candidates] == [SOURCE]
+    assert candidates[0].search_complete is complete
+
+
+def test_scheduled_truncation_survives_a_complete_later_pass(monkeypatch: pytest.MonkeyPatch) -> None:
+    damaged = "ms10testsxPxxxxxPxxxxxPxxxxxPxxxxxP4nzvca9cmczlw"
+    interpretation = _case_interpretation(damaged, "", (Profile.MS,), None)
+    assert interpretation is not None
+    _direct, normalized, erased, _prefix = interpretation
+    immutable = normalized[: normalized.rfind("1") + 1]
+    found, _complete, _deadline = _correction_candidates(
+        erased, Profile.MS, None, immutable, deadline=monotonic() + 10, required_only=True
+    )
+    full_searches: list[str] = []
+
+    def truncated_first(value: str, *_args: object, **kwargs: object) -> tuple[object, bool, float]:
+        if kwargs.get("required_only"):
+            return (), True, 0.0
+        full_searches.append(value)
+        if len(full_searches) == 1:
+            return (replace(found[0], search_complete=False),), False, 0.0
+        return (), True, 0.0
+
+    monkeypatch.setattr("codex32._cli_input._correction_candidates", truncated_first)
+
+    candidates, complete = _scheduled_candidates(normalized, erased, Profile.MS, None, immutable)
+
+    assert full_searches == [erased, normalized]
+    assert not complete
+    assert [(candidate.artifact.text, candidate.search_complete) for candidate in candidates] == [
+        (SOURCE, False)
+    ]