Fix final 2 P1s: uncertainty detector covers all syntaxes, stale review gating

P1: Replace broad_sev regex with line-by-line _BLOCK_START scan in uncertainty
detector, so **Severity:** P1 and **Severity: P1** formats correctly trigger
parse_uncertain=True when the block parser can't extract findings.

P1: Move previous-review preservation inside the validated-state path in Step 4.
When state is invalidated (branch mismatch, non-ancestor, rebase), delete
local-review-previous.md to prevent stale findings leaking via --previous-review.

P2: Add 2 regression tests for bold-label uncertainty detection, fix 2 existing
test assertions for mid-line severity markers (correctly non-detected).

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

Author: igerber

.claude/commands/ai-review-local.md

@@ -244,19 +244,24 @@ if [ -f .claude/reviews/review-state.json ]; then
             rm -f /tmp/ai-review-diff.patch /tmp/ai-review-files.txt
             # Stop here
         fi
+        # State validated and delta generated — preserve previous review for re-review context
+        if [ -f .claude/reviews/local-review-latest.md ]; then
+            cp .claude/reviews/local-review-latest.md .claude/reviews/local-review-previous.md
+            echo "Previous review preserved for re-review context."
+        fi
     else
         echo "Warning: Previous review commit is not an ancestor of HEAD (likely rebase). Running fresh review."
         rm -f .claude/reviews/review-state.json
+        rm -f .claude/reviews/local-review-previous.md
     fi
 fi
-
-# Preserve previous review text (for re-review context)
-if [ -f .claude/reviews/local-review-latest.md ]; then
-    cp .claude/reviews/local-review-latest.md .claude/reviews/local-review-previous.md
-    echo "Previous review preserved for re-review context."
-fi
 ```
 
+**Important**: Previous review text is ONLY preserved when delta mode is active (state was
+validated). When state is invalidated (branch mismatch, non-ancestor, rebase), the previous
+review file is deleted to prevent stale findings from leaking into a fresh review via
+`--previous-review`.
+
 ### Step 5: Run the Review Script
 
 Build and run the command. Include optional arguments only when their conditions are met:

.claude/scripts/openai_review.py

@@ -551,17 +551,17 @@ def parse_review_findings(
             "status": "open",
         })
 
-    # Fail-safe: check if ANY severity marker exists but we parsed nothing.
-    # Use a broad pattern (not line-anchored) to catch markers anywhere in text.
+    # Fail-safe: check if ANY supported severity syntax exists but we parsed
+    # nothing. Scan line-by-line using the same _BLOCK_START pattern the parser
+    # uses, ensuring the uncertainty detector covers every accepted format.
     parse_uncertain = False
     if not findings:
-        broad_sev = re.compile(
-            r"\*\*(P[0-3])\*\*"
-            r"|(?:^|\s)Severity:\s*\*?\*?\s*P[0-3]",
-            re.MULTILINE,
-        )
-        if broad_sev.search(review_text):
-            parse_uncertain = True
+        for line in review_text.splitlines():
+            if _should_skip_line(line):
+                continue
+            if _BLOCK_START.search(line):
+                parse_uncertain = True
+                break
 
     return (findings, parse_uncertain)
 

tests/test_openai_review.py

@@ -827,30 +827,41 @@ def test_parses_plain_multiline_block(self, review_mod):
         assert "NaN guard" in findings[0]["summary"]
         assert not uncertain
 
-    def test_plain_severity_triggers_uncertainty(self, review_mod):
-        """Plain Severity: markers should trigger uncertainty when no findings parsed."""
-        # This format has severity but in a context the block parser can't extract
+    def test_midline_severity_not_detected(self, review_mod):
+        """Severity markers embedded mid-line are not block starts — no uncertainty."""
         review_text = (
             "There is a Severity: P1 issue but the rest of the text\n"
             "doesn't follow any recognized block structure at all\n"
         )
         findings, uncertain = review_mod.parse_review_findings(review_text, 1)
-        # Whether or not it parses, if it fails, uncertain should be True
-        if not findings:
-            assert uncertain
+        # Mid-line markers are not valid block starts — correctly returns ([], False)
+        assert findings == []
+        assert not uncertain
 
-    def test_zero_findings_with_markers_sets_uncertain(self, review_mod):
-        """When severity markers exist but parsing yields nothing, flag uncertainty."""
-        # Markers in code blocks or unusual format the parser can't handle
+    def test_midline_bold_severity_not_detected(self, review_mod):
+        """Bold severity mid-line (not at line start) is not a block start."""
         review_text = (
             "The review found **P1** issues but in a format\n"
-            "that the block parser cannot delimit properly because\n"
-            "there are no standard block boundaries.\n"
+            "that the block parser cannot delimit properly.\n"
         )
         findings, uncertain = review_mod.parse_review_findings(review_text, 1)
-        # Parser may or may not extract this — but if it fails:
-        if not findings:
-            assert uncertain
+        # Mid-line bold is not a valid block start — correctly returns ([], False)
+        assert findings == []
+        assert not uncertain
+
+    def test_bold_label_severity_triggers_uncertainty(self, review_mod):
+        """**Severity:** P1 format with no parseable summary → uncertain=True."""
+        review_text = "- **Severity:** P1\n"
+        findings, uncertain = review_mod.parse_review_findings(review_text, 1)
+        assert findings == []
+        assert uncertain
+
+    def test_bold_inline_severity_triggers_uncertainty(self, review_mod):
+        """**Severity: P1** format with no parseable summary → uncertain=True."""
+        review_text = "- **Severity: P1**\n"
+        findings, uncertain = review_mod.parse_review_findings(review_text, 1)
+        assert findings == []
+        assert uncertain
 
     def test_ignores_multi_severity_prose(self, review_mod):
         """Lines like 'P2/P3 items may exist' should not be parsed as findings."""