napkin-math(compress): tighten token-overlap fallback to require every quote token (was 90%)

Code review on PR #744 noted the 90% threshold lets a long quote pass with one substituted content word (13/14 overlap), so 'highest'/'lowest' inversions in a long quote could verify even though they invert meaning. Tighten to require all quote tokens to appear in the source — the digit-bearing anchor is subsumed by the all-tokens rule, so it is removed.

Empirically (1366 scored candidates across 6 plans, 8 compress runs): 0 items lose qv=True under the tightening. The 90% rule was never functionally looser than the 100% rule on observed data; the LLM's paraphrases are either full token-overlap (reordering/elision) or hit the substring fast path. Tightening removes the theoretical false-positive surface at no empirical cost.

Adds a long-quote substitution test (14 tokens with one 'highest'/'lowest' swap) to lock the new bound in.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: neoneye

worker_plan/worker_plan_internal/parameter_extraction/compress_report_section.py

@@ -920,7 +920,6 @@ def normalise_for_quote_match(text: str) -> str:
 
 WORD_TOKEN_PATTERN: re.Pattern[str] = re.compile(r"\w+", re.UNICODE)
 
-QUOTE_MATCH_OVERLAP_THRESHOLD: float = 0.9
 QUOTE_MATCH_MIN_TOKENS: int = 3
 
 
@@ -929,8 +928,7 @@ def tokenize_for_quote_match(text: str) -> list[str]:
 
     Language- and domain-neutral: it splits on whatever the Unicode word
     class considers a word character. Numeric tokens like ``$75,000`` split
-    into ``["75", "000"]`` consistently in both quote and source, so digit
-    anchoring still works.
+    into ``["75", "000"]`` consistently in both quote and source.
     """
     return WORD_TOKEN_PATTERN.findall(normalise_for_quote_match(text))
 
@@ -940,12 +938,12 @@ def quote_is_in_source(quote: str, section_markdown: str) -> bool:
 
     Fast path is the existing substring check after normalisation. When the
     LLM paraphrases (drops intermediate words, reorders the noun phrase),
-    that fast path misses even though the quote is faithful to the source.
-    A token-overlap fallback catches those cases without letting hallucinated
-    numbers or substituted content words through: every digit-bearing token
-    in the quote must appear in the source, and at least
-    ``QUOTE_MATCH_OVERLAP_THRESHOLD`` of all quote tokens must appear in the
-    source token set.
+    that fast path misses even though every content token came from the
+    source. The fallback requires every quote token to appear in the source
+    token set, which accepts reordering and elision but rejects any
+    substituted word — including numeric substitutions, since digit-bearing
+    tokens fall under the same all-tokens rule. A short-quote floor avoids
+    trivial overlap on a large source.
     """
     if not quote:
         return False
@@ -959,11 +957,7 @@ def quote_is_in_source(quote: str, section_markdown: str) -> bool:
     if len(quote_tokens) < QUOTE_MATCH_MIN_TOKENS:
         return False
     source_tokens = set(tokenize_for_quote_match(section_markdown))
-    for tok in quote_tokens:
-        if any(ch.isdigit() for ch in tok) and tok not in source_tokens:
-            return False
-    matched = sum(1 for tok in quote_tokens if tok in source_tokens)
-    return matched / len(quote_tokens) >= QUOTE_MATCH_OVERLAP_THRESHOLD
+    return all(tok in source_tokens for tok in quote_tokens)
 
 
 def numeric_density_bonus(text: str) -> float:

worker_plan/worker_plan_internal/parameter_extraction/tests/test_compress_report_section.py

@@ -510,9 +510,9 @@ def test_quote_is_in_source_rejects_hallucinated_number() -> None:
 
 
 def test_quote_is_in_source_rejects_substituted_content_word() -> None:
-    """Token-overlap threshold (90%) blocks single-word substitutions that
-    invert meaning while keeping most surface tokens. ``highest`` is not in
-    the source, so a six-other-tokens overlap fails."""
+    """All-tokens-in-source rule blocks single-word substitutions that invert
+    meaning while keeping most surface tokens. ``highest`` is not in the
+    source, so even a six-other-tokens overlap fails."""
     from worker_plan_internal.parameter_extraction.compress_report_section import (
         quote_is_in_source,
     )
@@ -524,6 +524,30 @@ def test_quote_is_in_source_rejects_substituted_content_word() -> None:
     ) is False
 
 
+def test_quote_is_in_source_rejects_substitution_in_long_quote() -> None:
+    """A longer quote with one substituted content word must still fail —
+    high fractional overlap is not a free pass. The all-tokens rule rejects
+    on the single missing token regardless of quote length, which a
+    fractional threshold like ≥90% would let through."""
+    from worker_plan_internal.parameter_extraction.compress_report_section import (
+        quote_is_in_source,
+    )
+
+    source = (
+        "If the lowest qualified bid for OPC UA middleware exceeds $75,000, "
+        "then the project reverts to the current rule-based integration "
+        "vendor and escalates to the steering committee."
+    )
+    # Same 14-token clause; only ``lowest`` swapped for ``highest``. 13/14 of
+    # the tokens still appear in source, but the substituted word inverts
+    # the meaning and must not verify.
+    quote = (
+        "highest qualified bid for OPC UA middleware exceeds $75,000 "
+        "then project reverts to integration vendor"
+    )
+    assert quote_is_in_source(quote, source) is False
+
+
 def test_quote_is_in_source_rejects_short_unrelated_quote() -> None:
     """Two- or one-token quotes do not get the token-overlap fallback —
     too easy to satisfy by coincidence on a large source."""