napkin-math(compress): preserve acronym casing in the deterministic if/then rewrite

Review feedback on PR #750 (third round): the rewrite naively lowercased the first character of the subject and consequence, which damages acronyms — 'API job queue latency exceeds 100ms, ...' was being rewritten to 'If aPI job queue latency...' which is visibly broken.

Fix: only lowercase the first character when it is followed by a lowercase letter (a regular capitalised word like 'Middleware'). Acronyms like 'API' / 'OPC UA' / digit prefixes like '5G' all have a non-lowercase second character, so they are left unchanged.

Two new regression tests: (1) 'API job queue latency exceeds 100ms, ...' rewrites to 'If API job queue latency exceeds 100ms, then ...' with the acronym intact, (2) 'Middleware development bid exceeds $75,000, ...' still rewrites to 'If middleware development bid exceeds $75,000, then ...' (regular capitalisation still adjusted).

44 unit tests pass (42 prior + 2 new).

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

@@ -1105,6 +1105,21 @@ def format_scored_item_line(item: PublicScoredItem) -> str:
 )
 
 
+def _lowercase_first_preserving_acronyms(text: str) -> str:
+    """Lowercase the first character of ``text`` only when doing so does
+    not damage an acronym. Heuristic: lowercase only when the first
+    character is an uppercase letter AND the second character is a
+    lowercase letter (a regular capitalized word like ``Middleware``).
+    For tokens like ``API`` / ``OPC UA`` / ``5G`` the next character is
+    not a lowercase letter, so the casing is preserved.
+    """
+    if len(text) < 2:
+        return text
+    if text[0].isupper() and text[1].islower():
+        return text[0].lower() + text[1:]
+    return text
+
+
 def gate_shape_promotion(line: str) -> Optional[str]:
     """Return the if/then form of ``line`` if it has any recognised gate
     structural shape, else ``None``.
@@ -1126,6 +1141,12 @@ def gate_shape_promotion(line: str) -> Optional[str]:
     ``If middleware development bid exceeds $75,000, then consuming
     budget...`` so the downstream consumer reads a uniformly-shaped gate.
 
+    Casing in the rewrite is preserved for acronyms and proper nouns —
+    ``API job queue latency...`` becomes ``If API job queue latency...``,
+    not ``If aPI...``. The case adjustment only fires on regular
+    capitalised words where the first letter being lowercased reads
+    naturally mid-sentence.
+
     Returns ``None`` when the line matches neither shape — the promoter
     must not steal qualitative risks (triggers with a non-numeric source
     side, or risks framed without a comparison verb) into the gates pool.
@@ -1140,14 +1161,10 @@ def gate_shape_promotion(line: str) -> Optional[str]:
     m = DECLARATIVE_GATE_SHAPE_PATTERN.match(s)
     if m is None:
         return None
-    subject = m.group("subject").strip()
+    subject = _lowercase_first_preserving_acronyms(m.group("subject").strip())
     verb = " ".join(m.group("verb").split())
     threshold = m.group("threshold").strip()
-    consequence = m.group("consequence").strip()
-    if subject and subject[0].isupper():
-        subject = subject[0].lower() + subject[1:]
-    if consequence and consequence[0].isupper():
-        consequence = consequence[0].lower() + consequence[1:]
+    consequence = _lowercase_first_preserving_acronyms(m.group("consequence").strip())
     return f"If {subject} {verb} {threshold}, then {consequence}"
 
 

worker_plan/worker_plan_internal/parameter_extraction/tests/test_compress_report_section.py

@@ -662,6 +662,40 @@ def test_gate_shape_promotion_passes_through_canonical_if_then() -> None:
     assert gate_shape_promotion(line) == line
 
 
+def test_gate_shape_promotion_preserves_acronyms_in_subject() -> None:
+    """Subject acronyms like ``API`` / ``OPC UA`` must NOT be lowercased
+    by the rewrite — that would damage the readable form. The case
+    adjustment only fires on regular capitalised words (uppercase
+    followed by lowercase), not on acronyms (uppercase followed by
+    uppercase)."""
+    from worker_plan_internal.parameter_extraction.compress_report_section import (
+        gate_shape_promotion,
+    )
+
+    line = (
+        "API job queue latency exceeds 100ms, "
+        "requiring control board upgrades to meet the responsiveness target."
+    )
+    rewritten = gate_shape_promotion(line)
+    assert rewritten is not None
+    assert rewritten.startswith("If API "), rewritten
+    assert "aPI" not in rewritten
+
+
+def test_gate_shape_promotion_lowercases_regular_capitalised_subject() -> None:
+    """Counterpart to the acronym test: a regular capitalised subject
+    SHOULD be lowercased mid-sentence so the rewritten if/then reads
+    naturally. ``Middleware`` → ``middleware`` is the canonical case."""
+    from worker_plan_internal.parameter_extraction.compress_report_section import (
+        gate_shape_promotion,
+    )
+
+    line = "Middleware development bid exceeds $75,000, scope is cut."
+    rewritten = gate_shape_promotion(line)
+    assert rewritten is not None
+    assert rewritten.startswith("If middleware development bid "), rewritten
+
+
 def test_promote_gate_shaped_risks_moves_misfiled_gate() -> None:
     """Focal v53c scenario: gates emitted some items but missed a tripwire;
     risks emitted the tripwire with if/then numeric shape. Promotion