614 lines
27 KiB
Markdown
614 lines
27 KiB
Markdown
# FU-2a: Idempotent Ingest + Write-Time Normalization + `searchable` Flag — Implementation Plan
|
|
|
|
> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
|
|
|
|
**Goal:** Make ingest idempotent (`ON CONFLICT` upsert), normalize identifiers at the write boundary (type-aware), and add a materialized `searchable` flag — all forward-only, no identifier migration.
|
|
|
|
**Architecture:** Pure-code + one schema-additive migration (V21) in `db.py`. The two `create_*_case_law` functions move from app-level SELECT-then-INSERT/UPDATE to atomic `INSERT … ON CONFLICT … DO UPDATE` against the existing V15 partial unique indexes (predicate repeated). A new `_canonical_case_number` normalizes at write for identifier-keyed corpora (internal/cases), not for external (citation is its id). A new `searchable` boolean is recomputed from the completeness contract on ingest/metadata completion; the search-layer filter is gated behind a dry-run.
|
|
|
|
**Tech Stack:** Python 3.12, asyncpg, PostgreSQL (pgvector) at localhost:5433, pytest offline, local `.venv` at `mcp-server/.venv`.
|
|
|
|
**Spec:** [docs/superpowers/specs/2026-05-30-fu2a-idempotent-ingest-design.md](../specs/2026-05-30-fu2a-idempotent-ingest-design.md)
|
|
|
|
**Run tests:** `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/test_idempotent_ingest.py -v`
|
|
**DB smoke (real Postgres):** source `~/.env`, connect to `localhost:5433` db `legal_ai` (see Task 6).
|
|
|
|
---
|
|
|
|
## File Structure
|
|
|
|
- **Modify** `mcp-server/src/legal_mcp/services/db.py`:
|
|
- add `_canonical_case_number(s)` (pure) near `_normalize_case_number` (~line 1196).
|
|
- add pure `_compute_searchable(row, has_embedded_chunk)` + async `recompute_searchable(...)`.
|
|
- add `SCHEMA_V21_SQL` (after V20, ~line 1094) + wire into `_run_schema_migrations` (~line 1119).
|
|
- normalize at write in `create_case`, `create_internal_committee_decision` (NOT `create_external_case_law`).
|
|
- convert `create_external_case_law` + `create_internal_committee_decision` to `ON CONFLICT … DO UPDATE`.
|
|
- **Modify** `mcp-server/src/legal_mcp/services/ingest.py`: call `db.recompute_searchable(case_law_id)` after statuses are set (uniform, both types).
|
|
- **Modify** the search layer (`services/hybrid_search.py` and/or `db.py` search functions) — gated `searchable = true` filter (Task 6, only if dry-run is clean).
|
|
- **Create** `mcp-server/tests/test_idempotent_ingest.py` — offline tests for the pure pieces + ingest wiring.
|
|
|
|
**Unchanged:** public signatures of `ingest_precedent`/`ingest_internal_decision` (FU-1) and the DB-create parameter lists. Normalization/upsert live inside the write boundary.
|
|
|
|
---
|
|
|
|
## Task 1: Failing tests (pure logic + ingest wiring)
|
|
|
|
**Files:** Create `mcp-server/tests/test_idempotent_ingest.py`
|
|
|
|
- [ ] **Step 1: Write the failing tests**
|
|
|
|
```python
|
|
"""FU-2a: idempotent ingest + write-time normalization + searchable flag.
|
|
|
|
Offline tests for the *pure* pieces (canonical normalization, completeness
|
|
predicate) and ingest wiring. The real ON CONFLICT upsert is verified by a
|
|
DB smoke test against localhost:5433 (see plan Task 6), since it requires a
|
|
live Postgres partial unique index.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
from legal_mcp.services import db, ingest
|
|
|
|
|
|
def _run(coro):
|
|
return asyncio.run(coro)
|
|
|
|
|
|
# ── GAP-06: canonical normalization (pure, deterministic) ──────────────
|
|
@pytest.mark.parametrize("raw,expected", [
|
|
("ערר 8137/24", "8137-24"),
|
|
(" עע\"מ 1/20 ", "1-20"),
|
|
("8126-03-25", "8126-03-25"), # month segment preserved
|
|
("בל\"מ 1010-01-25", "1010-01-25"),
|
|
("8047/23", "8047-23"),
|
|
])
|
|
def test_canonical_case_number(raw, expected):
|
|
assert db._canonical_case_number(raw) == expected
|
|
|
|
|
|
def test_canonical_does_not_invent_month():
|
|
# No month in input → none added (X1 §1).
|
|
assert db._canonical_case_number("8126/24") == "8126-24"
|
|
|
|
|
|
# ── GAP-13: completeness predicate (pure) ──────────────────────────────
|
|
def _complete_row():
|
|
return {
|
|
"case_number": "8047-23", "case_name": "פלוני נ' הוועדה",
|
|
"practice_area": "rishuy_uvniya", "source_kind": "internal_committee",
|
|
"extraction_status": "completed", "headnote": "תקציר",
|
|
"summary": "", "subject_tags": [],
|
|
}
|
|
|
|
|
|
def test_compute_searchable_true_when_complete():
|
|
assert db._compute_searchable(_complete_row(), has_embedded_chunk=True) is True
|
|
|
|
|
|
def test_compute_searchable_false_without_embedded_chunk():
|
|
assert db._compute_searchable(_complete_row(), has_embedded_chunk=False) is False
|
|
|
|
|
|
def test_compute_searchable_false_without_metadata():
|
|
row = _complete_row()
|
|
row["headnote"] = ""; row["summary"] = ""; row["subject_tags"] = []
|
|
assert db._compute_searchable(row, has_embedded_chunk=True) is False
|
|
|
|
|
|
def test_compute_searchable_false_when_extraction_incomplete():
|
|
row = _complete_row(); row["extraction_status"] = "pending"
|
|
assert db._compute_searchable(row, has_embedded_chunk=True) is False
|
|
|
|
|
|
def test_compute_searchable_false_without_core_fields():
|
|
row = _complete_row(); row["practice_area"] = ""
|
|
assert db._compute_searchable(row, has_embedded_chunk=True) is False
|
|
|
|
|
|
# ── ingest wires in recompute_searchable (both types) ──────────────────
|
|
def test_ingest_calls_recompute_searchable(monkeypatch, tmp_path):
|
|
calls = {"recompute": [], "meta": [], "hal": []}
|
|
|
|
async def _extract_text(path): return ("text", 1, [0])
|
|
monkeypatch.setattr(ingest.extractor, "extract_text", _extract_text)
|
|
monkeypatch.setattr(ingest.extractor, "strip_nevo_preamble", lambda t: t)
|
|
monkeypatch.setattr(ingest.chunker, "chunk_document",
|
|
lambda t, page_offsets=None: [type("C", (), {
|
|
"chunk_index": 0, "content": "c", "section_type": "b",
|
|
"page_number": 1})()])
|
|
|
|
async def _embed(texts, input_type="document"): return [[0.0] * 8 for _ in texts]
|
|
monkeypatch.setattr(ingest.embeddings, "embed_texts", _embed)
|
|
|
|
async def _store(cid, dicts): return len(dicts)
|
|
monkeypatch.setattr(ingest.db, "store_precedent_chunks", _store)
|
|
|
|
async def _create_internal(**kw): return {"id": uuid4()}
|
|
monkeypatch.setattr(ingest.db, "create_internal_committee_decision", _create_internal)
|
|
|
|
async def _noop(*a, **k): return None
|
|
monkeypatch.setattr(ingest.db, "set_case_law_extraction_status", _noop)
|
|
monkeypatch.setattr(ingest.db, "set_case_law_halacha_status", _noop)
|
|
monkeypatch.setattr(ingest.db, "request_metadata_extraction",
|
|
lambda cid: calls["meta"].append(cid) or _noop())
|
|
monkeypatch.setattr(ingest.db, "request_halacha_extraction",
|
|
lambda cid: calls["hal"].append(cid) or _noop())
|
|
|
|
async def _recompute(cid): calls["recompute"].append(cid)
|
|
monkeypatch.setattr(ingest.db, "recompute_searchable", _recompute)
|
|
monkeypatch.setattr(ingest.config, "PARENT_DOC_RETRIEVAL_ENABLED", False)
|
|
monkeypatch.setattr(ingest.config, "MULTIMODAL_ENABLED", False)
|
|
|
|
from legal_mcp.services import internal_decisions
|
|
_run(internal_decisions.ingest_internal_decision(
|
|
case_number="8047/23", text="t", chair_name="x", practice_area="rishuy_uvniya"))
|
|
assert len(calls["recompute"]) == 1, "ingest must recompute searchable after success"
|
|
```
|
|
|
|
- [ ] **Step 2: Run to verify failure**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/test_idempotent_ingest.py -v`
|
|
Expected: FAIL — `AttributeError: module 'legal_mcp.services.db' has no attribute '_canonical_case_number'` (and `_compute_searchable`, `recompute_searchable`).
|
|
|
|
- [ ] **Step 3: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add mcp-server/tests/test_idempotent_ingest.py
|
|
git commit -m "test(ingest): failing tests for idempotent ingest + searchable (FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 2: `_canonical_case_number` + write-time normalization
|
|
|
|
**Files:** Modify `mcp-server/src/legal_mcp/services/db.py`
|
|
|
|
- [ ] **Step 1: Add `_canonical_case_number` next to `_normalize_case_number` (~line 1212)**
|
|
|
|
```python
|
|
def _canonical_case_number(s: str) -> str:
|
|
"""Canonical write-time form per X1 §1: trim · prefix-strip · '/'→'-'.
|
|
|
|
Deterministic and format-only — does NOT add or remove a month segment.
|
|
Used at the write boundary for identifier-keyed corpora (internal
|
|
committee decisions, active cases). NOT for external precedents, whose
|
|
canonical identifier is the full citation.
|
|
"""
|
|
s = (s or "").strip()
|
|
m = re.search(r"\d", s)
|
|
if m:
|
|
s = s[m.start():]
|
|
return s.strip().replace("/", "-")
|
|
```
|
|
|
|
- [ ] **Step 2: Normalize at write in `create_case` (~line 1158)**
|
|
|
|
Change the INSERT's `case_number` binding to normalized form. Replace `case_id, case_number, title,` with:
|
|
|
|
```python
|
|
case_id, _canonical_case_number(case_number), title,
|
|
```
|
|
|
|
- [ ] **Step 3: Normalize at write in `create_internal_committee_decision` (top of function body, ~line 2649)**
|
|
|
|
Immediately after `pool = await get_pool()`, add:
|
|
|
|
```python
|
|
case_number = _canonical_case_number(case_number)
|
|
```
|
|
|
|
(Do NOT add this to `create_external_case_law` — external keeps its citation verbatim; that function only `.strip()`s, which the caller adapter already does.)
|
|
|
|
- [ ] **Step 4: Run normalization tests**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/test_idempotent_ingest.py -k "canonical" -v`
|
|
Expected: `test_canonical_case_number` (5 cases) + `test_canonical_does_not_invent_month` PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add mcp-server/src/legal_mcp/services/db.py
|
|
git commit -m "feat(ingest): write-time canonical case_number normalization (GAP-06, FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 3: Convert both create functions to `ON CONFLICT DO UPDATE`
|
|
|
|
**Files:** Modify `mcp-server/src/legal_mcp/services/db.py`
|
|
|
|
- [ ] **Step 1: Replace `create_external_case_law` body (lines 2566-2624, from `pool = await get_pool()` to `return _row_to_case_law(row)`)**
|
|
|
|
```python
|
|
pool = await get_pool()
|
|
tags_json = json.dumps(subject_tags or [], ensure_ascii=False)
|
|
async with pool.acquire() as conn:
|
|
# Atomic upsert on the V15 partial unique index
|
|
# uq_case_law_external_number (case_number) WHERE source_kind <> 'internal_committee'.
|
|
# The predicate is repeated in ON CONFLICT (required for partial indexes).
|
|
# This also subsumes the old cited_only→external_upload promotion: a
|
|
# cited_only row with the same case_number conflicts and is promoted by
|
|
# DO UPDATE. Scoped to the external partial index, so an internal row with
|
|
# the same number is NOT touched (the old SELECT-without-source_kind could
|
|
# wrongly promote it).
|
|
row = await conn.fetchrow(
|
|
"""
|
|
INSERT INTO case_law (
|
|
case_number, case_name, court, date, subject_tags,
|
|
summary, key_quote, full_text, source_url,
|
|
source_kind, document_id, extraction_status,
|
|
halacha_extraction_status, practice_area, appeal_subtype,
|
|
headnote, source_type, precedent_level, is_binding
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6, $7, $8, $9,
|
|
'external_upload', $10, 'processing', 'pending',
|
|
$11, $12, $13, $14, $15, $16
|
|
)
|
|
ON CONFLICT (case_number) WHERE source_kind <> 'internal_committee'
|
|
DO UPDATE SET
|
|
case_name = EXCLUDED.case_name,
|
|
court = COALESCE(NULLIF(EXCLUDED.court, ''), case_law.court),
|
|
date = COALESCE(EXCLUDED.date, case_law.date),
|
|
practice_area = EXCLUDED.practice_area,
|
|
appeal_subtype = EXCLUDED.appeal_subtype,
|
|
subject_tags = EXCLUDED.subject_tags,
|
|
summary = COALESCE(NULLIF(EXCLUDED.summary, ''), case_law.summary),
|
|
headnote = EXCLUDED.headnote,
|
|
key_quote = COALESCE(NULLIF(EXCLUDED.key_quote, ''), case_law.key_quote),
|
|
full_text = EXCLUDED.full_text,
|
|
source_url = COALESCE(NULLIF(EXCLUDED.source_url, ''), case_law.source_url),
|
|
source_type = EXCLUDED.source_type,
|
|
precedent_level = EXCLUDED.precedent_level,
|
|
is_binding = EXCLUDED.is_binding,
|
|
document_id = COALESCE(EXCLUDED.document_id, case_law.document_id),
|
|
source_kind = 'external_upload',
|
|
extraction_status = 'processing',
|
|
halacha_extraction_status = 'pending'
|
|
RETURNING *
|
|
""",
|
|
case_number, case_name, court, decision_date, tags_json,
|
|
summary, key_quote, full_text, source_url,
|
|
document_id, practice_area, appeal_subtype, headnote,
|
|
source_type, precedent_level, is_binding,
|
|
)
|
|
return _row_to_case_law(row)
|
|
```
|
|
|
|
- [ ] **Step 2: Replace `create_internal_committee_decision` body (lines 2649-2708)**
|
|
|
|
```python
|
|
pool = await get_pool()
|
|
case_number = _canonical_case_number(case_number)
|
|
tags_json = json.dumps(subject_tags or [], ensure_ascii=False)
|
|
async with pool.acquire() as conn:
|
|
# Atomic upsert on V15 partial unique index
|
|
# uq_case_law_internal_number_proc (case_number, proceeding_type)
|
|
# WHERE source_kind = 'internal_committee'. Predicate repeated for the
|
|
# partial index. Replaces the old SELECT-then-INSERT/UPDATE (race-prone).
|
|
row = await conn.fetchrow(
|
|
"""
|
|
INSERT INTO case_law (
|
|
case_number, case_name, court, date, chair_name, district,
|
|
subject_tags, summary, full_text,
|
|
source_kind, source_type, document_id,
|
|
extraction_status, halacha_extraction_status,
|
|
practice_area, appeal_subtype, is_binding, proceeding_type
|
|
) VALUES (
|
|
$1, $2, $3, $4, $5, $6,
|
|
$7, $8, $9,
|
|
'internal_committee', 'appeals_committee', $10,
|
|
'processing', 'pending',
|
|
$11, $12, $13, $14
|
|
)
|
|
ON CONFLICT (case_number, proceeding_type)
|
|
WHERE source_kind = 'internal_committee'
|
|
DO UPDATE SET
|
|
case_name = EXCLUDED.case_name,
|
|
court = COALESCE(NULLIF(EXCLUDED.court, ''), case_law.court),
|
|
date = COALESCE(EXCLUDED.date, case_law.date),
|
|
chair_name = COALESCE(NULLIF(EXCLUDED.chair_name, ''), case_law.chair_name),
|
|
district = COALESCE(NULLIF(EXCLUDED.district, ''), case_law.district),
|
|
practice_area = EXCLUDED.practice_area,
|
|
appeal_subtype = EXCLUDED.appeal_subtype,
|
|
subject_tags = EXCLUDED.subject_tags,
|
|
summary = COALESCE(NULLIF(EXCLUDED.summary, ''), case_law.summary),
|
|
full_text = EXCLUDED.full_text,
|
|
source_type = 'appeals_committee',
|
|
source_kind = 'internal_committee',
|
|
is_binding = EXCLUDED.is_binding,
|
|
document_id = COALESCE(EXCLUDED.document_id, case_law.document_id),
|
|
extraction_status = 'processing',
|
|
halacha_extraction_status = 'pending'
|
|
RETURNING *
|
|
""",
|
|
case_number, case_name, court, decision_date, chair_name, district,
|
|
tags_json, summary, full_text,
|
|
document_id, practice_area, appeal_subtype, is_binding,
|
|
proceeding_type,
|
|
)
|
|
return _row_to_case_law(row)
|
|
```
|
|
|
|
- [ ] **Step 3: Verify import + no syntax error**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -c "from legal_mcp.services import db; print('db imports')"`
|
|
Expected: prints `db imports`.
|
|
|
|
- [ ] **Step 4: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add mcp-server/src/legal_mcp/services/db.py
|
|
git commit -m "feat(ingest): atomic ON CONFLICT upsert in create_*_case_law (GAP-03, FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 4: V21 migration — `searchable` column + recompute
|
|
|
|
**Files:** Modify `mcp-server/src/legal_mcp/services/db.py`
|
|
|
|
- [ ] **Step 1: Add `SCHEMA_V21_SQL` after `SCHEMA_V20_SQL` (~line 1094)**
|
|
|
|
```python
|
|
# ── V21: explicit `searchable` flag (GAP-13 / INV-DM1) ─────────────
|
|
# Materialized completeness flag — a case_law row is exposed to search only
|
|
# when it satisfies the completeness contract (02-data-model §2a). Recomputed
|
|
# on ingest/metadata completion via recompute_searchable(); not inferred at
|
|
# query time. Default false so a freshly-inserted row is excluded until proven
|
|
# complete. Health-check surfaces count(*) FILTER (WHERE NOT searchable).
|
|
SCHEMA_V21_SQL = """
|
|
ALTER TABLE case_law ADD COLUMN IF NOT EXISTS searchable boolean NOT NULL DEFAULT false;
|
|
CREATE INDEX IF NOT EXISTS idx_case_law_searchable ON case_law (searchable);
|
|
"""
|
|
```
|
|
|
|
- [ ] **Step 2: Wire V21 into `_run_schema_migrations` (~line 1119) and bump the log line**
|
|
|
|
After `await conn.execute(SCHEMA_V20_SQL)` add:
|
|
|
|
```python
|
|
await conn.execute(SCHEMA_V21_SQL)
|
|
```
|
|
|
|
Change the log line `"Database schema initialized (v1-v20)"` → `"Database schema initialized (v1-v21)"`.
|
|
|
|
- [ ] **Step 3: Add `_compute_searchable` (pure) + `recompute_searchable` (async) near the case_law helpers (after `create_internal_committee_decision`, ~line 2709)**
|
|
|
|
```python
|
|
def _compute_searchable(row: dict, has_embedded_chunk: bool) -> bool:
|
|
"""Completeness contract (INV-DM1 / 02-data-model §2a).
|
|
|
|
A row is searchable IFF: canonical id present · case_name/practice_area/
|
|
source_kind present · ≥1 chunk with a non-null embedding · extraction
|
|
completed · metadata non-empty (≥1 of headnote/summary/subject_tags).
|
|
Pure — `has_embedded_chunk` is supplied by the caller (cross-table check).
|
|
"""
|
|
if not has_embedded_chunk:
|
|
return False
|
|
if (row.get("extraction_status") or "") != "completed":
|
|
return False
|
|
if not (row.get("case_number") or "").strip():
|
|
return False
|
|
if not (row.get("case_name") or "").strip():
|
|
return False
|
|
if not (row.get("practice_area") or "").strip():
|
|
return False
|
|
if not (row.get("source_kind") or "").strip():
|
|
return False
|
|
tags = row.get("subject_tags") or []
|
|
has_meta = bool((row.get("headnote") or "").strip()) \
|
|
or bool((row.get("summary") or "").strip()) \
|
|
or (len(tags) > 0)
|
|
return has_meta
|
|
|
|
|
|
async def recompute_searchable(case_law_id: "UUID | str | None" = None) -> int:
|
|
"""Recompute and persist the `searchable` flag. Idempotent / reversible.
|
|
|
|
If case_law_id is None, recompute ALL rows (used by the V21 backfill and
|
|
the dry-run). Returns the number of rows now marked searchable=true.
|
|
"""
|
|
pool = await get_pool()
|
|
async with pool.acquire() as conn:
|
|
if case_law_id is not None:
|
|
cid = case_law_id if isinstance(case_law_id, UUID) else UUID(str(case_law_id))
|
|
rows = await conn.fetch(
|
|
"SELECT * FROM case_law WHERE id = $1", cid)
|
|
else:
|
|
rows = await conn.fetch("SELECT * FROM case_law")
|
|
n_true = 0
|
|
for r in rows:
|
|
row = dict(r)
|
|
# subject_tags is stored jsonb; _row_to_case_law parses it, but here
|
|
# we read raw — normalize to a list length check.
|
|
tags = row.get("subject_tags")
|
|
if isinstance(tags, str):
|
|
try:
|
|
tags = json.loads(tags)
|
|
except (ValueError, TypeError):
|
|
tags = []
|
|
row["subject_tags"] = tags or []
|
|
has_chunk = await conn.fetchval(
|
|
"SELECT EXISTS(SELECT 1 FROM precedent_chunks "
|
|
"WHERE case_law_id = $1 AND embedding IS NOT NULL)", row["id"])
|
|
val = _compute_searchable(row, bool(has_chunk))
|
|
await conn.execute(
|
|
"UPDATE case_law SET searchable = $2 WHERE id = $1", row["id"], val)
|
|
if val:
|
|
n_true += 1
|
|
return n_true
|
|
```
|
|
|
|
- [ ] **Step 4: Run the completeness-predicate tests**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/test_idempotent_ingest.py -k "searchable and not ingest" -v`
|
|
Expected: all `test_compute_searchable_*` PASS.
|
|
|
|
- [ ] **Step 5: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add mcp-server/src/legal_mcp/services/db.py
|
|
git commit -m "feat(data-model): V21 searchable flag + recompute_searchable (GAP-13, FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 5: Wire `recompute_searchable` into ingest
|
|
|
|
**Files:** Modify `mcp-server/src/legal_mcp/services/ingest.py`
|
|
|
|
- [ ] **Step 1: Call recompute after statuses are set in `ingest_document`**
|
|
|
|
In `ingest.py`, find the block (added by FU-1) that sets statuses + queues extraction:
|
|
```python
|
|
await db.set_case_law_extraction_status(case_law_id, "completed")
|
|
await db.set_case_law_halacha_status(case_law_id, "pending")
|
|
await db.request_metadata_extraction(case_law_id)
|
|
await db.request_halacha_extraction(case_law_id)
|
|
```
|
|
Immediately AFTER `request_halacha_extraction`, add:
|
|
```python
|
|
await db.recompute_searchable(case_law_id)
|
|
```
|
|
|
|
> Rationale: at this point chunks+embeddings are stored and extraction_status is
|
|
> completed, so the completeness predicate is meaningful. Metadata may still be
|
|
> pending (queued), so the row may compute searchable=false until metadata fills —
|
|
> the metadata extractor also calls recompute (Task 5 Step 2).
|
|
|
|
- [ ] **Step 2: Call recompute after metadata extraction fills fields**
|
|
|
|
In `mcp-server/src/legal_mcp/services/precedent_metadata_extractor.py`, find `extract_and_apply`'s success path (where it persists the filled metadata fields). After the DB update that writes the extracted metadata, add a call:
|
|
```python
|
|
await db.recompute_searchable(case_law_id)
|
|
```
|
|
(Import `db` is already present in that module; if not, add `from legal_mcp.services import db`. Confirm by reading the file's imports first.)
|
|
|
|
- [ ] **Step 3: Run the ingest-wiring test**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/test_idempotent_ingest.py -k "ingest_calls_recompute" -v`
|
|
Expected: `test_ingest_calls_recompute_searchable` PASS.
|
|
|
|
- [ ] **Step 4: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add mcp-server/src/legal_mcp/services/ingest.py mcp-server/src/legal_mcp/services/precedent_metadata_extractor.py
|
|
git commit -m "feat(ingest): recompute searchable on ingest + metadata completion (GAP-13, FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 6: DB smoke + dry-run + GATED search filter
|
|
|
|
**Files:** Modify search layer ONLY if dry-run is clean (see Step 4).
|
|
|
|
- [ ] **Step 1: Apply the V21 migration to the local DB and smoke-test upsert idempotency**
|
|
|
|
Run (sources env, exercises real Postgres):
|
|
```bash
|
|
cd ~/legal-ai && set -a && source ~/.env && set +a
|
|
cd mcp-server && .venv/bin/python -c "
|
|
import asyncio, uuid
|
|
from legal_mcp.services import db
|
|
async def main():
|
|
await db.get_pool() # runs migrations incl V21
|
|
# idempotent internal upsert: same (case_number, proceeding_type) twice
|
|
cn = 'ZZ9999/24'
|
|
r1 = await db.create_internal_committee_decision(case_number=cn, case_name='t', full_text='x', practice_area='rishuy_uvniya')
|
|
r2 = await db.create_internal_committee_decision(case_number=cn, case_name='t2', full_text='x2', practice_area='rishuy_uvniya')
|
|
assert r1['id'] == r2['id'], 'upsert must update, not duplicate'
|
|
# cleanup
|
|
pool = await db.get_pool()
|
|
async with pool.acquire() as c:
|
|
await c.execute(\"DELETE FROM case_law WHERE case_number = 'ZZ9999-24'\")
|
|
print('UPSERT IDEMPOTENT OK; normalized stored as ZZ9999-24')
|
|
asyncio.run(main())
|
|
"
|
|
```
|
|
Expected: `UPSERT IDEMPOTENT OK` and no duplicate. (Note: `ZZ9999/24` normalizes to `ZZ9999-24` — confirms write-time normalization too.)
|
|
|
|
- [ ] **Step 2: Backfill the `searchable` flag (recompute, reversible)**
|
|
|
|
```bash
|
|
cd ~/legal-ai && set -a && source ~/.env && set +a
|
|
cd mcp-server && .venv/bin/python -c "
|
|
import asyncio
|
|
from legal_mcp.services import db
|
|
async def main():
|
|
n = await db.recompute_searchable()
|
|
print('recompute_searchable: rows now searchable =', n)
|
|
asyncio.run(main())
|
|
"
|
|
```
|
|
|
|
- [ ] **Step 3: Dry-run report — which rows would drop from search if the filter is enabled**
|
|
|
|
```bash
|
|
cd ~/legal-ai && set -a && source ~/.env && set +a
|
|
PGPASSWORD="$POSTGRES_PASSWORD" psql "host=$POSTGRES_HOST port=$POSTGRES_PORT dbname=$POSTGRES_DB user=$POSTGRES_USER" -c "
|
|
SELECT source_kind,
|
|
count(*) AS total,
|
|
count(*) FILTER (WHERE NOT searchable) AS would_drop
|
|
FROM case_law GROUP BY source_kind ORDER BY source_kind;"
|
|
```
|
|
Report the table to the controller. **Decision gate:** if `would_drop` includes legitimate, currently-findable precedents (e.g. external_upload / internal_committee rows that users rely on), DO NOT enable the search filter in Step 4 — stop and report; the filter waits for FU-2b. If `would_drop` is only genuinely-incomplete rows, proceed.
|
|
|
|
- [ ] **Step 4: (GATED) Enable `searchable = true` filter in the search layer**
|
|
|
|
ONLY if Step 3 is clean. Read `mcp-server/src/legal_mcp/services/hybrid_search.py` to find the `case_law` WHERE clauses in `search_precedent_library_hybrid` / `search_documents_hybrid`. Add `AND cl.searchable = true` (alias as used in that query) to the case_law-joined precedent search paths. Add a focused test asserting a non-searchable row is excluded (monkeypatch or DB smoke). If deferred, write a one-line note in the spec §7 that the filter is pending FU-2b and skip.
|
|
|
|
- [ ] **Step 5: Add health-check visibility**
|
|
|
|
Find the health-check endpoint/function (search `def health` / `processing_status` in `web/app.py` or `tools/`). Add a field `non_searchable_case_law = SELECT count(*) FROM case_law WHERE NOT searchable`. Keep it a single cheap COUNT.
|
|
|
|
- [ ] **Step 6: Commit**
|
|
|
|
```bash
|
|
cd ~/legal-ai
|
|
git add -A mcp-server/ web/
|
|
git commit -m "feat(retrieval): gated searchable filter + health-check visibility (GAP-13, FU-2a)"
|
|
```
|
|
|
|
---
|
|
|
|
## Task 7: Full suite + smoke + lint + TaskMaster
|
|
|
|
- [ ] **Step 1: Full test suite**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m pytest tests/ -q`
|
|
Expected: all pass (the FU-1 77 + new FU-2a tests). Report the summary line.
|
|
|
|
- [ ] **Step 2: Smoke-import**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -c "from legal_mcp.services import db, ingest, precedent_library, internal_decisions; print('clean')"`
|
|
Expected: `clean`.
|
|
|
|
- [ ] **Step 3: Lint changed files (if ruff available)**
|
|
|
|
Run: `cd ~/legal-ai/mcp-server && .venv/bin/python -m ruff check src/legal_mcp/services/db.py src/legal_mcp/services/ingest.py 2>/dev/null; echo "exit=$?"`
|
|
Expected: clean or "ruff not available".
|
|
|
|
- [ ] **Step 4: Mark TaskMaster #60 + subtasks done**
|
|
|
|
Controller handles this (edit `.taskmaster/tasks/tasks.json`, verify via MCP get_task). Subtasks 60.1 (GAP-03), 60.2 (GAP-06), 60.5 (GAP-13).
|
|
|
|
---
|
|
|
|
## Self-Review Notes
|
|
|
|
- **GAP-03** → Task 3 (ON CONFLICT both functions). **GAP-06** → Task 2 (`_canonical_case_number` + write-time, type-aware). **GAP-13** → Tasks 4-5 (column + recompute + wiring) and gated Task 6 (filter).
|
|
- **No identifier migration** — FU-2b (#67) owns GAP-07/08. The V21 backfill only sets a derived, reversible flag.
|
|
- **Gated search filter** (Task 6 Step 3-4): the behavior-visible change is contingent on a clean dry-run; otherwise deferred. Surface the dry-run table to the user.
|
|
- **Offline-test limitation:** ON CONFLICT needs real Postgres → verified by Task 6 Step 1 smoke; offline tests cover the pure logic (normalize, completeness) and ingest wiring.
|
|
- **Type-consistency:** `_canonical_case_number`, `_compute_searchable(row, has_embedded_chunk)`, `recompute_searchable(case_law_id=None)` — names used identically in tests (Task 1) and impl (Tasks 2,4).
|