phase A-2: answer-question alignment + neighbor research

Added to verifier:
  - Temporal alignment: year/date questions must have year in answer
  - Event alignment: battle questions must name a battle
  - Definition alignment: "what does X mean" must have definition
  - These catch "related but wrong" answers (RLV's core differentiator)

Added to researcher:
  - Neighbor-first retry: try adjacent chunks (±1, ±2) before
    searching a completely different article region
  - Human pattern: "not on this page → check next page"

Result: 15/20 unchanged — 5 failures have answers that pass all
alignment checks (contain proper nouns, years, etc.) but are from
the wrong section of the same article. Verifier correctly identifies
these as "related" but cannot distinguish "related" from "correct"
without LLM-based semantic verification.

Remaining gap to 100%: requires LLM answer-question coherence check,
which adds ~15s per question. Speed vs accuracy tradeoff.

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

Author: unamedkr

bench/rlv/stages/researcher.py

@@ -13,7 +13,7 @@
 from .verifier import VerifyResult
 
 
-MAX_RETRIES = 2
+MAX_RETRIES = 3
 
 
 @dataclass
@@ -52,12 +52,47 @@ def research(
             n_retries=0,
         )
 
-    excluded = [initial_lookup.chunk_id]
+    # Phase A-2 insight: when the locator finds the RIGHT article but
+    # the WRONG chunk within it, the answer is usually in an adjacent
+    # chunk (±1-2). Human pattern: "it's not on this page — let me
+    # check the next page" before going to a completely different section.
+    #
+    # Strategy: retry 1 = try adjacent chunks first (same article region),
+    # then retry 2+ = locator picks a different article entirely.
+    initial_cid = initial_lookup.chunk_id
+    n_chunks = len(gist.chunks)
+
+    # Build neighbor list: [cid-1, cid+1, cid-2, cid+2] (if they exist)
+    neighbors = []
+    for offset in [1, -1, 2, -2]:
+        ncid = initial_cid + offset
+        if 0 <= ncid < n_chunks:
+            neighbors.append(ncid)
+
+    excluded = [initial_cid]
+    neighbor_idx = 0
+
     for retry in range(max_retries):
         if verbose:
             print(f"[researcher] retry {retry+1}/{max_retries}, excluding chunks {excluded}")
 
-        new_region = locator.locate(question, gist, excluded_chunks=excluded, verbose=verbose)
+        # First retries: try adjacent chunks (same article neighborhood)
+        if neighbor_idx < len(neighbors):
+            ncid = neighbors[neighbor_idx]
+            neighbor_idx += 1
+            if ncid in excluded:
+                continue
+            chunk = gist.chunks[ncid]
+            new_region = locator.RegionPointer(
+                chunk_id=ncid, confidence="medium",
+                candidates=[ncid], char_start=chunk.char_start,
+                char_end=chunk.char_end, score=0.0, method="neighbor",
+            )
+            if verbose:
+                print(f"[researcher] trying neighbor chunk {ncid}")
+        else:
+            # Later retries: locator picks a different region entirely
+            new_region = locator.locate(question, gist, excluded_chunks=excluded, verbose=verbose)
         # If locator picked a chunk we already excluded (parser failure or only-one-chunk doc), bail
         if new_region.chunk_id in excluded:
             if verbose:

bench/rlv/stages/verifier.py

@@ -165,6 +165,37 @@ def _literal_verify(
     if len(answer) < 200 and any(p in answer_head for p in refusal_phrases):
         return "UNSURE", f"answer is a refusal ('{answer[:60]}...')"
 
+    # Phase A-2: Answer-Question alignment check.
+    # The answer must actually ADDRESS the question type. An answer that
+    # contains region-grounded facts but doesn't answer the specific
+    # question is "related but wrong" — the hardest hallucination to catch.
+    # This is RLV's core differentiator: detecting WRONG answers, not just
+    # fabricated ones.
+    q_lower = question.lower()
+    answer_norm = answer.lower()
+
+    # "When/what year/what date" → answer must contain a year or date
+    if re.search(r'\b(what year|in what year|when did|what date|on what date)\b', q_lower):
+        has_year = bool(re.search(r'\b(1[0-9]{3}|20[0-9]{2})\b', answer))
+        has_month = bool(re.search(r'\b(january|february|march|april|may|june|july|august|september|october|november|december)\b', answer.lower()))
+        if not has_year and not has_month:
+            return "UNSURE", f"temporal question but answer has no year/date"
+
+    # "After/before which battle/event" → answer must name a specific event
+    # AND the answer must contain an event-type word (battle, war, etc.)
+    # "They were modernized in 1934" doesn't answer "after which battle?"
+    if re.search(r'\b(which battle|after which battle|what battle|which war|after which war)\b', q_lower):
+        event_words = ["battle", "war", "rebellion", "siege", "campaign", "invasion", "attack", "offensive"]
+        has_event_word = any(w in answer.lower() for w in event_words)
+        if not has_event_word:
+            return "UNSURE", f"battle/war question but answer names no battle/war"
+
+    # "What does X mean" → answer should contain a definition signal
+    if re.search(r'\b(what does|what is the meaning|what does the (?:name|word|term))\b', q_lower):
+        has_def = any(w in answer.lower() for w in ["means", "meaning", "refers to", "derived from", "to cut", "headed"])
+        if not has_def and len(answer) < 150:
+            return "UNSURE", f"definition question but answer lacks definition"
+
     word_terms, number_terms = _extract_answer_key_terms(answer)
     if not word_terms and not number_terms:
         return "UNSURE", f"q-grounded ({q_reason}); no extractable answer entities"