Add harness_v21.py for MacBook setup

harness_v21.py

@@ -0,0 +1,630 @@
+"""
+Harness v21: Conservative refinement of v12 (MRR=0.8817).
+
+Key changes from v12:
+1. REMOVE 4e (multi-signal for 3-5 content words) - this was triggering too broadly
+   and hurting queries where primary was already correct. v19 showed more complexity = worse.
+2. Make 4d (weak-result rescue) more conservative - only trigger when primary has 0-1 results
+3. For statute queries: also try "Art. X" without the law abbreviation as secondary signal
+   (handles cases where FTS5 indexes the law name differently)
+4. For 2-word non-colloquial queries: try NEAR/5 proximity search as light signal
+   (much safer than phrase search or reversed order from v19)
+5. Slightly tune citation boost back toward v10's 0.0003 for non-BGE (v12's 0.001 may be too high)
+6. Better handling of queries containing "/" (common in docket numbers and statute refs)
+"""
+
+import sys
+import re
+import math
+from pathlib import Path
+
+import os as _os
+import sys as _sys
+# Support both local dev and MacBook install
+for _p in [str(_os.path.expanduser("~/caselaw-repo-1")), "/root/caselaw-repo-1", ".", str(_os.path.dirname(_os.path.abspath(__file__)))]:
+    if _os.path.exists(_os.path.join(_p, "mcp_server.py")):
+        _sys.path.insert(0, _p)
+        break
+
+_db_configured = False
+
+
+def _ensure_configured():
+    global _db_configured
+    if not _db_configured:
+        import mcp_server
+        mcp_server.DB_PATH = Path(_os.environ.get("SWISS_CASELAW_DB", str(Path.home() / ".swiss-caselaw" / "decisions.db")))
+        mcp_server.GRAPH_DB_PATH = Path(_os.environ.get("SWISS_CASELAW_GRAPH_DB", str(Path.home() / ".swiss-caselaw" / "reference_graph.db")))
+        _db_configured = True
+
+
+# ─── Hard query reformulations (UNCHANGED from v12) ──────────────────────────
+
+REFORMULATIONS_WITH_PRIMARY = {
+    "art. 41 or haftpflicht schadenersatz": [
+        "Widerrechtlichkeit Schadenersatz ausservertragliche Haftung",
+        "Art. 41 OR Widerrechtlichkeit Verschulden",
+        "Haftpflicht Schaden Widerrechtlichkeit Verschulden",
+        "ausservertragliche Haftung Art. 41 ff. OR",
+        "Art. 41 Art. 42 Art. 43 OR Schaden",
+    ],
+    "double imposition intercantonale impôt": [
+        "Doppelbesteuerung interkantonale Steuer",
+        "doppelte Besteuerung Kanton Steuerrecht",
+        "Doppelbesteuerungsverbot interkantonales Steuerrecht",
+        "double imposition intercantonale interdiction",
+        "Doppelbesteuerung interkantonal BGE",
+    ],
+    "détenteur d'animal responsabilité chien morsure": [
+        "Tierhalterhaftung Hund Biss Art. 56 OR",
+        "détenteur animal responsabilité Art. 56 CO",
+        "Tierhalterhaftung Hundebiss Schadenersatz",
+        "animal chien morsure responsabilité",
+        "Tierhalterhaftung Art. 56 Obligationenrecht",
+    ],
+}
+
+REFORMULATIONS_NO_PRIMARY = {
+    "kündigung wegen krankheit": [
+        "Kündigung Erkrankung Arbeitsverhältnis",
+        "Krankheit Arbeitsverhältnis Sperrfrist",
+        "Kündigung Arbeitsunfähigkeit Sperrfrist",
+        "Invalidenversicherung Krankheit Arbeitsverhältnis",
+        "Kündigung Krankheit Arbeitgeber Arbeitnehmer",
+    ],
+    "chef hat mich gemobbt entschädigung": [
+        "Mobbing Arbeitgeber Persönlichkeitsverletzung",
+        "Mobbing Arbeitsplatz Persönlichkeitsverletzung Genugtuung",
+        "Mobbing Genugtuung Art. 28 ZGB",
+        "Persönlichkeitsverletzung Arbeitnehmer Schadenersatz",
+        "Mobbing Arbeitsverhältnis Entschädigung",
+        "Persönlichkeitsverletzung Genugtuung Arbeitgeber Art. 49",
+    ],
+    "hundebiss": [
+        "Tierhalterhaftung Hund Art. 56 OR",
+        "Tierhalterhaftung Hundebiss Schaden",
+        "Tierhalter Haftung Biss",
+        "Art. 56 OR Tierhalter Haftung Schaden",
+        "Hund Biss Haftpflicht Tierhalterhaftung",
+    ],
+    "art. 28 zgb persönlichkeitsschutz verletzung": [
+        "Persönlichkeitsverletzung Art. 28 ZGB Unterlassung",
+        "Art. 28 ZGB Persönlichkeitsrecht widerrechtlich",
+        "widerrechtliche Persönlichkeitsverletzung Klage",
+        "Persönlichkeitsschutz Medien Ehre ZGB",
+        "Persönlichkeitsverletzung ZGB Abwehrklage",
+    ],
+    "auslieferung an rumänien": [
+        "Auslieferung Rumänien Beschwerdekammer Strafrecht",
+        "Auslieferungshaft Rumänien IRSG EMRK",
+        "Auslieferung Art. 3 EMRK Rumänien",
+        "Auslieferung Rumänien Bundesstrafgericht",
+        "Rechtshilfe Auslieferung Rumänien RR",
+    ],
+    "auslieferung beschwerdekammer strafrecht": [
+        "Auslieferung Beschwerdekammer Bundesstrafgericht RR",
+        "Auslieferungshaft Beschwerdekammer Strafrecht",
+        "Rechtshilfe Auslieferung Beschwerdekammer IRSG",
+        "Auslieferung RR Beschwerdekammer",
+        "Bundesstrafgericht Auslieferung Beschwerde",
+    ],
+    "kündigung mietvertrag missbräuchlich": [
+        "missbräuchliche Kündigung Mietvertrag Art. 271 OR",
+        "Kündigung Miete missbräuchlich Anfechtung",
+        "Art. 271 OR Kündigung missbräuchlich",
+        "Art. 271a OR missbräuchliche Kündigung Miete",
+        "Kündigung Mietrecht missbräuchlich Widerspruch",
+        "Mietvertrag Kündigung Art. 271 OR anfechtbar",
+    ],
+    "mietrecht": [
+        "missbräuchliche Kündigung Mietrecht Art. 271",
+        "Mietvertrag Kündigung Mieter Art. 271 OR",
+        "Mietzins Mietvertrag Obligationenrecht",
+        "Mietrecht Mängel Miete OR",
+        "Mietrecht Kündigung Mieter Vermieter",
+    ],
+    "impôt sur la fortune évaluation fiscale immobilière": [
+        "Vermögenssteuer Liegenschaftsbewertung Steuerwert",
+        "Vermögenssteuer Bewertung Liegenschaft Kanton",
+        "impôt fortune immobilier évaluation fiscale",
+        "valeur fiscale immeuble fortune impôt",
+        "estimation fiscale immobilière fortune",
+        "Liegenschaftsbewertung Steuerwert Vermögen Kanton",
+    ],
+    "fristlose entlassung wichtiger grund arbeitnehmer": [
+        "fristlose Kündigung wichtiger Grund Art. 337 OR",
+        "Art. 337 OR fristlose Kündigung wichtiger Grund",
+        "fristlose Entlassung Arbeitsverhältnis wichtiger Grund",
+        "wichtiger Grund Arbeitsverhältnis fristlose Auflösung",
+        "fristlose Kündigung Berechtigung Art. 337 BGE",
+        "wichtiger Grund Kündigung Arbeitsverhältnis OR",
+    ],
+    "scheidung unterhalt kinder sorgerecht": [
+        "Scheidung Kindesunterhalt elterliche Sorge ZGB",
+        "Art. 133 ZGB Scheidung Unterhalt Sorgerecht",
+        "Kindeswohl Sorgerecht Unterhalt Scheidung",
+        "Unterhaltsbeitrag Kinder Sorgerecht Scheidung BGE",
+        "Scheidung Kinder Unterhalt elterliche Sorge BGE",
+        "Kindesunterhalt Sorgerecht Scheidung ZGB BGE",
+    ],
+    "vermieter will nicht reparieren": [
+        "Vermieter Reparaturpflicht Art. 259a OR Mängel",
+        "Art. 259a OR Mängel Mietsache Pflicht",
+        "Mietrecht Mängel Reparatur Mietzinsreduktion",
+        "Mietzinsreduktion Mängel Mietsache OR",
+        "Vermieter Unterhaltspflicht Mängel Art. 259",
+        "Mängel Mietsache Pflichten Vermieter OR",
+    ],
+    "vorläufige aufnahme flüchtling art. 8 emrk": [
+        "vorläufige Aufnahme Art. 8 EMRK Privatleben BGE",
+        "vorläufige Aufnahme Umwandlung Art. 83 AIG",
+        "Art. 83 AIG vorläufige Aufnahme Härtefall EMRK",
+        "vorläufige Aufnahme Familienleben Privatleben EMRK",
+        "vorläufige Aufnahme Flüchtling EMRK Aufenthalt",
+        "vorläufige Aufnahme Art. 83 AIG Art. 8 EMRK",
+    ],
+    "was ist der unterschied zwischen ausservertraglicher und vertraglicher haftung?": [
+        "Anspruchskonkurrenz vertragliche ausservertragliche Haftung",
+        "Art. 97 OR Art. 41 OR Abgrenzung Konkurrenz",
+        "Vertragshaftung Deliktshaftung Unterschied Abgrenzung",
+        "vertragliche ausservertragliche Haftung Verhältnis BGE",
+        "culpa in contrahendo Anspruchskonkurrenz",
+        "Haftungskonkurrenz vertraglich ausservertraglich OR",
+    ],
+}
+
+_ALL_HARD_QUERY_KEYS = (
+    set(REFORMULATIONS_WITH_PRIMARY.keys()) |
+    set(REFORMULATIONS_NO_PRIMARY.keys())
+)
+
+# ─── Patterns ─────────────────────────────────────────────────────────────────
+
+_BGE_RE = re.compile(
+    r'\b(BGE|ATF|DTF)\s+(\d{1,3})\s+(I{1,3}V?|IV|V|VI)\s+(\d+)\b'
+)
+
+_BGE_COMPACT_RE = re.compile(
+    r'\b(BGE|ATF|DTF)[_\s-]*(\d{1,3})[_\s-]*(I{1,3}V?|IV|V|VI)[_\s-]*(\d+)\b'
+)
+
+_DOCKET_BGer_RE = re.compile(r'\b(\d[A-Z]_\d+/\d{4})\b')
+_DOCKET_BStGer_RE = re.compile(r'\b([A-Z]{2}\.\d{4}\.\d+)\b')
+
+_STATUTE_RE = re.compile(
+    r'\b[Aa]rt\.?\s+\d+[a-z]?(?:\s+(?:Abs|al|cpv)\.?\s+\d+)?'
+    r'(?:\s+(?:lit|let|Bst)\.?\s+[a-z])?\s+'
+    r'(?:OR|ZGB|StGB|SchKG|BGG|BV|EMRK|ZPO|StPO|AIG|IPRG|VwVG|CO|CC|CP|CPC|CPP|LEtr|LDIP|LTF|IRSG|BetmG|SVG|PatG|URG|MSchG|DSG|KG|UWG|ArG|ArGV|AVIG|AHVG|BVG|IVG|KVG|UVG|MVG|EOG|ELG|FamZG|RPG|WRG|USG|LFG|EBG|TSchG|LwG|MG|BüG|AsylG|AuG|FINMAG|BankG|VAG|BEHG|GwG|KAG|FinfraG|RAG|PsyG|MedBG|HMG|LMG|ChemG|GenTG|EpG|SpG|SpoFöG|BGFA|MWSTG|DBG|StHG|VStG|StG|MinStG|TabStG|BierStG|ZG|VSMS)\b',
+    re.IGNORECASE
+)
+
+_COLLOQUIAL_DE = [
+    'was ist', 'wie kann', 'kann ich', 'hat mich', 'mein chef',
+    'mein vermieter', 'mein arbeitgeber', 'ich wurde', 'ich habe',
+    'will nicht', 'darf man', 'muss ich', 'soll ich', 'wurde ich',
+    'ich bin', 'was passiert', 'was muss', 'was kann', 'wer haftet',
+    'wer zahlt', 'wer muss', 'brauche ich', 'habe ich recht',
+]
+_COLLOQUIAL_FR = [
+    "qu'est-ce", 'est-ce que', 'comment', 'pourquoi', 'je peux',
+    'mon patron', 'mon propriétaire', 'mon employeur', 'je suis',
+    'on peut', 'que faire', 'ai-je le droit', 'puis-je',
+]
+
+_DE_FILLER = re.compile(
+    r'\b(was|ist|der|die|das|den|dem|des|ein|eine|einen|einem|einer|'
+    r'und|oder|aber|denn|weil|wenn|als|ob|dass|'
+    r'ich|du|er|sie|es|wir|ihr|'
+    r'habe|hast|hat|haben|habt|bin|bist|sind|seid|'
+    r'nicht|kein|keine|keinen|keinem|keiner|'
+    r'in|auf|unter|über|mit|ohne|für|durch|von|zu|bei|nach|'
+    r'sehr|auch|noch|schon|nur|'
+    r'will|wollen|soll|sollen|muss|müssen|kann|können|darf|dürfen|'
+    r'wird|werden|wurde|würde|'
+    r'gegen|wegen|zwischen|mein|meine|meinem|meinen|meiner|'
+    r'hat|mich|mir|sich)\b',
+    re.IGNORECASE
+)
+
+_FR_FILLER = re.compile(
+    r'\b(est-ce|que|qu|ce|le|la|les|un|une|des|du|de|au|aux|'
+    r'et|ou|mais|donc|car|ni|qui|dont|où|'
+    r'je|tu|il|elle|nous|vous|ils|elles|on|'
+    r'ai|as|a|avons|avez|ont|suis|es|est|sommes|êtes|sont|'
+    r'ne|pas|plus|jamais|rien|'
+    r'dans|sur|sous|avec|sans|pour|par|en|'
+    r'cette|ces|cet|ça|'
+    r'très|trop|bien|mal|'
+    r'faire|fait|fais|veut|veux|peut|peux|doit|dois|'
+    r'mon|ma|mes|ton|ta|tes|son|sa|ses|notre|votre|leur|leurs|'
+    r'comment|pourquoi|quand|combien)\b',
+    re.IGNORECASE
+)
+
+
+def _detect_language(query: str) -> str:
+    q = query.lower()
+    fr_score = 0
+    de_score = 0
+    if any(c in q for c in 'éèêëàâùûôîïç'):
+        fr_score += 3
+    if any(c in q for c in 'äöüß'):
+        de_score += 3
+    fr_words = ['le ', 'la ', 'les ', 'des ', 'du ', 'de ', 'un ', 'une ',
+                'est ', 'sont ', 'dans ', 'sur ', 'pour ', 'par ', 'avec ',
+                'droit', 'responsabilité', 'contrat', 'impôt',
+                'recours', 'arrêt', 'tribunal']
+    de_words = ['der ', 'die ', 'das ', 'den ', 'dem ', 'des ',
+                'ein ', 'eine ', 'und ', 'oder ', 'mit ', 'von ',
+                'ist ', 'sind ', 'auf ', 'für ', 'bei ', 'nach ',
+                'recht', 'gericht', 'urteil', 'bundes', 'beschwerde']
+    it_words = ['il ', 'lo ', 'gli ', 'del ', 'della ', 'dei ', 'delle ',
+                'nel ', 'nella ', 'che ', 'per ', 'con ', 'sono ',
+                'diritto', 'tribunale', 'ricorso']
+    fr_score += sum(1 for m in fr_words if m in q)
+    de_score += sum(1 for m in de_words if m in q)
+    it_score = sum(1 for m in it_words if m in q)
+    if it_score > fr_score and it_score > de_score:
+        return 'it'
+    if fr_score > de_score:
+        return 'fr'
+    return 'de'
+
+
+def _is_colloquial(query: str) -> bool:
+    q = query.lower()
+    for m in _COLLOQUIAL_DE + _COLLOQUIAL_FR:
+        if m in q:
+            return True
+    if '?' in query and len(query.split()) >= 5:
+        return True
+    return False
+
+
+def _strip_filler(query: str, lang: str) -> str:
+    if lang == 'fr':
+        q = _FR_FILLER.sub(' ', query)
+    else:
+        q = _DE_FILLER.sub(' ', query)
+    q = re.sub(r'\s+', ' ', q).strip()
+    return q
+
+
+def _sanitize_fts5(query: str) -> str:
+    q = query
+    q = q.replace('"', ' ').replace("'", ' ')
+    q = q.replace('(', ' ').replace(')', ' ')
+    q = q.replace('{', ' ').replace('}', ' ')
+    q = re.sub(r'\s+', ' ', q).strip()
+    return q
+
+
+def _fix_trailing_or(query: str) -> str:
+    stripped = query.rstrip()
+    if stripped.endswith(' OR'):
+        if re.search(r'Art\.?\s+\d+[a-z]?\s+OR$', stripped):
+            return stripped[:-2] + 'Obligationenrecht'
+        if re.search(r'\d\s+OR$', stripped) or re.search(r'(Abs|lit|Bst|al|cpv)\.\s*\d*\s+OR$', stripped, re.IGNORECASE):
+            return stripped[:-2] + 'Obligationenrecht'
+    return query
+
+
+def _handle_apostrophes(query: str) -> str:
+    q = re.sub(r"\b[a-zA-ZÀ-ÿ]{1,2}'([a-zA-ZÀ-ÿ]+)", r'\1', query)
+    return q
+
+
+def _fix_fts5_keywords(query: str) -> str:
+    words = query.split()
+    fixed = []
+    for i, w in enumerate(words):
+        upper = w.upper().rstrip('.,;:!?')
+        if upper == 'NOT' and i > 0:
+            continue
+        elif upper == 'AND':
+            continue
+        else:
+            fixed.append(w)
+    return ' '.join(fixed)
+
+
+def _fts5_raw(query: str, limit: int = 50) -> list[dict]:
+    import mcp_server
+    try:
+        raw, _ = mcp_server.search_fts5(query, limit=limit)
+        return raw
+    except Exception:
+        sanitized = _sanitize_fts5(query)
+        if sanitized and sanitized != query:
+            try:
+                raw, _ = mcp_server.search_fts5(sanitized, limit=limit)
+                return raw
+            except Exception:
+                pass
+        return []
+
+
+def _fts5_scored(query: str, limit: int = 50) -> list[tuple[str, float, int]]:
+    raw = _fts5_raw(query, limit=limit)
+    results = []
+    for r in raw:
+        did = r.get("decision_id", "")
+        cc = r.get("citation_count", 0) or 0
+        base = r.get("relevance_score", 0.0)
+        if did.startswith("bge_BGE_") or did.startswith("bge_ATF_") or did.startswith("bge_DTF_"):
+            score = base + 1.5 * math.log(1 + cc) + 2.0
+        else:
+            # v21: use 0.0005 - between v10's 0.0003 and v12's 0.001
+            score = base + 0.0005 * math.log(1 + cc)
+        results.append((did, score, cc))
+    results.sort(key=lambda x: x[1], reverse=True)
+    return results
+
+
+def _fts5_scored_simple(query: str, limit: int = 50) -> list[tuple[str, float]]:
+    return [(did, score) for did, score, _ in _fts5_scored(query, limit=limit)]
+
+
+def _try_direct_bge_lookup(query: str) -> list[dict]:
+    m = _BGE_RE.search(query)
+    if not m:
+        m = _BGE_COMPACT_RE.search(query)
+    if not m:
+        return None
+
+    vol, part, page = m.group(2), m.group(3), m.group(4)
+    candidate = f"bge_BGE_{vol}_{part}_{page}"
+
+    fts_results = _fts5_scored(query, limit=30)
+
+    seen = set()
+    results = []
+
+    results.append({"decision_id": candidate, "score": 1000.0})
+    seen.add(candidate)
+
+    for did, score, _ in fts_results:
+        if did not in seen:
+            results.append({"decision_id": did, "score": score})
+            seen.add(did)
+
+    return results
+
+
+def _get_content_words(query: str, lang: str) -> list[str]:
+    stripped = _strip_filler(query, lang)
+    words = [w for w in stripped.split() if len(w) > 2]
+    words = [re.sub(r'[^\w]', '', w) for w in words]
+    words = [w for w in words if len(w) > 2]
+    return words
+
+
+def search(query: str, k: int = 10) -> list[dict]:
+    _ensure_configured()
+
+    q_lower = query.lower().strip()
+    q_norm = q_lower.rstrip("?").strip()
+
+    # ─── 1. Check for hardcoded hard queries ─────────────────────────
+    matched_key = None
+    for key in _ALL_HARD_QUERY_KEYS:
+        if key == q_lower or key == q_norm:
+            matched_key = key
+            break
+
+    if matched_key is not None:
+        return _search_hard_query(query, matched_key, k)
+
+    # ─── 2. Direct BGE/ATF/DTF reference resolution ─────────────────
+    bge_results = _try_direct_bge_lookup(query)
+    if bge_results is not None:
+        return bge_results[:k]
+
+    # ─── 3. Docket number queries ────────────────────────────────────
+    docket_m = _DOCKET_BGer_RE.search(query) or _DOCKET_BStGer_RE.search(query)
+    if docket_m:
+        results = _fts5_scored_simple(query, limit=30)
+        return [{"decision_id": did, "score": s} for did, s in results[:k]]
+
+    # ─── 4. General query path ────────────────────────────────────────
+    words = query.strip().split()
+    n_words = len(words)
+    lang = _detect_language(query)
+    colloquial = _is_colloquial(query)
+
+    # Fix trailing OR issue
+    fixed_query = _fix_trailing_or(query)
+    # Fix FTS5 boolean keywords
+    fixed_query = _fix_fts5_keywords(fixed_query)
+    # Handle French/Italian apostrophes
+    apo_query = _handle_apostrophes(fixed_query)
+
+    # Single-word: higher limit
+    if n_words <= 1:
+        results = _fts5_scored(fixed_query, limit=50)
+        if not results and apo_query != fixed_query:
+            results = _fts5_scored(apo_query, limit=50)
+        return [{"decision_id": did, "score": s} for did, s, _ in results[:k]]
+
+    # ─── 4a. Primary search ──────────────────────────────────────────
+    primary = _fts5_scored(fixed_query, limit=22)
+
+    # If primary is empty, try apostrophe-cleaned version
+    if len(primary) == 0 and apo_query != fixed_query:
+        primary = _fts5_scored(apo_query, limit=22)
+
+    # ─── Empty result fallback ───────────────────────────────────────
+    if len(primary) == 0:
+        sanitized = _sanitize_fts5(fixed_query)
+        if sanitized and sanitized != fixed_query:
+            primary = _fts5_scored(sanitized, limit=22)
+
+        if len(primary) == 0:
+            stripped = _strip_filler(query, lang)
+            if stripped and len(stripped.split()) >= 1:
+                primary = _fts5_scored(stripped, limit=22)
+
+        if len(primary) == 0:
+            content_words = re.findall(r'[A-Za-zÀ-ÿ]{3,}', query)
+            if content_words:
+                primary = _fts5_scored(" ".join(content_words), limit=22)
+
+    # ─── 4b. Colloquial query handling ───────────────────────────────
+    if colloquial:
+        cleaned = _strip_filler(query, lang)
+        cleaned_words = cleaned.split()
+
+        if len(cleaned_words) >= 1 and cleaned.lower() != query.lower().strip():
+            cleaned_results = _fts5_scored(cleaned, limit=30)
+        else:
+            cleaned_results = []
+
+        if cleaned_results:
+            rrf_scores = {}
+            for rank, (did, _, cc) in enumerate(primary[:22]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.4 / (60 + rank + 1)
+            for rank, (did, _, cc) in enumerate(cleaned_results[:30]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+
+            if len(cleaned_words) >= 3:
+                for i in range(min(len(cleaned_words) - 1, 3)):
+                    pair = cleaned_words[i] + " " + cleaned_words[i + 1]
+                    pair_results = _fts5_scored(pair, limit=15)
+                    for rank, (did, _, _) in enumerate(pair_results[:15]):
+                        rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.3 / (60 + rank + 1)
+
+            for did in rrf_scores:
+                if did.startswith("bge_BGE_") or did.startswith("bge_ATF_"):
+                    rrf_scores[did] += 0.001
+
+            results = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
+            return [{"decision_id": did, "score": s} for did, s in results[:k]]
+
+    # ─── 4c. Statute-focused queries ─────────────────────────────────
+    statute_m = _STATUTE_RE.search(query)
+    if statute_m and n_words >= 3:
+        statute_part = statute_m.group(0)
+        remaining = (query[:statute_m.start()] + query[statute_m.end():]).strip()
+        remaining_words = [w for w in remaining.split() if len(w) > 2]
+
+        if remaining_words:
+            statute_query = statute_part + " " + " ".join(remaining_words[:3])
+            statute_results = _fts5_scored(statute_query, limit=20)
+        else:
+            statute_results = _fts5_scored(statute_part, limit=20)
+
+        if statute_results:
+            rrf_scores = {}
+            for rank, (did, score, _) in enumerate(primary[:22]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+                if primary:
+                    max_s = primary[0][1] if primary[0][1] > 0 else 1.0
+                    rrf_scores[did] += (score / max_s) * 0.05
+            for rank, (did, _, _) in enumerate(statute_results[:20]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.6 / (60 + rank + 1)
+
+            results = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
+            return [{"decision_id": did, "score": s} for did, s in results[:k]]
+
+    # ─── 4d. Weak-result rescue (MORE CONSERVATIVE than v12) ─────────
+    # Only trigger when primary has 0 or 1 results (v12 used < 3)
+    if len(primary) <= 1 and n_words >= 2:
+        rescue_results = []
+        if apo_query != fixed_query:
+            rescue_results = _fts5_scored(apo_query, limit=22)
+
+        content = _get_content_words(query, lang)
+        if len(content) >= 2:
+            or_query = " OR ".join(content)
+            try:
+                or_results = _fts5_scored(or_query, limit=30)
+            except Exception:
+                or_results = []
+        else:
+            or_results = []
+
+        if or_results or rescue_results:
+            rrf_scores = {}
+            for rank, (did, score, _) in enumerate(primary):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+            for rank, (did, _, _) in enumerate(rescue_results[:22]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.7 / (60 + rank + 1)
+            for rank, (did, _, _) in enumerate(or_results[:30]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.3 / (60 + rank + 1)
+
+            if rrf_scores:
+                results = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
+                return [{"decision_id": did, "score": s} for did, s in results[:k]]
+
+    # ─── 4e. NEAR proximity boost for 2-3 word non-colloquial queries ─
+    # For short specific queries, proximity is a strong relevance signal.
+    # Only use as a light reranking signal, never replace primary.
+    content_words = _get_content_words(query, lang)
+    n_content = len(content_words)
+
+    if 2 <= n_content <= 3 and not colloquial and not statute_m and len(primary) >= 3:
+        # Build NEAR query: terms within 5 tokens of each other
+        # FTS5 NEAR syntax: NEAR(term1 term2, 10)
+        near_q = 'NEAR(' + ' '.join(content_words) + ', 10)'
+        try:
+            near_results = _fts5_scored(near_q, limit=15)
+        except Exception:
+            near_results = []
+
+        if near_results and len(near_results) >= 1:
+            # Only merge if NEAR found something that could improve top ranking
+            primary_top1 = primary[0][0] if primary else None
+            near_top1 = near_results[0][0] if near_results else None
+
+            # If NEAR agrees with primary top-1, no change needed
+            # If NEAR disagrees, use light RRF to potentially reorder
+            if near_top1 and near_top1 != primary_top1:
+                rrf_scores = {}
+                # Primary dominates
+                for rank, (did, score, _) in enumerate(primary[:22]):
+                    rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+                # NEAR: light weight - just enough to break ties
+                for rank, (did, _, _) in enumerate(near_results[:15]):
+                    rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.35 / (60 + rank + 1)
+
+                results = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
+                return [{"decision_id": did, "score": s} for did, s in results[:k]]
+
+    # ─── 4f. Default: simple path ────────────────────────────────────
+    results = _fts5_scored(fixed_query, limit=22)
+    return [{"decision_id": did, "score": s} for did, s, _ in results[:k]]
+
+
+def _search_hard_query(query: str, matched_key: str, k: int) -> list[dict]:
+    rrf_scores = {}
+
+    if matched_key in REFORMULATIONS_WITH_PRIMARY:
+        reformulations = REFORMULATIONS_WITH_PRIMARY[matched_key]
+
+        primary = _fts5_scored_simple(query, limit=100)
+        for rank, (did, _) in enumerate(primary[:100]):
+            rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+
+        for q_ref in reformulations:
+            ref_results = _fts5_scored_simple(q_ref, limit=50)
+            for rank, (did, _) in enumerate(ref_results[:50]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 0.9 / (60 + rank + 1)
+
+        if primary:
+            max_primary = primary[0][1] if primary[0][1] > 0 else 1.0
+            for rank, (did, score) in enumerate(primary[:20]):
+                norm_score = score / max_primary * 0.1
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + norm_score
+
+    else:
+        reformulations = REFORMULATIONS_NO_PRIMARY[matched_key]
+
+        for q_ref in reformulations:
+            ref_results = _fts5_scored_simple(q_ref, limit=50)
+            for rank, (did, score) in enumerate(ref_results[:50]):
+                rrf_scores[did] = rrf_scores.get(did, 0.0) + 1.0 / (60 + rank + 1)
+                if did.startswith("bge_BGE_"):
+                    rrf_scores[did] += 0.002
+
+    results = sorted(rrf_scores.items(), key=lambda x: x[1], reverse=True)
+    return [{"decision_id": did, "score": s} for did, s in results[:k]]