nexo-brain 2.0.0 → 2.2.0

package/src/scripts/nexo-immune.py

@@ -901,30 +901,17 @@ Raw findings:
 Write the report. Be concise — max 40 lines."""
 
     print("\n[TRIAGE] Running CLI interpretation...")
-
-    # Verify Claude CLI is authenticated before calling
-    try:
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            print("[TRIAGE] Claude CLI not available or not authenticated. Skipping triage.")
-            return
-    except Exception:
-        print("[TRIAGE] Claude CLI check failed. Skipping triage.")
-        return
-
     env = os.environ.copy()
+    env["NEXO_HEADLESS"] = "1"  # Skip stop hook post-mortem
     env.pop("CLAUDECODE", None)
     env.pop("CLAUDE_CODE", None)
 
     try:
         result = subprocess.run(
             [str(CLAUDE_CLI), "-p", prompt, "--model", "opus",
-             "--output-format", "text", "--bare",
-             "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-            capture_output=True, text=True, timeout=120, env=env
+             "--output-format", "text",
+             "--allowedTools", "Read,Write,Edit,Glob,Grep,Bash,mcp__nexo__*"],
+            capture_output=True, text=True, timeout=21600, env=env
         )
         if result.returncode == 0:
             print(f"[TRIAGE] Report written to {triage_file}")

package/src/scripts/nexo-inbox-hook 2.sh

@@ -0,0 +1,74 @@
+#!/bin/bash
+# nexo-inbox-hook.sh — PostToolUse: automatic inter-terminal inbox check (D+)
+#
+# Zero output when no messages = zero tokens consumed in Claude's context.
+# Reads SQLite directly (no MCP overhead). Write-only: INSERT OR IGNORE for mark-as-read.
+# Debounce: skips if last check was <2 seconds ago.
+
+INPUT=$(cat)
+
+# 1. Skip read-only tools (same logic as capture-tool-logs.sh)
+TOOL_NAME=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('tool_name',''))" 2>/dev/null)
+case "$TOOL_NAME" in
+    Read|Grep|Glob|LS|Skill|ToolSearch|Agent) exit 0 ;;
+esac
+
+# 2. Extract Claude Code session_id
+CLAUDE_SID=$(echo "$INPUT" | python3 -c "import sys,json; print(json.load(sys.stdin).get('session_id',''))" 2>/dev/null)
+[ -z "$CLAUDE_SID" ] && exit 0
+
+# 3. Debounce: skip if last check <2s ago
+DEBOUNCE_FILE="/tmp/nexo-inbox-ts-${CLAUDE_SID}"
+NOW=$(date +%s)
+LAST=$(cat "$DEBOUNCE_FILE" 2>/dev/null || echo 0)
+DIFF=$((NOW - LAST))
+[ "$DIFF" -lt 2 ] && exit 0
+echo "$NOW" > "$DEBOUNCE_FILE"
+
+# 4. Find NEXO SID mapped to this Claude session_id
+NEXO_HOME="${NEXO_HOME:-$HOME/.nexo}"
+DB="$NEXO_HOME/data/nexo.db"
+[ -f "$DB" ] || exit 0
+
+NEXO_SID=$(sqlite3 "$DB" "SELECT sid FROM sessions WHERE claude_session_id = '${CLAUDE_SID}' AND last_update_epoch > (strftime('%s','now') - 900) ORDER BY last_update_epoch DESC LIMIT 1;" 2>/dev/null)
+[ -z "$NEXO_SID" ] && exit 0
+
+# 5. Check inbox — messages addressed to this session or broadcast
+MESSAGES=$(sqlite3 -separator '|' "$DB" "
+    SELECT m.id, m.from_sid, m.text FROM messages m
+    WHERE (m.to_sid = 'all' OR m.to_sid = '${NEXO_SID}')
+    AND m.from_sid != '${NEXO_SID}'
+    AND m.id NOT IN (SELECT message_id FROM message_reads WHERE sid = '${NEXO_SID}')
+    LIMIT 5;
+" 2>/dev/null)
+
+# 6. Check pending questions
+QUESTIONS=$(sqlite3 -separator '|' "$DB" "
+    SELECT qid, from_sid, question FROM questions
+    WHERE to_sid = '${NEXO_SID}' AND answer IS NULL
+    LIMIT 3;
+" 2>/dev/null)
+
+# 7. If empty → silent exit (0 tokens consumed)
+[ -z "$MESSAGES" ] && [ -z "$QUESTIONS" ] && exit 0
+
+# 8. Format and output (injected into Claude's context)
+echo ""
+echo "📨 INTER-TERMINAL MESSAGE (auto-detected):"
+
+if [ -n "$MESSAGES" ]; then
+    echo "$MESSAGES" | while IFS='|' read -r mid from text; do
+        echo "  [$from]: $text"
+        # Mark as read (lightweight INSERT, WAL mode, no lock contention)
+        sqlite3 "$DB" "INSERT OR IGNORE INTO message_reads (message_id, sid) VALUES ('${mid}', '${NEXO_SID}');" 2>/dev/null
+    done
+fi
+
+if [ -n "$QUESTIONS" ]; then
+    echo "  ⚠ PREGUNTAS de otra terminal — responder con nexo_answer:"
+    echo "$QUESTIONS" | while IFS='|' read -r qid from question; do
+        echo "  Q[$qid] de [$from]: $question"
+    done
+fi
+
+exit 0

package/src/scripts/nexo-install 2.py

@@ -0,0 +1,6 @@
+#!/usr/bin/env python3
+"""DEPRECATED: Use 'npx nexo-brain' instead. This installer is no longer maintained."""
+import sys
+print("This installer is deprecated. Please use: npx nexo-brain")
+print("See: https://github.com/wazionapps/nexo#installation")
+sys.exit(1)

package/src/scripts/nexo-learning-housekeep 2.py

@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""NEXO Learning Housekeeping — Nightly dedup, weight adjustment, and review.
+
+Runs daily. Adjusts learning weights based on usage (guard_hits),
+detects duplicates via semantic similarity, and archives stale learnings.
+"""
+
+import json
+import os
+import sqlite3
+import sys
+import time
+from datetime import datetime, timedelta
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+# Auto-detect: if running from repo (src/scripts/), use src/ as NEXO_CODE
+_script_dir = Path(__file__).resolve().parent
+_repo_src = _script_dir.parent  # src/scripts/ -> src/
+NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(_repo_src) if (_repo_src / "server.py").exists() else str(NEXO_HOME)))
+
+sys.path.insert(0, str(NEXO_CODE))
+
+DB_PATH = NEXO_HOME / "data" / "nexo.db"
+STATE_FILE = NEXO_HOME / "operations" / ".catchup-state.json"
+
+# Weight adjustment rates
+GUARD_HIT_BOOST = 0.02       # per guard hit since last run
+DECAY_RATE = 0.005            # daily decay for unused learnings
+MIN_WEIGHT = 0.05
+MAX_WEIGHT = 1.0
+DEDUP_THRESHOLD = 0.85        # cosine similarity for duplicate detection
+ARCHIVE_AFTER_DAYS = 90       # archive if weight < 0.1 and no hits in this many days
+
+
+def get_db():
+    conn = sqlite3.connect(str(DB_PATH))
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def update_catchup_state():
+    try:
+        state = json.loads(STATE_FILE.read_text()) if STATE_FILE.exists() else {}
+    except Exception:
+        state = {}
+    state["learning-housekeep"] = datetime.now().isoformat()
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(state, indent=2))
+
+
+def adjust_weights(conn):
+    """Boost weight for frequently-used learnings, decay unused ones."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    now = time.time()
+    one_day_ago = now - 86400
+
+    learnings = conn.execute(
+        "SELECT id, weight, guard_hits, last_guard_hit_at, priority, created_at "
+        "FROM learnings WHERE status = 'active'"
+    ).fetchall()
+
+    adjusted = 0
+    for l in learnings:
+        old_weight = l["weight"] or 0.5
+        hits = l["guard_hits"] or 0
+        last_hit = l["last_guard_hit_at"] or 0
+        priority = l["priority"] or "medium"
+
+        # Priority floor — critical learnings never drop below 0.5
+        priority_floor = {"critical": 0.5, "high": 0.3, "medium": 0.1, "low": 0.05}[priority]
+
+        new_weight = old_weight
+
+        if last_hit > one_day_ago:
+            # Recent guard hit — boost
+            recent_hits = 1  # Simplified: at least 1 hit today
+            new_weight = min(MAX_WEIGHT, old_weight + (GUARD_HIT_BOOST * recent_hits))
+        else:
+            # No recent hits — decay
+            new_weight = max(priority_floor, old_weight - DECAY_RATE)
+
+        new_weight = max(MIN_WEIGHT, min(MAX_WEIGHT, new_weight))
+
+        if abs(new_weight - old_weight) > 0.001:
+            conn.execute("UPDATE learnings SET weight = ? WHERE id = ?", (round(new_weight, 4), l["id"]))
+            adjusted += 1
+
+    conn.commit()
+    print(f"[{ts}] Weight adjustment: {adjusted}/{len(learnings)} learnings adjusted")
+    return adjusted
+
+
+def auto_prioritize(conn):
+    """Auto-upgrade priority based on guard hits and repetitions."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+
+    # Learnings with 10+ guard hits that are still medium → upgrade to high
+    upgraded = conn.execute(
+        "UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7) "
+        "WHERE status = 'active' AND priority = 'medium' AND guard_hits >= 10"
+    ).rowcount
+
+    # Learnings with repetitions (same error happened again) → upgrade to high
+    repeated = conn.execute(
+        """UPDATE learnings SET priority = 'high', weight = MAX(weight, 0.7)
+           WHERE status = 'active' AND priority IN ('medium', 'low')
+           AND id IN (SELECT original_learning_id FROM error_repetitions)"""
+    ).rowcount
+
+    conn.commit()
+    total = upgraded + repeated
+    if total > 0:
+        print(f"[{ts}] Auto-prioritize: {upgraded} by guard_hits, {repeated} by repetitions")
+    return total
+
+
+def detect_duplicates(conn):
+    """Find semantically similar learnings using fastembed."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    try:
+        from fastembed import TextEmbedding
+        import numpy as np
+    except ImportError:
+        print(f"[{ts}] Dedup skipped: fastembed not available")
+        return []
+
+    learnings = conn.execute(
+        "SELECT id, title, content, weight, guard_hits FROM learnings WHERE status = 'active'"
+    ).fetchall()
+
+    if len(learnings) < 2:
+        return []
+
+    model = TextEmbedding("BAAI/bge-base-en-v1.5")
+    texts = [f"{l['title']}: {l['content'][:300]}" for l in learnings]
+    embeddings = list(model.embed(texts))
+    embeddings = np.array(embeddings)
+
+    # Normalize
+    norms = np.linalg.norm(embeddings, axis=1, keepdims=True)
+    norms[norms == 0] = 1
+    embeddings = embeddings / norms
+
+    duplicates = []
+    for i in range(len(learnings)):
+        for j in range(i + 1, len(learnings)):
+            sim = float(np.dot(embeddings[i], embeddings[j]))
+            if sim >= DEDUP_THRESHOLD:
+                # Keep the one with higher weight/hits
+                a, b = learnings[i], learnings[j]
+                score_a = (a["weight"] or 0.5) + (a["guard_hits"] or 0) * 0.01
+                score_b = (b["weight"] or 0.5) + (b["guard_hits"] or 0) * 0.01
+                keep, drop = (a, b) if score_a >= score_b else (b, a)
+                duplicates.append({
+                    "keep_id": keep["id"], "keep_title": keep["title"],
+                    "drop_id": drop["id"], "drop_title": drop["title"],
+                    "similarity": round(sim, 3)
+                })
+
+    if duplicates:
+        print(f"[{ts}] Duplicates found: {len(duplicates)} pairs (>= {DEDUP_THRESHOLD})")
+        for d in duplicates[:10]:
+            print(f"[{ts}]   [{d['similarity']}] keep #{d['keep_id']} '{d['keep_title'][:40]}', archive #{d['drop_id']} '{d['drop_title'][:40]}'")
+            # Archive the duplicate (don't delete — just mark inactive)
+            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (d["drop_id"],))
+        conn.commit()
+    else:
+        print(f"[{ts}] No duplicates found ({len(learnings)} learnings scanned)")
+
+    return duplicates
+
+
+def archive_stale(conn):
+    """Archive learnings with very low weight and no recent guard hits."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    cutoff = time.time() - (ARCHIVE_AFTER_DAYS * 86400)
+
+    stale = conn.execute(
+        "SELECT id, title, weight, last_guard_hit_at FROM learnings "
+        "WHERE status = 'active' AND weight < 0.1 AND priority NOT IN ('critical', 'high') "
+        "AND (last_guard_hit_at IS NULL OR last_guard_hit_at < ?)",
+        (cutoff,)
+    ).fetchall()
+
+    if stale:
+        for s in stale:
+            conn.execute("UPDATE learnings SET status = 'archived' WHERE id = ?", (s["id"],))
+            print(f"[{ts}]   Archived #{s['id']} '{s['title'][:50]}' (weight={s['weight']:.2f})")
+        conn.commit()
+        print(f"[{ts}] Archived {len(stale)} stale learnings")
+    else:
+        print(f"[{ts}] No stale learnings to archive")
+
+    return len(stale)
+
+
+def print_summary(conn):
+    """Print summary stats."""
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    stats = conn.execute(
+        """SELECT
+            COUNT(*) as total,
+            SUM(CASE WHEN status = 'active' THEN 1 ELSE 0 END) as active,
+            SUM(CASE WHEN status = 'archived' THEN 1 ELSE 0 END) as archived,
+            SUM(CASE WHEN priority = 'critical' THEN 1 ELSE 0 END) as critical,
+            SUM(CASE WHEN priority = 'high' THEN 1 ELSE 0 END) as high,
+            SUM(CASE WHEN priority = 'medium' THEN 1 ELSE 0 END) as medium,
+            SUM(CASE WHEN priority = 'low' THEN 1 ELSE 0 END) as low,
+            printf('%.2f', AVG(CASE WHEN status = 'active' THEN weight END)) as avg_weight
+        FROM learnings"""
+    ).fetchone()
+    print(f"[{ts}] Summary: {stats['active']} active, {stats['archived']} archived | "
+          f"Priority: {stats['critical']}C {stats['high']}H {stats['medium']}M {stats['low']}L | "
+          f"Avg weight: {stats['avg_weight']}")
+
+
+def main():
+    ts = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    print(f"[{ts}] Learning housekeeping starting...")
+
+    conn = get_db()
+
+    # 1. Adjust weights based on usage
+    adjust_weights(conn)
+
+    # 2. Auto-prioritize based on guard hits and repetitions
+    auto_prioritize(conn)
+
+    # 3. Detect and archive duplicates
+    detect_duplicates(conn)
+
+    # 4. Archive stale learnings
+    archive_stale(conn)
+
+    # 5. Summary
+    print_summary(conn)
+
+    conn.close()
+    update_catchup_state()
+    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] Done.")
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-learning-validator 2.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+NEXO Learning Validator — Cross-checks findings against existing learnings.
+
+Wrapper collects the finding + all learnings from SQLite, then passes
+to Claude CLI (opus) to make an intelligent determination of whether
+the finding is known, related, or genuinely new.
+
+Usage as CLI:
+    python3 nexo-learning-validator.py "finding text to validate"
+    python3 nexo-learning-validator.py --category project "finding text"
+
+Usage as library:
+    from nexo_learning_validator import validate_finding
+    result = validate_finding("CRITICAL: message_id column is NULL")
+    if result["known"]:
+        print(f"Already known: {result['matching_learnings']}")
+
+Exit codes:
+    0 = Finding is NEW (not known)
+    1 = Finding is KNOWN (matches existing learning)
+"""
+
+import json
+import os
+import sqlite3
+import subprocess
+import sys
+from pathlib import Path
+
+NEXO_HOME = Path(os.environ.get("NEXO_HOME", str(Path.home() / ".nexo")))
+
+NEXO_DB = NEXO_HOME / "data" / "nexo.db"
+CLAUDE_CLI = Path.home() / ".local" / "bin" / "claude"
+
+
+def get_all_learnings(category: str = None) -> list[dict]:
+    """Fetch all learnings from nexo.db."""
+    conn = sqlite3.connect(str(NEXO_DB), timeout=10)
+    conn.row_factory = sqlite3.Row
+    if category:
+        rows = conn.execute(
+            "SELECT id, category, title, content FROM learnings WHERE category = ?",
+            (category,)
+        ).fetchall()
+    else:
+        rows = conn.execute(
+            "SELECT id, category, title, content FROM learnings"
+        ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def validate_finding(finding: str, category: str = None) -> dict:
+    """
+    Validate a finding against existing learnings using Claude CLI.
+
+    Returns:
+        {
+            "known": bool,
+            "confidence": float (0-1),
+            "matching_learnings": [{"id": int, "title": str, "similarity": float}],
+            "recommendation": str
+        }
+    """
+    learnings = get_all_learnings(category)
+
+    if not learnings:
+        return {
+            "known": False,
+            "confidence": 0,
+            "matching_learnings": [],
+            "recommendation": "No learnings in DB — finding is new by default"
+        }
+
+    # Build compact learnings reference for CLI
+    learnings_ref = []
+    for l in learnings:
+        learnings_ref.append({
+            "id": l["id"],
+            "cat": l["category"],
+            "title": l["title"],
+            "content": (l["content"] or "")[:300],
+        })
+
+    prompt = f"""You are a finding deduplication engine. Compare a new finding against existing learnings and determine if it's already known.
+
+NEW FINDING:
+{finding}
+
+EXISTING LEARNINGS ({len(learnings_ref)} total):
+{json.dumps(learnings_ref, indent=1)}
+
+Respond with ONLY valid JSON (no markdown, no code fences):
+{{
+  "known": true/false,
+  "confidence": 0.0-1.0,
+  "matching_learnings": [
+    {{"id": <learning_id>, "title": "<title>", "similarity": 0.0-1.0}}
+  ],
+  "recommendation": "<one line: KNOWN/LIKELY KNOWN/POSSIBLY RELATED/NEW>"
+}}
+
+Rules:
+- confidence >= 0.7 and same root cause = known: true
+- confidence 0.55-0.7 and related topic = known: true, say LIKELY KNOWN
+- confidence < 0.55 = known: false
+- Max 5 matching_learnings, sorted by similarity descending
+- If the finding describes the SAME bug/issue/pattern as a learning, it's known even if worded differently
+- Be strict: different symptoms of different bugs are NOT the same even if they mention the same file"""
+
+    # Try CLI first, fall back to mechanical similarity
+    if CLAUDE_CLI.exists():
+    # Fallback: mechanical SequenceMatcher (original logic)
+    return _mechanical_validate(finding, learnings)
+
+
+def _mechanical_validate(finding: str, learnings: list[dict]) -> dict:
+    """Fallback validation using SequenceMatcher when CLI is unavailable."""
+    from difflib import SequenceMatcher
+
+    threshold = 0.45
+    finding_kw = _extract_keywords(finding)
+    matches = []
+
+    for learning in learnings:
+        title_sim = SequenceMatcher(None, finding.lower(), learning["title"].lower()).ratio()
+        content_sim = SequenceMatcher(None, finding.lower(), (learning["content"] or "").lower()).ratio()
+
+        learning_text = f"{learning['title']} {learning['content'] or ''}"
+        learning_kw = _extract_keywords(learning_text)
+        kw_overlap = len(finding_kw & learning_kw) / len(finding_kw) if finding_kw and learning_kw else 0
+
+        combined = max(title_sim, content_sim) * 0.6 + kw_overlap * 0.4
+
+        if combined >= threshold:
+            matches.append({
+                "id": learning["id"],
+                "category": learning["category"],
+                "title": learning["title"],
+                "similarity": round(combined, 3),
+            })
+
+    matches.sort(key=lambda x: x["similarity"], reverse=True)
+    top = matches[:5]
+
+    if not top:
+        return {"known": False, "confidence": 0, "matching_learnings": [], "recommendation": "NEW finding"}
+
+    best = top[0]["similarity"]
+    if best >= 0.7:
+        return {"known": True, "confidence": best, "matching_learnings": top,
+                "recommendation": f"KNOWN issue (learning #{top[0]['id']})"}
+    elif best >= 0.55:
+        return {"known": True, "confidence": best, "matching_learnings": top,
+                "recommendation": f"LIKELY KNOWN (learning #{top[0]['id']})"}
+    else:
+        return {"known": False, "confidence": best, "matching_learnings": top,
+                "recommendation": "POSSIBLY RELATED but different enough to report"}
+
+
+def _extract_keywords(text: str) -> set:
+    """Extract meaningful keywords from text."""
+    stop_words = {
+        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+        'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+        'should', 'may', 'might', 'must', 'shall', 'can', 'need', 'dare',
+        'to', 'of', 'in', 'for', 'on', 'with', 'at', 'by', 'from', 'as',
+        'and', 'but', 'or', 'nor', 'not', 'so', 'yet', 'both', 'either',
+        'error', 'critical', 'warning', 'bug', 'issue', 'problem', 'fix',
+        'el', 'la', 'los', 'las', 'un', 'una', 'de', 'en', 'que', 'por',
+    }
+    words = set()
+    for word in text.lower().split():
+        clean = ''.join(c for c in word if c.isalnum() or c == '_')
+        if clean and len(clean) > 2 and clean not in stop_words:
+            words.add(clean)
+    return words
+
+
+def main():
+    import argparse
+    parser = argparse.ArgumentParser(description="Validate findings against existing NEXO learnings")
+    parser.add_argument("finding", help="The finding text to validate")
+    parser.add_argument("--category", "-c", help="Filter learnings by category")
+    parser.add_argument("--json", "-j", action="store_true", help="Output as JSON")
+    args = parser.parse_args()
+
+    result = validate_finding(args.finding, args.category)
+
+    if args.json:
+        print(json.dumps(result, indent=2))
+    else:
+        status = "KNOWN" if result["known"] else "NEW"
+        print(f"Status: {status} (confidence: {result['confidence']:.0%})")
+        print(f"Recommendation: {result['recommendation']}")
+        if result["matching_learnings"]:
+            print(f"Related learnings:")
+            for m in result["matching_learnings"]:
+                cat = m.get('category', '?')
+                print(f"  #{m['id']} [{cat}] {m['title']} ({m['similarity']:.0%})")
+
+    sys.exit(1 if result["known"] else 0)
+
+
+if __name__ == "__main__":
+    main()

package/src/scripts/nexo-learning-validator.py

@@ -111,35 +111,6 @@ Rules:
 
     # Try CLI first, fall back to mechanical similarity
     if CLAUDE_CLI.exists():
-        auth_check = subprocess.run(
-            [str(CLAUDE_CLI), "-p", "Reply with exactly: ok", "--bare", "--output-format", "text", "--model", "haiku"],
-            capture_output=True, text=True, timeout=15
-        )
-        if auth_check.returncode != 0:
-            # CLI not authenticated, skip gracefully
-            return {"known": False, "confidence": 0, "recommendation": "CLI not authenticated — skipped validation", "matching_learnings": []}
-
-        env = os.environ.copy()
-        env.pop("CLAUDECODE", None)
-        env.pop("CLAUDE_CODE", None)
-
-        try:
-            result = subprocess.run(
-                [str(CLAUDE_CLI), "-p", prompt, "--model", "opus", "--output-format", "text", "--bare",
-                 "--allowedTools", "Read,Write,Edit,Glob,Grep"],
-                capture_output=True, text=True, timeout=60, env=env
-            )
-            if result.returncode == 0:
-                text = result.stdout.strip()
-                # Strip markdown fences if present
-                if "```json" in text:
-                    text = text.split("```json")[1].split("```")[0]
-                elif "```" in text:
-                    text = text.split("```")[1].split("```")[0]
-                return json.loads(text.strip())
-        except (subprocess.TimeoutExpired, json.JSONDecodeError, Exception):
-            pass  # Fall through to mechanical fallback
-
     # Fallback: mechanical SequenceMatcher (original logic)
     return _mechanical_validate(finding, learnings)