Day 54+: ChatGPT hallucination filter (Tier 0+2)

- /v1/verify_citations endpoint — batch corpus existence check
- chatgpt-overlay v0.4.0 — verifies every cite via 4-tier fallback:
corpus → wikisource → wikipedia → Google→court.gov.il
- Color-coded chip: 🟡 checking → 🟢 verified / 🔴 not_found
- background.js: POST support + JSON content-type + legal-eye/HF allowlist
- manifest 0.4.0: host_permissions for backend API access

tau_rag/api/fastapi_app.py

@@ -23123,6 +23123,66 @@ def judgment_reader_by_cite(cite: str):  # type: ignore
         })
 
 
+class _VerifyCitationsRequest(BaseModel):  # type: ignore
+    cites: List[str]
+
+
+@app.post("/v1/verify_citations")
+def verify_citations(body: _VerifyCitationsRequest):  # type: ignore
+    """Day 54 — bulk citation existence check, powers the ChatGPT
+    hallucination filter. For each cite, returns:
+      - status='verified_corpus' + doc_id  (found in our corpus)
+      - status='not_found_locally'         (extension should try web)
+
+    Designed to be fast: no parsing, no external fetches. Just a corpus
+    index lookup per cite. Wikisource/Wikipedia/court.gov.il are checked
+    by the extension itself (which has the helper privileges).
+    """
+    try:
+        from ..pipeline import get_pipeline
+        from ..citation_network import get_or_build
+        pipe = get_pipeline()
+        cn = get_or_build(pipe)
+
+        results = []
+        for raw_cite in (body.cites or [])[:100]:  # cap at 100 per request
+            raw = (raw_cite or "").strip()
+            if not raw:
+                results.append({"cite": raw_cite, "status": "empty"})
+                continue
+            m = _JR_CASE_RX.search(raw)
+            prefix = m.group(1).strip() if m else raw
+            candidates = [
+                prefix,
+                prefix.replace('"', '"').replace("'", "׳"),
+                prefix.replace('"', '"').replace("'", "'"),
+                _re.sub(r"\s+", "", prefix),
+            ]
+            doc_id = None
+            for c in candidates:
+                doc_id = cn.doc_for_citation.get(c)
+                if doc_id:
+                    break
+            if doc_id:
+                results.append({
+                    "cite":     raw_cite,
+                    "prefix":   prefix,
+                    "status":   "verified_corpus",
+                    "doc_id":   doc_id,
+                })
+            else:
+                results.append({
+                    "cite":     raw_cite,
+                    "prefix":   prefix,
+                    "status":   "not_found_locally",
+                })
+        return {"results": results}
+    except Exception as e:
+        return JSONResponse(status_code=500, content={
+            "ok": False, "error": f"{type(e).__name__}: {e}"
+        })
+
+
 @app.get("/v1/judgment/{doc_id:path}/render")
 def judgment_reader_render(doc_id: str):  # type: ignore
     """Day 51 — full structured render of a single judgment for the

tau_rag/chrome-extension/background.js

@@ -7,18 +7,28 @@
 // We only allow fetches to the small set of legal sites declared in
 // host_permissions — anything else gets refused.
 
-const ALLOWED_HOSTS = [
-  'www.court.gov.il',
-  'supreme.court.gov.il',
+// Allowed hosts: exact matches OR any subdomain of *.court.gov.il
+// (covers www., supreme., elyon1., labor., etc. — many famous Israeli
+// judgments live on the older elyon1 subdomain).
+const ALLOWED_EXACT = new Set([
   'www.google.com',
   'html.duckduckgo.com',
   'www.pador.co.il',
   'www.psakdin.co.il',
   'www.takdin.co.il',
   'www.lawdata.co.il',
+  'www.nlrc.gov.il',
   'he.wikipedia.org',
   'he.wikisource.org',
-];
+  // v0.4.0 — backend API access (for ChatGPT hallucination filter)
+  'legal-i-legal-eye.hf.space',
+  'legal-eye.1bigfam.com',
+]);
+function isHostAllowed(host) {
+  if (ALLOWED_EXACT.has(host)) return true;
+  if (/\.court\.gov\.il$/.test(host)) return true;
+  return false;
+}
 
 // Simple per-host rate limit: max 20 fetches/host/minute.
 // Prevents the page (or a bug) from hammering a site.
@@ -44,7 +54,7 @@ chrome.runtime.onMessage.addListener((req, _sender, sendResponse) => {
   (async () => {
     try {
       const u = new URL(req.url);
-      if (!ALLOWED_HOSTS.includes(u.hostname)) {
+      if (!isHostAllowed(u.hostname)) {
         sendResponse({ error: `host_not_allowed: ${u.hostname}` });
         return;
       }
@@ -52,15 +62,23 @@ chrome.runtime.onMessage.addListener((req, _sender, sendResponse) => {
         sendResponse({ error: 'rate_limited' });
         return;
       }
+      // v0.4.0 — support POST + custom headers/body (for the
+      // verify_citations API call). Defaults still match a real
+      // browser for HTML scraping use case.
+      const method = req.method || 'GET';
+      const isApi  = req.contentType === 'application/json';
       const r = await fetch(req.url, {
+        method,
         credentials: 'include',
         redirect: 'follow',
-        headers: {
-          // Mirror what a real user's browser would send
-          'Accept':           'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
-          'Accept-Language':  'he-IL,he;q=0.9,en;q=0.8',
-          'Cache-Control':    'no-cache',
-        },
+        headers: isApi
+          ? { 'Content-Type': 'application/json', 'Accept': 'application/json' }
+          : {
+              'Accept':           'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+              'Accept-Language':  'he-IL,he;q=0.9,en;q=0.8',
+              'Cache-Control':    'no-cache',
+            },
+        body: req.body || undefined,
       });
       const html = await r.text();
       sendResponse({

tau_rag/chrome-extension/chatgpt-overlay.js

@@ -0,0 +1,315 @@
+// Legal Eye Helper — ChatGPT overlay v0.4.0
+// ──────────────────────────────────────────────────────────────────────
+// Hallucination filter for Israeli legal citations in ChatGPT.
+//
+// For every Hebrew case citation ChatGPT produces, we verify it exists:
+//   Tier 0: backend lookup against our corpus (instant)
+//   Tier 1: Wikisource title check (fast)
+//   Tier 2: Wikipedia title check (fast)
+//   Tier 3: Google search → court.gov.il / pador / psakdin (helper)
+//
+// Color-coded result chip:
+//   🟢 verified — exists in at least one source
+//   🟡 checking — verification in flight
+//   🔴 not_found — likely a ChatGPT hallucination
+//
+// Lawyer use case: never cite a ruling to court without confirming it
+// exists. ChatGPT routinely makes up citations.
+
+(function () {
+  const LE_CITE_RE = /(?:בג"?ץ|ע"?א|ע"?פ|ע"?ע|דנ"?א|דנ"?פ|רע"?א|רע"?פ|רע"?ב|דב"?ע|בש"?א|בש"?פ|תפ"?ח|ת"?א|ה"?פ|ע"?מ|ע"?ר|בר"?ע)\s+(?:[א-ת]+\s*\/\s*\d+\s*-\s*\d+|\d+\s*[\/\-]\s*\d+(?:\s*-\s*\d+)?)/g;
+
+  const API_BASE      = 'https://legal-i-legal-eye.hf.space';
+  const LEGAL_EYE_URL = 'https://legal-eye.1bigfam.com/?cite=';
+  const MARK_CLASS    = 'legal-eye-cite-mark';
+
+  // Verification result cache (session-scoped, in-memory only).
+  // Map<cite, {status, source?}>
+  const VERIFY_CACHE = new Map();
+
+  // ── Helpers ────────────────────────────────────────────────────────
+  function alreadyMarked(node) {
+    return node?.parentElement?.closest?.('.' + MARK_CLASS);
+  }
+
+  // chrome.runtime.sendMessage Promise wrapper
+  function helperFetch(url, opts) {
+    return new Promise((resolve, reject) => {
+      try {
+        chrome.runtime.sendMessage({
+          op:           'fetch',
+          url,
+          method:       opts?.method || 'GET',
+          contentType:  opts?.contentType || null,
+          body:         opts?.body || null,
+        }, (resp) => {
+          if (chrome.runtime.lastError) {
+            reject(new Error(chrome.runtime.lastError.message));
+            return;
+          }
+          if (!resp || resp.error) {
+            reject(new Error(resp?.error || 'helper_fetch_failed'));
+            return;
+          }
+          resolve(resp);
+        });
+      } catch (e) { reject(e); }
+    });
+  }
+
+  // ── Verification chain ─────────────────────────────────────────────
+  async function verifyOne(cite) {
+    if (VERIFY_CACHE.has(cite)) return VERIFY_CACHE.get(cite);
+    let result;
+    try {
+      // Tier 0 — backend corpus check
+      const resp = await helperFetch(API_BASE + '/v1/verify_citations', {
+        method:      'POST',
+        contentType: 'application/json',
+        body:        JSON.stringify({ cites: [cite] }),
+      });
+      const data = JSON.parse(resp.html);
+      const row  = (data.results || [])[0];
+      if (row && row.status === 'verified_corpus') {
+        result = { status: 'verified', source: 'corpus', doc_id: row.doc_id };
+      }
+    } catch (e) { /* fall through */ }
+
+    if (!result) {
+      // Tier 1 — Wikisource title check (HEAD-ish: API JSON)
+      try {
+        const prefix = extractPrefix(cite);
+        const wsUrl  = 'https://he.wikisource.org/w/api.php?action=query&format=json&list=search&srsearch=' +
+                       encodeURIComponent('"' + prefix + '"') + '&srlimit=3&origin=*';
+        const wsResp = await helperFetch(wsUrl);
+        const ws     = JSON.parse(wsResp.html);
+        if (ws.query?.search?.length > 0) {
+          result = { status: 'verified', source: 'wikisource' };
+        }
+      } catch (e) { /* fall through */ }
+    }
+
+    if (!result) {
+      // Tier 2 — Wikipedia title check
+      try {
+        const prefix = extractPrefix(cite);
+        const wpUrl  = 'https://he.wikipedia.org/w/api.php?action=query&format=json&list=search&srsearch=' +
+                       encodeURIComponent('"' + prefix + '"') + '&srlimit=3&origin=*';
+        const wpResp = await helperFetch(wpUrl);
+        const wp     = JSON.parse(wpResp.html);
+        if (wp.query?.search?.length > 0) {
+          result = { status: 'verified', source: 'wikipedia' };
+        }
+      } catch (e) { /* fall through */ }
+    }
+
+    if (!result) {
+      // Tier 3 — Google search → look for court.gov.il / pador / psakdin / etc.
+      try {
+        const prefix = extractPrefix(cite);
+        const gUrl   = 'https://www.google.com/search?q=' +
+                       encodeURIComponent('"' + prefix + '"') + '&hl=he';
+        const gResp  = await helperFetch(gUrl);
+        if (gResp.html && !/sorry\/index|recaptcha|unusual traffic/i.test(gResp.html)) {
+          const HOST_RX = /(?:[a-z0-9-]+\.court\.gov\.il|www\.pador\.co\.il|www\.psakdin\.co\.il|www\.takdin\.co\.il|www\.lawdata\.co\.il|www\.nevo\.co\.il)/i;
+          // Look in Google's wrapped URLs first
+          let found = false;
+          for (const m of gResp.html.matchAll(/\/url\?q=([^&"]+)/g)) {
+            try {
+              const decoded = decodeURIComponent(m[1]);
+              if (HOST_RX.test(decoded)) { found = true; break; }
+            } catch {}
+          }
+          if (!found) {
+            for (const m of gResp.html.matchAll(/href="(https?:\/\/[^"]+)"/g)) {
+              if (HOST_RX.test(m[1])) { found = true; break; }
+            }
+          }
+          if (found) {
+            result = { status: 'verified', source: 'court_external' };
+          }
+        }
+      } catch (e) { /* fall through */ }
+    }
+
+    if (!result) {
+      result = { status: 'not_found' };
+    }
+    VERIFY_CACHE.set(cite, result);
+    return result;
+  }
+
+  function extractPrefix(cite) {
+    // Same regex as backend — the cite text WE detected already IS just the prefix
+    return cite.trim();
+  }
+
+  // ── Chip construction ──────────────────────────────────────────────
+  function buildChipFragment(text) {
+    const frag = document.createDocumentFragment();
+    let lastIdx = 0;
+    LE_CITE_RE.lastIndex = 0;
+    let m;
+    while ((m = LE_CITE_RE.exec(text)) !== null) {
+      if (m.index > lastIdx) {
+        frag.appendChild(document.createTextNode(text.slice(lastIdx, m.index)));
+      }
+      const cite = m[0];
+      const wrap = document.createElement('span');
+      wrap.className = MARK_CLASS;
+      wrap.setAttribute('dir', 'rtl');
+      wrap.dataset.cite = cite;
+      // Start in "checking" state (yellow)
+      applyChipState(wrap, { status: 'checking' }, cite);
+      frag.appendChild(wrap);
+      lastIdx = m.index + cite.length;
+      // Kick off verification (async)
+      verifyOne(cite).then(res => {
+        applyChipState(wrap, res, cite);
+      }).catch(() => {
+        applyChipState(wrap, { status: 'not_found' }, cite);
+      });
+    }
+    if (lastIdx < text.length) {
+      frag.appendChild(document.createTextNode(text.slice(lastIdx)));
+    }
+    return frag;
+  }
+
+  const STYLES = {
+    checking: {
+      bg:     'linear-gradient(135deg,#fef3c7,#fde68a)',
+      border: '#d97706',
+      ink:    '#78350f',
+      tagBg:  '#bf9b30',
+      icon:   '⏳',
+      label:  'בודק…',
+      title:  'מאמת קיום ב-corpus / Wikipedia / court.gov.il',
+    },
+    verified: {
+      bg:     'linear-gradient(135deg,#d1fae5,#a7f3d0)',
+      border: '#059669',
+      ink:    '#065f46',
+      tagBg:  '#059669',
+      icon:   '✓',
+      label:  'אומת',
+      title:  '✓ הציטוט אומת — קיים במקור משפטי',
+    },
+    not_found: {
+      bg:     'linear-gradient(135deg,#fee2e2,#fecaca)',
+      border: '#dc2626',
+      ink:    '#7f1d1d',
+      tagBg:  '#dc2626',
+      icon:   '❌',
+      label:  'לא נמצא',
+      title:  '❌ הציטוט לא נמצא בשום מקור — כנראה הלוסינציה של ChatGPT',
+    },
+  };
+
+  function applyChipState(wrap, res, cite) {
+    const state = STYLES[res.status] || STYLES.checking;
+    wrap.innerHTML = '';
+    wrap.style.cssText = [
+      'display:inline-flex',
+      'align-items:center',
+      'gap:6px',
+      'background:' + state.bg,
+      'border:1px solid ' + state.border,
+      'border-radius:6px',
+      'padding:1px 4px 1px 8px',
+      'margin:0 3px',
+      'font-weight:600',
+      'color:' + state.ink,
+      'vertical-align:baseline',
+      'white-space:nowrap',
+      'transition:background .15s,border-color .15s',
+    ].join(';');
+
+    wrap.appendChild(document.createTextNode(cite));
+
+    const tag = document.createElement('a');
+    tag.href     = LEGAL_EYE_URL + encodeURIComponent(cite);
+    tag.target   = '_blank';
+    tag.rel      = 'noopener noreferrer';
+    tag.title    = state.title +
+                   (res.source ? `\n(מקור: ${res.source})` : '') +
+                   '\nלחץ לפתיחה בלגל-אי';
+    tag.style.cssText = [
+      'text-decoration:none',
+      'background:' + state.tagBg,
+      'color:white',
+      'border-radius:4px',
+      'padding:1px 7px',
+      'font-size:0.85em',
+      'font-weight:700',
+      'line-height:1.4',
+      'transition:transform .08s,opacity .08s',
+    ].join(';');
+    tag.textContent = state.icon + ' ' + state.label;
+    tag.addEventListener('mouseenter', () => {
+      tag.style.opacity = '0.85';
+      tag.style.transform = 'translateY(-1px)';
+    });
+    tag.addEventListener('mouseleave', () => {
+      tag.style.opacity = '';
+      tag.style.transform = '';
+    });
+    wrap.appendChild(tag);
+  }
+
+  // ── DOM walker ─────────────────────────────────────────────────────
+  function processTextNode(textNode) {
+    if (alreadyMarked(textNode)) return;
+    const text = textNode.textContent;
+    if (!text || text.length < 6) return;
+    LE_CITE_RE.lastIndex = 0;
+    if (!LE_CITE_RE.test(text)) return;
+    const frag = buildChipFragment(text);
+    textNode.replaceWith(frag);
+  }
+
+  function walkAndProcess(root) {
+    if (!root || root.nodeType !== Node.ELEMENT_NODE) {
+      if (root && root.nodeType === Node.TEXT_NODE) processTextNode(root);
+      return;
+    }
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
+      acceptNode: (n) => {
+        if (alreadyMarked(n)) return NodeFilter.FILTER_REJECT;
+        if (!n.textContent || n.textContent.length < 6) return NodeFilter.FILTER_REJECT;
+        const p = n.parentElement;
+        if (!p) return NodeFilter.FILTER_REJECT;
+        const tag = p.tagName;
+        if (tag === 'SCRIPT' || tag === 'STYLE' ||
+            tag === 'TEXTAREA' || tag === 'INPUT' ||
+            p.isContentEditable) {
+          return NodeFilter.FILTER_REJECT;
+        }
+        return NodeFilter.FILTER_ACCEPT;
+      },
+    });
+    const nodes = [];
+    let n;
+    while ((n = walker.nextNode())) nodes.push(n);
+    nodes.forEach(processTextNode);
+  }
+
+  // Debounced — ChatGPT streams char-by-char, wait for settle.
+  let debounceTimer = null;
+  function scheduleProcess() {
+    if (debounceTimer) clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(() => {
+      walkAndProcess(document.body);
+    }, 400);
+  }
+
+  const observer = new MutationObserver(scheduleProcess);
+  observer.observe(document.body, {
+    childList:     true,
+    subtree:       true,
+    characterData: true,
+  });
+  setTimeout(() => walkAndProcess(document.body), 1500);
+
+  console.info('[legal-eye] ChatGPT overlay v0.4.0 — hallucination filter active');
+})();

tau_rag/chrome-extension/content.js

@@ -11,12 +11,22 @@
 //   PAGE   ← { type: 'LE_HELPER_READY', version }   (announces presence on load)
 
 (function () {
-  const VERSION = '0.1.0';
+  const VERSION = '0.2.1';
 
   window.addEventListener('message', async (e) => {
     if (e.source !== window) return;
     const msg = e.data;
-    if (!msg || msg.type !== 'LE_HELPER_FETCH') return;
+    if (!msg) return;
+
+    // v0.2.1 — page can probe us with PING; we respond with READY.
+    // Fixes timing issue where READY announce fired before page set up
+    // its listener (e.g. on install-instructions page).
+    if (msg.type === 'LE_HELPER_PING') {
+      announce();
+      return;
+    }
+
+    if (msg.type !== 'LE_HELPER_FETCH') return;
     const { id, url } = msg;
     if (!id || !url) return;
 

tau_rag/chrome-extension/manifest.json

@@ -1,20 +1,21 @@
 {
   "manifest_version": 3,
   "name": "Legal Eye Helper",
-  "version": "0.1.0",
+  "version": "0.4.0",
   "description": "מאפשר ל-Legal Eye לטעון פסקי-דין ישירות מאתרי הפסיקה (בית-המשפט, ויקיטקסט, וכו'). דורש הסכמה מפורשת לכל בקשה.",
-  "default_locale": "he",
   "host_permissions": [
-    "https://www.court.gov.il/*",
-    "https://supreme.court.gov.il/*",
+    "https://*.court.gov.il/*",
     "https://www.google.com/*",
     "https://html.duckduckgo.com/*",
     "https://www.pador.co.il/*",
     "https://www.psakdin.co.il/*",
     "https://www.takdin.co.il/*",
     "https://www.lawdata.co.il/*",
+    "https://www.nlrc.gov.il/*",
     "https://he.wikipedia.org/*",
-    "https://he.wikisource.org/*"
+    "https://he.wikisource.org/*",
+    "https://legal-i-legal-eye.hf.space/*",
+    "https://legal-eye.1bigfam.com/*"
   ],
   "permissions": ["storage"],
   "content_scripts": [{
@@ -24,6 +25,13 @@
     ],
     "js": ["content.js"],
     "run_at": "document_start"
+  }, {
+    "matches": [
+      "https://chatgpt.com/*",
+      "https://chat.openai.com/*"
+    ],
+    "js": ["chatgpt-overlay.js"],
+    "run_at": "document_idle"
   }],
   "background": {
     "service_worker": "background.js"