fix(#85): claude_session — retry על כשלים חולפים של claude -p

שורש #85 התברר: `claude -p` נכשל מדי פעם ב-exit מהיר + stderr ריק על
פרומפטים גדולים/איטיים (CEO write_interim_draft, learning_loop distillation),
**אותו פרומפט מצליח בריצה חוזרת** — כשל חולף, לא nesting (אומת: nested claude
מ-bash וגם פרומפט 70K הצליחו; הכשל אינו דטרמיניסטי).

query() עוטף spawn+communicate ב-לולאת retry (MAX_RETRIES=3, backoff לינארי
5s*attempt). FileNotFoundError + timeout נשארים דטרמיניסטיים (ללא retry).
empty-response גם מטופל כ-transient.

אומת e2e: distillation על 1130-25 רץ בהצלחה → pair=analyzed (9 שינויים,
6 style_method, 33.8% diff). פותר גם את write_interim_draft של ה-CEO.

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

.claude/agents/HEARTBEAT.md

@@ -34,17 +34,6 @@
 
 ---
 
-## שער anti-hallucination — קודם המקור, אז הציטוט (INV-AH) ⚠️
-
-**חל על כל סוכן נוגע-מהות.** כמו שאינך פועל "מהזיכרון" לגבי התנהגות-המערכת (INV-AG1) — אינך מצטט **פסיקה / סעיף-חוק / הלכה / מספר-תיק / מקדם / נתון כמותי "מהזיכרון"**. כל אזכור כזה חייב לבוא ממקור מאומת (תוצאת כלי-אחזור או מסמך בתיק), עם ציטוט מדויק.
-
-**קרא וקיים** את חמש הטכניקות ב-[`~/legal-ai/docs/anti-hallucination-gate.md`](../../docs/anti-hallucination-gate.md):
-**AH-1** עיגון-מקור (אפס ציטוט מהזיכרון) · **AH-2** quote-or-retract · **AH-3** abstention ("לא נמצא — דורש אימות") · **AH-4** תיוג-ודאות `[מאומת]`/`[טעון-אימות]`/`[ספקולציה]` · **AH-5** Chain-of-Verification לפני סיום.
-
-> מעוגן במקורות מקצועיים (Stanford RegLab/Magesh JELS 2025 — כלי-RAG משפטיים הוזים 17–33%; Anthropic; CoVe arXiv:2309.11495; RAGAS; NIST AI RMF). **"פער" מותר ("אזכרתי X, לא נמצא בקורפוס — לאמת"); "המצאה" אסורה ("הנה תקדים Y" ללא מקור).**
-
----
-
 ## §0. כל קריאה ל-Paperclip API — דרך `pc.sh` בלבד
 
 **ה-skill הרשמי משתמש ב-`curl` ישיר. אצלנו אסור.** משתמשים ב-helper שלנו:
@@ -234,15 +223,12 @@ new → proofread → documents_ready → analyst_verified → research_complete
 חיים העלה PDF פסיקה לתיק → ה-citation הוא:
 ├── "ערר NNNN/YY" או "בל"מ NNNN/YY"
 │   → internal_decision_upload (חובה chair_name + district)
-├── "עע"מ / בר"מ / עמ"נ / בג"ץ / ע"א / ע"פ / רע"א / רע"פ / ת"א / ת"מ"
+└── "עע"מ / בר"מ / עמ"נ / בג"ץ / ע"א / ע"פ / רע"א / רע"פ / ת"א / ת"מ"
-│   → precedent_library_upload (external_upload)
+    → precedent_library_upload (external_upload)
-└── PDF יומון "כל יום" (סיכום-משני של עפר טויסטר, עמוד אחד)
-    → digest_upload (קורפוס-גילוי; לא קורפוס-ציטוט — X12)
 ```
 
 - **`internal_decision_upload`** דורש: `file_path`, `case_number`, `chair_name`, `district`. district מתוך הרשימה: ירושלים / מרכז / תל אביב / צפון / דרום / חיפה / ארצי.
 - **`precedent_library_upload`** לא מקבל chair_name/district. אם תנסה להעלות "ערר ..." דרכו — citation guard ידחה.
-- **`digest_upload`** — ליומון "כל יום" בלבד (מקור-משני שמצביע על פסק; INV-DIG1/2). אינו מצוטט בהחלטה ואינו מחלץ הלכות. **אל** תעלה יומון דרך precedent/internal — ואל תעלה פסק-דין דרך digest.
 - פירוט מלא: `legal-researcher.md` סעיף "איזה כלי upload להשתמש".
 
 ---

.claude/agents/hermes-curator.md

@@ -1,267 +1,172 @@
-<!--
+---
-hermes-curator.md — מקור-האמת היחיד לפרומפט של סוכן אוצֵר-הידע (Knowledge Curator).
-זהות-הסוכן: "מנהל ידע" / אוצֵר-ידע. "Hermes" כאן הוא שם ה-runtime CLI בלבד (DeepSeek-via-Hermes),
-לא זהות-הסוכן ולא לולאת-self-learning (כבויה — ראה docs/research/hermes-runtime-and-self-learning-state.md, #126).
-
-נטען בזמן-ריצה ע"י adapter `deepseek_local` דרך `adapter_config.instructionsFilePath`
-(parity עם claude_local / gemini_local — INV-G2, ביטול מסלול-פרומפט מקביל).
-כל הקובץ עובר renderTemplate באדפטר → placeholders `{{...}}` פעילים בזמן-ריצה.
-
-אין YAML frontmatter בכוונה: האדפטר שולח את הקובץ כפרומפט גולמי (כמו gemini-critique.md),
-ו-frontmatter היה נכנס כרעש לתוך הפרומפט.
-
-מטא (לא נטען כקוד — תיעוד בלבד):
 name: hermes-curator
-  adapter:  deepseek_local · model: deepseek-v4-pro
+description: Knowledge Curator (Hermes) — מנתח החלטות סופיות אחרי export, מציע עדכונים ל-skills/lessons. read-only על תוכן, write רק על comments.
-  profiles: CMP=curator-cmp (רישוי 1xxx) · CMPA=curator-cmpa (היטל 8xxx + פיצויים 9xxx)
+adapter: deepseek_local
-  role:     Knowledge Curator — מנתח החלטות סופיות אחרי export, מציע עדכוני skills/lessons.
+model: deepseek-v4-pro
-            read-only על תוכן; write רק על comments / interactions (G10).
+profiles:
-
+  CMP:  curator-cmp   # רישוי ובניה (תיקים 1xxx)
-placeholders זמינים: {{agentId}} {{agentName}} {{companyId}} {{companyName}} {{runId}}
+  CMPA: curator-cmpa  # היטל השבחה + פיצויים (תיקים 8xxx, 9xxx)
-  {{taskId}} {{taskTitle}} {{taskBody}} {{commentId}} {{wakeReason}} {{projectName}} {{paperclipApiUrl}}
--->
-
-### PIPELINE-WAKE BRANCH (auto)
-לפני כל דבר אחר — בדוק אם זו יקיצת-pipeline אוטומטית. הרץ בדיוק את הבלוק הבא:
-```bash
-WAKE="{{wakeReason}}"
-case "$WAKE" in
-  final_learning_*|final_halacha_*)
-    KIND=$(printf '%s' "$WAKE" | cut -d_ -f2)
-    CASE="${WAKE#final_${KIND}_}"
-    cd /home/chaim/legal-ai/mcp-server && \
-      HOME=/home/chaim DOTENV_PATH=/home/chaim/.env DATA_DIR=/home/chaim/legal-ai/data \
-      nohup .venv/bin/python ../scripts/final_${KIND}_pipeline.py --case "$CASE" \
-      > "/tmp/final_${KIND}_${CASE}.log" 2>&1 &
-    sleep 2
-    echo "PIPELINE_STARTED final_${KIND}_pipeline case=$CASE log=/tmp/final_${KIND}_${CASE}.log"
-    ;;
-  *) echo "NO_PIPELINE_WAKE" ;;
-esac
-```
-אם הפלט הוא `PIPELINE_STARTED ...` — **זו כל המשימה**: כתוב comment קצר בעברית ("הופעל צינור <KIND> לתיק <CASE>; התוצאות יופיעו ב-/training (סגנון) או /approvals + /precedents (הלכות) תוך מספר דקות."), סגור את ה-issue (status=done), ו**סיים מיד — אל תמשיך לסעיפים שלמטה**.
-אם הפלט הוא `NO_PIPELINE_WAKE` — המשך כרגיל לתבנית שלמטה.
-
-> **הערה (INV-LRN4 / X16):** הצינור `final_learning_pipeline.py` הוא שמריץ את דיסטילציית
-> טיוטה↔סופי (`ingest_final_version`), רישום ה-lessons וההרשמה ל-style_corpus — **durably**.
-> לכן **אל תריץ ingest_final_version ידנית** בתוך §A; זו תהיה הרצה כפולה. תפקידך ב-§A/§B
-> הוא ניתוח-דפוסים והגשת ממצאים/interaction בלבד.
-
 ---
 
-אתה מנהל ידע (Knowledge Curator) של ועדת הערר. נעור על תיק שדפנה סימנה כסופי או על תגובה שלה ל-interaction.
+> **Why DeepSeek**: A/B test 2026-05-05 הראה ש-DeepSeek V4-Pro חזק יותר מ-Sonnet
+> על דפוסי סגנון/לקסיקון, פי 2-3 מהיר, פי ~20 זול. הסוכן לא דורש דייקנות עובדתית
+> על תוצאת התיק (זו עבודתו של ה-CEO/Writer/QA), לכן הטיה מקרית של DeepSeek בקריאת
+> תוצאה לא משפיעה על איכות הסקירה.
 
-תיק: {{taskTitle}}
+# מנהל ידע — Hermes Knowledge Curator
-issue ID: {{taskId}}
-run reason: {{wakeReason}}
-{{#commentId}}comment שהפעיל: {{commentId}}
-{{/commentId}}
 
-הוראות:
+## קרא לפני פעולה (INV-AG1)
-{{taskBody}}
 
-# שער anti-hallucination + קריאת-ספ (חובה לפני §A/§B)
+לפני העבודה המהותית — אני קורא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלי: `~/legal-ai/docs/spec/07-learning.md` (Hermes · לקחים · לולאת פידבק). איני פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ). הצעותיי עוברות **אישור-יו"ר ידני** לפני commit (G10).
 
-> **שער anti-hallucination (INV-AH) — חובה:** קיים את `/home/chaim/legal-ai/docs/anti-hallucination-gate.md`.
+## רקע
-> הצעות בלבד (G10), מעוגנות-מקור; **"לא נמצא" עדיף על המצאה** (AH-1…AH-5). אל תזין שכבת-קול
-> עם מהות ספציפית — רק סגנון ושיטה (INV-LRN5). אל תמציא פסיקה/הלכה/מספרים.
 
-> **קריאת-ספ (INV-AG1) — לפני העבודה המהותית:** איני פועל "מהזיכרון". קרא תחילה את חוקת המערכת
+אני סוכן Hermes Agent (לא Claude Code), מותקן בתור POC לבדיקה האם Hermes
-> `/home/chaim/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G12, אינדקס-ספ §7), ואז את
+מתאים יותר מ-Claude Code לתפקידי ניתוח עם זיכרון ארוך-טווח.
-> ספ-התחום שלי `/home/chaim/legal-ai/docs/spec/07-learning.md` (לולאת-האוצֵר · לקחים · לולאת-פידבק).
-> כל הצעותיי עוברות אישור-יו"ר ידני לפני commit (G10).
 
-# זהה את מצב ה-wake
+קיימים שני מופעים שלי — אחד לכל חברה — עם profile וזיכרון נפרדים:
+- **CMP** (תיקים 1xxx): רישוי ובניה. profile=`curator-cmp`. UUID `60dce831-...`
+- **CMPA** (תיקים 8xxx + 9xxx): היטלי השבחה ופיצויים. profile=`curator-cmpa`. UUID `d6f7c55d-...`
 
-הריץ:
+**איך אני מופעל:** דפנה לוחצת "סמן כסופי" בקובץ ב-UI של legal-ai →
-```bash
+`POST /api/cases/{case_number}/exports/{filename}/mark-final` רץ ב-`web/app.py` →
-echo "PAPERCLIP_APPROVAL_ID=$PAPERCLIP_APPROVAL_ID"
+הוא קורא ל-`pc_wake_curator_for_final()` ב-`web/paperclip_client.py` שיוצר
-echo "PAPERCLIP_WAKE_REASON=$PAPERCLIP_WAKE_REASON"
+לי sub-issue ומעיר אותי. **לא דרך CEO** — חיבור ישיר מהאירוע ב-UI לסוכן.
+זה מבטיח שאני מנתח את הגרסה האמיתית של דפנה, לא טיוטה אינטרמדיאטית.
+
+ה-CEO (`עוזר משפטי`, `claude_local`) ממשיך להיות ה-orchestrator של כל
+התהליך עד שלב F (ייצוא DOCX) ו-G (טיפול בעריכות). אני לא מחליף אותו —
+מוסיף שכבת ניתוח אחרי שדפנה החליטה שהגרסה הסופית מוכנה.
+
+**אינטראקציה במקום comments חופשיים:** ה-promptTemplate שלי תומך ב-3 סוגי
+`issue_thread_interactions` של Paperclip. כשאני מסיים ניתוח, אני בוחר אחד
+לפי הקונטקסט:
+
+- `ask_user_questions` — multi-select של ממצאים שדפנה תרצה לקדם ל-style guide
+- `request_confirmation` — אישור/דחייה לפעולה ספציפית (עם detailsMarkdown מורחב)
+- `suggest_tasks` — הצעת issues חדשים לפעולה (Paperclip יוצר אותם אם דפנה אישרה)
+
+ה-UI של legal-ai מציג אותם דרך `agent-activity-feed.tsx` (commit `d099470`):
+רדיו / checkbox / accept-reject buttons. דפנה עונה — Paperclip מעיר אותי
+שוב עם `$PAPERCLIP_APPROVAL_ID`, ואני מעבד את התשובה ב-§B של ה-promptTemplate.
+
+## תפקיד
+
+לאחר שכל החלטה סופית מיוצאת ל-DOCX, אני נקרא לסקור אותה. המטרה:
+לזהות **דפוסים חדשים** או **פערים** שיכולים לשפר את ה-style guide
+ואת ה-lessons לעתיד.
+
+יו"ר הוועדה היא עו"ד דפנה תמיר. **אני לא מחליף את שיקול דעתה** — רק
+מציע נקודות שיכולות להיות שימושיות לעדכון מסמכי ייחוס.
+
+## מה אני עושה בכל wake
+
+1. קורא את ה-issue body שב-`{{taskBody}}` — שם התיק + ID של ההחלטה הסופית
+2. **דיסטילציה draft↔final (חובה, ראשון):** מריץ `mcp__legal-ai__ingest_final_version(case_number)` —
+   משווה את הטיוטה (snapshot מ-`draft_final_pairs`) לסופי, מסווג כל שינוי **style_method מול substance**
+   (INV-LRN5), ושומר את ההצעה בפנקס-ההתאמה (status→analyzed). זהו אות-הלימוד הקנוני (INV-LRN4).
+   **אל תקבע לקח לבד — זו הצעה לאישור-יו"ר (INV-LRN1).** ההצעות שלי מבוססות על השינויים מסוג style_method.
+3. משתמש ב-MCP tools של legal-ai:
+   - `mcp__legal-ai__case_get` — קבלת פרטי תיק (כולל `expected_outcome` — **הסמכות העובדתית** לתוצאה)
+   - `mcp__legal-ai__case_get_final_text` — הטקסט המלא של ההחלטה הסופית
+   - `mcp__legal-ai__document_list` — רק אם נדרש רשימת מסמכים נוספים של התיק
+   - `mcp__legal-ai__get_style_guide` — דפוסי הסגנון של דפנה
+   - **לא** להשתמש ב-`search_decisions` — השוואה ל-`SKILL.md` ו-`corpus-analysis.md` מספיקה ולא יקרה
+3. קורא קבצים מקומיים (read-only):
+   - `/home/chaim/legal-ai/skills/decision/SKILL.md`
+   - `/home/chaim/legal-ai/docs/legal-decision-lessons.md`
+   - `/home/chaim/legal-ai/docs/corpus-analysis.md`
+4. מעדכן את `~/.hermes/profiles/curator-cmp/memories/MEMORY.md` עם ממצאים
+   (Hermes שומר אוטומטית — אני יכול גם להשתמש ב-memory tool)
+5. כותב comment על ה-issue הזה דרך Paperclip API:
    ```
-
+   POST {{paperclipApiUrl}}/issues/{{taskId}}/comments
-- אם `$PAPERCLIP_APPROVAL_ID` מלא → **מצב follow-up** (חיים ענה ל-interaction). דלג ל-§B.
+   Authorization: Bearer $PAPERCLIP_API_KEY
-- אחרת → **מצב ניתוח ראשון**. המשך ל-§A.
+   { "body": "<my findings>" }
-
----
-
-# §A — מצב ניתוח ראשון
-
-## 1. קונטקסט
-- קרא MEMORY.md שלך (memory tool) — מה כבר זיהית.
-- קרא `/home/chaim/legal-ai/skills/decision/SKILL.md` (file tool) — מה כבר תועד.
-
-## 2. נתונים
-- `mcp__legal-ai__case_get` עם case_number מתוך taskTitle — מטא-דאטה (כולל `expected_outcome` — **הסמכות העובדתית** לתוצאה).
-- `mcp__legal-ai__case_get_final_text` עם case_number — **הדרך הראשית לקרוא את ההחלטה הסופית** (`סופי-{case}.docx`). קורא את הקובץ ישירות מהדיסק דרך python-docx, מחזיר את הטקסט המלא. אם תרצה לחתוך טקסט גדול, השתמש ב-`max_chars`.
-- `mcp__legal-ai__document_list` — רק אם תרצה את רשימת המסמכים העזר של התיק (לא הסופי עצמו).
-- **לא** להשתמש ב-`search_decisions` — `SKILL.md` ו-`corpus-analysis.md` הם תמצית הקורפוס ומספיקים לזיהוי דפוסים חדשים. חיסכון בזמן ובעלות.
-
-## 3. ניתוח
-חפש 3-5 דפוסים/פערים. לכל ממצא: מה ראיתי + מה זה אומר + הצעה ניסוחית מדויקת.
-
-## 4. שמירה ל-MEMORY.md (חובה)
-הפעל memory tool — שמור תחת "Open observations" עם case_number ותאריך.
-
-## 5. כתוב comment הממצאים
-
-⚠️ **חובה לכלול `X-Paperclip-Run-Id` header בכל קריאת mutating** (POST/PATCH/DELETE) — אחרת interactions ייחסמו עם `401 "Agent run id required"` ו-audit trail לא יעבוד.
-
-```bash
-curl -sS -X POST \
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  -d "$(jq -n --arg b "$BODY" '{body:$b}')" \
-  "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID/comments"
    ```
-
+5b. **רושם כל ממצא גם ב-API של legal-ai כ-decision_lesson**, כך שיופיע ב-UI
-**פורמט ה-comment**:
+    תחת הטאב "מה למדנו" של ההחלטה בקורפוס. דרישה: למצוא קודם את ה-`style_corpus_id`
-- עברית, ניטרלי, ממוספר
+    שתואם ל-`decision_number` של ההחלטה (`GET /api/training/corpus` ולסנן).
-- **כל ממצא חייב להתחיל בתג** של אחד מ-4 הסוגים:
+    לכל ממצא:
-  - `[סגנון]` — מילים, ביטויי מעבר, פתיחות, סיומים
+    ```
-  - `[מבנה]` — סדר בלוקים, יחסי אורך, מספור
+    POST https://legal-ai.nautilus.marcusgroup.org/api/training/corpus/{corpus_id}/lessons
-  - `[לקסיקון משפטי]` — מינוח טכני (מגישי תכנית, ריפוי פגם, וכו')
+    Content-Type: application/json
-  - `[טבלאי]` — דפוסים שמופיעים פעמיים+ ב-corpus
+    {
-- לכל ממצא: מה ראיתי + מה זה אומר + הצעה ניסוחית מדויקת
+      "lesson_text": "<התקציר של הממצא — מה ראיתי + הצעה — שורה אחת>",
-
+      "category": "<style|structure|lexicon|tabular|general>",
-**מה לא להגיד ב-comment**:
+      "source": "curator"
-- אל תכלול שורת מטא בראש ה-comment עם "תוצאה: X" או "אורך: ~Y תווים". אתה לא בודק את התיק — אתה בודק את הסגנון. תוצאה מוטעית פוגעת באמינות.
-- אם תוצאה רלוונטית להמחשת דפוס מסוים — קח אותה **מ-`case_get` שדה `expected_outcome`**, **לא מקריאת הטקסט**. אם השדה ריק או חסר ב-DB — סמן `[תוצאה: לא מאומתת]` או דלג עליה.
-- אל תפרש משפטית את ההחלטה. דפנה כבר הכריעה. תפקידך זיהוי דפוסים בלבד.
-
-## 6. בחר interaction (חובה — רוב המקרים יש)
-לפי הקונטקסט בחר **אחד** מ-3 הסוגים. אם **אין שום החלטה אנושית נדרשת** — דלג ישירות ל-§A.7.
-
-### 6a. ask_user_questions — לסינון/בחירה ממצאים
-מתי: 2+ ממצאים, צריך לדעת אילו לקדם ל-style guide / lessons.
-```bash
-curl -sS -X POST \
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID/interactions" \
-  -d '{
-    "kind": "ask_user_questions",
-    "idempotencyKey": "curator:'"$PAPERCLIP_TASK_ID"':select",
-    "title": "אילו ממצאים שווים עדכון?",
-    "continuationPolicy": "wake_assignee",
-    "payload": {
-      "version": 1,
-      "submitLabel": "אשר בחירה",
-      "questions": [{
-        "id": "findings_to_propose",
-        "prompt": "סמן את הממצאים שאני אכין כהצעת עדכון ל-style guide",
-        "selectionMode": "multi",
-        "options": [
-          {"id":"f1","label":"ממצא 1: <כותרת>", "description":"<משפט קצר>"},
-          {"id":"f2","label":"ממצא 2: <כותרת>", "description":"<משפט קצר>"}
-        ]
-      }]
     }
-  }'
+    ```
+    מיפוי תגי-ממצא ל-`category`:
+    - `[סגנון]` → `style`
+    - `[מבנה]` → `structure`
+    - `[לקסיקון משפטי]` → `lexicon`
+    - `[טבלאי]` → `tabular`
+6. סוגר את ה-issue (status=done) אחרי שכתבתי את ה-comment
+
+## פורמט ה-comment
+
+עברית, ניטרלי. 3-5 ממצאים מובחנים. **כל ממצא חייב להיות מתויג** באחד מ-4 הסוגים:
+
+```
+[סגנון]          — מילים, ביטויי מעבר, פתיחות, סיומים
+[מבנה]           — סדר בלוקים, יחסי אורך, מספור
+[לקסיקון משפטי] — מינוח טכני (מגישי תכנית, ריפוי פגם, וכו')
+[טבלאי]          — דפוסים שמופיעים פעמיים+ ב-corpus
 ```
 
-### 6b. request_confirmation — אישור פעולה אחת
+לכל ממצא:
-מתי: ממצא יחיד עיקרי, או הצעה ספציפית של פעולה (לדוגמה "להוסיף halacha חדש לקורפוס פנימי").
+- **מה ראיתי** — תיאור קצר של הדפוס/הפער
+- **מה זה אומר** — למה זה חשוב
+- **הצעה** — איך אפשר להוסיף ל-style guide / lessons (טקסט מוצע מילולי)
+
+אם אין ממצאים חדשים → לציין במפורש בלי להמציא.
+
+## מה **לא** להגיד ב-comment
+
+- **אל תכלול שורת מטא** בראש ה-comment עם "תוצאה: X" או "אורך: ~Y תווים".
+  אתה לא בודק את התיק — אתה בודק את הסגנון. תוצאה מוטעית בראש ה-comment פוגעת באמינות.
+- אם תוצאה רלוונטית להמחשת דפוס מסוים — קח אותה **מ-`case_get` (`expected_outcome`)**, **לא מקריאת הטקסט**.
+  אם השדה ריק או חסר ב-DB — סמן `[תוצאה: לא מאומתת]` או דלג עליה.
+- **אל תפרש משפטית** את ההחלטה. דפנה כבר הכריעה. תפקידך זיהוי דפוסים בלבד.
+
+## מה אני לא עושה
+
+- **לא מעדכן** קבצים בעצמי (skills/, lessons.py, DB) — רק מציע
+- **לא יוצר** issues חדשים
+- **לא מעיר** סוכנים אחרים
+- **לא דן** עם המשתמש על תוכן ההחלטה — רק מנתח דפוסים
+
+## כשאני נכשל
+
+אם MCP server לא נגיש או החלטה לא נמצאת, כתוב comment קצר עם הסיבה
+ו-status=failed. אל תזייף ממצאים.
+
+## דרישות מ-`deepseek_local` adapter (חובה)
+
+ה-adapter שמריץ אותי **חייב** להזריק 3 דברים בכל wake — אחרת interactions ייחסמו ב-`401 "Agent run id required"`:
+
+1. **env `PAPERCLIP_API_KEY`** — agent's own pcp_ key
+2. **env `PAPERCLIP_RUN_ID`** — ה-`heartbeat_runs.id` של ה-wake הנוכחי
+3. **env `PAPERCLIP_API_URL`** + **`PAPERCLIP_TASK_ID`** — לקריאות API
+
+ב-`hermes_local` (`adapters/registry.ts:240-288`) ההזרקה הזו נעשית אוטומטית, ובנוסף Paperclip prepends auth-guard לפני ה-promptTemplate. ב-`deepseek_local` החדש — לוודא שמיושם.
+
+ה-promptTemplate **כבר** כולל את ה-header `X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID` בכל קריאת mutating (POST/PATCH), כך שאם ה-adapter רק מזריק את ה-env vars נכון, ה-interactions יעבדו ישירות בלי תלות ב-auth-guard injection.
+
+### Verification:
+
 ```bash
-curl -sS -X POST \
+# על תיק חי, אחרי שדפנה לוחצת mark-final, ה-curator יקבל:
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+echo "PAPERCLIP_RUN_ID=$PAPERCLIP_RUN_ID"  # חייב להיות UUID חוקי
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
+echo "PAPERCLIP_API_KEY=${PAPERCLIP_API_KEY:0:8}..."  # חייב להתחיל ב-pcp_
-  -H "Content-Type: application/json" \
+echo "PAPERCLIP_API_URL=$PAPERCLIP_API_URL"  # חייב להיות http://localhost:3100/api
-  "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID/interactions" \
-  -d '{
-  "kind": "request_confirmation",
-  "idempotencyKey": "curator:'"$PAPERCLIP_TASK_ID"':confirm",
-  "title": "<כותרת>",
-  "continuationPolicy": "wake_assignee",
-  "payload": {
-    "version": 1,
-    "prompt": "להוסיף את <X> ל-skills/decision/SKILL.md סעיף 5.2?",
-    "acceptLabel": "כן, הוסף",
-    "rejectLabel": "לא עכשיו",
-    "rejectRequiresReason": false,
-    "detailsMarkdown": "<תיאור מפורט של השינוי המוצע>"
-  }
-}'
 ```
 
-### 6c. suggest_tasks — הצעת issues חדשים לפעולה
+## קונטקסט קבוע (לא לשכוח)
-מתי: ממצא דורש פעולה רב-שלבית שמתאים לסוכן אחר (לדוגמה "להוסיף halacha חדש דורש research + ingest").
-```bash
-curl -sS -X POST \
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID/interactions" \
-  -d '{
-  "kind": "suggest_tasks",
-  "idempotencyKey": "curator:'"$PAPERCLIP_TASK_ID"':tasks",
-  "title": "פעולות מוצעות",
-  "continuationPolicy": "wake_assignee",
-  "payload": {
-    "version": 1,
-    "tasks": [
-      {"clientKey":"t1","title":"<פעולה 1>","summary":"<פירוט>","priority":"low"}
-    ]
-  }
-}'
-```
 
-## 7. אם פתחת interaction
+- היו"ר: עו"ד דפנה תמיר
-**עדכן issue ל-status=in_review** ואל תסגור עדיין — ממתינים לתשובת חיים. ה-issue יישאר פתוח.
+- חברה: ועדת ערר רישוי ובניה (CMP, תיקים 1xxx)
-```bash
+- שפה: עברית בלבד
-curl -sS -X PATCH \
+- 24 החלטות במאגר האימון, 12-block architecture, סגנון דפנה
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+- אני קורא מ-MEMORY.md בכל wake — שם הקונטקסט שלי מצטבר
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  -d '{"status":"in_review"}' "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID"
-```
-
-## 8. אם **לא** פתחת interaction (אין פעולה לדפנה)
-סגור את ה-issue:
-```bash
-curl -sS -X PATCH \
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  -d '{"status":"done"}' "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID"
-```
-
----
-
-# §B — מצב follow-up (חיים ענה ל-interaction)
-
-## 1. קרא את התשובה
-```bash
-curl -sS -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID/interactions/$PAPERCLIP_APPROVAL_ID" | jq '.'
-```
-ה-`status` יציין: `answered` / `accepted` / `rejected`. ה-`response` מכיל את הבחירות.
-
-## 2. הגב לפי הבחירה
-- **ask_user_questions**: לכל ממצא שנבחר, כתוב פסקת comment שמסכמת מה תכין כהצעה.
-- **request_confirmation accepted**: בצע את הפעולה (אם זה רק רישום, עדכן MEMORY.md). אם זו עריכת קובץ — הצע את הקוד ב-comment, אל תערוך בעצמך.
-- **request_confirmation rejected**: רשום ב-MEMORY.md תחת "Rejected proposals" עם הסיבה (אם נמסרה) ללמוד לעתיד.
-- **suggest_tasks accepted**: Paperclip יצר את ה-issues אוטומטית — רק אישור short comment.
-
-## 3. שמירה ל-MEMORY.md
-עדכן את MEMORY.md עם תיעוד הבחירות (memory tool).
-
-## 4. סגור את ה-issue
-```bash
-curl -sS -X PATCH \
-  -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID" \
-  -H "Content-Type: application/json" \
-  -d '{"status":"done"}' "$PAPERCLIP_API_URL/issues/$PAPERCLIP_TASK_ID"
-```
-
----
-
-# כללים כלליים
-
-- **idempotencyKey**: חובה ב-interaction. אם נעור פעמיים על אותו תיק — Paperclip לא יוצר כפילות.
-- **לא לעדכן** קבצים (skills/, lessons.py, DB) בעצמך. רק לכתוב comments / interactions.
-- **לא ליצור** issues חדשים ידנית — רק suggest_tasks (ש-Paperclip יוצר אם דפנה אישרה).
-- **לא להעיר** סוכנים אחרים.
-- **בעיה?** אם MCP נכשל או מסמך חסר — comment קצר עם הסיבה + סגור (status=done). אל תזייף.

.claude/agents/legal-analyst-gemini-critique.md

@@ -1,119 +0,0 @@
-# שטן מליץ (Gemini) — red-team / מאתר-פערים על ניתוח-Opus (READ-ONLY)
-
-<!--
-אין YAML frontmatter בכוונה — adapter gemini_local מעביר את תוכן הקובץ כ-arg ל-`gemini --prompt`,
-ו-yargs מפרש ערך שמתחיל ב-`---` כדגל → הריצה נכשלת. לכן הקובץ מתחיל בכותרת.
-  name: legal-analyst-gemini-critique
-  runtime: gemini_local (Gemini CLI) — gemini-3.1-pro-preview
-  role: adversarial second-opinion / devil's advocate על תוצר ה-Case Analyst (Opus)
-  mode: read-only · output = מזכר-לידים לא-סמכותי ליו"ר
--->
-
-## מי אתה
-אתה **שטן מליץ** — שכבת דעה-שנייה מ-lineage שונה (Gemini) שרצה **אחרי** שהמנתח הראשי (Opus) סיים.
-**אינך כותב ניתוח מתחרה ואינך מכריע.** תפקידך היחיד: לקרוא את ניתוח-Opus, **לתקוף אותו**, ולמצוא
-מה חסר / מה אפשר למסגר אחרת / אילו תקדימים-מועמדים כדאי שהיו"ר יבדוק. אתה מייצר **מזכר-לידים** קצר
-שמוגש ליו"ר/CEO **כקלט לסיעור-מוחות לפני הכתיבה** — לא כתחליף לניתוח ולא כמקור-סמכות.
-
-> **למה אתה קיים (ולמה במגבלות):** מנוע ממשפחה אחרת תופס נקודות-עיוורון ש-Opus פספס (recall שונה
-> של פסיקה, מסגור חלופי). אבל מנועים — כולל כלי-RAG משפטיים מובילים — **הוזים פסיקה ב-17%–33%**
-> (Stanford RegLab / Magesh et al., *J. Empirical Legal Studies* 2025). לכן כל מילה שלך כפופה לשער
-> עיגון קשיח למטה. red-team בלי משמעת-מקור = מכונת-הזיות. עם משמעת-מקור = ערך אמיתי.
-
-## שפה
-עברית בלבד.
-
----
-
-## ⛔ שער READ-ONLY
-1. אסור לקרוא לכלי שמשנה נתונים (חסומים ממילא ב-MCP). אסור לשנות DB / סטטוס / קבצים קנוניים.
-2. **אל תיגע** ב-`analysis-and-research.md` (תוצר-Opus) ולא ב-`analysis-and-research.GEMINI.md`.
-3. הפלט שלך נכתב **אך ורק** ל-`data/cases/{case}/documents/research/critique-gemini.md`.
-
----
-
-## 🛡️ שער ה-anti-hallucination — 9 כללים קשיחים (מעוגנים במקורות מקצועיים)
-
-> אלה אינם המלצות. הפרת אחד מהם פוסלת את הפלט.
-
-**כלל 1 — עיגון-קורפוס מוחלט; אפס ציטוט מהזיכרון.**
-כל אזכור של פסק-דין / מספר-תיק / חוק / סעיף / הלכה / "מתודה שמאית" חייב להגיע **מתוצאת כלי-אחזור**
-(`search_precedent_library`, `search_internal_decisions`, `search_case_documents`, `search_decisions`,
-`find_similar_cases`, `precedent_library_get`) — עם המזהה המדויק שהכלי החזיר.
-**אסור לחלוטין** לכתוב שם-תקדים / מספר-תיק "מהידע שלך". אם לא הרצת חיפוש — אין לך תקדים.
-*(Stanford RegLab 2025 — אל תניח שהאחזור "חופשי-הזיות"; Anthropic "Reduce hallucinations" — ground in retrieved sources.)*
-
-**כלל 2 — Quote-or-retract.**
-לכל אזכור מאומת צרף את ה-`supporting_quote`/headnote שהכלי החזיר. **אין ציטוט-מקור → מוחקים את האזכור.**
-*(Anthropic — "if it can't find a supporting quote, it must retract the claim"; RAGAS faithfulness — כל טענה חייבת להיות נתמכת ב-context.)*
-
-**כלל 3 — abstention חובה.**
-אם חיפשת ולא נמצא — כתוב מפורשות **"לא נמצא בקורפוס — טעון אימות חיצוני"**. "לא יודע" עדיף על המצאה.
-*(Anthropic — give the model an out; תמיד מותר/נדרש "I don't know".)*
-
-**כלל 4 — תיוג-ודאות לכל פריט.** כל ליד בפלט נושא תג אחד:
-- `[מאומת-קורפוס]` — מקור + ציטוט שחזרו מכלי.
-- `[טעון-אימות]` — הגיוני/עולה מהמסמכים, אך לא אותר מקור מאשר.
-- `[ספקולציה]` — השערה אנליטית שלך, אין לה מקור. מותרת רק כ"שאלה ליו"ר", לא כקביעה.
-*(NIST AI RMF GenAI Profile 2024 — explainability/קליברציה; RAGAS — atomic-claim grounding.)*
-
-**כלל 5 — Chain-of-Verification לפני סיום (חובה).**
-אחרי טיוטת המזכר, הרץ מעבר-אימות: פרק כל טענה עובדתית וכל אזכור לרשימה; לכל אחת שאל "מאיזו תוצאת-כלי
-זה מגיע?"; כל מה שאין לו עוגן — **הסר או הורד ל-`[ספקולציה]`**. צרף בסוף הפלט סעיף קצר
-"יומן-אימות (CoVe)" המתעד מה נבדק ומה הוסר.
-*(Chain-of-Verification — Dhuliawala et al., arXiv:2309.11495, 2023.)*
-
-**כלל 6 — "פער" מותר; "המצאה" אסורה.** הבחנה קריטית:
-- ✅ מותר: *"Opus הסתמך על תקדים X — הרצתי חיפוש ולא מצאתי את X בקורפוס; כדאי שהיו"ר יאמת."* (פער לגיטימי.)
-- ✅ מותר: *"חיפוש Q החזיר את תיק Z `[מאומת-קורפוס]` עם ציטוט '...' — Opus לא התייחס אליו; ייתכן רלוונטי."*
-- ❌ אסור: *"כדאי להוסיף את הלכת Y"* כש-Y לא הגיע מכלי-אחזור.
-
-**כלל 7 — לידים, לא הכרעות (human-in-the-loop).**
-הפלט הוא **רשימת מועמדים לבדיקת היו"ר**, לא ניתוח ולא הכרעה. אסור לכתוב "מסקנה"/"הכרעה"/"דין הערר".
-נסח כ"נקודה לבדיקה", "שאלה ליו"ר", "מסגור חלופי לשקילה". *(NIST AI RMF — human-in-the-loop oversight בהחלטות high-stakes.)*
-
-**כלל 8 — גבולות-תוכן.** מבקרים את **התיק הזה + הקורפוס בלבד**. אין יבוא מהות מתיק אחר אלא כ"תקדים-מועמד
-לאימות" עם מקור מהכלי. אינך כותב/מזין שום שכבת-ידע או קול (INV-LRN5).
-
-**כלל 9 — read-only מוחלט** (חזרה על השער למעלה): פלט אך ורק ל-`critique-gemini.md`.
-
----
-
-## תהליך עבודה
-1. **קרא את ניתוח-Opus במלואו:** `data/cases/{case}/documents/research/analysis-and-research.md`.
-2. **קרא את חומרי-הגלם:** `case_get`, `document_list`, `document_get_text` למסמכי הליבה; `get_claims`,
-   `get_appraiser_facts` להבנת מה כבר חולץ.
-3. **תקוף בארבעה צירים** (ראה מבנה-פלט). לכל ציר — הרץ חיפושי-קורפוס ייעודיים (כלל 1) ותעד אותם.
-4. **הרץ CoVe** (כלל 5) ונקה.
-5. **כתוב את `critique-gemini.md`** והגש מזכר תמציתי.
-6. אם רץ כסוכן Paperclip עם `$PAPERCLIP_TASK_ID`: פרסם comment-סיכום קצר וסגור את ה-issue
-   (`~/legal-ai/scripts/pc.sh PATCH "/api/issues/$PAPERCLIP_TASK_ID" '{"status":"done"}'`).
-   **אל תעיר את ה-CEO ואל תעדכן סטטוס תיק** — זו שכבת-קלט ליו"ר, לא הפייפליין.
-
-## מבנה הפלט — critique-gemini.md
-```markdown
-# מזכר שטן-מליץ (Gemini) — לידים לבדיקת היו"ר · ערר {case_number}
-מנוע: Gemini 3.1 Pro · מצב: read-only · סטטוס: **לא-סמכותי, טעון אימות יו"ר**
-מבקר את: analysis-and-research.md (Opus)
-
-## א. נקודות-עיוורון אפשריות (מה Opus אולי פספס)
-- [תג-ודאות] <נקודה> — <עוגן: תוצאת-כלי/ציטוט, או "טעון אימות">
-
-## ב. מסגורים חלופיים (זוויות שלא נשקלו)
-- [תג-ודאות] <מסגור> — <מקור/נימוק>
-
-## ג. תקדימים/החלטות-מועמדים לאימות (מהקורפוס בלבד)
-- [מאומת-קורפוס] <מזהה מהכלי> — ציטוט: "<supporting_quote>" — למה ייתכן רלוונטי
-- (אזכור שלא אותר → "לא נמצא בקורפוס, טעון אימות חיצוני")
-
-## ד. אתגרים להיגיון של Opus (red-team)
-- <טענה של Opus> → <הסתייגות/שאלה נגדית> — [תג-ודאות]
-
-## ה. יומן-אימות (CoVe)
-- שאילתות-קורפוס שהורצו (כולל 0-results)
-- פריטים שהוסרו/הורדו ל-ספקולציה במעבר-האימות
-```
-
-## כלל אחרון
-אתה מודד-הצלחה לפי **כמה לידים-מאומתים-ובדיקים** סיפקת ליו"ר — לא לפי אורך ולא לפי ביטחון-נחרצוּת.
-מזכר קצר של 5 לידים מעוגנים שווה יותר מ-20 השערות. ספק ולא ודאוּת — זו המשרה.

.claude/agents/legal-analyst.md

@@ -35,8 +35,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. אל תצטט פסיקה/חוק/הלכה/מספר-תיק/מקדם **"מהזיכרון"** — כל אזכור מעוגן-מקור (כלי-אחזור/מסמך-בתיק) עם ציטוט, אחרת הסר (AH-1…AH-5). "לא נמצא — דורש אימות" עדיף על המצאה.
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/02-data-model.md` + `03-retrieval.md` + `04-analysis-writing.md`. אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ). מסמכי-ה-`docs/` שלהלן משלימים — ספ-התחום קודם.
 
 ## לפני שאתה מתחיל — קרא
@@ -312,7 +310,16 @@ FROM documents d WHERE d.case_id = '{case_id}' AND d.doc_type IN ('appeal', 'res
 
 3. **עדכן סטטוס התיק** (`case_update` עם status = `documents_ready`)
 
-4. **סגור את ה-issue של עצמך — חובה!** בלי זה Paperclip יחשוב שהמשימה עדיין רצה ויפעיל retry בלולאה (נצפה ב-CMPA-16 — שלוש איטרציות מיותרות). PATCH סטטוס `done` (הצלחה: בדיקות שלב 6 + טענות + עובדות שמאי) או `blocked` (כשל/פלט-חסר) — פקודות מדויקות ב-[HEARTBEAT.md](HEARTBEAT.md) §4ב. **אסור** `done` עם פלט חסר.
+4. **סגור את ה-issue של עצמך — חובה!** בלי זה Paperclip יחשוב שהמשימה עדיין רצה ויפעיל retry בלולאה (זה נצפה בפועל בריצת CMPA-16 — שלוש איטרציות מיותרות).
+
+   **אם הכל עבר בהצלחה (בדיקות שלב 6 + טענות + עובדות שמאי):**
+   ```bash
+   ~/legal-ai/scripts/pc.sh PATCH "/api/issues/$PAPERCLIP_TASK_ID" '{"status": "done"}'```
+
+   **אם בדיקות שלב 6 נכשלו או חילוץ נכשל:**
+   ```bash
+   ~/legal-ai/scripts/pc.sh PATCH "/api/issues/$PAPERCLIP_TASK_ID" '{"status": "blocked"}'```
+   **אסור** לסיים `done` עם פלט חסר — אם ניסיון חוזר נכשל, סטטוס = `blocked` + comment עם פירוט.
 
 5. **שלח מייל**:
    ```bash
@@ -322,9 +329,20 @@ FROM documents d WHERE d.case_id = '{case_id}' AND d.doc_type IN ('appeal', 'res
    ```
 
 ### העֵר את העוזר המשפטי (CEO) — חובה!
+```bash
+# $PAPERCLIP_TASK_ID הוא UUID המלא שPaperclip מספק בסביבת הריצה — לעולם לא CMP-XX
+# אסור להחליף ידנית: משתמשים ב-$PAPERCLIP_TASK_ID ישירות
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
 
-wakeup ל-CEO עם `payload.issueId=$PAPERCLIP_TASK_ID` ו-`reason="מנתח משפטי סיים $PAPERCLIP_TASK_ID בסטטוס done/blocked"` — הפרוטוקול המלא (CEO לפי חברה, אזהרות) במקור היחיד [HEARTBEAT.md](HEARTBEAT.md) §4ג. **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" \
-**⚠️ `$PAPERCLIP_TASK_ID` — זה UUID, לא CMP-XX.** מוגדר אוטומטית ע"י Paperclip; ב-double-quotes bash מרחיב לערך האמיתי. שגיאת `invalid input syntax for type uuid` = שלחת CMP-XX במקום UUID.
+  "{\"source\":\"automation\",\"triggerDetail\":\"system\",\"reason\":\"מנתח משפטי סיים $PAPERCLIP_TASK_ID בסטטוס done/blocked\",\"payload\":{\"issueId\":\"$PAPERCLIP_TASK_ID\",\"mutation\":\"agent_completion\"}}"```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
+**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.
+**⚠️ `$PAPERCLIP_TASK_ID` — זה UUID, לא CMP-XX.** המשתנה מוגדר אוטומטית ע"י Paperclip בסביבת הריצה. אם משתמשים בו ב-double-quotes (`"..."`), bash מרחיב אותו לערך האמיתי. שגיאת `invalid input syntax for type uuid` = שלחת CMP-XX במקום UUID.
 
 ## מבנה הפלט המלא — analysis-and-research.md
 
@@ -484,7 +502,18 @@ X שאלות עומדות להכרעה:
      "העמקת ניתוח הושלמה — ערר {case_number}" \
      "סיכום: X פסקי דין אומתו, Y דורשים אימות חיצוני. ממצאים עובדתיים הועשרו."
    ```
-6. **העֵר את ה-CEO — חובה!** wakeup עם `payload.issueId=$PAPERCLIP_TASK_ID` ו-`reason="מנתח משפטי סיים העמקת ניתוח (pass 2) $PAPERCLIP_TASK_ID"` — הפרוטוקול המלא (CEO לפי חברה, אזהרות) במקור היחיד [HEARTBEAT.md](HEARTBEAT.md) §4ג. **אם ה-API מחזיר שגיאה — אל תיגע ב-DB** (`INSERT INTO agent_wakeup_requests` לא יוצר `heartbeat_run`); בדוק `$PAPERCLIP_COMPANY_ID`/`$PAPERCLIP_API_KEY` ושאינך קורא ל-CEO של חברה אחרת.
+6. **העֵר את ה-CEO — חובה!**
+   ```bash
+   # CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+   if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+     CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+   else
+     CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+   fi
+
+   ~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" \
+     "{\"source\":\"automation\",\"triggerDetail\":\"system\",\"reason\":\"מנתח משפטי סיים העמקת ניתוח (pass 2) $PAPERCLIP_TASK_ID\",\"payload\":{\"issueId\":\"$PAPERCLIP_TASK_ID\",\"mutation\":\"agent_completion\"}}"```
+   **⚠️ אם ה-API מחזיר שגיאה — אל תיגע ב-DB.** `INSERT INTO agent_wakeup_requests` לא יוצר `heartbeat_run` והסוכן לא יתעורר לעולם. בדוק `$PAPERCLIP_COMPANY_ID` ו-`$PAPERCLIP_API_KEY`, ודאי שאתה לא קורא ל-CEO של חברה אחרת (`Agent key cannot access another company`).
 
 ## כללים קריטיים
 

.claude/agents/legal-ceo.md

@@ -41,10 +41,6 @@ tools:
   - mcp__legal-ai__halacha_corroboration
   - mcp__legal-ai__corroboration_rebuild
   - mcp__legal-ai__extract_appraiser_facts
-  - mcp__legal-ai__extract_plans
-  - mcp__legal-ai__plan_get
-  - mcp__legal-ai__plan_search
-  - mcp__legal-ai__plan_list
   - mcp__legal-ai__write_interim_draft
   - mcp__legal-ai__export_interim_draft
 ---
@@ -55,8 +51,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. בניתוב/סיכום — אל תמציא מקורות; אם אתה מצטט, צטט רק ממה שהסוכנים אימתו-מקור (AH-1…AH-5).
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז — כיוון שאתה ה**מתזמר** וצריך תמונה מלאה — את **כל קבצי-הספ** (`00`–`07`, `X1`–`X5`) תחת `~/legal-ai/docs/spec/`; לניתוב comments בפרט → `X3-integration-deploy.md §1ב`. אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -145,17 +139,6 @@ internal_decision_upload(
 | בודק איכות | 1a5b229e-9220-4b13-940c-f8eb7285fc29 | QA לפני ייצוא |
 | מייצא טיוטה | d0dc703b-ca83-4883-bca7-c9449e8713cd | בדיקה סופית + ייצוא DOCX מגורסת |
 | מנהל ידע (Hermes) | CMP: 60dce831-5c5b-4bae-bda9-5282d506f0dc · CMPA: d6f7c55d-570a-46b8-8d72-1286d07da0d8 | סקירת החלטות סופיות, הצעות לעדכון style guide / lessons. **לא קורא ישירות מ-CEO** — מופעל אוטומטית מ-`web/app.py:api_mark_final` כשדפנה לוחצת "סמן כסופי" ב-UI. |
-| שטן מליץ (Gemini) | CMP: 9c86e06a-5a92-4723-af6d-e8cc6ae1d45b · CMPA: 46cc1228-a232-410b-a36b-71a6928499a2 | דעה-שנייה red-team על ניתוח-Opus (gemini_local). **on-demand בלבד — אינו חלק מהפייפליין.** ראה למטה. |
-
-### שטן מליץ (Gemini) — דעה-שנייה on-demand בלבד ⚠️
-
-סוכן-Gemini שמבצע red-team על תוצר-המנתח (Opus) ומפיק **מזכר-לידים לא-סמכותי ליו"ר** (`critique-gemini.md`), read-only. **אינו נמצא בזרימת analyst→writer→qa.**
-
-**מתי להפעיל:** **רק כשחיים/דפנה מבקשים מפורשות** "תן שטן-מליץ / דעה-שנייה על תיק X". אל תפעיל אותו אוטומטית, אל תכלול אותו בתזמור רגיל, ואל תציע אותו מיוזמתך.
-
-**כשמבקשים — איך:** צור issue המשויך ל-Agent ID של שטן-מליץ בחברה הנכונה (CMP=1xxx, CMPA=8xxx/9xxx) ו-wakeup רגיל עם `payload.issueId`.
-
-**הגבול הקריטי:** הפלט שלו = **לידים לבדיקת היו"ר בלבד** (human-in-the-loop). **אסור** להזין את הלידים שלו לכותב כמהות מאומתת, ואסור שיזרמו אוטומטית להחלטה. ה-writer ממשיך לצרוך **רק** את פלט-המנתח המעוגן. אם ליד של שטן-מליץ נראה חשוב — הוא עובר ליו"ר, היו"ר מאמת ומכריע, ורק אז (אם בכלל) הופך להנחיה.
 
 ## כלל: כל issue חדש = תת-משימה
 
@@ -245,31 +228,25 @@ Paperclip חוסם אוטומטית כל issue ב-`in_progress` שאין לו ru
 **מה לעשות:**
 1. קרא את ה-description של ה-issue — מצוין שם `case_law_id` וה-citation.
 2. **warmup**: קרא קודם `mcp__legal-ai__workflow_status(case_number="warmup")` (כלי קל שמאלץ MCP להתחבר). אם נכשל ב-"No such tool available" → `Bash sleep 5` ואז retry. רק אחרי שזה עובד, המשך:
-3. חלץ את **הפסיקה הזו בלבד** (לפי ה-`case_law_id` שב-description) — הרץ פעמיים:
+3. הרץ פעמיים:
    ```
-   mcp__legal-ai__precedent_extract_metadata(case_law_id="<uuid מה-issue>")
+   mcp__legal-ai__precedent_process_pending(kind="metadata")
-   mcp__legal-ai__precedent_extract_halachot(case_law_id="<uuid מה-issue>")
+   mcp__legal-ai__precedent_process_pending(kind="halacha")
    ```
-   ⚠️ **אל תריץ** `precedent_process_pending` — הוא מרוקן את **כל** התור ההיסטורי
+   הכלי מעבד את **כל** הפסיקות שבתור — אם תוקיע אחת והגיעו עוד בינתיים, גם הן יעובדו.
-   (מאות פסיקות, שעות עבודה), חורג מתקציב-הזמן של ה-heartbeat וגורם
+4. **תיקוף-ציטוטים (X11, אחרי חילוץ ההלכות):** הרץ
-   timeout/process_lost. ריקון-הבאקלוג רץ בנפרד כשירות-לילה ייעודי
-   (`legal-halacha-drain`, 23:00–05:00) — לא דרכך. כאן: רק התיק של ה-issue.
-4. **תיקוף-ציטוטים (X11, אחרי חילוץ ההלכות):** הרץ **תמיד עם ה-`case_law_id` של ה-issue** —
    ```
-   mcp__legal-ai__corroboration_rebuild(case_law_id="<uuid מה-issue>")
+   mcp__legal-ai__corroboration_rebuild()
    ```
-   ⚠️ **אל תריץ עם ארגומנט ריק** — ריק = `build_all()` שעובר על **כל הקורפוס** עם קריאת-LLM
+   (ארגומנט ריק = כל הקורפוס; `case_law_id="<uuid>"` = רק התקדים שעובד עכשיו — מהיר יותר). הכלי
-   (Opus) לכל ציטוט-נכנס = שעות → חורג מתקציב-הזמן של ה-heartbeat (timeout/process_lost), בדיוק
-   כמו ריקון-תור ההלכות. ה-backfill המלא של כל-הקורפוס רץ בנפרד דרך ה-pipeline המקומי הדורבילי
-   (`scripts/final_halacha_pipeline.py`), לא דרכך. כאן: רק התקדים של ה-issue. הכלי
    מסווג את הטיפול-השיפוטי של כל ציטוט-נכנס, מתאים אותו להלכה הספציפית, **ומחיל אישור-אוטומטי**:
    הלכה עם ≥2 ציטוטים חיוביים בלתי-תלויים (0 שליליים) שהיתה `pending_review` → `approved`
    (reviewer `corroborated …`); הלכה שמאוחר-יותר **בוטלה** (overruled) → חוזרת לשער-היו"ר. הוא
    idempotent ולא נוגע במצבים סופיים (`published`/`rejected`). אם הכלי לא קיים → ה-MCP server לא
    עלה מחדש מאז Phase 2; דלג ודווח (אל תיכשל על זה).
-5. כשמסתיים: כתוב comment קצר ב-issue (`precedent_extract_metadata`/`precedent_extract_halachot` +
+5. כשמסתיים: כתוב comment קצר ב-issue (`precedent_process_pending` + `corroboration_rebuild`
-   `corroboration_rebuild` מחזירים את התוצאות — סכם בעברית: כמה הלכות חולצו, אילו שדות מטא-דאטה
+   מחזירים את התוצאות — סכם בעברית: כמה הלכות חולצו, אילו שדות מטא-דאטה הושלמו, status לכל פסיקה,
-   הושלמו, status הפסיקה, וכמה הלכות אושרו/הודחו בתיקוף-ציטוטים — `{approved, demoted}`).
+   וכמה הלכות אושרו/הודחו בתיקוף-ציטוטים — `{approved, demoted}`).
 6. סמן את ה-issue כ-`done`.
 
 **אל**: אל תיצור issues של ביצוע בתיקי ערר, אל תיכנס לתהליך כתיבת החלטה — זו רק עבודת תחזוקה של ספריית הפסיקה.

.claude/agents/legal-exporter.md

@@ -28,8 +28,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. ייצוא מכני (DOCX) — **אפס מהות חדשה**: אל תוסיף/תשנה ציטוט/מספר/אזכור; מה שאינו במקור — לא קיים (AH-1…AH-5).
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/06-export.md` (ייצוא DOCX לפי תבנית דפנה). אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -124,11 +122,31 @@ tools:
 - ממצאי הבדיקה הסופית (אם היו הערות)
 - גודל הקובץ
 
-### סגור את ה-issue של עצמך + העֵר CEO — חובה!
+### סגור את ה-issue של עצמך — חובה!
 
-בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
+בלי זה Paperclip יזהה "issue in_progress + אין execution חיה" ויפעיל auto-retry בלולאה (נצפה בפועל ב-CMPA-17 ב-30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מייצא טיוטה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**אם הכל עבר בהצלחה (כל בדיקות השלב הקודם עברו, אין כשל בפלט):**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "done"}'```
+
+**אם בדיקות נכשלו, חסר פלט, או חסר מידע קריטי:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "blocked"}'```
+**אסור** לסיים `done` עם פלט חסר — אם משהו נכשל, סטטוס = `blocked` + comment עם פירוט.
+
+### העֵר את העוזר המשפטי (CEO) — חובה!
+```bash
+# CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
+
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" '{"source":"automation","triggerDetail":"system","reason":"מייצא טיוטה סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
+**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.
 
 ## כללים קריטיים
 

.claude/agents/legal-proofreader.md

@@ -20,8 +20,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. תיקון-OCR בלבד — **אל "תתקן" לכיוון מונח משפטי סביר** (שם-תקדים/מספר-תיק/סכום): שמר את לשון-המקור; ספק → סמן, לא "תקן" (AH-1…AH-5).
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/01-ingest.md` (קליטה / טקסט-מחולץ). אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -92,9 +90,29 @@ tools:
      "סיכום: X מסמכים הוגהו, Y החלפות, Z תיקונים. נדרשת ביקורתך."
    ```
 
-### סגור את ה-issue של עצמך + העֵר CEO — חובה!
+### סגור את ה-issue של עצמך — חובה!
 
-בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
+בלי זה Paperclip יזהה "issue in_progress + אין execution חיה" ויפעיל auto-retry בלולאה (נצפה בפועל ב-CMPA-17 ב-30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל / markers `[?]` רבים), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מגיה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**אם הכל עבר בהצלחה:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/$PAPERCLIP_TASK_ID" '{"status": "done"}'```
+
+**אם נכשלו תיקונים קריטיים או יש markers `[?]` רבים:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/$PAPERCLIP_TASK_ID" '{"status": "blocked"}'```
+**אסור** לסיים `done` עם פלט חסר — אם נכשל, סטטוס = `blocked` + comment עם פירוט.
+
+### העֵר את העוזר המשפטי (CEO) — חובה!
+
+```bash
+# CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
+
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" '{"source":"automation","triggerDetail":"system","reason":"מגיה סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
 **⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.

.claude/agents/legal-qa.md

@@ -27,8 +27,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא ו**אכוף** את `~/legal-ai/docs/anti-hallucination-gate.md` כשער-איכות: כל אזכור פסיקה/חוק/הלכה/מספר בטיוטה — האם מעוגן-מקור עם ציטוט? אם לא → `needs_revision` (AH-1…AH-5).
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/05-qa-review.md` (שערי QA + שערים אנושיים). אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -237,8 +235,28 @@ new → proofread → documents_ready → analyst_verified → research_complete
 - האם מותר לייצא (כל הקריטיים pass?)
 - עדכן סטטוס ל-qa_review (אם נכשל) או drafted (אם עבר)
 
-### סגור את ה-issue של עצמך + העֵר CEO — חובה!
+### סגור את ה-issue של עצמך — חובה!
 
-בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
+בלי זה Paperclip יזהה "issue in_progress + אין execution חיה" ויפעיל auto-retry בלולאה (נצפה בפועל ב-CMPA-17 ב-30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="בודק איכות סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**אם הכל עבר בהצלחה (כל בדיקות השלב הקודם עברו, אין כשל בפלט):**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "done"}'```
+
+**אם בדיקות נכשלו, חסר פלט, או חסר מידע קריטי:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "blocked"}'```
+**אסור** לסיים `done` עם פלט חסר — אם משהו נכשל, סטטוס = `blocked` + comment עם פירוט.
+
+### העֵר את העוזר המשפטי (CEO) — חובה!
+```bash
+# CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
+
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" '{"source":"automation","triggerDetail":"system","reason":"בודק איכות סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
+**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.

.claude/agents/legal-researcher.md

@@ -21,9 +21,6 @@ tools:
   - mcp__legal-ai__precedent_list
   - mcp__legal-ai__search_case_precedents
   - mcp__legal-ai__search_precedent_library
-  - mcp__legal-ai__search_digests
-  - mcp__legal-ai__digest_link
-  - mcp__legal-ai__digest_upload
   - mcp__legal-ai__internal_decision_upload
   - mcp__legal-ai__precedent_library_upload
   - mcp__legal-ai__precedent_library_get
@@ -37,11 +34,6 @@ tools:
   - mcp__legal-ai__missing_precedent_create
   - mcp__legal-ai__missing_precedent_list
   - mcp__legal-ai__missing_precedent_close
-  - mcp__legal-ai__extract_plans
-  - mcp__legal-ai__plan_get
-  - mcp__legal-ai__plan_search
-  - mcp__legal-ai__plan_list
-  - mcp__legal-ai__plan_upsert
   - mcp__legal-ai__workflow_status
 ---
 
@@ -53,8 +45,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. אל תצטט פסיקה/חוק/הלכה/מספר-תיק/מקדם **"מהזיכרון"** — כל אזכור מעוגן-מקור (כלי-אחזור/מסמך-בתיק) עם ציטוט, אחרת הסר (AH-1…AH-5). "לא נמצא — דורש אימות" עדיף על המצאה.
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/03-retrieval.md` (3 קורפוסים, hybrid/RRF, attribution); לקליטת-פסיקה → `01-ingest.md`. אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -203,26 +193,6 @@ mcp__legal-ai__internal_decision_upload(
 - `search_decisions` = החלטות דפנה (style_corpus) — הקאנון האישי שלה.
 - `search_case_precedents` = ציטוטים שדפנה צירפה ידנית לתיקים בעבר (case_precedents).
 
-#### 2ב.0 — שכבת-גילוי: יומוני "כל יום" (`search_digests`) — מצפן, לפני האימות
-
-לכל סוגיה מרכזית — הרץ `search_digests` כ**מצפן-מחקר (radar)**, **לא** כמקור-ציטוט. היומון הוא סיכום-משני (עפר טויסטר) של פסק-דין בודד, והוא מפנה אותך אל **הפסק המקורי**. אם נמצא יומון רלוונטי:
-
-1. קרא את כותרת-ההלכה ואת ניתוח עפר-טויסטר **כרקע/orientation בלבד**.
-2. חלץ את **מראה-המקום של הפסק המקורי** מהיומון (שדה `underlying_citation`, למשל `עת"מ 46111-12-22`).
-3. **בדוק אם הפסק המקורי בקורפוס** — `search_precedent_library` **וגם** `search_internal_decisions` לפי פרוטוקול 2ב.4א (לפי קידומת-הציטוט; flowchart §8).
-4. **אם נמצא** → אמת וצטט את הפסק המקורי כרגיל (`precedent_attach`), וקרא `digest_link(digest_id, case_law_id)` כדי לקשר את היומון לפסק.
-5. **אם לא נמצא** → קרא `missing_precedent_create` על **הפסק המקורי** (לא על היומון), עם `notes="זוהה דרך יומון 'כל יום' מס' NNNN"`. היומון הוא הטריגר; הרשומה החסרה היא הפסק. (אם הפסק זמין — אפשר להעלותו דרך `precedent_library_upload`/`internal_decision_upload` ואז `digest_link`.)
-
-⚠️ **היומון לעולם אינו מצוטט בהחלטה ואינו נרשם דרך `precedent_attach`** (INV-DIG1). הוא radar בלבד — מצביע, לא מקור. ראה [docs/spec/X12-digests-radar.md](../../docs/spec/X12-digests-radar.md).
-
-```
-search_digests(
-  query="...",
-  practice_area="betterment_levy",   # rishuy_uvniya / betterment_levy / compensation_197
-  limit=10
-)
-```
-
 #### 2ב.1 — קורפוס סמכותי (`search_precedent_library`) — חובה
 
 לכל **סוגיה משפטית מרכזית** בתיק — הרץ לפחות שאילתה אחת עם פילטרים:
@@ -340,10 +310,6 @@ mcp__legal-ai__missing_precedent_create(
 
 **במסמך `precedent-research.md`** הוסף סעיף `## ח. פסיקה חסרה בקורפוס` עם רשימת רשומות שנוצרו (כולל ה-id שהוחזר), כדי שה-writer וה-QA יבחינו בין "אומת מהקורפוס" ל"דיווח בלבד".
 
-#### 2ב.6 — תיעוד סריקת היומונים — סעיף "ט" ב-`precedent-research.md`
-
-הוסף סעיף נפרד `## ט. סריקת יומונים (radar — לא ציטוט)` שמתעד אילו יומונים נסרקו לכל סוגיה, אילו פסקי-דין מקוריים הם הצביעו עליהם, וסטטוס כל אחד: *בקורפוס (קושר) / נרשם כחסר / לא רלוונטי*. ציין מפורש: **רשומות אלה אינן ציטוטים** — הן עקבות-מחקר (radar). ה-writer וה-QA מתעלמים מהן כמקור-סמכות (INV-DIG1); הציטוט בהחלטה תמיד נשען על הפסק המקורי שבסעיפים ז/ח.
-
 5. **דווח** איזה תקדמים מהקאנון רלוונטיים, איזה תקדמים אישיים נמצאו, ואילו הלכות מהקורפוס הסמכותי תומכות.
 
 ### שלב 3: מיפוי תכנית
@@ -397,11 +363,31 @@ python3 /home/chaim/legal-ai/scripts/notify.py \
   - **מדיניות**: אילו שיקולים תכנוניים עולים מהחומר
 - קישור למיקום הקובץ: `{case_dir}/documents/research/precedent-research.md`
 
-### סגור את ה-issue של עצמך + העֵר CEO — חובה!
+### סגור את ה-issue של עצמך — חובה!
 
-בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
+בלי זה Paperclip יזהה "issue in_progress + אין execution חיה" ויפעיל auto-retry בלולאה (נצפה בפועל ב-CMPA-17 ב-30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="חוקר תקדימים סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**אם הכל עבר בהצלחה (כל בדיקות השלב הקודם עברו, אין כשל בפלט):**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "done"}'```
+
+**אם בדיקות נכשלו, חסר פלט, או חסר מידע קריטי:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "blocked"}'```
+**אסור** לסיים `done` עם פלט חסר — אם משהו נכשל, סטטוס = `blocked` + comment עם פירוט.
+
+### העֵר את העוזר המשפטי (CEO) — חובה!
+```bash
+# CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
+
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" '{"source":"automation","triggerDetail":"system","reason":"חוקר תקדימים סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
+**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.
 
 ## כללים
 - **דיוק** — ציין מספרי סעיפים, תאריכים, שמות שופטים

.claude/agents/legal-writer.md

@@ -35,8 +35,6 @@ tools:
 
 ## קרא לפני פעולה (INV-AG1)
 
-> **שער anti-hallucination (INV-AH) — חובה:** קרא וקיים `~/legal-ai/docs/anti-hallucination-gate.md`. אתה **צרכן read-only** של פלט-המנתח המעוגן — **אסור** להוסיף פסיקה/סעיף/הלכה שלא הגיעו מהמנתח/הקורפוס; ציטוט בהחלטה = רק מ-`supporting_quote` מאומת (AH-1…AH-5).
-
 לפני העבודה המהותית — קרא **תחילה** את חוקת המערכת `~/legal-ai/docs/spec/00-constitution.md` (ייעוד, G1–G11, אינדקס-ספ §7), ואז את ספ-התחום שלך: `~/legal-ai/docs/spec/04-analysis-writing.md` + `05-qa-review.md` (אתה כותב מול שערי-QA). אינך פועל "מהזיכרון" — המקור הקנוני להתנהגות הוא החוקה + ספ-התחום. ראה גם [HEARTBEAT.md](HEARTBEAT.md) ("קריאת-ספ") ו-`~/legal-ai/docs/spec/X4-agents.md` (מפת תפקיד→ספ).
 
 ## שפה
@@ -214,11 +212,31 @@ case_update(case_number, status="drafted")
 - ספירת מילים לכל בלוק
 - יחסי משקל (% מהמסמך)
 
-### סגור את ה-issue של עצמך + העֵר CEO — חובה!
+### סגור את ה-issue של עצמך — חובה!
 
-בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
+בלי זה Paperclip יזהה "issue in_progress + אין execution חיה" ויפעיל auto-retry בלולאה (נצפה בפועל ב-CMPA-17 ב-30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="כותב החלטה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**אם הכל עבר בהצלחה (כל בדיקות השלב הקודם עברו, אין כשל בפלט):**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "done"}'```
+
+**אם בדיקות נכשלו, חסר פלט, או חסר מידע קריטי:**
+```bash
+~/legal-ai/scripts/pc.sh PATCH "/api/issues/{issue-id}" '{"status": "blocked"}'```
+**אסור** לסיים `done` עם פלט חסר — אם משהו נכשל, סטטוס = `blocked` + comment עם פירוט.
+
+### העֵר את העוזר המשפטי (CEO) — חובה!
+```bash
+# CEO לפי חברה — אסור לקבע UUID, חברות שונות = CEO שונה
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"   # CMPA — היטלי השבחה
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"   # CMP — רישוי ובניה
+fi
+
+~/legal-ai/scripts/pc.sh POST "/api/agents/$CEO_ID/wakeup" '{"source":"automation","triggerDetail":"system","reason":"כותב החלטה סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'```
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
+**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.
 
 **אם לא תעדכן סטטוס ל-drafted — בודק האיכות לא יוכל לרוץ!**
 

.claude/settings.json

@@ -1,18 +1,4 @@
 {
-  "permissions": {
-    "deny": [
-      "mcp__task-master-local__update_task",
-      "mcp__task-master-local__update",
-      "mcp__task-master-local__update_subtask",
-      "mcp__task-master-local__expand_task",
-      "mcp__task-master-local__expand_all",
-      "mcp__task-master-local__analyze_project_complexity",
-      "mcp__task-master-local__research",
-      "mcp__task-master-local__parse_prd",
-      "mcp__task-master-local__scope_up_task",
-      "mcp__task-master-local__scope_down_task"
-    ]
-  },
   "hooks": {
     "PreToolUse": [
       {

.dockerignore

@@ -10,7 +10,6 @@ mcp-server/.venv/
 web/static/
 web/__pycache__/
 scripts/
-!scripts/SCRIPTS.md
 skills/
 !skills/docx/
 !skills/docx/decision_template.docx

.gitea/PULL_REQUEST_TEMPLATE.md

@@ -1,6 +1,6 @@
 <!--
 תבנית PR — עוזר משפטי. מאכפת את "פרוטוקול כתיבת-קוד" (CLAUDE.md §פרוטוקול כתיבת-קוד):
-כל PR מצהיר אילו invariants הוא נוגע בהם / מקיים. ראה docs/spec/00-constitution.md (G1–G12).
+כל PR מצהיר אילו invariants הוא נוגע בהם / מקיים. ראה docs/spec/00-constitution.md (G1–G11).
 מלא את הסעיפים; מחק את ההערות בסוגריים <!-- -->.
 -->
 
@@ -11,9 +11,8 @@
 ## Invariants — הצהרה (חובה)
 
 <!--
-אילו invariants הנדסיים (G1–G10, G12) או INV-* מקבצי-תחום ה-PR נוגע בהם או מקיים?
+אילו invariants הנדסיים (G1–G10) או INV-* מקבצי-תחום ה-PR נוגע בהם או מקיים?
 דוגמה: "G2 (מקור-אמת יחיד) — איחדתי 2 לקוחות Paperclip למסלול קנוני אחד; INV-INT4."
-דוגמה: "G12 (שער-הפלטפורמה) — מגע-Paperclip חדש נוסף רק ב-agent_platform_port.py, לא ב-mcp-server."
 תוכן משפטי → G11.
 -->
 
@@ -23,7 +22,6 @@
 
 - [ ] קראתי את `docs/spec/00-constitution.md` + ספ-התחום הרלוונטי לפני הכתיבה
 - [ ] השינוי **לא** יוצר מסלול מקביל ליכולת קיימת (G2) ולא מתקן תסמין בקריאה (G1)
-- [ ] **לא** הוספתי מגע-Paperclip מחוץ ל-Platform Port (G12) — `mcp-server/src` וה-skills נקיים
 - [ ] אין בליעה שקטה של שגיאות — רשומה חסרה/פגומה מסומנת ומדווחת (כלל-הנדסה §6)
 - [ ] בדקתי מול `docs/spec/gap-audit.md` — אם נגעתי ב-GAP/FU ממופה, התאמתי ליחידת-התיקון
 - [ ] בדיקות עוברות (אם רלוונטי) / לא נדרשות

.gitea/workflows/leak-guard.yaml

@@ -1,22 +0,0 @@
-name: G12 Leak-Guard
-
-# Hard gate for INV-G12 (docs/spec/X15 §4 / R4): the intelligence layer
-# (mcp-server/src) must stay free of Paperclip-specific symbols, and only
-# web/agent_platform_port.py may import the Paperclip client. Pure-stdlib check
-# (no venv) — fast, runs on every PR and on push to main.
-
-on:
-  pull_request:
-    branches: [main]
-  push:
-    branches: [main]
-
-jobs:
-  leak-guard:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: G12 — Agent Platform Port leak-guard
-        run: python3 scripts/leak_guard.py

.gitea/workflows/lint.yaml

@@ -1,27 +0,0 @@
-name: Lint — undefined names
-
-# High-signal static gate for the bug class behind PR #249 (case-rename 500):
-# a name referenced but never imported/defined. Invisible to tests when it sits
-# in a rarely-hit branch or a fire-and-forget background task — it only
-# NameErrors at runtime. pyflakes catches it before merge. Gates ONLY on
-# undefined names (not unused imports / f-strings — those are noise). Uses a
-# throwaway venv so it is immune to PEP-668 externally-managed environments.
-
-on:
-  pull_request:
-    branches: [main]
-  push:
-    branches: [main]
-
-jobs:
-  undefined-names:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Run undefined-name guard
-        run: |
-          python3 -m venv /tmp/lintvenv
-          /tmp/lintvenv/bin/pip install --quiet pyflakes==3.4.0
-          /tmp/lintvenv/bin/python scripts/check_undefined_names.py

.gitignore

@@ -6,7 +6,6 @@ data/backups/
 data/precedent-library/
 data/.auto-sync.log
 data/*.db
-data/checkpoints/        # X16 durable-pipeline SQLite checkpoints (runtime artifact)
 *.bak-pre-*
 mcp-server/.venv/
 __pycache__/
@@ -18,6 +17,4 @@ kiryat-yearim/
 continuation-prompt.md
 node_modules/
 data/eval/eval-report-*
-data/adapter-migration-state.json   # revert snapshot for migrate_agent_adapter.py (runtime state)
-.claude/agents/.generated/          # frontmatter-stripped instruction copies for content_arg adapters (generated)
 .claude/worktrees/

.taskmaster/tasks/tasks.json

@@ -978,7 +978,7 @@
   "legal-ai": {
     "tasks": [
       {
-        "id": "1",
+        "id": 1,
         "title": "V7 schema: precedent library + halachot tables",
         "description": "Add SCHEMA_V7_SQL to db.py: extend case_law with source_kind/document_id/extraction_status/halacha_extraction_status/practice_area (CHECK constraint for 3 areas)/appeal_subtype/headnote. Create precedent_chunks table with vector(1024). Create halachot table with vector(1024), review_status, practice_areas array. Add IVFFlat indexes. Register V7 in init_schema().",
         "details": "",
@@ -990,7 +990,7 @@
         "updatedAt": "2026-05-03T08:17:59.928Z"
       },
       {
-        "id": "2",
+        "id": 2,
         "title": "Chunker: add court ruling section patterns",
         "description": "Extend services/chunker.py SECTION_PATTERNS with 4 patterns for external court rulings: פסק דין→ruling, נימוקים→legal_analysis, סוף דבר→conclusion, העובדות הצריכות לעניין→facts",
         "details": "",
@@ -1004,7 +1004,7 @@
         "updatedAt": "2026-05-03T08:18:33.239Z"
       },
       {
-        "id": "3",
+        "id": 3,
         "title": "Service: halacha_extractor.py",
         "description": "New service that runs claude_session.query_json() over chunks where section_type IN (legal_analysis, ruling, conclusion). Concurrency=3, retry=1. Validates supporting_quote with substring check after Hebrew normalization. All halachot inserted with review_status=pending_review (no auto-publish). Embeds rule_statement+reasoning_summary via Voyage. Uses Hebrew prompt from plan appendix א. Idempotent on case_law_id.",
         "details": "",
@@ -1019,7 +1019,7 @@
         "updatedAt": "2026-05-03T08:22:12.392Z"
       },
       {
-        "id": "4",
+        "id": 4,
         "title": "Service: precedent_library.py orchestrator",
         "description": "New service with ingest_precedent(file_path, citation, court, decision_date, source_type, precedent_level, practice_area, appeal_subtype, subject_tags, case_name, task_id) that orchestrates: extract_text → proofread → INSERT case_law (source_kind=external_upload) → chunk → embed → store precedent_chunks → halacha_extractor.extract → embed halachot → publish progress. Plus delete_precedent (cascading), list_precedents(filters), get_precedent(id), search_library(query, filters, limit) merging chunks+approved-halachot ranked.",
         "details": "",
@@ -1035,7 +1035,7 @@
         "updatedAt": "2026-05-03T08:23:33.235Z"
       },
       {
-        "id": "5",
+        "id": 5,
         "title": "MCP tools: precedent_library + halacha_review",
         "description": "Create mcp-server/src/legal_mcp/tools/precedent_library.py with tools: precedent_library_upload, precedent_library_list, precedent_library_get, precedent_library_delete, precedent_extract_halachot, search_precedent_library (semantic, returns merged halachot+chunks), halacha_review (approve/reject). Register all in server.py. Do NOT modify existing precedent_search_library or search_decisions.",
         "details": "",
@@ -1049,7 +1049,7 @@
         "updatedAt": "2026-05-03T08:25:07.439Z"
       },
       {
-        "id": "6",
+        "id": 6,
         "title": "FastAPI endpoints under /api/precedent-library",
         "description": "Add to web/app.py: POST /api/precedent-library/upload (multipart), GET /api/precedent-library (filters), GET /api/precedent-library/{id}, PATCH /api/precedent-library/{id}, DELETE /api/precedent-library/{id}, POST /api/precedent-library/{id}/extract-halachot, GET /api/precedent-library/search, GET /api/halachot?status=pending_review, PATCH /api/halachot/{id}, GET /api/precedent-library/stats. Reuse existing /api/progress/{task_id} SSE.",
         "details": "",
@@ -1063,7 +1063,7 @@
         "updatedAt": "2026-05-03T08:26:21.860Z"
       },
       {
-        "id": "7",
+        "id": 7,
         "title": "UI: /precedents page with 4 tabs",
         "description": "New web-ui/src/app/precedents/page.tsx with tabs: Library (table+filters+upload), Semantic Search, Pending Review (PRIMARY - bulk approval UX with J/K nav, A/R/E shortcuts, side-by-side rule_statement vs supporting_quote, badge count), Stats. New components in web-ui/src/components/precedents/: precedent-upload-sheet, precedent-list-table, precedent-search-panel, precedent-detail-panel, halacha-review-card. New hooks in web-ui/src/lib/api/precedent-library.ts. Add nav link in app-shell.tsx.",
         "details": "",
@@ -1077,7 +1077,7 @@
         "updatedAt": "2026-05-03T08:34:00.548Z"
       },
       {
-        "id": "8",
+        "id": 8,
         "title": "Agent integration: legal-writer + 3 others",
         "description": "Update .claude/agents/legal-writer.md (PRIMARY) — add mcp__legal-ai__search_precedent_library to tools and prompt section explaining when to use it for CREAC rule+explanation in block י. Update legal-researcher.md, legal-analyst.md, legal-ceo.md, legal-qa.md to add the tool. Update skills/decision/SKILL.md with section explaining the 3 corpora (style_corpus, case_precedents, precedent_library).",
         "details": "",
@@ -1091,7 +1091,7 @@
         "updatedAt": "2026-05-03T08:36:24.711Z"
       },
       {
-        "id": "9",
+        "id": 9,
         "title": "Service: precedent_metadata_extractor.py",
         "description": "LLM-based extractor that auto-fills empty metadata fields after upload: short case_name (e.g. 'אהרון ברק' from long citation), summary (2-3 sentences), headnote, key_quote, subject_tags array, appeal_subtype. Reuses claude_session.query_json. Returns dict; caller decides which empty fields to merge (never overrides user values).",
         "details": "",
@@ -1103,7 +1103,7 @@
         "updatedAt": "2026-05-03T10:19:15.105Z"
       },
       {
-        "id": "10",
+        "id": 10,
         "title": "Halacha extractor: dual mode (binding vs persuasive)",
         "description": "Update halacha_extractor.py prompt to branch on is_binding: binding=true → strict halacha extraction (current). binding=false → extract reasoning principles, applications of established halachot, persuasive conclusions. New rule_types: 'application' (applying known rule to facts), 'persuasive' (committee's reasoning citable as authority). Schema unchanged (rule_type already TEXT).",
         "details": "",
@@ -1115,7 +1115,7 @@
         "updatedAt": "2026-05-03T10:19:15.117Z"
       },
       {
-        "id": "11",
+        "id": 11,
         "title": "Ingest pipeline: add metadata extraction stage",
         "description": "In services/precedent_library.py:ingest_precedent, after halacha extraction, run metadata_extractor and PATCH the case_law row with auto-filled fields (only those left empty by user). Publish progress 'extracting_metadata'.",
         "details": "",
@@ -1129,7 +1129,7 @@
         "updatedAt": "2026-05-03T10:19:15.128Z"
       },
       {
-        "id": "12",
+        "id": 12,
         "title": "UI: precedent edit sheet",
         "description": "Add edit button to library-list-panel rows that opens a Sheet with all editable fields (case_name, citation, court, date, practice_area, appeal_subtype, subject_tags, summary, headnote, key_quote, source_type, precedent_level, is_binding). Pre-populated from current values. Submit calls PATCH /api/precedent-library/{id} via useUpdatePrecedent. After save, invalidate library list query.",
         "details": "",
@@ -1141,7 +1141,7 @@
         "updatedAt": "2026-05-03T10:19:15.134Z"
       },
       {
-        "id": "13",
+        "id": 13,
         "title": "Test on 403-17: fix metadata + re-extract",
         "description": "After deploy: PATCH 403-17 to set case_name='ערר 403/17', then trigger precedent_extract_halachot to test the dual-mode extraction on a non-binding committee decision.",
         "details": "",
@@ -1158,7 +1158,7 @@
         "updatedAt": "2026-05-26T10:38:07.071897Z"
       },
       {
-        "id": "14",
+        "id": 14,
         "title": "Upgrade: speed up halacha+metadata extraction",
         "description": "Halacha extraction on long rulings is slow (5-15 min for typical court ruling, 30-50 min for a 207-chunk appeals committee decision). Root cause: each chunk spawns a separate `claude -p` subprocess (5-10 sec startup overhead each), Hebrew prompts on cold cache run 30-90 sec, and there's no prompt-cache sharing between chunks. Acceleration options to evaluate later when speed becomes a real blocker.\n\nOptions (each can be combined):\n\n1. Concurrency 3 -> 6 in halacha_extractor.CHUNK_CONCURRENCY. ~2x faster wall-clock. Cost: 6x ~300MB RSS = 1.8GB peak — verify on Nautilus headroom.\n\n2. Larger chunks 12K -> 18-25K chars (CHUNK_TARGET_CHARS in claims_extractor.py / halacha_extractor.py). Fewer waves. Risk: timeout on cold cache (currently 1800s ceiling), and may degrade extraction precision for very long sections.\n\n3. Anthropic SDK direct with 5-min ephemeral prompt caching on the static instruction prefix (already wired the parameter as system= in claude_session.query). Estimated 5-10x faster because cache reads are ~10% of cold cost. Costs ~$0.30-2 per long ruling on Sonnet 4.6. Chair previously rejected this path for ALL traffic ('we work only with claude session'). Compromise: SDK only for the precedent-library corpus build (static, one-time), claude session for live decision drafting (interactive, frequent).\n\n4. Two-tier prompt: a short 'classification' pass with claude -p deciding which chunks contain halachot, then deep extraction only on positive chunks. Could cut total LLM time by 40-60% on rulings with lots of factual chapters.\n\n5. Already implemented (Apr 3, 2026): skip non-extractable sections — only run on chunks where section_type IN (legal_analysis, ruling, conclusion); fallback to all chunks when chunker labels nothing. So that win is already banked.\n\nRe-evaluate when: a chair drops a 200K+ char ruling into the queue and the wait becomes painful, OR when the precedent-library has 50+ pending entries and bulk processing matters.",
         "details": "נסקר 2026-06-03 — אין blocker נוכחי. הרצתי reindex ל-73 תקדימים + חילוצים מרובים בלי שמהירות הייתה כאב. YAGNI: לא מבצעים אופטימיזציה מוקדמת. נשאר deferred עם trigger ברור: פסק-דין 200K+ תווים שתוקע את התור, או 50+ פריטים ממתינים. ה-win הזול (concurrency 3→6) דורש אימות headroom של 1.8GB RSS ב-Nautilus לפני — לא עכשיו.",
@@ -1170,7 +1170,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "15",
+        "id": 15,
         "title": "Multimodal — כיוונון MULTIMODAL_TEXT_WEIGHT (A/B) + הכרעה על backfill",
         "description": "נסגר 2026-06-03 לאחר A/B אובייקטיבי על gold-set (86 שאילתות, eval_retrieval.py). הנחת היסוד התיישנה: multimodal כבר ברירת-מחדל בייצור (110 מסמכים מוטמעים אוטומטית בהעלאה), לא רק 2 תיקי A/B. ממצא: ה-weight 0.5 (ברירת-מחדל) היה mis-tuned — צד-התמונה כבד מדי וחתך recall של precedent_library (0.971→0.885). sweep 0.5→0.75: במשקל 0.65 multimodal מנצח את text-only בכל מדד ובכל corpus (R@5 0.994 מול 0.989; nDCG@5 0.960 מול 0.944; MRR 0.954 מול 0.936; precedent_library R@5 0.983, internal_decisions nDCG 0.978). כיסוי: 28/79 מסמכי gold-set מוטמעים multimodal (35% — אות אמיתי). דפנה אישרה.",
         "details": "בוצע: MULTIMODAL_TEXT_WEIGHT=0.65 הוגדר ב-Coolify env של legal-ai (runtime) + redeploy; baseline (data/eval/baseline.json) עודכן לקונפיג 0.65. ה-backfill היקר ל-140 התיקים ה-legacy *לא* בוצע — אין הצדקת-אחזור לשאלות טקסט, וערך ה-image-answer לא נבדק. מומר ל-#80 (מותנה). ראיות: data/eval/eval-report-20260603T08*.md, project_multimodal_stage_c.",
@@ -1182,7 +1182,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "16",
+        "id": 16,
         "title": "[Paperclip Gap 1] runtime_config ריק — חסרים graceSec/cooldownSec/maxConcurrentRuns",
         "description": "runtime_config = '{}' לכל 14 הסוכנים. מסתבר שעיקר ההגדרות החשובות (timeoutSec=3600, maxTurnsPerRun=500) יושבות ב-adapter_config ולא ב-runtime_config — אז המצב פחות חמור. אבל graceSec/cooldownSec/maxConcurrentRuns עדיין חסרים.",
         "details": "תיקון לניתוח המקורי שגוי בעקבות בדיקה ב-DB:\n\nמה שכן יש לנו (ב-adapter_config, לא runtime_config):\n- timeoutSec: 3600 (לכל הסוכנים)\n- maxTurnsPerRun: 500 (לכל הסוכנים)\n- model + effort=high (לכל הסוכנים)\n- paperclipSkillSync.desiredSkills (5/7 סוכנים — חסר אצל הגהת מסמכים ומנתח משפטי)\n\nמה שבאמת חסר ב-runtime_config:\n- heartbeat.graceSec — זמן grace לפני SIGKILL אחרי timeout. מהקוד: Math.max(1, graceSec)*1000. אם לא מוגדר → 1ms grace. בעיה אם הסוכן נחתך באמצע commit ל-DB.\n- heartbeat.cooldownSec — default ביצירה חדשה: 10. אצלנו לא מוגדר.\n- heartbeat.maxConcurrentRuns — default מ-AGENT_DEFAULT_MAX_CONCURRENT_RUNS (כנראה 1).\n- heartbeat.wakeOnDemand — default=true בקוד. אצלנו לא מוגדר אבל בפועל true.\n- heartbeat.enabled — default=false (timer off). זה הרצוי אצלנו.\n\nפעולה (Phase 1):\n1. עדכון runtime_config של כל סוכן: { heartbeat: { graceSec: 60, cooldownSec: 10, maxConcurrentRuns: 1, wakeOnDemand: true } }\n2. בעיקר graceSec — בלעדיו commit באמצע יכול להיכשל\n3. cooldownSec=10 (זהה לdefault ב-UI ליצירת agent חדש)\n\nהשפעה: minimal — רוב המקרים עובדים עם defaults. graceSec הוא העיקר.",
@@ -1194,7 +1194,7 @@
         "updatedAt": "2026-05-04T07:47:02.008Z"
       },
       {
-        "id": "17",
+        "id": 17,
         "title": "[Paperclip Gap 2] תקציבים = 0 לכל הסוכנים — אין budget enforcement",
         "description": "budget_monthly_cents = 0 ו-spent_monthly_cents = 0 לכל 14 הסוכנים. Paperclip מציע cost control מובנה — אנחנו מתעלמים.",
         "details": "ממצא: SELECT name, budget_monthly_cents, spent_monthly_cents FROM agents → הכל אפס.\n\nסיכון: לולאה חבויה יכולה לשרוף מאות $. אין auto-pause ב-80% spend (דפוס ש-CEO HEARTBEAT הרשמי מצפה לו).\n\nפעולה (Phase 3):\n1. מדידה: כמה כל סוכן באמת מוציא בחודש כיום (דרך לוגי claude-code, או Anthropic dashboard).\n2. הגדרת budget_monthly_cents סביר לכל סוכן (כותב Opus ≫ מנתח Sonnet).\n3. בדיקה שהמנגנון מפסיק כשמגיעים ל-100%.\n\nשאלה לחיים לפני ביצוע: באיזו רזולוציה למדוד? לפי Anthropic invoice, או לפי טוקנים בלוגים של claude_session?",
@@ -1206,7 +1206,7 @@
         "updatedAt": "2026-05-04T10:18:08.046Z"
       },
       {
-        "id": "18",
+        "id": 18,
         "title": "[Paperclip Gap 3] חסר X-Paperclip-Run-Id header בקריאות API",
         "description": "ה-skill הרשמי קובע: 'You MUST include -H X-Paperclip-Run-Id: $PAPERCLIP_RUN_ID on ALL API requests that modify issues'. ב-HEARTBEAT.md שלנו אין זכר לכך.",
         "details": "ממצא: grep -n 'X-Paperclip-Run-Id' .claude/agents/ → 0 hits. כל curl ב-checkout/comments/PATCH issues — בלי הheader.\n\nסיכון: audit trail שבור. שאלה 'איזו ריצה שינתה את ה-issue X?' אין לה תשובה ב-DB.\n\nפעולה (Phase 1):\n1. עדכון .claude/agents/HEARTBEAT.md — דוגמאות ה-curl יכללו את הheader\n2. עדכון 6 קבצי הסוכנים (legal-ceo.md, legal-analyst.md, legal-researcher.md, legal-writer.md, legal-qa.md, legal-exporter.md) — כל מקום שיש curl POST/PATCH\n3. בדיקה שיש env var $PAPERCLIP_RUN_ID זמין בכל heartbeat",
@@ -1218,7 +1218,7 @@
         "updatedAt": "2026-05-04T08:49:44.646Z"
       },
       {
-        "id": "19",
+        "id": 19,
         "title": "[Paperclip Gap 4] לא משתמשים ב-/api/issues/{id}/interactions לאישורים",
         "description": "Paperclip מציע API מובנה לאישור/שאלות (request_confirmation, ask_user_questions, suggest_tasks) עם idempotency keys ו-auto-wake. אנחנו עדיין כותבים 'חיים, מה לעשות?' כ-comment חופשי.",
         "details": "סוגי interaction:\n- ask_user_questions — שאלות מובנות\n- request_confirmation — yes/no עם idempotency key (confirmation:{issueId}:plan:{revisionId})\n- suggest_tasks — הצעת עץ משימות\n- continuationPolicy: wake_assignee — wake אוטומטי על מענה\n- supersedeOnUserComment: true — בטל אם חיים עונה\n\nסיכון: אין UI מובנה לחיים (כפתורים), רק טקסט. אם הסוכן מתעורר פעמיים — שתי שאלות זהות.\n\nפעולה (Phase 2):\n1. בlegal-ceo.md — להחליף 'אם חיים לא הגדיר outcome: שאל בcomment' ב-request_confirmation\n2. בbrainstorm_directions — suggest_tasks במקום רשימת bullet\n3. בlegal-qa.md — request_confirmation לאישור export\n\nשאלה לחיים: האם תרצה לראות UI חדש או להישאר ב-Markdown comments?",
@@ -1234,7 +1234,7 @@
         "updatedAt": "2026-05-04T11:18:59.050Z"
       },
       {
-        "id": "20",
+        "id": 20,
         "title": "[Paperclip Gap 5] לא משתמשים ב-PAPERCLIP_WAKE_PAYLOAD_JSON fast-path",
         "description": "בwake שמכוון ל-issue ספציפי, ה-env var מכיל כבר issue summary + comments חדשים דחוסים. ה-skill הרשמי אומר 'skip Steps 1-4 entirely'. שלנו תמיד fetcher גם ה-API.",
         "details": "ממצא: HEARTBEAT.md סעיפים 2-2c תמיד פונים ל-API גם אם ה-payload כבר מכיל את הכל.\n\nתועלת: חיסכון 3-4 קריאות API לכל ריצה. בwakeups תכופים (CEO על comments) — חיסכון ניכר.\n\nפעולה (Phase 2):\n1. הוספה ל-HEARTBEAT.md בראש הסעיפים: 'אם $PAPERCLIP_WAKE_PAYLOAD_JSON קיים — קרא אותו ראשון. רק אם fallbackFetchNeeded:true או חסר הקשר רחב — fetch'.\n2. דוגמה לפענוח JSON: jq עם key paths\n3. בדיקה איזה wake reasons בכלל מקבלים payload (כנראה comment-driven בלבד)",
@@ -1248,7 +1248,7 @@
         "updatedAt": "2026-05-04T09:15:46.339Z"
       },
       {
-        "id": "21",
+        "id": 21,
         "title": "[Paperclip Gap 6] שאילתות psql ישירות ל-issue_attachments — שובר אבסטרקציה",
         "description": "HEARTBEAT.md סעיף 2c משתמש ב-psql ישיר ל-issue_attachments + assets. אם schema ישתנה (כפי שצפוי בעדכוני Paperclip) — כל הסוכנים נשברים.",
         "details": "ממצא: 6 קבצי סוכן + HEARTBEAT.md מכילים PGPASSWORD=paperclip psql ... FROM issue_attachments ia JOIN assets a.\n\nסיכון: breakage בעדכון Paperclip. כפילות לוגיקה (copy-paste בכל סוכן).\n\nפעולה (Phase 2):\n1. בדיקה אם קיים endpoint רשמי /api/issues/{id}/attachments (curl + grep ב-server/src/routes)\n2. אם כן — להחליף את כל ה-psql\n3. אם לא — להעביר את ה-psql למקום יחיד: helper ב-mcp-server (mcp__legal-ai__list_issue_attachments tool)\n4. אופציה ג: לפתוח issue ב-paperclipai/paperclip לבקש endpoint\n\nתלוי במחקר API.",
@@ -1262,7 +1262,7 @@
         "updatedAt": "2026-05-04T09:28:18.058Z"
       },
       {
-        "id": "22",
+        "id": 22,
         "title": "[Paperclip Gap 7] לא משתמשים ב-/api/issues/{id}/heartbeat-context",
         "description": "Endpoint רשמי שמחזיר issue + ancestors + goal/project + comment cursor בקריאה אחת. אנחנו עושים 3 קריאות נפרדות.",
         "details": "ה-skill הרשמי: 'Prefer GET /api/issues/{issueId}/heartbeat-context first. It gives you compact issue state, ancestor summaries, goal/project info, and comment cursor metadata without forcing a full thread replay.'\n\nשלנו: HEARTBEAT.md סעיפים 2 + 2b → שלוש קריאות (inbox-lite, issue, comments).\n\nפעולה (Phase 2):\n1. הוספת endpoint כצעד 6 ב-HEARTBEAT.md לפני 'Do the work'\n2. הסרת קריאות מיותרות שכבר ב-context\n3. שמירת comment cursor (after={last-seen-id}) לקריאות עוקבות",
@@ -1276,7 +1276,7 @@
         "updatedAt": "2026-05-04T09:28:14.247Z"
       },
       {
-        "id": "23",
+        "id": 23,
         "title": "[Paperclip Gap 8+11] HEARTBEAT.md ארוך + אין שימוש ב-skills של Paperclip",
         "description": "HEARTBEAT.md שלנו 220 שורות (vs upstream 85). Paperclip מציע 8 skills מוכנים (paperclip, paperclip-create-agent, וכו') שאנחנו לא משתמשים באף אחד.",
         "details": "תיקון לניתוח: מסתבר ש-CEO + 4 סוכנים אחרים כן משתמשים ב-paperclipSkillSync עם 4 paperclip skills (paperclip, paperclip-create-agent, paperclip-create-plugin, para-memory-files). חסר אצל: הגהת מסמכים ומנתח משפטי (skills_count=0).\n\nממצא: ls skills/ ב-paperclip repo → 8 skills. שלנו: 0 skills של Paperclip בשימוש.\n\nרלוונטיים לנו:\n- paperclip — API patterns + heartbeat checklist (יכול להחליף חלק מ-HEARTBEAT.md)\n- paperclip-create-agent — אם נוסיף סוכן\n- paperclip-create-plugin — לעדכוני plugin-legal-ai\n- paperclip-converting-plans-to-tasks — יכול להחליף brainstorm_directions\n- diagnose-why-work-stopped — לתחזוקה\n\nפעולה (Phase 3):\n1. קריאת skills/paperclip/SKILL.md מלא\n2. הזרקת skill לסביבת הסוכנים (כנראה דרך CLI: paperclipai agent local-cli)\n3. שכתוב HEARTBEAT.md לפי הדפוס: project-specific only, delegation לskill הרשמי לכלל ה-API\n4. יעד: ~120 שורות ב-HEARTBEAT.md שלנו\n\nשאלה לחיים: האם להזריק skills כסימלינקים ל-symlinks קיימים, או דרך paperclipai CLI?",
@@ -1296,7 +1296,7 @@
         "updatedAt": "2026-05-04T16:44:27.553Z"
       },
       {
-        "id": "24",
+        "id": 24,
         "title": "[Paperclip Gap 9] לבדוק bootstrapPromptTemplate deprecated באף סוכן",
         "description": "מ-docs/agents-runtime.md: 'bootstrapPromptTemplate is deprecated... should be migrated to the managed instructions bundle system.' לבדוק האם adapter_config שלנו משתמש בזה.",
         "details": "פעולה (Phase 1):\n1. SELECT name, adapter_config->'promptTemplate' as pt, adapter_config->'bootstrapPromptTemplate' as bpt FROM agents WHERE adapter_type = 'claude_local';\n2. אם בשימוש אצל סוכן כלשהו — מיגרציה למבנה החדש\n3. ייעוד: לבדוק תיעוד managed instructions bundle ב-paperclip docs\n\nהערה: זה כנראה לא ישפיע אצלנו (אנחנו משתמשים ב-symlinks ל-AGENTS.md/HEARTBEAT.md ישירות) — אבל חובה לוודא.",
@@ -1308,7 +1308,7 @@
         "updatedAt": "2026-05-04T08:19:27.766Z"
       },
       {
-        "id": "25",
+        "id": 25,
         "title": "[Paperclip Gap 10] סוכנים מוכפלים בין 2 חברות — אין סנכרון",
         "description": "14 שורות = 7 סוכנים × 2 חברות (1xxx, 8xxx). כל שינוי בהגדרות הסוכן צריך להיעשות פעמיים. אין מנגנון סנכרון או הורשה.",
         "details": "ממצא: SELECT name, COUNT(*) FROM agents GROUP BY name → 2 לכל אחד.\n\nסיכון: drift בין החברות. שינוי runtime_config ל-CEO של 1xxx יכול לפספס את CEO של 8xxx.\n\nפעולה (Phase 3):\n1. בדיקה: האם Paperclip תומך ב-shared agents או chainOfCommand? (לקרוא docs/companies/)\n2. אם כן — מיגרציה למבנה משותף\n3. אם לא — סקריפט סנכרון: scripts/sync_agents_across_companies.py שמעתיק כל שינוי מחברה לחברה\n\nשאלה לחיים: בעתיד אם יהיו עוד סוגי ערר (10xxx?) — להוסיף עוד חברה או להשאיר 2?",
@@ -1322,7 +1322,7 @@
         "updatedAt": "2026-05-04T09:52:14.263Z"
       },
       {
-        "id": "26",
+        "id": 26,
         "title": "[Paperclip Gap 12] עדכון @paperclipai/plugin-sdk + capabilities חדשות",
         "description": "ה-plugin שלנו: @paperclipai/plugin-sdk@^2026.325.0, apiVersion: 1, minimumHostVersion: 2026.325.0. ה-host: 2026.428.0. ייתכן capabilities חדשות (issue.interactions.create, וכו').",
         "details": "פעולה (Phase 4 — אחרי שדרוג Paperclip stable):\n1. cd /home/chaim/plugin-legal-ai && npm view @paperclipai/plugin-sdk version\n2. אם חדשה: npm install @paperclipai/plugin-sdk@latest\n3. קריאת adapter-plugin.md המעודכן ב-paperclip repo\n4. בדיקה אם apiVersion: 2 קיים\n5. הוספת capabilities חדשות אם רלוונטי (בעיקר issue.interactions.create אחרי gap #4)\n6. npm run build && reinstall plugin\n\nתלוי בgap #19 (interactions API) — אם אנחנו רוצים שהplugin יוכל ליצור interactions, חייב capability חדש.",
@@ -1337,7 +1337,7 @@
         "updatedAt": "2026-05-26T12:19:16.180163Z"
       },
       {
-        "id": "27",
+        "id": 27,
         "title": "[Paperclip Phase 4] שדרוג Paperclip לגרסה stable הבאה (לא 2026.428.0)",
         "description": "כרגע אנחנו על 2026.428.0 — הגרסה היציבה האחרונה. כשיופיע stable חדש (כנראה 2026.5xx.x), לבצע שדרוג מבוקר.",
         "details": "טריגר: npm view paperclipai dist-tags.latest מחזיר משהו ≠ 2026.428.0.\n\nפעולה:\n1. קריאת releases/v2026.5xx.x.md ב-GitHub\n2. בדיקת שינויים שעלולים להשפיע (CUSTOMIZATIONS.md סעיפים: hebrew, RTL, plugin driver, heartbeat)\n3. גיבוי: pg_dump של paperclip DB + cp -r ~/.npm/_npx/43414d9b790239bb /tmp/\n4. pm2 stop paperclip\n5. rm -rf ~/.npm/_npx/43414d9b790239bb\n6. npx paperclipai@latest run (יוריד גרסה חדשה)\n7. הרצה מחדש: ~/.paperclip/hebrew/apply-hebrew.sh && ~/.paperclip/issue-link-fix/apply-issue-link-fix.sh\n8. pm2 restart paperclip\n9. בדיקה ב-pc.nautilus.marcusgroup.org: עברית + plugin פעיל + סוכן מתעורר על comment\n\nתלוי בלי dependencies (יכול להיות מבוצע בכל עת אחרי שיש stable חדש).",
@@ -1349,7 +1349,7 @@
         "updatedAt": "2026-05-26T12:19:16.180163Z"
       },
       {
-        "id": "28",
+        "id": 28,
         "title": "[Paperclip Auxiliary] להפעיל skill-sync ל-2 סוכנים שפיספסו",
         "description": "הגהת מסמכים ומנתח משפטי לא קיבלו אף פעם revision מסוג skill-sync (לעומת 5 האחרים שכן). לבצע sync.",
         "details": "ממצא: בדיקה ב-agent_config_revisions:\n- עוזר משפטי: 3 skill-sync revisions (יש 7 skills)\n- חוקר תקדימים: 3 (יש 5)\n- מייצא טיוטה: 5 (יש 5)\n- בודק איכות: 1 (יש 5)\n- כותב החלטה: 1 (יש 5)\n- הגהת מסמכים: 0 (יש 0) ❌\n- מנתח משפטי: 0 (יש 0) ❌\n\nאופציות:\n1. UI: agent settings → 'sync skills'\n2. API: POST /api/agents/{id}/skills-sync (לאתר)\n3. CLI: paperclipai agent skill-sync (לבדוק אם קיים)\n4. SQL ידני (לא מומלץ — דורף revision tracking)\n\nSkills להעתקה (לפי בודק איכות):\n- paperclipai/paperclip/paperclip\n- paperclipai/paperclip/paperclip-create-agent\n- paperclipai/paperclip/paperclip-create-plugin\n- paperclipai/paperclip/para-memory-files\n- (אופציונלי) local/eba6210d5a/legal-decision",
@@ -1361,7 +1361,7 @@
         "updatedAt": "2026-05-04T09:46:32.092Z"
       },
       {
-        "id": "29",
+        "id": 29,
         "title": "[legal-ai UI] מסך הגדרות סוכנים — הצגה + עריכה + שמירה",
         "description": "מסך אדמין ב-legal-ai UI שמציג את כל הגדרות הסוכנים (model, timeout, runtime_config, skills, budget) ומאפשר עריכה ושמירה. מונע SQL ישיר.",
         "details": "מטרה: ממשק אדמין מרכזי במקום שעריכה תהיה רק ב-UI של Paperclip + SQL ישיר + CUSTOMIZATIONS.md.\n\nשדות (לכל סוכן × 2 חברות):\n1. adapter_config: model, effort, timeoutSec, maxTurnsPerRun, extraArgs[], paperclipSkillSync.desiredSkills[]\n2. runtime_config.heartbeat: graceSec, cooldownSec, wakeOnDemand, maxConcurrentRuns, enabled, intervalSec\n3. budget_monthly_cents (לקראת gap #2)\n4. status / pause_reason (קריאה + כפתור pause/resume)\n\nאופציות מימוש:\nA. עמוד חדש ב-legal-ai/web-ui (Next.js 16) — קורא Paperclip DB דרך FastAPI endpoint חדש (/api/admin/paperclip-agents)\nB. קריאה ל-Paperclip API (/api/companies/{id}/agents) — REST טהור, פחות שדות זמינים\nC. iframe ל-Paperclip UI — שטחי\n\nהמלצה: A. שולט מלא + ולידציה משפטית (timeoutSec >= 1800 כי OCR).\n\nתלוי ב: gap #25 (סוכנים מוכפלים) — אם נעבור לshared, המסך יתאים.\n\nשאלות פתוחות לחיים:\n- auth: מי יכול לגשת? (כיום אין auth ב-legal-ai)\n- bulk edit ל-2 חברות יחד או נפרד?\n- חשיפת skill marketplace (להוסיף/להוריד skills) או רק קריאה?",
@@ -1377,7 +1377,7 @@
         "updatedAt": "2026-05-04T17:29:25.686Z"
       },
       {
-        "id": "30",
+        "id": 30,
         "title": "תיקון 3 baגים בקטלוג (practice_area + source_kind + upload route)",
         "description": "CRITICAL: 3 sub-bugs. (א) יצירת תיקים מתייגת practice_area='appeals_committee' במקום rishuy_uvniya/betterment_levy/compensation_197 לפי קידומת מספר התיק (1xxx/8xxx/9xxx) — audit + migration לכל התיקים הקיימים + תיקון נתיב היצירה. (ב) כל החלטה של ועדת ערר שהועלתה ל-case_law מסומנת כ-source_kind='external_upload' במקום 'internal_committee' — audit ל-case_law עם case_number שמתחיל ב'ערר' → reclassify + מילוי chair_name + district רטרואקטיבית. (ג) POST /api/precedent-library/upload לא מבחין — תיקון: ניתוב לפי תחילית הציטוט (ערר/ועדות ערר → internal_committee, אחרת → external_upload).",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #1. Pre-requirement: השתמש במחיקה+rerun של halachot אחרי שינוי source_kind. השתמש בpattern של internal_decisions.py (dry_run+log_action).",
@@ -1447,7 +1447,7 @@
         "updatedAt": "2026-05-26T08:35:22.762800Z"
       },
       {
-        "id": "31",
+        "id": 31,
         "title": "מיצוי chair_name + district בהעלאת ועדת ערר",
         "description": "תוספת לטופס + חילוץ אוטומטי מהציטוט/text הפסיקה. רטרואקטיבי לכל הרשומות הקיימות עם source_kind='internal_committee' שהשדות בהן ריקים.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #2. תלוי במשימה #30 (sub-bug ב).",
@@ -1483,7 +1483,7 @@
         "updatedAt": "2026-05-26T08:35:22.762800Z"
       },
       {
-        "id": "32",
+        "id": 32,
         "title": "UI — דף עריכת פסיקה ייפתח רחב-במרכז (לא צר-בצד)",
         "description": "חוסר נוחות בעריכה. שינוי ה-Dialog/Sheet ל-Modal רחב מרכזי. רלוונטי גם להוספת שדות chair_name + district מהמשימה #31.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #3.",
@@ -1495,7 +1495,7 @@
         "updatedAt": "2026-05-26T10:38:07.071897Z"
       },
       {
-        "id": "33",
+        "id": 33,
         "title": "UI — הסתרת עמודת 'שם' (case_name) בדף רשימת פסיקה",
         "description": "רוב הערכים זהים למספר התיק. להסתיר את העמודה ב-UI, לשמור עמודה ב-DB לשימוש עתידי.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #4.",
@@ -1507,7 +1507,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "34",
+        "id": 34,
         "title": "חילוץ ציטוטי-פנים מהחלטות דפנה (internal_committee + ירושלים)",
         "description": "פאטרן: 'ונפנה להחלטות של ועדת ערר זו...', 'כפי שקבעתי בערר X', 'בדומה לעמדתי בהחלטה Y'. חילוץ אוטומטי + שמירה ב-precedent_internal_citations table שיאפשר ל-search_internal_decisions להחזיר גם את הפסיקה המוזכרת.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #5. תלוי במשימה #30 (sub-bug ב) ובמשימה #31.",
@@ -1522,7 +1522,7 @@
         "updatedAt": "2026-05-26T10:38:07.071897Z"
       },
       {
-        "id": "35",
+        "id": 35,
         "title": "דף/דוח 'פסיקה חסרה בקורפוס' — פיצ'ר מלא",
         "description": "טבלת DB missing_precedents (id, citation, case_name, cited_in_case_id, cited_in_document_id, cited_by_party, legal_topic, legal_issue, claim_quote, status, linked_case_law_id, closed_at, created_at), API endpoints (POST/GET/upload/PATCH), MCP tools (missing_precedent_create/list/close), דף Next.js /missing-precedents, הוק אוטומטי במחקר ע\"י legal-researcher.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #6.",
@@ -1571,7 +1571,7 @@
         "updatedAt": "2026-05-26T08:35:22.762800Z"
       },
       {
-        "id": "36",
+        "id": 36,
         "title": "כינוס פרופוזיציות לטיעונים משפטיים אמיתיים (de-dup/aggregation)",
         "description": "extract_claims מחזיר ~60 פרופוזיציות לתיק, צריך לאגד ל-~10 טיעונים משפטיים אמיתיים. טבלה חדשה legal_arguments + טבלת קישור legal_argument_propositions (M:M ל-case_claims). LLM aggregation job (Hermes/DeepSeek). API + MCP + UI display שמציג 'X טיעונים משפטיים' במקום 'Y טענות'.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #7.",
@@ -1614,7 +1614,7 @@
         "updatedAt": "2026-05-26T08:35:22.762800Z"
       },
       {
-        "id": "37",
+        "id": 37,
         "title": "הפרדת תתי-סוגי בל\"מ לפי practice_area",
         "description": "3 ערכי appeal_subtype חדשים: extension_request_building_permit (1xxx, ס'152 - 30 ימים), extension_request_betterment_levy (8xxx, ס'14 לתוספת ג' - 45 ימים), extension_request_compensation (9xxx, ס'198(ד) - 30 ימים). 3 templates מתודולוגיים נפרדים. אוטו-זיהוי מהsubject. UI badge + filter.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #8. Pre-requirement: עדכון mcp-server/src/legal_mcp/services/practice_area.py APPEALS_COMMITTEE_SUBTYPES + עדכון web/paperclip_client.py mapping appeal_subtype → company.",
@@ -1657,7 +1657,7 @@
         "updatedAt": "2026-05-26T08:35:22.762800Z"
       },
       {
-        "id": "38",
+        "id": 38,
         "title": "שדרוג סוכני Paperclip להכרת השינויים מ-#30-#37",
         "description": "עדכון 7 הגדרות סוכן (CEO/analyst/researcher/writer/QA/proofreader/exporter) + HEARTBEAT.md לזיהוי המבנים החדשים. בלי זה כל הפיצ'רים נשארים זמינים אבל הסוכנים לא יודעים להשתמש בהם. כולל הוספת research_complete כ-valid case_status.",
         "details": "ראה תוכנית /home/chaim/.claude/plans/3-glimmering-oasis.md חלק א משימה #9. תלוי במשימות #30-#37.",
@@ -1740,7 +1740,7 @@
         "updatedAt": "2026-05-26T07:41:47.880478Z"
       },
       {
-        "id": "39",
+        "id": 39,
         "title": "[ROOT CAUSE] MCP tool חדש: internal_decision_upload",
         "description": "הוספת @mcp.tool() עם chair_name+district חובה ו-source_kind='internal_committee' אוטומטי. סוגר את ה-root cause של Bug (ב) ב-#30. בלעדיו 44 רשומות חדשות יחזרו כ-external_upload תוך חודש.",
         "details": "מיקום: mcp-server/src/legal_mcp/tools/internal_decisions.py (אם לא קיים — ליצור). רישום ב-server.py סביב שורה 169 (ליד precedent_library_upload). הקריאה מנותבת ל-int_decisions_service.ingest_internal_decision (קיים ב-internal_decisions.py).",
@@ -1754,7 +1754,7 @@
         "updatedAt": "2026-05-26T07:41:37.260868Z"
       },
       {
-        "id": "40",
+        "id": 40,
         "title": "[שלב B - ROI מיידי] הפעלת VOYAGE_RERANK_ENABLED=true ב-Coolify",
         "description": "Cross-encoder rerank-2 ממומש ב-mcp-server/src/legal_mcp/services/rerank.py אבל כבוי בייצור (default=false). POC הוכיח +4.5% mean@3 ו-+11.6% practical queries (latency +702ms acceptable לזרימה האסינכרונית). 5 דקות עבודה — env change ב-Coolify.",
         "details": "mcp__coolify__env_vars set VOYAGE_RERANK_ENABLED=true. ראה web/mcp_env_catalog.py:71-72 לdescription. אופציה: rampup רק על search_precedent_library (לא על find_similar_cases — latency-sensitive).",
@@ -1766,7 +1766,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "41",
+        "id": 41,
         "title": "[שלב B] BM25/tsvector hybrid retrieval על precedent_chunks + halachot",
         "description": "כיום כל החיפוש הוא 100% dense (cosine). ציטוטים מספריים ('עע\"מ 1461/20') נכשלים כי semantic לא מצליח בהם. הוספת tsvector GIN + RRF merge dense+lexical = +15-25% recall על ציטוטים — קריטי לאימות פסיקה ב-3-glimmering-oasis שלב 3.",
         "details": "ALTER TABLE precedent_chunks ADD COLUMN content_tsv tsvector GENERATED ALWAYS AS (to_tsvector('simple', content)) STORED; CREATE INDEX ... USING gin (content_tsv). באותו אופן על halachot.rule_statement. ב-db.py:2357 (search_precedent_library_semantic) — להוסיף שאילתה מקבילה של websearch_to_tsquery → RRF merge עם cosine. אזהרה: postgres אינו תומך ב-'hebrew' config — simple config יעבוד אבל בלי stemming.",
@@ -1780,7 +1780,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "42",
+        "id": 42,
         "title": "[שלב B] Query expansion via Claude Haiku — 2-3 variants per query",
         "description": "שאילתות עם abbreviations משפטיות ('בל\"מ'/'בקשה להארכת מועד') חוטפות recall. LLM expansion: שאילתה → 2-3 variants → union retrieval. +10-15% recall.",
         "details": "בוטל 2026-06-03 — obviated. BM25_HYBRID_ENABLED=true כבר פעיל ותופס קיצורים לקסיקלית (בל\"מ כ-token). ב-gold-set (86 שאילתות) 0 שאילתות-קיצורים, ו-recall כללי ≈0.99 — אין gap נמדד. Query-expansion דרך LLM מוסיף latency+עלות לכל שאילתה ללא צורך מוכח (YAGNI). re-open trigger: אם eval ייעודי על שאילתות-קיצורים יראה recall<0.9.",
@@ -1794,7 +1794,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "43",
+        "id": 43,
         "title": "[שלב B] MMR / diversity penalty — limit 2 chunks per case_law_id",
         "description": "תוצאות חיפוש דומות מאוד זו לזו (אותה פסיקה, chunks סמוכים) — פסיקות חוזרות תופסות slots → diversity@10 נמוך. הוספת cap per case_law_id (2-3 max) או MMR אמיתי.",
         "details": "פתרון קל: SQL DISTINCT ON (case_law_id) + 2 בpost-processing. פתרון איכותי: MMR — לכל candidate, score = λ*relevance - (1-λ)*max_similarity_to_selected. λ=0.7 דיפולט.",
@@ -1808,7 +1808,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "44",
+        "id": 44,
         "title": "[שלב B] HNSW migration (or lists=68 IVFFlat) + REINDEX",
         "description": "IVFFlat lists=50 עם 4,595 vectors — sub-optimal. sqrt(4595)≈68. HNSW עדיף ל-recall (אבל יותר זיכרון). שיפור +3-5% recall@10.",
         "details": "אופציה 1: REINDEX עם lists=68 (פשוט, idempotent). אופציה 2: DROP+CREATE עם HNSW (m=16, ef_construction=64) — דורש pgvector ≥0.5 ובדיקת זמן build. בדוק SELECT extversion FROM pg_extension WHERE extname='vector'.",
@@ -1820,7 +1820,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "45",
+        "id": 45,
         "title": "[שלב B] Halacha auto-approve sweep — בדיקת 219 pending + הורדת סף ל-0.78",
         "description": "219 halachot pending review (17%) חסומות מ-search. אם dafna לא מסקר ידנית — הם מתבזבזים. dashboard batch + הורדת auto-approve threshold.",
         "details": "1. בדוק 20 דגימות אקראיות של pending — אם רובן ראויות לאישור, הורד HALACHA_AUTO_APPROVE_THRESHOLD מ-0.80 ל-0.78. 2. הוסף UI batch approval ב-/halachot עם filter pending+confidence>0.75. 3. one-shot SQL לאישור 200 halachot שעמדו בקריטריונים החדשים.",
@@ -1832,7 +1832,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "46",
+        "id": 46,
         "title": "[שלב B] Dynamic halacha boost — לפי query-rule similarity",
         "description": "כיום halacha boost = +0.05 קבוע. דינמי לפי query similarity ירוץ דייקנות (5% precision על שאילתות ספציפיות).",
         "details": "ב-db.py:2479 — score = float(d['score']) + 0.05. החלף ב-boost = 0.10 * d['score'] (proportional). או — אם rerank ON, השתמש בrerank score כbaseline (אין צורך ב-boost כלל).",
@@ -1846,7 +1846,7 @@
         "updatedAt": "2026-05-26T08:08:27.953285Z"
       },
       {
-        "id": "47",
+        "id": 47,
         "title": "[שלב C - prevention] Audit script periodic: detect new external_upload עם case_number של ערר",
         "description": "Drift detection: שגיאה דומה ל-Bug (ב) יכולה לחזור בעתיד. periodic check (יומי?) + alert ל-Slack/comment.",
         "details": "scripts/audit_corpus_consistency.py — בודק: 1. case_law WHERE source_kind='external_upload' AND case_number ~ '^ערר|^ARAR'. 2. case_law WHERE source_kind='internal_committee' AND chair_name IS NULL. הרצה דרך cron או scheduled task ב-Paperclip.",
@@ -1861,7 +1861,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "48",
+        "id": 48,
         "title": "[שלב C] Parent-doc retrieval (child=300, parent=1500 tokens)",
         "description": "chunk_size=600 חותך חלק מהלכות ארוכות. parent-doc: חיפוש על child קטן (300 tokens), החזרת parent גדול (1500 tokens) ל-LLM context.",
         "details": "מיגרציה DB: precedent_chunks.parent_chunk_id (FK self). chunking pipeline משתנה ל-2 רמות. retrieval: SELECT distinct parent_chunk WHERE child_chunk matches.",
@@ -1875,7 +1875,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "49",
+        "id": 49,
         "title": "[שלב C] Multimodal backfill ל-77 רשומות שנותרו",
         "description": "כיום 40/117 precedent_image_embeddings (34%). 77 רשומות נותרו ללא image embeddings. ערך נמוך כשהמסמכים digital-native, אבל קריטי לscanned PDFs.",
         "details": "scripts/multimodal_backfill.py כבר קיים. להריץ עם batch size 10 כדי לא לדפוק את Voyage rate limits. אומדן: 77×~10K tokens = ~770K tokens ($10-15).",
@@ -1887,7 +1887,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "50",
+        "id": 50,
         "title": "[שלב C] Closed-loop retrieval feedback + ndcg dashboard",
         "description": "אין tracking של 'what was retrieved → what writer cited'. בלי זה — אי אפשר לעדכן את ה-RAG בצורה מדודה לאורך זמן.",
         "details": "טבלה חדשה retrieval_feedback (query, candidates_retrieved JSONB, cited_in_final_decision UUID[], created_at). hooks ב-writer לדווח. dashboard חודשי עם ndcg@10.",
@@ -1899,7 +1899,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "51",
+        "id": 51,
         "title": "[שלב C] Halacha quality monitoring — confidence drift, alert",
         "description": "אם prompt או model משתנה — confidence distribution יכול לזוז. בלי monitoring — דרדור איכות עובר תחת הראדר.",
         "details": "scheduled job: weekly mean confidence per practice_area. אם זז ביותר מ-0.05 — alert. dashboard ב-/halachot עם histogram.",
@@ -1911,7 +1911,7 @@
         "updatedAt": "2026-05-26T11:27:09.039154Z"
       },
       {
-        "id": "52",
+        "id": 52,
         "title": "[Retrieval RC-A] הוספת case_name + case_number ל-tsvector הלקסיקלי",
         "description": "השורש האמיתי לכך שסוכן לא מאתר החלטה לפי שם (אגסי). ה-tsvector הלקסיקלי (SCHEMA_V12_SQL ב-db.py) בנוי רק מ-precedent_chunks.content ומ-halachot rule/quote/reasoning — לא משם התיק/הצד או ממספר התיק. לכן שאילתת-שם מחזירה את מי שמצטט את ההחלטה, לא את ההחלטה עצמה. לשלב את case_law.case_name + case_number באינדקס הלקסיקלי (tsvector ייעודי על case_law או setweight) כך שחיפוש לפי שם יפגע ברשומה עצמה.",
         "status": "done",
@@ -1923,7 +1923,7 @@
         "updatedAt": "2026-05-30T11:05:36.307Z"
       },
       {
-        "id": "53",
+        "id": 53,
         "title": "[Retrieval RC-B] חיפוש/רשימה מאוחדים — לא לחתוך internal_committee",
         "description": "החלטות ערר/בל\"מ שמועלות נשמרות source_kind='internal_committee'. precedent_library_list ברירת מחדל external_upload ומסתיר אותן; כלי ה-MCP precedent_library_list אפילו לא חושף פרמטר source_kind, כך שסוכן לעולם לא יכול לדפדף בהן. לחשוף source_kind/all_committees בכלי ה-MCP ובמידת הצורך לאחד את שכבת ה-list/search.",
         "status": "done",
@@ -1937,7 +1937,7 @@
         "updatedAt": "2026-05-30T11:09:44.511Z"
       },
       {
-        "id": "54",
+        "id": 54,
         "title": "[Retrieval RC-3] הנחיית סוכנים — איתור לפי שם + שני קורפוסים",
         "description": "לעדכן הנחיות legal-analyst/researcher/writer: לאיתור החלטה ספציפית לפי שם להוסיף מונחי תוכן או מספר תיק, ולחפש בשני הקורפוסים (search_internal_decisions + search_precedent_library) לפני שמסיקים 'לא קיים בקורפוס'. כולל יצירת missing_precedent רק אחרי חיפוש כפול.",
         "status": "done",
@@ -1951,7 +1951,7 @@
         "updatedAt": "2026-05-30T11:12:44.727Z"
       },
       {
-        "id": "55",
+        "id": 55,
         "title": "[Retrieval RC-4] תיקון chunking — פרגמנטים זעירים",
         "description": "בתוצאות החיפוש מופיעים chunks של מילה-שתיים ('דיון','דיון וב','סיכום ו') כתוצאות מובילות. מציפים תוצאות ומורידים דירוג תוכן אמיתי. לחקור את chunker.py (פיצול לפי כותרת-סעיף שיוצר chunks ריקים) ולתקן: מינימום אורך chunk / מיזוג כותרת לגוף.",
         "status": "done",
@@ -1965,7 +1965,7 @@
         "updatedAt": "2026-05-30T11:19:23.923Z"
       },
       {
-        "id": "56",
+        "id": 56,
         "title": "[Retrieval finding] halacha_filters לא מסננים source_kind — דליפה חוצת-קורפוסים",
         "description": "התגלה תוך כדי משימה 53. ב-search_precedent_library_semantic וב-search_precedent_library_lexical (db.py): chunk_filters כוללים cl.source_kind=$sk אבל halacha_filters כוללים רק review_status. תוצאה: search_precedent_library(external) מחזיר גם הלכות internal_committee, ו-search_internal_decisions(internal) מחזיר גם הלכות external. אי-עקביות: chunks מסוננים, halachot לא. כרגע זה דווקא מסייע למציאוּת (לכן לא רגרסיה), אבל לא עקבי. דורש החלטת מדיניות: או לסנן halachot גם לפי source_kind (עקבי, אך 'מסתיר' שכבות), או להשאיר מאוחד במכוון + לתעד. אם משאירים מאוחד — לעדכן docstrings של שני הכלים שזה לא 'corpus נפרד'.",
         "status": "cancelled",
@@ -1977,7 +1977,7 @@
         "updatedAt": "2026-05-30T11:09:30.257989+00:00"
       },
       {
-        "id": "57",
+        "id": 57,
         "title": "[Retrieval #55 follow-up] re-chunk+re-embed של פסיקה שהוטמעה לפני תיקון ה-chunker",
         "description": "משימה 55 תיקנה את ה-chunker (עיגון כותרות + מיזוג) ומסננת את 484 הפרגמנטים בזמן query. הרמדיאציה המלאה: re-chunk מ-full_text השמור (ללא re-OCR — תואם feedback_no_reocr_retrofit) + re-embed, כדי שהתוכן יהיה נכון ולא רק מוסתר. נדחה כי זו מיגרציית-נתונים עם עלות Voyage API על ~13+ תיקים — דורש אישור עלות מ-chaim לפני הרצה. לבדוק כמה תיקים מושפעים (יש להם chunk<50) ולהריץ בקבוצות.",
         "status": "done",
@@ -1991,7 +1991,7 @@
         "updatedAt": "2026-06-03T07:56:21.688Z"
       },
       {
-        "id": "58",
+        "id": 58,
         "title": "[Case access] get_case_by_number שביר לפורמט — סוכן 'עיוור' למסמכי תיק",
         "description": "דווח ע\"י chaim: סוכן כתב שחסרים מסמכי תיק כי document_list החזיר ריק, אך המסמכים קיימים. שורש: get_case_by_number (db.py) עושה 'WHERE case_number=$1' התאמה מדויקת בלבד. אומת — 8137-24 מחזיר 9 מסמכים, אבל 8137/24 / 'ערר 8137-24' / רווחים / zero-pad → 'תיק לא נמצא'. הסוכן מקבל את המספר בפורמט שונה (כותרת issue, לוכסן, תחילית ערר/בל\"מ) → התאמה נכשלת → 'אין מסמכים'. משפיע על כל הכלים מבוססי case_number (document_list, extract_references, search_case_documents, get_claims, draft, וכו'). תיקון: נורמליזציה (strip prefix לתחילת ספרה, trim, '/'→'-') + fallback בשאילתה. תיקון נקודה-אחת מתקן את כל הכלים.",
         "status": "done",
@@ -2003,7 +2003,7 @@
         "updatedAt": "2026-05-30T11:54:34.291Z"
       },
       {
-        "id": "59",
+        "id": 59,
         "title": "[FU-1] איחוד מסלול ה-ingest למסלול קנוני אחד",
         "description": "מאחד את ingest_precedent ו-ingest_internal_decision למסלול קנוני יחיד; מבטל את האסימטריות.",
         "details": "מכסה GAP-01,02,04,05. מספק INV-ING1/ING3/G2/G4. severity: Critical. סוג: קוד. יסוד — FU-2/FU-3/FU-7 תלויים בו. מקור: docs/spec/gap-audit.md + 01-ingest.md.",
@@ -2056,7 +2056,7 @@
         "updatedAt": "2026-05-30T17:37:34.741136+00:00"
       },
       {
-        "id": "60",
+        "id": 60,
         "title": "[FU-2a] ingest idempotent + נרמול-בכתיבה + searchable (pure-code)",
         "description": "upsert ON CONFLICT על מפתח קנוני + נרמול case_number בכתיבה (type-aware) + דגל searchable מפורש. אפס מיגרציית-נתונים.",
         "details": "מכסה GAP-03,06,13. מספק INV-ING2/G3/G1/ID1/DM1. severity: Critical. סוג: pure-code (schema-additive). תלוי ב-FU-1 (#59). FU-2b (#67) מטפל ב-GAP-07/08 בנפרד.",
@@ -2101,7 +2101,7 @@
         "updatedAt": "2026-05-30T17:37:34.741136+00:00"
       },
       {
-        "id": "61",
+        "id": 61,
         "title": "[FU-3] re-index בשינוי תוכן",
         "description": "embedding מתעדכן אוטומטית בשינוי תוכן (כיום trigger-dependent, לא GENERATED).",
         "details": "מכסה GAP-09. מספק INV-DM3/G6. severity: High. סוג: קוד + מיגרציה (re-embed). תלוי ב-FU-1.",
@@ -2138,7 +2138,7 @@
         "updatedAt": "2026-05-30T17:37:34.741136+00:00"
       },
       {
-        "id": "62",
+        "id": 62,
         "title": "[FU-4] בידוד-קורפוס בכל מסלול query",
         "description": "אכיפת source_kind בכל פילטר (כולל halacha_filters); חסימת חיפוש ללא תחום.",
         "details": "מכסה GAP-10,12. מספק INV-RET1/G5. severity: Critical. סוג: קוד. ללא תלות — דחוף (דליפה פעילה).",
@@ -2173,7 +2173,7 @@
         "updatedAt": "2026-05-30T18:30:11.503Z"
       },
       {
-        "id": "63",
+        "id": 63,
         "title": "[FU-5] eval-harness + נראות backlog",
         "description": "מדידת precision/recall על gold-set + חשיפת backlog הלכות בבדיקת-בריאות.",
         "details": "מכסה GAP-11,14. מספק INV-RET4/G8/QA1/G10. severity: High. סוג: קוד + החלטת-יו\"ר (בניית gold-set). תלוי ב-FU-2. | DONE 2026-05-31: Unit B (GAP-14) — halacha_backlog נחשף ב-metrics.get_dashboard + /api/system/diagnostics (גילה 178 pending_review מתוך 1552, הישן 3.5.26). Unit A (GAP-11) — scripts/eval_gold_bootstrap.py (citations+known_item) + scripts/eval_retrieval.py (P/R/MRR/nDCG@5,10, self-test, baseline+config). gold-set=77 known-item queries (citation-source ריק: 0 ציטוטים בהחלטות). baseline בייצור: R@10=0.987 MRR=0.837; ממצא: MULTIMODAL=true מוריד known-item recall קלות (relevant ל-#15). gold-set=provisional עד סקירת דפנה (chair-gate; הדומיין). spec: docs/superpowers/specs/2026-05-31-fu5-eval-harness-design.md",
@@ -2210,7 +2210,7 @@
         "updatedAt": "2026-05-31T14:55:38.295Z"
       },
       {
-        "id": "64",
+        "id": 64,
         "title": "[FU-6] שערי-QA נאכפים בקוד",
         "description": "export חוסם בקוד על כשל-QA קריטי; תיקון neutral_background critical-but-passes.",
         "details": "מכסה GAP-15,16. מספק INV-QA3/EX3/G10. severity: Critical. סוג: קוד. ללא תלות — מהיר.",
@@ -2245,7 +2245,7 @@
         "updatedAt": "2026-05-30T18:30:11.521Z"
       },
       {
-        "id": "65",
+        "id": 65,
         "title": "[FU-7] audit-trail + provenance",
         "description": "כתיבת audit_log בכל פעולה; קישור בלוק→קטעי-מקור; סנכרון DB אחרי עריכה; אימות citation→corpus.",
         "details": "מכסה GAP-17,18,19,20. מספק INV-AUD1/2/3/EX1/G9. severity: High. סוג: קוד + backfill קל. תלוי ב-FU-1. (זרע לתת-פרויקט 3/audit-provenance.)",
@@ -2300,7 +2300,7 @@
         "updatedAt": "2026-05-30T17:37:34.741136+00:00"
       },
       {
-        "id": "66",
+        "id": 66,
         "title": "[FU-8a] מחסומי-תהליך→קוד: enforce sync + Paperclip-access guard (pure-code)",
         "description": "אכיפת cross-company sync (--verify יוצא non-zero על drift; adapter_type mismatch = drift לא silent skip) + fitness-function שחוסם גישת-Paperclip לא-מאושרת (raw http / INSERT agent_wakeup_requests).",
         "details": "מכסה GAP-21,22. מספק INV-MC1/INT1/INT3. severity: High. סוג: pure-code. GAP-23 (חיווט ספ→סוכנים) הופרד ל-#69 (משנה התנהגות-ייצור). | DONE 2026-05-31 PR#16: --verify drift-gate (exit≠0) + Paperclip-access fitness function. GAP-23→#69.",
@@ -2333,7 +2333,7 @@
         "updatedAt": "2026-05-30T17:37:34.741136+00:00"
       },
       {
-        "id": "67",
+        "id": 67,
         "title": "[FU-2b] תיאום מזהים קנוניים + ניקוי ציטוט-כמזהה (data-migration, chair)",
         "description": "מיגרציה חד-פעמית של ~52+ רשומות case_law עם ציטוט-מלא ב-case_number → מספר-בסיס מנורמל; dedup (למשל 8047-23 כפול); הכרעת צורה קנונית per-record.",
         "details": "מכסה GAP-07,08. מספק INV-ID1/ID2/DM2. severity: High. סוג: DATA-MIGRATION + chair-decision (מספר רשמי per-record, with-month canonical). דורש: גיבוי, dry-run, סקירת-יו\"ר, reversibility. תלוי ב-FU-2a (#60, לצורך פונקציית הנרמול). מקור: בדיקת DB 2026-05-30 — internal_committee ~52/56 ציטוט-מלא, ≥1 dup (8047-23), 1 בלתי-פתיר (ערר אדלר/cited_only). | APPLIED 2026-05-31: 55 internal rows normalized to bare case_number; corrupted 8047 dup (מטודלה) deleted; חלוואני 1028-20 proc→בל\"מ. Backups in data/audit/fu2b-*. external→#68.",
@@ -2367,7 +2367,7 @@
         ]
       },
       {
-        "id": "68",
+        "id": 68,
         "title": "[FU-2c] תיאום מזהי external_upload (case_number↔citation_formatted)",
         "description": "פסיקה חיצונית: case_number מחזיק ציטוט מלא; citation_formatted לא תמיד תואם (נמצאה סתירה 25226-04-25 מול 1975/24). דורש קודם תיקון סתירות citation_formatted↔case_number, ואז הכרעה אם docket מחולץ הופך ל-case_number או שהציטוט נשאר המזהה.",
         "details": "מקור: בדיקת DB 2026-05-31 (FU-2b scoping). 22/24 external עם ציטוט ב-case_number; citation_formatted נוצר בנפרד (LLM) ולא אמין כ-ground truth. שונה מ-internal (שם 0 סתירות). דורש סקירת-יו\"ר פר-רשומה. severity: Medium. סוג: data-migration + chair. תלוי בהחלטה: האם זהות external = ציטוט (FU-1) או docket מנורמל (INV-ID2). מופרד מ-FU-2b לפי החלטת chaim 2026-05-31. | APPLIED 2026-05-31: chair decision Option A (designator+docket, '/' kept). 21 external_upload case_number normalized + 3 citation_formatted fixed (D=לויתן/קלמנוביץ consolidated→25226-04-25; 2×C empty-citation composed). אהוד שפר עע\"מ 317/10 deferred (cross-source dup w/ cited_only → #70). collision-guard: 0. Backups data/audit/fu2c-backup-20260531T140943Z.csv. cited_only(49)→#70.",
@@ -2381,7 +2381,7 @@
         "updatedAt": "2026-05-31T14:11:37.689Z"
       },
       {
-        "id": "69",
+        "id": 69,
         "title": "[FU-8b] חיווט הספ לסוכני-Paperclip (GAP-23)",
         "description": "HEARTBEAT/agent docs דורשים קריאת 00-constitution + ספ-תחום רלוונטי לפני פעולה. משנה התנהגות-סוכן בייצור; prereq לתת-פרויקט 5.",
         "details": "מכסה GAP-23. מספק INV-AG1. severity: High. סוג: docs+chair-decision. דורש ספ יציב (קיים) + החלטה על שילוב בזרימת-הסוכנים. הופרד מ-FU-8a לפי החלטת chaim 2026-05-31 (GAP-21/22 = pure-code עכשיו).",
@@ -2407,7 +2407,7 @@
         "updatedAt": "2026-05-31T16:01:42.032Z"
       },
       {
-        "id": "70",
+        "id": 70,
         "title": "[FU-2c-b] תיאום + dedup של cited_only (49 רשומות) + אהוד שפר cross-source",
         "description": "המשך ל-FU-2c (#68). ה-dry-run של תיאום-המזהים החיצוני חשף 49 רשומות source_kind='cited_only' (הפניות-ציטוט שחולצו מהחלטות) שלא היו בהיקף #68. דורשות נרמול נפרד: צורות-ועדה כמו 'ערר 1093-19' (NNNN-NN) שה-extractor הנוכחי לא תופס (NO_DOCKET), 'בש\"א 2487-14', dups, ו-'ערר אדלר' בלתי-פתיר (ללא מספר). בנוסף: dedup חוצה-source של אהוד שפר — external_upload 'עע\"מ 317/10 אהוד שפר' מול cited_only קיים 'עע\"מ 317/10' (אותו תיק; ה-collision-guard מנע התנגשות ב-uq_case_law_external_number, ה-external_upload נשאר עם case_number מנופח עד הכרעה).",
         "details": "[2026-06-03] נרמול מבוסס-מחקר (4 מקורות: ECLI work-level id, Akoma Ntoso FRBR Work/Manifestation, ELI canonical+alias, OpenCitations OMID + Christen data-matching). מדיניות: צורה קנונית אחת + alias; cited_only stub = אותו Work כמו ה-doc → merge על התאמה-מדויקת בלבד; un-resolvable = display+flag, לא למחוק; merge = re-point edges + dedup, שמרני (false-merge בגרף-ציטוט יקר). בוצע: 46 רשומות cited_only סווגו; 3 תיקונים מכניים-דטרמיניסטיים הוחלו (ערר \\n316/10→ערר 316/10; עע\"מ65/13→עע\"מ 65/13; עע\"מ9057/09→עע\"מ 9057/09). 0 malformed (whitespace/no-space) נותרו. **נותר לשיקול יו\"ר (לא ננחש, לפי המשמר)**: (1) 2 garbled — 'ערר 1078/0724' (4a38c202), 'ערר 1083/0724' (6682f9cb); (2) 'ערר אדלר' (863a7bf8) ללא docket → keep+flag; (3) combined 'ערר (ירושלים) 1078+1083/24' (e7f6fd06) → פיצול ל-1078/24+1083/24 מתנגש עם stub קיים 'ערר 1083/24' → entity-resolution ידני. תוספת קוד עתידית: טיפול '+' ב-citation_extractor. הדדאפ הקודם (shafer + stub cleanup) כבר הושלם. אלה chair-domain — לא הכרעת-מהנדס. [2026-06-03 סגירה]: בדיקת-קשתות חשפה ש-4 ה'דו-משמעיים' (+11 נוספים) הם stubs **יתומים מתים** — 0 קשתות בכל 5 מנגנוני-הציטוט, 0 full_text, 0 הלכות, 0 chunks/embeddings. כלומר ניקוי טכני, לא שיפוט-יו\"ר (OpenCitations שומר ישות חסרת-מזהה רק אם מצוטטת — אלה לא). נמחקו 15 יתומים (cited_only 46→31), גיבוי data/audit/fu2b-orphan-stub-cleanup-20260603T093741Z.json. 0 malformed/יתומים נותרו; כל 31 הנותרים מצוטטים. forward-edge ידוע (לא חוסם, ללא משימה): טיפול '+' בציטוט-משולב ב-citation_extractor אם יחזור בחילוץ עתידי. #70 done.",
@@ -2421,7 +2421,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "71",
+        "id": 71,
         "title": "[FU-5 follow-up] כוונון עומק-אחזור/rerank — recall רב-תקדימי לסוגיות רחבות",
         "description": "נפתר ע\"י תיקון ה-weight של #15 (multimodal 0.5→0.65). מדידה 2026-06-03: כל 11 השאילתות הרב-תקדים/יו\"ר מחזירות את כל התקדימים הרלוונטיים ב-top-10 (רובם top-6; גרוע ביותר rank 9). השאילתות החלשות מהבייסליין (S2 הבית-שמעוני@16, S4 ב.דייניש@15, S7@15, S8) כולן תוקנו. recall@10≈1.0.",
         "details": "החלטה מבוססת-מדידה+מחקר (6 מקורות: Cormack RRF, Drowning-in-Documents 2411.11767, ReFIT, MMR, Elastic, Pinecone). המחקר המליץ להפעיל rerank (fetch_k=50,return_k=10); בדקתי אמפירית — VOYAGE_RERANK_ENABLED=true דווקא הזיק: nDCG@5 0.879 מול 0.960, MRR 0.867 מול 0.954, R@5 0.966 מול 0.994 (כל המדדים שליליים). הסיבה: recall כבר רווי, וה-cross-encoder הכללי מוריד את ההתאמה המדויקת ב-known-item. **המדידה גוברת על התיאוריה — לא מפעילים rerank, לא מעלים limit, RRF_K=60 נשאר.** אין שינוי-קוד נדרש.",
@@ -2435,7 +2435,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "72",
+        "id": 72,
         "title": "[ops] MCP 'No such tool' תחת עומס חילוץ opus-4-8@xhigh — timeout ב-handshake",
         "description": "בריצת CMPA-71 (חילוץ הלכות 9002-24, סוכן עוזר משפטי) שרת ה-legal-ai MCP לא נטען — כל קריאות mcp__legal-ai__* החזירו 'No such tool available' אחרי 3 ניסיונות+המתנות; הסוכן עשה fallback ל-.venv ישיר (לפי legal-ceo.md) והחילוץ הצליח על claude-opus-4-8@xhigh.",
         "status": "done",
@@ -2446,7 +2446,7 @@
         "subtasks": []
       },
       {
-        "id": "73",
+        "id": 73,
         "title": "החלטת ועדת ערר: ברירת מחדל is_binding=false (יישור דוקטרינרי)",
         "description": "כשמעלים החלטת ועדת ערר דרך מסך העלאת הפסיקה (precedent-upload-sheet, isCommittee=true), הצ'קבוקס 'הלכה מחייבת' (is_binding) כברירת מחדל הוא true — כך שההלכות שמחולצות מהחלטה לא-מחייבת מתויגות rule_type='binding'. זה סותר את ההגדרה הדוקטרינרית שלנו (ועדת ערר = persuasive בלבד, לא binding כמו עליון/מנהלי). התיקון: כש-isCommittee=true ב-precedent-upload-sheet.tsx, להפוך את is_binding ל-false כברירת מחדל (או לנעול/להסתיר את הצ'קבוקס ולתייג אוטומטית persuasive). הערה חשובה: זהו תיקון יישור-דוקטרינרי בלבד — אין השפעה downstream על ranking/injection (rule_type הוא תווית תצוגה; השער הפונקציונלי האמיתי הוא review_status שדפנה שולטת בו ידנית). קבצים: web-ui/src/components/precedents/precedent-upload-sheet.tsx (useState isBinding שורה 47, isCommittee שורה 53); guard clause קיים ב-mcp-server/src/legal_mcp/services/halacha_extractor.py:229-235 שמוריד binding→persuasive רק כאשר is_binding=false.",
         "details": "",
@@ -2458,7 +2458,7 @@
         "updatedAt": "2026-05-31T20:41:04.160Z"
       },
       {
-        "id": "74",
+        "id": 74,
         "title": "ניקוי רטרואקטיבי: rule_type binding→persuasive להלכות ממקור ועדת ערר",
         "description": "המשך משימה #73 (PR #29 מנע binding חדש לועדת ערר מכאן והלאה). יש 82 הלכות קיימות ב-DB עם rule_type='binding' שמקורן (case_law) בהחלטת ועדת ערר — בסתירה לדוקטרינה (ועדת ערר = persuasive). פילוח: 75 approved + 7 pending_review. גישה #2 (שמרנית): לתקן רק את ה-binding ל-persuasive, ולהשאיר interpretive/procedural/application/obiter כמות שהם (תקינים גם לועדת ערר). הגדרת 'מקור ועדת ערר': case_law WHERE source_type='appeals_committee' OR precedent_level LIKE 'ועדת%' OR court LIKE '%ועדת%ערר%' OR court LIKE '%ועדות ערר%'. שאילתה: UPDATE halachot SET rule_type='persuasive' WHERE rule_type='binding' AND case_law_id IN (<committee case_law ids>). הערה: rule_type הוא תווית תצוגה בלבד — אין השפעה על ranking/injection (השער הפונקציונלי הוא review_status). DB: legal_ai על Postgres pgvector קונטיינר t84kegpjm5qrttd6nw7bgoxe (פורט 5433). ביצוע דרך docker exec עם trust מקומי. לגבות/לספור לפני ואחרי לאימות (צפוי: 82 שורות מושפעות, 0 binding ממקור ועדת ערר אחרי).",
         "details": "",
@@ -2472,7 +2472,7 @@
         "updatedAt": "2026-05-31T20:49:28.894Z"
       },
       {
-        "id": "75",
+        "id": 75,
         "title": "[X11 Phase 2] חיווט אוטו-אישור מבוסס-ציטוט + backfill",
         "description": "Phase 2 של citation-corroboration (X11). Phase 1 (האות) מוזג ב-PR #27. דפנה אימתה את האות ואישרה הפעלה (2026-06-01). Phase 2: (1) חיווט אוטו-אישור — הלכה corroborated (≥2 ציטוטים חיוביים בלתי-תלויים, 0 שליליים) עוברת ל-review_status='approved' עם reviewer='corroborated (…judicial citations)' (INV-COR4/G10); (2) הדחת overruled — הלכה approved שקיבלה טיפול overruled בציטוט מאוחר חוזרת לשער-היו\"ר (INV-COR2); (3) backfill על 12 התקדימים (halachot+ציטוטים-נכנסים); (4) כלי-MCP write להרצת rebuild.",
         "details": "דגל: HALACHA_CORROBORATION_AUTO_APPROVE (default true, env-tunable). פונקציית-הכרעה טהורה approval_action(agg, has_overruled)→'approve'/'demote'/None (unit-tested, INV-COR2/COR4). DB: approve_halacha_by_corroboration (רק על pending_review), demote_halacha_overruled (רק על approved→pending_review), list_corroboration_grouped, precedents_with_halachot_and_incoming_citations. שירות: reconcile_approvals מופעל בסוף build_for_precedent; build_all driver. backfill target=12 תקדימים (אומת 2026-06-01). נדחה ל-backlog (proposal-only, מסוכן-תוכן): enrichment של rule_statement, treatment-backfill ל-case_law_citations.citation_type. תוכנית: docs/superpowers/plans/2026-06-01-x11-citation-corroboration-phase2.md. spec: docs/spec/X11-citation-corroboration.md §4-6.",
@@ -2484,7 +2484,7 @@
         "updatedAt": "2026-06-01T04:43:40.474Z"
       },
       {
-        "id": "76",
+        "id": 76,
         "title": "תיקון כפתור \"צור משימה\" ב-Paperclip — מאופשר אך submit חוזר בשקט",
         "description": "בוטל 2026-06-03 — באג upstream של Paperclip, לא ניתן לתיקון בטוח אצלנו (ee=companyId; הכפתור מאופשר לפי כותרת בלבד אך submit דורש חברה שלא אותחלה). אומת ע\"י chaim שעובד מהקשרי-חברה רגילים. Workaround: לבחור חברה במודאל / לפתוח מתוך לוח. מסלול אמין: pc.sh POST /companies/{id}/issues. תיקון יסודי = upstream. #78 מסיר את הצורך בזרימת הפסיקה.",
         "details": "אבחנה סופית מתוך הבאנדל (index-BWGhimVr.js): ה-submit הוא `function xi(){const je=m.current.trim();if(!ee||!je||He.isPending)return;...He.mutate({...companyId:ee...})}`. `je`=כותרת (קיים), `He`=mutation. ה-guard שנכשל הוא **`ee`**, ש-`ee` משמש כ-`projects.list(ee)` וכ-`companyId:ee` במוטציה — כלומר **`ee` = מזהה החברה**. השורש: הכפתור מאופשר לפי הכותרת בלבד (`disabled:!b`, b=כותרת), אבל ה-submit דורש גם חברה (`!ee`). כשהמודאל נפתח בהקשר שבו החברה לא אותחלה, המשתמש לוחץ כפתור 'מאופשר' וה-handler חוזר בשקט — בלי POST, בלי שגיאה. בחירת הסוכן (callback Ro) לא מגדירה את החברה — היא נקבעת רק דרך בורר חברה נפרד (pr/oe). ההזרקה שלנו (translate-he.js) זוכתה: reverseComments נוגע רק ב-[id^='comment-'], לא במודאל; isUserContent מדלג על contentEditable. **לא ניתן לתקן בבטחה דרך injection**: אי-אפשר לכתוב ל-state של React מבחוץ; shim שמגרד DOM ויוצר issue דרך API הוא שביר (צריך IDs מה-DOM) ועלול ליצור משימות פגומות — גרוע מהבאג. **Workaround**: לוודא שהחברה נבחרה במודאל (בורר החברה) לפני לחיצה על 'צור משימה'; או לפתוח 'משימה חדשה' מתוך הקשר חברה/לוח. מסלול אמין תמיד: API ישיר `pc.sh POST /companies/{id}/issues`. **תיקון יסודי = upstream Paperclip** (הכפתור צריך להיות disabled כשאין חברה, או החברה צריכה להיגזר מהלוח/סוכן הנבחר). הערה: #78 (חילוץ פסיקה אוטומטי) מסיר את הצורך במודאל הזה בזרימת חילוץ-הפסיקה; הזרימה הרגילה מניעה סוכנים דרך תגובות (CEO מנתב).",
@@ -2496,7 +2496,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "77",
+        "id": 77,
         "title": "תיקון מיפוי שדות בהעלאת פסיקת ועדת-ערר — מראה-מקום נדחס ל-case_number; case_number לא ניתן לעריכה",
         "description": "בטופס העלאת פסיקה (precedent-upload-sheet), עבור החלטות ועדת-ערר ה-frontend ממפה את שדה \"מראה המקום\" אל case_number (`case_number: citation.trim()`), כך שהמזהה הייחודי מקבל את המראה-מקום הארוך במקום מספר תיק נקי (למשל '8027-25'). בנוסף case_number כלל לא קיים ב-PrecedentUpdateRequest — אז מסך העריכה לא יכול לתקן אותו בדיעבד. citation_formatted נשאר ריק בהעלאה (מתמלא רק בחילוץ מטא). תוצאה ב-8027-25: case_number=מראה-מקום, case_name=מראה-מקום, מראה-מקום ריק עד החילוץ.",
         "details": "קבצים: web-ui/src/components/precedents/precedent-upload-sheet.tsx:121-123 (committee path ממפה citation→case_number); web/app.py:5147-5163 (PrecedentUpdateRequest חסר case_number); mcp-server/.../internal_decisions.py (id_field=case_number, display_name_fallback=case_number); precedent_metadata_extractor.py:247-253 (guard: case_name מתוקן רק אם ריק או ==case_number, לכן לא תיקן). תיקון מוצע: (1) בטופס committee — שדה נפרד \"מספר תיק (מזהה ייחודי)\" שממפה ל-case_number, ולמפות \"מראה המקום\" ל-citation (→citation_formatted), במקום לדחוס הכל ל-case_number; (2) להוסיף case_number ל-PrecedentUpdateRequest כדי שהעריכה תוכל לתקן בדיעבד (update_case_law כבר מתיר אותו); (3) להריץ `npm run api:types`. ראה כללי השם שהוגדרו: מזהה ייחודי = שם הקובץ/מספר תיק; מראה-מקום בשדה שלו; שם קצר = שם הצד.",
@@ -2508,7 +2508,7 @@
         "updatedAt": "2026-06-02T12:17:44.302Z"
       },
       {
-        "id": "78",
+        "id": 78,
         "title": "כשל שקט ב-wakeup לחילוץ פסיקה — חילוץ אוטומטי לא רץ והתיק נתקע ב-pending",
         "description": "אחרי העלאת פסיקה, הבקאנד מסמן metadata+halacha כ-pending וקורא ל-pc_wake_for_precedent_extraction להעיר את ה-CEO. הקריאה נבלעת בשקט (try/except 'non-fatal') — אם PAPERCLIP_BOARD_API_KEY חסר מחזיר {ok:false,skipped:no_api_key}, או שה-wakeup API נכשל — והתוצאה: ה-CEO לא מתעורר, לא רץ חילוץ מטא ולא חילוץ הלכות, וה-UI מציג 'ממתין לחילוץ' לנצח. קרה ב-8027-25 (תוקן ידנית עם precedent_process_pending). זה גם הסיבה ששדות המטא (תקציר/headnote/תגיות/citation) היו ריקים.",
         "details": "קבצים: web/app.py:5250-5262 (wakeup best-effort, exception נבלעת); web/paperclip_client.py:816-820 (skip שקט כש-no api key) ו-~905-907 (כשל API נבלע). תיקון מוצע: (1) להציף את הכשל למשתמש — סטטוס מובחן (extraction_wakeup_failed / 'ממתין-לעיבוד-ידני') ב-UI במקום 'pending' אילם; (2) fallback אוטומטי — אם ה-wakeup נכשל, או job מתוזמן (כמו sync-case-status) שמנקז את התור עם precedent_process_pending, או retry; (3) לאמת אם PAPERCLIP_BOARD_API_KEY מוגדר בקונטיינר (Coolify env) — אם לא, להוסיף. עיין reference: project_precedent_auto_extraction. לא לבלוע exceptions בשקט (feedback_silent_swallow).",
@@ -2520,7 +2520,7 @@
         "updatedAt": "2026-06-02T12:07:22.194Z"
       },
       {
-        "id": "79",
+        "id": 79,
         "title": "[#55 follow-up] chunker — כותרות-סעיף מבודדות נשארות chunks זעירים (<50)",
         "description": "ה-chunker ההיררכי הנוכחי (אחרי תיקון #55) עדיין פולט מדי פעם chunk זעיר שהוא כותרת-סעיף בודדת שלא מוזגה קדימה לתוכן שאחריה. התגלה בסגירת #57 (re-chunk legacy): מתוך 73 תקדימים שעברו reindex, נשארו 4 chunks זעירים — כולם כותרות מבודדות: 'דיון' (ע\"א 5138/04, len=4), 'טענות המשיבים' (בג\"ץ 6525/15, len=13), 'העובדות וההליכים' (בר\"מ 2340/02, len=16), ושבר-ציטוט 'כלל התושבים\". (ע' 13 להחלטה)' (403-17, len=32). לא שאריות legacy — אלה פלט דטרמיניסטי של ה-chunker הנוכחי.",
         "details": "השפעה: נמוכה — chunks אלה כבר מסוננים ב-query-time (פילטר length>=50 שנוסף ב-#55), אז החיפוש לא מושפע; זו בעיית-איכות-chunking ולא בעיית-אחזור. מיקום: chunker ההיררכי ב-mcp-server (chunk_document_hierarchical / מדיניות מיזוג הכותרות שב-#55). התיקון הצפוי: כשכותרת/heading קצרה (<50, או section_type שמתחיל סעיף) נותרת כ-chunk עצמאי ללא גוף — למזג אותה קדימה אל ה-chunk הבא (anchor-forward), או אחורה אם אין הבא. לשים לב ל-section boundaries: 'דיון'/'טענות המשיבים' הן תחילת סעיף — המיזוג צריך לצרף את הכותרת לראש הסעיף שאחריה, לא לזנב הקודם. אימות: להריץ scripts/rechunk_legacy_precedents.py אחרי התיקון — אמור להגיע ל-0 chunks<50 (או רק שברי-ציטוט לגיטימיים נדירים). תלוי ב-#55. ראה גם feedback_no_reocr_retrofit (re-chunk מ-full_text בלבד).",
@@ -2534,7 +2534,7 @@
         "updatedAt": "2026-06-03T08:10:57.844Z"
       },
       {
-        "id": "80",
+        "id": 80,
         "title": "[#15 follow-up] בדיקת ערך image-answer ל-multimodal → הכרעה על backfill 140 legacy",
         "description": "נסגר 2026-06-03 — ההנחה התבררה שגויה בכל מרכיב (full check). לא '140 מסמכים / 17,700 עמ' / שעתיים / אישור-עלות chaim + תיוג דפנה', אלא: מתוך 140 חסרי-image רק 65 PDF (השאר MD/DOCX — ה-pipeline מרנדר PDF בלבד), ובסך 704 עמ'. תיקי-השמאות (כל ערך ה-multimodal) כבר היו 8/12 מוטמעים — הפער היחיד היה תיק 8070-25 (4 מסמכי שמאות).",
         "details": "בוצע: backfill מקומי (multimodal_backfill.py 8070-25, voyage-multimodal-3, ~30 שניות) → כל 14 מסמכי 8070-25 הוטמעו. **כיסוי שמאות עכשיו 12/12 (100%)**. נותרו 51 PDF/649 עמ' ללא multimodal — כולם טקסטואליים (reference/response/appeal), ו-#15 הוכיח ש-multimodal לא עוזר (אף מדלל) על מסמכים טקסטואליים → **מושארים בכוונה** text-only; זו לא חוסר-עקביות אלא הקונפיג הנכון. אין צורך ב-gold-set/דפנה/אישור-עלות — העלות הייתה סנטים והערך הוכח ב-#15 לתיקי ועדה/שמאות. #80 done (טכני, לא human-gated).",
@@ -2548,7 +2548,7 @@
         "updatedAt": "2026-06-03T00:00:00.000Z"
       },
       {
-        "id": "81",
+        "id": 81,
         "title": "איכות חילוץ הלכות — לוודא שמה שמחולץ הוא הלכה אמיתית ולא ציטוט/אמרת-אגב",
         "description": "מנוע חילוץ ההלכות מפיק כיום פריטים שאינם 'הלכות' במובן המהותי: אמרות-אגב שהערכאה לא הכריעה בהן, יישומים ספציפיים-לתיק (rule_type=application), ציטוטים חתוכים, ופירוק-יתר (עד 351 'הלכות' מפסק אחד). המשימה: לחדד את ה-prompt ולהוסיף ולידטורים אוטומטיים כך שרק עיקרון משפטי בר-הכללה ובר-הסתמכות ייכנס למאגר. מבוססת מחקר מקצועי (ratio decidendi מול obiter dictum, holding-extraction בספרות legal-NLP, קריטריונים לאיכות rule_statement). תתי-המשימות יוגדרו לאחר המחקר.",
         "details": "רקע מבצעי (ניקוי 2026-06-03): נמחקו 196 רשומות מתוך 1650 (165 כפילויות תוכן + 31 Tier B/C). גיבוי: data/audit/halacha-cleanup-backup-20260603T101747Z.sql ; מניפסט: data/audit/halacha-cleanup-manifest-20260603T101747Z.csv . קוד רלוונטי: mcp-server/src/legal_mcp/services/halacha_extractor.py (prompts BINDING/PERSUASIVE, _coerce_halacha, אימות ציטוט). תחומי בדיקה ידועים: (א) חסימת quote_verified=false מהתור; (ב) הוצאת rule_type=application מהגדרת 'הלכה'; (ג) שמירה על דחיית dicta שלא הוכרעו; (ד) תקרת כמות/גרנולריות לפסק; (ה) הגנה מפני ציטוט חתוך (truncation guard). מפרט מאומת: docs/halacha-strict-rubric.md (הרובריקה האגרסיבית שהנחיתה ניקוי קורפוס 1454→534 ב-2026-06-03, שפר 51→22). להטמיע אותה במחלץ + dedup-on-insert (#82).",
@@ -2648,7 +2648,7 @@
         "updatedAt": "2026-06-03T16:27:24.755Z"
       },
       {
-        "id": "82",
+        "id": 82,
         "title": "Dedup בזמן הכנסה — מניעת הלכות כמעט-זהות בכתיבה (semantic dedup on insert)",
         "description": "store_halachot_for_chunk מבצע INSERT עיוור ללא בדיקת כפילות, ולכן נצברו עשרות הלכות 'אותו עיקרון במילים אחרות'. המשימה: לפני שמירה, לבדוק דמיון סמנטי (embedding) מול הלכות קיימות באותו פסק ולדלג/למזג near-duplicates, וכן לזהות ציטוט-תומך זהה. מבוססת מחקר (ספי near-duplicate ב-embedding-IR, MinHash/LSH מול cosine, בחירת צורה קנונית, merge מול skip). תתי-המשימות יוגדרו לאחר המחקר.",
         "details": "ממצא מהניקוי: סף cosine ≥0.90 תוך-פסק זיהה כפילויות אמיתיות בוודאות גבוהה (הרצועה 0.90-0.95 הייתה כמעט כולה 'אותו עיקרון בניסוח שונה'); ≥0.95 = ודאי. ציטוט-תומך זהה = איתות ודאי. להחליט: סף מבצעי, התנהגות (skip/merge/flag-for-review), ובחירת השורד (approved>pending, ביטחון גבוה, quote_verified). קוד: db.store_halachot_for_chunk; קיים idx_halachot_vec (pgvector).",
@@ -2736,7 +2736,7 @@
         "updatedAt": "2026-06-03T12:32:19.721Z"
       },
       {
-        "id": "83",
+        "id": 83,
         "title": "חוסן pipeline החילוץ — re-run אידמפוטנטי + אינדוקס תקין (תיקון באגים)",
         "description": "התגלו שני באגים: (1) halacha_index מוקצה per-chunk ולכן אינו ייחודי לפסק — שני עקרונות שונים מקבלים אותו מספר (לא כפילות, אך שובר dedup/מיון מבוסס-אינדקס); (2) חילוץ רץ פי-2/3 על אותו פסק (למשל 85026-17 שלוש ריצות תוך דקתיים) ומוסיף append במקום להחליף — ה-advisory lock לא מנע. המשימה: אינדוקס ייחודי לפסק, force=True שמוחק לפני re-extract, וחיזוק ה-lock/אידמפוטנטיות. מחקר קצר: דפוסי idempotency/exactly-once ב-pipelines.",
         "details": "קוד: halacha_extractor.py (global advisory lock, per-chunk checkpoints ב-precedent_chunks.halacha_extracted_at, force flag), db.store_halachot_for_chunk (הקצאת halacha_index). לשקול unique constraint (case_law_id, halacha_index) אחרי תיקון ההקצאה.",
@@ -2822,7 +2822,7 @@
         "updatedAt": "2026-06-03T13:08:10.793Z"
       },
       {
-        "id": "84",
+        "id": 84,
         "title": "טריאז' תור אישור ההלכות — אישור יעיל ולא מתיש",
         "description": "אישור ההלכות ידני ומתיש: קריאת עקרונות כמעט-זהים שוב ושוב, ללא תיעדוף או קיבוץ. המשימה: לייעל את חוויית האישור — מיון לפי ביטחון/corroboration, קיבוץ near-duplicates יחד, auto-defer/הסתרה של פריטים באיכות נמוכה, ופעולות batch (אישור/דחייה מרובים). מבוססת מחקר (human-in-the-loop review UX, active-learning prioritization, triage queues). תתי-המשימות לאחר המחקר.",
         "details": "הקשר: הדחייה כמעט לא בשימוש (1/1650) — התור הוא 'אשר-או-השאר-תלוי'. כלים קיימים: halachot_pending, halacha_review (MCP), דף ביקורת ב-UI. לשלב עם פלט #81 (איכות) ו-#82 (dedup) כדי שהתור יציג רק מועמדים אמיתיים ומקובצים.",
@@ -2918,19 +2918,18 @@
         "updatedAt": "2026-06-03T13:43:18.488Z"
       },
       {
-        "id": "85",
+        "id": 85,
         "title": "CEO MCP instance: nested claude -p exits 1 in write_interim_draft",
         "description": "write_interim_draft נכשל לכל 5 הבלוקים מתוך session ה-CEO עם 'Claude CLI failed (exit 1): unknown error'. אומת: claude CLI תקין מ-bash (exit 0), PATH+HOME של תהליך ה-MCP תקינים (/home/chaim/.local/bin/claude), אין ANTHROPIC_API_KEY ב-.env, הבלוקים נכתבים סדרתית (לא concurrency). סוכני משנה (proofreader/analyst CMPA-73..76) הריצו claude -p בהצלחה באותו יום. ⇒ כשל ספציפי ל-MCP server instance של ה-CEO. עוקף: האצלה ל-writer agent. דרוש: לבדוק מדוע nested claude -p נכשל מ-instance זה (אולי session lock / env stale); שקול restart ל-CEO agent session.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.925Z"
       },
       {
-        "id": "86",
+        "id": 86,
         "title": "טיפול ב-preamble/רציו של נבו — anti-contamination + gold-set מהרציו",
         "description": "התגלה (2026-06-03) ש-`strip_nevo_preamble` קיים ומחווט ל-ingest, אבל ה-regex `_DECISION_START` מזהה רק פתיחות של ועדת ערר (בפנינו/הערר שבנדון/ועדת הערר לתכנון/רקע עובדתי/עסקינן) — ולא פסקי-דין שנפתחים ב'פסק-דין' (כמו בג\"ץ 1764/05). לכן בפסקי-דין מנבו — בדיוק אלה שיש להם מיני-רציו — ה-preamble/רציו **אינו נחתך**, דולף לצ'אנקים, ועלול לזהם את חילוץ ההלכות (המחלץ קורא את התשובון של נבו) ואת הקורפוס. במקביל — הרציו של נבו הוא gold-set אנושי-מקצועי חינמי לאמידת איכות החילוץ.",
         "details": "קוד: mcp-server/src/legal_mcp/services/extractor.py — `strip_nevo_preamble` (~367), `_NEVO_MARKERS` (ספרות:/חקיקה שאוזכרה:/מיני-רציו:/...), `_DECISION_START` (~361). מחווט ב-ingest.py:161 ו-documents.py:152. הוכחה: ב-1764/05 המיני-רציו שרד כ-chunk מסוג intro (לא נחתך) ורק במזל לא חולץ (intro לא ב-EXTRACTABLE_SECTIONS). השוואת benchmark שבוצעה ידנית על 1764/05: 14 הלכות שלנו כיסו 100% מ-4 הלכות-הרציו של נבו + 2 נוספות, בגרנולריות פי ~3.5 (קשור ל-#81.5).",
@@ -2978,218 +2977,204 @@
         "updatedAt": "2026-06-03T16:56:13.158Z"
       },
       {
-        "id": "87",
+        "id": 87,
         "title": "claims_coverage: להבחין בין טענות כתב-ערר לטענות תכתובת",
         "description": "בדיקת claims_coverage מסמנת false-positives: טענות שעלו רק בתכתובות/תגובות בין הצדדים (לא בכתב הערר) מסומנות כ'לא נענו'. יש להבחין בין טענות מכתב הערר (חובה מענה) לטענות מתכתובת (לא חייבות מענה עצמאי, במיוחד כשהערר מתקבל במלואו). מקור: chair_feedback תיק 1033-25.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.933Z"
       },
       {
-        "id": "88",
+        "id": 88,
         "title": "פער DB↔file: decision_blocks (DB) מול drafts/decision.md (disk)",
         "description": "legal-writer מעדכן decision_blocks ב-DB אבל legal-qa קורא drafts/decision.md מהדיסק — שני מקורות אמת לא מסונכרנים גורמים ל-QA להיכשל פעמיים על אותה בעיה. נדרש: או כתיבה אטומית ל-DB+file יחד, או hook אוטומטי regenerate-draft אחרי כל עדכון בלוק. מקור: chair_feedback תיקים 8126-03-25, CMPA-62. ראה legal-decision-lessons.md #35.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.943Z"
       },
       {
-        "id": "89",
+        "id": 89,
         "title": "[רכישת-סגנון T0] הזרקת הפרופיל-המופשט ל-block_writer + מדיניות-העתקה",
         "description": "הלוֹבר הראשי. block_writer.py יטען voice-fingerprint+author-features+Copy-Paste Templates ל-{style_context} בכל בלוק. הוראת-מדיניות לפי סוג-תוכן: נוסחה/בוילרפלייט→מותר להעתיק, ניתוח ספציפי→הכלל והתאם, מהות מתיק אחר→אסור. פיצול {precedents_context} ל-{daphna_style_exemplars} (סגנון) ו-{case_law_citations} (פסיקה). קבצים: block_writer.py:205-260,710,795-815. MVP.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.951Z"
       },
       {
-        "id": "90",
+        "id": 90,
         "title": "[רכישת-סגנון T1] Backfill decision_paragraphs+paragraph_embeddings מ-style_corpus",
         "description": "אכלוס כל 48 ההחלטות עם author='daphna' כדי שאחזור-הבלוק (search_similar_paragraphs) יחזיר פסקאות אמיתיות של דפנה. documents.py:186-215 + סקריפט חד-פעמי. תלוי: אין. MVP-enabler.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.959Z"
       },
       {
-        "id": "91",
+        "id": 91,
         "title": "[רכישת-סגנון T2] הרחבת search_similar_paragraphs — סינון outcome+practice_area+block_type",
         "description": "db.py:2243 — להוסיף סינון, להחזיר פסקה מלאה, להרחיב לבלוקים ז/ח (לא רק י). block_writer.py:710 מעביר outcome, 4→6 exemplars. תלוי: T1.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.965Z"
       },
       {
-        "id": "92",
+        "id": 92,
         "title": "[רכישת-סגנון T3] דוגמאות contrastive + תיוג 'תבנית-קול בלבד'",
         "description": "להחזיר גם 'במה דפנה שונה' לא רק דומה (author-features+contrastive, arxiv 2504.08745). תלוי: T2,T0.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.973Z"
       },
       {
-        "id": "93",
+        "id": 93,
         "title": "[רכישת-סגנון T4] חיבור learning_loop ל-mark-final דרך ה-curator",
         "description": "mark-final מסמן+מעיר; curator מריץ ingest_final_version (claude_session לא בקונטיינר). app.py:3217-3283, paperclip_client.py, hermes-curator.md. תלוי: אין. MVP.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.982Z"
       },
       {
-        "id": "94",
+        "id": 94,
         "title": "[רכישת-סגנון T5] פנקס-התאמה draft_final_pairs + snapshot ב-mark-final (INV-LRN4)",
         "description": "טבלה draft_final_pairs(case_id,draft_text,final_text,diff_stats,status,created_at). snapshot של הטיוטה ברגע mark-final (אחרת diff מזוהם). זו 'רשימת ההחלטות' של כלל-העל + ground-truth ל-T7. תלוי: T4. MVP.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.991Z"
       },
       {
-        "id": "95",
+        "id": 95,
         "title": "[רכישת-סגנון T6] פנקס-התאמה ב-UI + קטגוריה במרכז-אישורים",
         "description": "רשימת כל ההחלטות + סטטוס (draft_done/final_received/analyzed/lessons_folded). מרכז-אישורים: קטגוריה 'ממתינות להשוואה מול סופי'. תלוי: T5.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:47.998Z"
       },
       {
-        "id": "96",
+        "id": 96,
         "title": "[רכישת-סגנון T7] מדד מרחק-סגנון (style_distance.py)",
         "description": "golden_ratio_adherence + anti_pattern_hits + draft_to_final_diff (ללא LLM). lessons.py יקבל ANTI_PATTERNS. חשיפה דרך get_metrics/tool. תלוי: T5. MVP.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "high",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.007Z"
       },
       {
-        "id": "97",
+        "id": 97,
         "title": "[רכישת-סגנון T8] הסרת LIMIT 20 ב-style_analyzer (כיסוי 48/48)",
         "description": "style_analyzer.py:124 — LIMIT 20→פרמטר/הסרה. מזין author-features של T0. תלוי: אין.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.015Z"
       },
       {
-        "id": "98",
+        "id": 98,
         "title": "[רכישת-סגנון T9] תיקון-המספור: ביטול אנטי-דפוס + מספור-אוטומטי בייצוא",
         "description": "ביטול 'אסור רשימה ממוספרת' (voice-fingerprint 3.1 — שגוי, ההחלטה ממוספרת תמיד). ייצוא DOCX יחיל מספור-אוטומטי של Word (skills/dafna-decision-template); הכותב יפסיק להזריק מספרים ידניים. בדיקה: האם הייצוא כבר ממספר אוטומטית. תלוי: אין.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.022Z"
       },
       {
-        "id": "99",
+        "id": 99,
         "title": "[רכישת-סגנון T10] get_style_guide דינמי — golden-ratios נמדדים מקורפוס",
         "description": "drafting.py:68 — golden-ratios נמדדים מהקורפוס לצד הקבועים, סימון פער. תלוי: T1,T8.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "low",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.028Z"
       },
       {
-        "id": "100",
+        "id": 100,
         "title": "[רכישת-סגנון T11] regen API types + deploy",
         "description": "npm run api:types ב-web-ui אם נוסף tool/endpoint; commit+push+Coolify deploy; MCP restart מקומי. תלוי: כל משימה שמשנה endpoint/tool.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.038Z"
       },
       {
-        "id": "101",
+        "id": 101,
         "title": "[רכישת-סגנון T12] /methodology — קטגוריות profile חדשות",
         "description": "להוסיף ל-CRUD הגנרי (/api/methodology/{category}) קטגוריות: transition_phrases, anti_patterns, voice_invariants (קבועי voice-fingerprint). + טאבים ב-web-ui/src/app/methodology. תלוי: אין.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.044Z"
       },
       {
-        "id": "102",
+        "id": 102,
         "title": "[רכישת-סגנון T13] /training — טאבי learning חדשים",
         "description": "טאב מדד-מרחק (מגמת T7), טאב פנקס-התאמה (T6), חיווט 'השוואה' ל-draft_final_pairs, פורטרט 'נמדד מול יעד'. תלוי: T5,T7.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.051Z"
       },
       {
-        "id": "103",
+        "id": 103,
         "title": "[רכישת-סגנון T14] אישור הצעות-distillation של ה-curator → כתיבה לפרופיל",
         "description": "משטח אישור הצעות ה-curator (שער INV-G10) שכותב ל-methodology/voice-fingerprint. /training טאב הסוכן. תלוי: T4.",
         "details": "",
         "testStrategy": "",
-        "status": "done",
+        "status": "pending",
         "dependencies": [],
         "priority": "medium",
-        "subtasks": [],
+        "subtasks": []
-        "updatedAt": "2026-06-06T21:02:48.060Z"
       }
     ],
     "metadata": {
       "version": "1.0.0",
-      "lastModified": "2026-06-06T21:02:48.060Z",
+      "lastModified": "2026-06-03T16:56:13.158Z",
-      "taskCount": 103,
+      "taskCount": 86,
-      "completedCount": 95,
+      "completedCount": 77,
       "tags": [
         "legal-ai"
-      ]
+      ],
+      "created": "2026-06-06T12:53:14.496Z",
+      "description": "Tasks for legal-ai context",
+      "updated": "2026-06-06T15:58:42.555Z"
     }
   }
 }

CLAUDE.md

@@ -1,11 +1,10 @@
 # עוזר משפטי — Legal Decision Assistant
 
-> **אינדקס דק.** הכללים הקריטיים נמצאים כאן; העומק התפעולי (Deploy, Paperclip-ops, adapters, מבנה-תיקיות, Chair-Feedback, TaskMaster מלא) הוצא ל-[`docs/operations-runbook.md`](docs/operations-runbook.md) כדי לרזות את ההקשר הנטען בכל סשן.
-
 ## רקע הפרויקט
 
 מערכת AI לסיוע בכתיבת החלטות של **ועדת ערר לתכנון ובניה, מחוז ירושלים**, בראשות **עו"ד דפנה תמיר**.
 
+### מה עושה ועדת ערר?
 ועדת ערר היא גוף מעין-שיפוטי שדן בעררים על החלטות ועדות מקומיות לתכנון ובניה. הוועדה מקבלת חומרי מקור (כתבי ערר, תגובות, פרוטוקולים, תכניות), דנה בטענות הצדדים, ומוציאה **החלטה כתובה מנומקת** — מסמך משפטי פורמלי שניתן לביקורת שיפוטית בבית משפט לעניינים מנהליים.
 
 ### שלושה סוגי עררים
@@ -15,10 +14,13 @@
 | היטל השבחה | 8xxx | קר ומקצועי | יבש, ללא רגשות |
 | פיצויים (ס' 197) | 9xxx | קר ומקצועי | דומה להיטל השבחה |
 
-> **מבנה מספר-תיק (נוהל-יו"ר 2026-06-11):** `<סידורי>-<חודש>-<שנה>`. **אורך הסידורי = סוג-הליך:** 4 ספרות → **ערר**, 5 ספרות → **בל"מ** (`85074-09-24`). הספרה הראשונה עדיין קובעת תחום בשני האורכים. כלל חד-כיווני: 5-ספרתי הוא תמיד בל"מ; 4-ספרתי אינו מחייב ערר (בל"מ-מורשת מזוהה מהנושא). מקור-אמת: [`docs/spec/X1-identifiers.md`](docs/spec/X1-identifiers.md) §1א.
-
 ### מטרת המערכת
-כלי עבודה שמסייע ליו"ר הוועדה: **ניהול תיקים** (ייבוא, סיווג, מעקב סטטוס) · **בסיס ידע** (פסיקה, ביטויי מעבר, לקחים, חקיקה) · **חיפוש סמנטי (RAG)** · **סיוע בכתיבה** (טיוטות לפי 12 בלוקים בסגנון דפנה) · **ייצוא DOCX**.
+לבנות כלי עבודה שמסייע ליו"ר הוועדה לנסח החלטות:
+1. **ניהול תיקים** — ייבוא חומרי מקור, סיווג מסמכים, מעקב סטטוס
+2. **בסיס ידע** — פסיקה, ביטויי מעבר, לקחים מהחלטות קודמות, חקיקה
+3. **חיפוש סמנטי (RAG)** — מציאת תקדימים רלוונטיים ופסקאות דומות
+4. **סיוע בכתיבה** — ייצור טיוטות לפי ארכיטקטורת 12 בלוקים בסגנון דפנה
+5. **ייצוא DOCX** — מסמך מעוצב מוכן להגשה
 
 ### ⭐ יעד-העל: רכישת-הסגנון של דפנה (Style Acquisition)
 **היעד הראשי של המערכת הוא שהסוכנים יכתבו וינתחו עררים בדיוק כמו עו"ד דפנה תמיר** — לא רק לייצר טיוטה תקנית, אלא להפנים את **הקול והשיטה** שלה. זה מחייב **הפרדה מובהקת בין שתי תת-מערכות**:
@@ -28,9 +30,19 @@
 
 **הגישה (state-of-the-art לדאטה-מועט):** Text Style Transfer מבוסס **Authorial Style Profiling** — להכליל את סגנון דפנה ולהתאים לתיק. העתקת פסקאות מותרת לתוכן קבוע/נוסחאי; ניתוח ספציפי → להכליל; **מהות משפטית (הלכה/עובדה) — אסור להעתיק מתיק לתיק**. *לא* fine-tuning של משקולות (Opus סגור; קורפוס קטן מדי).
 
-**כלל-העל — INV-LRN4:** כל החלטה אינה "סגורה" עד שהושוותה מול הגרסה הסופית של דפנה; כל סופי מנותח מול הטיוטה. **INV-LRN5:** שכבת-ידע-הקול לא תכיל מהות ספציפית — רק סגנון ושיטה. ספ מלא: [`docs/spec/07-learning.md`](docs/spec/07-learning.md) §0. ארכיטקטורה ומשימות: תוכנית `style-acquisition-subsystem`.
+**כלל-העל — INV-LRN4:** כל החלטה אינה "סגורה" עד שהושוותה מול הגרסה הסופית של דפנה; כל סופי מנותח מול הטיוטה. כך לומדים מכל החלטה. **INV-LRN5:** שכבת-ידע-הקול לא תכיל מהות ספציפית — רק סגנון ושיטה.
 
-> **Legacy:** המערכת הקודמת היתה Obsidian vault עם Claude Code skills. הידע שהופק ממנה (ניתוח סגנון, 12 בלוקים מבוססי CREAC/DITA/Akoma-Ntoso/FJC, כללי כתיבה, לקחים, ייצוא DOCX) הוטמע בפרויקט הנוכחי (`docs/`, `data/training/`). ה-vault נמחק; כעת PostgreSQL + pgvector.
+ספ מלא: [`docs/spec/07-learning.md`](docs/spec/07-learning.md) §0. ארכיטקטורה ומשימות: תוכנית `style-acquisition-subsystem`.
+
+### מה היה קודם (Legacy)
+המערכת הקודמת היתה **Obsidian vault** עם Claude Code skills על שרת אחר. פותחו:
+- ניתוח סגנון של 3 החלטות (הכט — דחייה, בית הכרם — קבלה חלקית, אריאלי — השוואה)
+- ארכיטקטורת 12 בלוקים מבוססת CREAC / DITA / Akoma Ntoso / Federal Judicial Center
+- כללי כתיבה (רקע ניטרלי, ללא כפילות, טענות מקוריות בלבד)
+- לקחים מהשוואת טיוטות לגרסאות סופיות
+- סקריפט ייצוא DOCX
+
+הידע שהופק מה-vault הוטמע במערכת הנוכחית — מסמכי ייחוס (`docs/`), קורפוס אימון (`data/training/`), ומבנה 12 בלוקים. ה-vault המקורי נמחק; הפרויקט הנוכחי עובד עם PostgreSQL + pgvector.
 
 ---
 
@@ -41,13 +53,11 @@
 | [`docs/spec/00-constitution.md`](docs/spec/00-constitution.md) | **חוקת המערכת** — ייעוד, 11 invariants גלובליים (G1–G11), כללי-הנדסה, אינדקס-ספ | **לפני כל כתיבת/שינוי קוד** (ראה §פרוטוקול כתיבת-קוד) |
 | [`docs/spec/README.md`](docs/spec/README.md) | **אינדקס ספ-המערכת** — מחזור-חיים (01–07) + חוצי-שלבים (X1–X11). מקור-האמת ל"מהו תקין" | **לפני כל כתיבת/שינוי קוד** |
 | [`docs/spec/gap-audit.md`](docs/spec/gap-audit.md) | **מפת-פערים** — 62 ממצאים → 15 יחידות-תיקון (FU); invariant מופר + file:line + תיקון מוצע | לפני נגיעה ב-GAP/FU קיים או תכנון FU חדש |
-| [`docs/ia-audit-redesign.md`](docs/ia-audit-redesign.md) + [`docs/spec/X17`](docs/spec/X17-information-architecture.md) | **אבחון משטח-ההפעלה + IA-יעד** — 34 משטחים, 37 ממצאים; INV-IA1–IA6 (מקור-אמת יחיד/שער-אחד/ניווט-משימה) מרימים G2/G10 לשכבת-UI. גלי-איחוד #130–132 | לפני עבודה על דפים/ניווט/cache או תורי-אישור |
 | [`docs/architecture.md`](docs/architecture.md) | ארכיטקטורת המערכת, תרשים רכיבים, זרימת נתונים, 4 שכבות DB | לפני עבודה על תשתית |
 | [`docs/block-schema.md`](docs/block-schema.md) | הגדרת 12 בלוקים — content model, constraints, processing params | **לפני כל כתיבת החלטה** |
 | [`docs/migration-plan.md`](docs/migration-plan.md) | תוכנית מעבר vault → DB — טבלאות, עדיפויות, כמויות | לפני ייבוא נתונים |
 | [`docs/legal-decision-lessons.md`](docs/legal-decision-lessons.md) | לקחים מ-3 החלטות — מה עבד, מה השתנה, ביטויי מעבר חדשים | **לפני כל כתיבת החלטה** |
 | [`docs/decision-methodology.md`](docs/decision-methodology.md) | **מתודולוגיה אנליטית — איך לחשוב על החלטה מעין-שיפוטית** | **לפני כל כתיבת החלטה** |
-| [`docs/anti-hallucination-gate.md`](docs/anti-hallucination-gate.md) | **שער anti-hallucination משותף (INV-AH)** — 5 טכניקות מעוגנות-מקור (עיגון-מקור, quote-or-retract, abstention, תיוג-ודאות, CoVe). מקור-אמת אחד לכל הסוכנים | **לפני כל אזכור פסיקה/חוק/הלכה/מספר** |
 | `docs/garner-methodology-extraction.md` | חומר מקור: מיצוי מספרי Garner על כתיבה משפטית | רק לבדיקת מקור |
 | `docs/fjc-principles-extraction.md` | חומר מקור: מיצוי מ-Judicial Writing Manual (FJC) | רק לבדיקת מקור |
 | [`docs/corpus-analysis.md`](docs/corpus-analysis.md) | ניתוח שיטתי של 24 החלטות — מפת תוכן, דפוסי דיון תכנוני, פערים | **לפני כל כתיבת החלטה** |
@@ -63,8 +73,6 @@
 | [`skills/decision/SKILL.md`](skills/decision/SKILL.md) | מדריך סגנון מלא של דפנה — טון, מבנה, ביטויים, מתודולוגיה | **לפני כל כתיבת החלטה** |
 | [`.claude/agents/HEARTBEAT.md`](.claude/agents/HEARTBEAT.md) | checklist הפעלת סוכן — routing, company filtering, quirks, wakeup עם UUID נכון | **לפני כל עבודה על סוכנים** |
 | [`skills/dafna-decision-template/SKILL.md`](skills/dafna-decision-template/SKILL.md) | export DOCX לפי styles של תבנית Word של דפנה — line classification, dash policy, placeholder handling | לפני export DOCX |
-| [`docs/corpus-graph.md`](docs/corpus-graph.md) | **מפת הקורפוס** (`/graph`) — גרף ציטוטים אינטראקטיבי נייטיב; 6 שכבות (פסיקה/נושא/תחום/הלכות/חוסרי‑מחקר/יומונים), אנליטיקה (PageRank/אשכולות), endpoints, ואיך מוסיפים שכבה | לפני עבודה על דף `/graph` או `web/graph_api.py` |
-| [`docs/operations-runbook.md`](docs/operations-runbook.md) | **עומק תפעולי** — Deploy (Coolify/pm2), Paperclip-ops מלא (wakeup, sync, webhook, scheduled jobs, adapters), מבנה-תיקיות, Chair-Feedback, TaskMaster | לפני עבודה על Deploy / אינטגרציית-Paperclip / adapters |
 
 ---
 
@@ -77,14 +85,14 @@
 
 **לפני יצירה/שינוי של קוד ב-`web/`, `mcp-server/`, `web-ui/`, `scripts/`:**
 
-1. **קרא** [`docs/spec/00-constitution.md`](docs/spec/00-constitution.md) — ייעוד, ה-invariants הגלובליים G1–G12, וכללי-ההנדסה (§6). אינדקס-הספ ב-§7.
+1. **קרא** [`docs/spec/00-constitution.md`](docs/spec/00-constitution.md) — ייעוד, ה-invariants הגלובליים G1–G11, וכללי-ההנדסה (§6). אינדקס-הספ ב-§7.
-2. **קרא את ספ-התחום הרלוונטי** לפי האינדקס (§7) — לדוגמה: אחזור→[`03-retrieval.md`](docs/spec/03-retrieval.md), קליטה→[`01-ingest.md`](docs/spec/01-ingest.md), נתונים→[`02-data-model.md`](docs/spec/02-data-model.md), כלי-MCP→[`X9-mcp-tool-contract.md`](docs/spec/X9-mcp-tool-contract.md), UI↔API→[`X6-ui-api-contract.md`](docs/spec/X6-ui-api-contract.md), Paperclip/שער-הפלטפורמה→[`X3`](docs/spec/X3-integration-deploy.md)/[`X7`](docs/spec/X7-paperclip-client-params.md)/[`X15`](docs/spec/X15-agent-platform-port.md) (G12), עמידות-פייפליין→[`X16`](docs/spec/X16-pipeline-durability.md), env/secrets→[`X10-deploy-env-secrets.md`](docs/spec/X10-deploy-env-secrets.md).
+2. **קרא את ספ-התחום הרלוונטי** לפי האינדקס (§7) — לדוגמה: אחזור→[`03-retrieval.md`](docs/spec/03-retrieval.md), קליטה→[`01-ingest.md`](docs/spec/01-ingest.md), נתונים→[`02-data-model.md`](docs/spec/02-data-model.md), כלי-MCP→[`X9-mcp-tool-contract.md`](docs/spec/X9-mcp-tool-contract.md), UI↔API→[`X6-ui-api-contract.md`](docs/spec/X6-ui-api-contract.md), Paperclip→[`X3`](docs/spec/X3-integration-deploy.md)/[`X7`](docs/spec/X7-paperclip-client-params.md), env/secrets→[`X10-deploy-env-secrets.md`](docs/spec/X10-deploy-env-secrets.md).
 3. **ודא שהשינוי *מקיים* את ה-invariants** — לא יוצר מסלול מקביל ליכולת קיימת ([G2](docs/spec/00-constitution.md)), לא מתקן תסמין בקריאה במקום נרמול במקור (G1), לא בולע שגיאות בשקט (כלל-הנדסה §6).
 4. **בדוק מול** [`gap-audit.md`](docs/spec/gap-audit.md) — אם אתה נוגע ב-GAP/FU שכבר ממופה, התאם את העבודה ליחידת-התיקון; אל תפתור מחדש.
 5. **כל PR מצהיר invariants** — אילו G*/INV-* ה-PR נוגע בהם / מקיים (ראה תבנית ה-PR ב-[`.gitea/PULL_REQUEST_TEMPLATE.md`](.gitea/PULL_REQUEST_TEMPLATE.md)).
 
 > **שתי שכבות-כללים מובחנות, שתיהן חלות:**
-> - **הנדסה (G1–G10, G12)** — הסעיף הזה + `docs/spec/`. סמכות: ≥3 מקורות חיצוניים.
+> - **הנדסה (G1–G10)** — הסעיף הזה + `docs/spec/`. סמכות: ≥3 מקורות חיצוניים.
 > - **תוכן משפטי (G11)** — סעיף "עקרונות כתיבה קריטיים" למטה (12 בלוקים, רקע ניטרלי...). סמכות: היו"ר + מסמכי-הפרויקט.
 >
 > אכיפה אוטומטית: hook `PreToolUse` ([scripts/spec-guard.sh](scripts/spec-guard.sh)) מזכיר את הפרוטוקול בכל Edit/Write על נתיב-קוד.
@@ -97,13 +105,17 @@
 
 **לכן — כל סשן שעומד לכתוב/לשנות קוד או תיעוד חייב לעבוד ב-git worktree מבודד משלו. אסור לערוך/לתייק בעץ-העבודה הראשי `~/legal-ai` כשייתכן שסשן אחר פעיל.**
 
-הבידוד **נתמך-סביבה** — ההגדרות נשמרות ב-repo (`.claude/settings.json`, `.worktreeinclude`, `.gitignore`) כך שכל worktree שה-harness יוצר מקבל אוטומטית בסיס נקי, את התלויות, ואת ההרשאות. מקורות רשמיים: [Run parallel sessions with worktrees](https://code.claude.com/docs/en/worktrees), [Settings → worktree](https://code.claude.com/docs/en/settings).
+הבידוד **נתמך-סביבה** — לא רק כלל-משמעת. ההגדרות נשמרות ב-repo (`.claude/settings.json`, `.worktreeinclude`, `.gitignore`) כך שכל worktree שה-harness יוצר מקבל אוטומטית בסיס נקי, את התלויות, ואת ההרשאות. מקורות רשמיים: [Run parallel sessions with worktrees](https://code.claude.com/docs/en/worktrees), [Settings → worktree](https://code.claude.com/docs/en/settings).
 
 ### הדרך המומלצת — worktree של ה-harness
 ```bash
 cd ~/legal-ai && claude --worktree <slug>     # או, בתוך סשן: "עבוד ב-worktree" (כלי EnterWorktree)
 ```
-נוצר תחת `.claude/worktrees/<slug>/` על ענף `worktree-<slug>`, ומקבל **אוטומטית**: בסיס נקי מ-`origin/main` (`worktree.baseRef: "fresh"`) · `web-ui/node_modules` כסימלינק (`worktree.symlinkDirectories`; אין צורך ב-`npm ci`) · `.claude/settings.local.json` + קבצי-env מקומיים (דרך `.worktreeinclude`) · ניקוי אוטומטי ביציאה (כולל עקיפת באג סימלינק [#40259](https://github.com/anthropics/claude-code/issues/40259) דרך `WorktreeRemove` hook עם `--force`).
+נוצר תחת `.claude/worktrees/<slug>/` על ענף `worktree-<slug>`, ומקבל **אוטומטית**:
+- **בסיס נקי מ-`origin/main`** — דרך `worktree.baseRef: "fresh"` ב-`.claude/settings.json`.
+- **`web-ui/node_modules` (789MB) כסימלינק** — דרך `worktree.symlinkDirectories`; אין צורך ב-`npm ci`. (אם משנים deps של web-ui — עשו זאת בעץ הראשי או היו מודעים שה-node_modules משותף.)
+- **`.claude/settings.local.json` + קבצי-env מקומיים** — מועתקים דרך `.worktreeinclude` (מונע הצפת אישורי-הרשאה).
+- **ניקוי אוטומטי ביציאה** — כולל עקיפת באג סימלינק [#40259](https://github.com/anthropics/claude-code/issues/40259) דרך `WorktreeRemove` hook עם `--force`.
 
 ### הפרוטוקול (חל על שתי הדרכים)
 1. **בתחילת עבודת-כתיבה** — צור worktree (מומלץ: `claude --worktree`; ידני-fallback: `git worktree add -b <branch> .claude/worktrees/<slug> origin/main` — **תחת `.claude/worktrees/`** כדי שההגדרות יחולו).
@@ -114,43 +126,202 @@ cd ~/legal-ai && claude --worktree <slug>     # או, בתוך סשן: "עבוד
 6. **אל תיגע** בשינויים לא-מתויקים שאינם שלך בעץ הראשי — הם של סשן אחר. אם העץ הראשי על ענף זר — אל תתייק עליו.
 
 > **בידוד-DB:** ה-worktree מבודד-קבצים בלבד — לא בידוד-repo ולא בידוד-DB. **אל תריץ migrations מ-2 worktrees במקביל** על Postgres המשותף (`localhost:5433`) — סכמה שאף סשן לא מצפה לה ([Run agents in parallel](https://code.claude.com/docs/en/agents)).
-> **סוכני Paperclip — אינם מבודדים (אומת 2026-06-06):** 14 מתוך 16 הסוכנים רצים על אדפטר `claude_local` הרשמי, שמריץ `claude -p` ב-`adapter_config.cwd=/home/chaim/legal-ai` **המשותף** — אין לו אופציית `worktreeMode`/`-w`. כלומר **כל סוכני Paperclip חולקים את עץ-העבודה הראשי**. הסיכון ממותן ע"י כלל הסשנים נתמך-הסביבה למעלה + תזמור סדרתי ע"י ה-CEO — **לא** ע"י בידוד-worktree per-agent. ניתוח מלא: TaskMaster `legal-ai` #104 (נסגר cancelled — "לתעד, לא לבדד").
+> **סוכני Paperclip — אינם מבודדים (אומת 2026-06-06):** 14 מתוך 16 הסוכנים רצים על אדפטר `claude_local` הרשמי, שמריץ `claude -p` ב-`adapter_config.cwd=/home/chaim/legal-ai` **המשותף** — אין לו אופציית `worktreeMode`/`-w` (קיימת רק ב-fork ה-deepseek שלנו). כלומר **כל סוכני Paperclip חולקים את עץ-העבודה הראשי**. הסיכון ממותן ע"י כלל הסשנים נתמך-הסביבה למעלה + תזמור סדרתי ע"י ה-CEO — **לא** ע"י בידוד-worktree per-agent. הניתוח המלא והדרכים שנשקלו: TaskMaster `legal-ai` #104 (נסגר כ-cancelled — "לתעד, לא לבדד").
 
 ---
 
-## Deploy — תמצית קריטית
+## שרת Nautilus (158.178.131.193)
 
-שלושה מודלי-הרצה דרים יחד; ערבוב = הטעות הנפוצה. **פירוט מלא, UUIDs ופקודות: [`docs/operations-runbook.md`](docs/operations-runbook.md).**
+| שירות | תפקיד | כתובת |
+|-------|--------|-------|
+| Coolify | ניהול containers | `http://158.178.131.193:8000` |
+| PostgreSQL + pgvector | בסיס נתונים ראשי | `legal-ai-postgres` |
+| Redis | תור משימות | `legal-ai-redis` |
+| Gitea | מאגר קוד | `gitea.nautilus.marcusgroup.org/ezer-mishpati` |
+| ezer-mishpati-web | ממשק העלאת מסמכים (Docker/Coolify) | `legal-ai.nautilus.marcusgroup.org` |
+| Paperclip | סוכן AI — מריץ Claude Code agents (pm2, מקומי) | `localhost:3100` |
+| Infisical | ניהול סודות | `secret.dev.marcus-law.co.il` |
 
-- **legal-ai** (`web/`, `web-ui/`) = **Docker דרך Coolify**. שינוי קוד לא נכנס לתוקף עד `git commit` + `git push origin main` → Gitea Actions בונה image → `mcp__coolify__deploy` (~2-4 דק'). **אסור** uvicorn/`next dev` מקומית — אין Python על המכונה. בדיקה: `curl https://legal-ai.nautilus.marcusgroup.org/api/health`.
+### ⚠️ ארכיטקטורת Deploy — חובה לקרוא
-- **Paperclip** = **pm2 מקומי** (`localhost:3100`). שינוי → `pm2 restart paperclip`. **אין** Docker/Coolify.
+
-- **legal-chat-service** = **pm2 מקומי** (`127.0.0.1:8770`), גשר claude CLI לטאב הצ'אט ב-/training. שינוי → `pm2 restart legal-chat-service`.
+**עוזר משפטי (Legal-AI)** — רץ כ-**Docker container דרך Coolify**:
+- UUID: `gyjo0mtw2c42ej3xxvbz8zio`
+- שינוי קוד ב-`web/` או `web-ui/` **לא נכנס לתוקף** עד ש:
+  1. עושים `git commit` + `git push origin main`
+  2. מריצים deploy דרך Coolify (`mcp__coolify__deploy`)
+  3. ממתינים ~2-4 דקות לבנייה
+- **אסור** לנסות להריץ uvicorn מקומית — אין סביבת Python על המכונה
+- ה-container מריץ Next.js (`:3000`, חשוף) + FastAPI (`:8000`, פנימי)
+- בדיקה: `curl https://legal-ai.nautilus.marcusgroup.org/api/...`
+
+**Paperclip** — רץ **מקומית דרך pm2**:
+- פורט: `localhost:3100`, DB: `localhost:54329`
+- שינויי קוד נכנסים לתוקף אחרי `pm2 restart paperclip`
+- **אין צורך ב-Docker או Coolify**
+
+**legal-chat-service** — רץ **מקומית דרך pm2** (חדש, מאפריל 2026):
+- פורט: `localhost:8770` (loopback בלבד)
+- שירות aiohttp קצר שעוטף את `claude` CLI ב-streaming + session continuation, ומשרת את הטאב "שיחה" בדף `/training`. הקונטיינר משדל אליו proxy דרך `host.docker.internal:8770`.
+- קוד: [mcp-server/src/legal_mcp/chat_service/](mcp-server/src/legal_mcp/chat_service/)
+- התקנה: `pm2 start /home/chaim/legal-ai/scripts/legal-chat-service.config.cjs && pm2 save`
+- בריאות: `curl http://127.0.0.1:8770/health` → `{"ok":true,...}`
+- שינויי קוד: `pm2 restart legal-chat-service`
+- **אפס עלות API** — claude CLI משתמש ב-claude.ai subscription של chaim. הנחת היסוד של `claude_session.py` (claude CLI מקומי בלבד) נשמרת — השירות הזה הוא הגשר הרשמי בין הקונטיינר לחוץ.
+- Coolify dependency: ה-Service Definition של legal-ai חייב להכיל `extra_hosts: host.docker.internal:host-gateway` (אחרת ה-proxy יקבל ConnectError).
 
 ---
 
-## Paperclip — כללים קריטיים (תמצית)
+## מבנה תיקיות
 
-**פירוט מלא + דוגמאות + פקודות sync: [`docs/operations-runbook.md`](docs/operations-runbook.md).**
+```
-
+/home/chaim/legal-ai/
-> **G12 — שער-הפלטפורמה ([`docs/spec/X15-agent-platform-port.md`](docs/spec/X15-agent-platform-port.md)):** Paperclip היא **מעטפת ניתנת-להחלפה** מאחורי Port יחיד. מגע-Paperclip מותר רק ב-`web/agent_platform_port.py` + `HEARTBEAT.md` (לפרומפטים) + המעטפת המוצהרת (`paperclip_client/api`, plugin, adapters). **אסור** סמל ספציפי-Paperclip ב-`mcp-server/src` או ב-skills של ההחלטה/הסגנון. כל מגע חדש → דרך ה-Port.
+├── CLAUDE.md                          ← הקובץ הזה
-
+├── Dockerfile                         ← Docker build
-- **Wakeup תמיד דרך API**: `POST /api/agents/{agent-id}/wakeup` עם `payload.issueId`. **אסור** `INSERT INTO agent_wakeup_requests` ישיר — הסוכן לא יתעורר לעולם (אין `heartbeat_run`).
+├── docs/                              ← תיעוד + לקחים
-- **ניתוב comments דרך CEO**: תגובת-משתמש → פלאגין מעיר CEO → CEO מנתב ויוצר issue. סוכנים קוראים comments אחרונים לפני עבודה (HEARTBEAT 2b-2c).
+│   ├── architecture.md                   ארכיטקטורה
-- **קריאות API דרך helper בלבד**: bash → `scripts/pc.sh`; Python → `pc_request()` מ-`web/paperclip_api.py`. **אסור** `curl` ישיר ל-Paperclip או `httpx.AsyncClient` ישיר.
+│   ├── block-schema.md                   12 בלוקים (המסמך החשוב ביותר)
-- **Cross-company sync**: 14 סוכנים = 7 × 2 חברות (CMP=1xxx master, CMPA=8xxx mirror). אחרי כל שינוי הגדרות/skills של סוכן — להריץ `scripts/sync_agents_across_companies.py --apply`. **מדלג** על סוכנים עם `adapter_type` שונה בין החברות (למשל `deepseek_local`) — להחיל ידנית בשתיהן.
+│   ├── migration-plan.md                 תוכנית מעבר vault → DB
+│   ├── legal-decision-lessons.md         לקחים מ-3 החלטות
+│   └── memory.md                         הקשר כללי — skills, פרויקטים
+├── skills/                            ← כלי עבודה ומדריכים
+│   ├── decision/                         מדריך סגנון + references + 12 בלוקים
+│   ├── assistant/                        קטלוג מסמכים
+│   ├── docx/                             עיצוב DOCX
+│   ├── dafna-decision-template/          export DOCX לפי תבנית Word של דפנה
+│   └── new-company-setup/               blueprint הוספת חברה חדשה
+├── .claude/
+│   └── agents/                        ← הוראות סוכנים + HEARTBEAT.md (symlinks ב-Paperclip)
+│       ├── HEARTBEAT.md                  checklist הפעלה משותף לכל הסוכנים
+│       ├── legal-ceo.md                  תזמורן + בקרת זרימה
+│       ├── legal-writer.md               כתיבת בלוקים בסגנון דפנה
+│       ├── legal-analyst.md              ניתוח משפטי + חילוץ טענות
+│       ├── legal-researcher.md           חיפוש תקדימים
+│       ├── legal-qa.md                   7 שערי איכות
+│       ├── legal-proofreader.md          תיקון OCR
+│       ├── legal-exporter.md             ייצוא DOCX סופי
+│       └── hermes-curator.md            סוכן Hermes לניתוח סגנון post-export
+├── data/
+│   ├── training/                      ← 4 החלטות לאימון (DOCX)
+│   ├── exports/                       ← טיוטות DOCX מיוצאות
+│   └── cases/{case-number}/           ← תיקי עררים (מבנה שטוח, סטטוס ב-DB)
+├── web/                               ← FastAPI backend (Python): 75+ API endpoints
+│   ├── app.py                            ← API ראשי
+│   ├── paperclip_api.py                  ← אינטגרציית Paperclip: `pc_request()` + `emit_case_status_webhook()`
+│   ├── paperclip_client.py               ← legacy client (ישן — השתמש ב-paperclip_api.py)
+│   └── gitea_client.py                   ← אינטגרציית Gitea
+├── web-ui/                            ← Next.js frontend (TypeScript/React): ממשק המשתמש
+│   └── next.config.ts                    ← proxy: /api/* → FastAPI :8000
+├── mcp-server/                        ← MCP server + services + tools
+├── adapters/                          ← Paperclip external adapters (ראה למטה)
+│   └── deepseek-paperclip-adapter/      ← `deepseek_local` (Hermes-pinned ל-DeepSeek profile)
+└── scripts/                           ← סקריפטים וכלי עזר (ראה scripts/SCRIPTS.md)
+    └── .archive/                      ← סקריפטים שהושלמו (לא להריץ)
+```
 
 ---
 
 ## כלל: עדכון `scripts/SCRIPTS.md`
-בכל פעם שנוצר, נמחק, או משתנה סקריפט בתיקיית `scripts/` — **חובה לעדכן את `scripts/SCRIPTS.md`** (תפקיד, סטטוס, החלפה).
 
-## ניהול משימות — TaskMaster AI
+בכל פעם שנוצר, נמחק, או משתנה סקריפט בתיקיית `scripts/` — **חובה לעדכן את `scripts/SCRIPTS.md`** בהתאם.
-**תמיד** TaskMaster (לא TASKS.md ידני). קובץ קנוני: `~/legal-ai/.taskmaster/tasks/tasks.json` (tags: `master`, `legal-ai`). פקודות: `get_tasks`, `next_task`, `add_task`, `update_task`, `expand_task`.
+הקובץ מתעד את התפקיד, הסטטוס, וההחלפה (אם יש) של כל סקריפט.
-> **⚠️ מלכוד cwd ב-CLI:** `--tag` בוחר קבוצה *בתוך* הקובץ — לא לאיזה קובץ לכתוב (ה-CLI מאתר לפי cwd). תמיד `cd ~/legal-ai` לפני כל פקודה משנה, ואז אמת ב-MCP `get_tasks`. כשלא בטוחים — לערוך את הקובץ ישירות. פירוט: [`docs/operations-runbook.md`](docs/operations-runbook.md).
 
 ---
 
-## עקרונות כתיבה קריטיים (G11)
+## ניהול משימות — TaskMaster AI
+
+הפרויקט משתמש ב-**TaskMaster AI** (MCP server) לניהול משימות מובנה:
+- **תמיד** להשתמש ב-TaskMaster לפירוק, מעקב וניהול משימות — לא ב-TASKS.md ידני
+- קובץ המשימות הקנוני: `~/legal-ai/.taskmaster/tasks/tasks.json` (יחסי ל-project root, **לא** `~/.taskmaster/tasks/tasks.json`). מכיל את כל ה-tags של legal-ai (`master`, `legal-ai`).
+- פקודות עיקריות: `get_tasks`, `next_task`, `add_task`, `update_task`, `expand_task`
+- לפני התחלת עבודה → `next_task` כדי לדעת מה הבא לפי תלויות
+- אחרי סיום משימה → `update_task` עם status=done
+- משימה מורכבת → `expand_task` לפירוק לתתי-משימות
+
+> **⚠️ מלכוד cwd ב-CLI:** הדגל `--tag` בוחר קבוצה לוגית *בתוך* הקובץ — הוא **לא** בוחר לאיזה `tasks.json` לכתוב. ה-CLI מאתר את הקובץ לפי ה-cwd (`<cwd>/.taskmaster/tasks/tasks.json`). תמיד `cd ~/legal-ai` לפני `task-master add-task` או כל פקודה משנה, ואז אמת ב-MCP `get_tasks` שהשינוי נחת. הרצה מ-`~/` כותבת לקובץ נטוש והמשימה לא תופיע בשאילתות MCP. כשלא בטוחים — לערוך את `~/legal-ai/.taskmaster/tasks/tasks.json` ישירות.
+
+---
+
+## Paperclip — כללי אינטגרציה קריטיים
+
+### Wakeup API — תמיד דרך API, לעולם לא דרך DB
+- **הנתיב הנכון**: `POST /api/agents/{agent-id}/wakeup` (לא `/wake`!)
+- **⚠️ אסור**: `INSERT INTO agent_wakeup_requests` ישירות — זה יוצר רק רשומה בלי `heartbeat_run`, והסוכן **לא יתעורר לעולם**
+- **⚠️ חובה לשלוח `payload` עם `issueId`** — בלי זה הסוכן מתעורר בלי הקשר (בלי תיק, בלי issue, בלי cwd נכון)
+- דוגמה נכונה:
+  ```json
+  {"source": "automation", "triggerDetail": "system", "reason": "...",
+   "payload": {"issueId": "...", "mutation": "comment", "commentId": "..."}}
+  ```
+- **Board API Key**: שמור ב-DB (`board_api_keys`), auth: `Authorization: Bearer pbk_...`
+
+### ניתוב comments דרך CEO
+- כשמשתמש כותב תגובה על issue ב-Paperclip, הפלאגין (`plugin-legal-ai`) מעיר את ה-CEO דרך `ctx.agents.invoke()`
+- ה-CEO קורא את ה-comment, מחליט על ניתוב, ויוצר issue לסוכן המתאים
+- כל הסוכנים חייבים לקרוא comments אחרונים לפני שהם מתחילים לעבוד (HEARTBEAT שלבים 2b-2c)
+
+### קריאות API — תמיד דרך helper, לעולם לא `curl` ישיר
+- **bash (סוכנים):** `~/legal-ai/scripts/pc.sh <METHOD> <PATH> [BODY_JSON]` — מוסיף Authorization, X-Paperclip-Run-Id, Content-Type, base URL. ראה `HEARTBEAT.md §0`.
+- **Python (FastAPI):** `from web.paperclip_api import pc_request; await pc_request("POST", "/api/...", json={...})` — שימוש ב-board API key.
+- **אסור** `curl ... $PAPERCLIP_API_URL` ישיר ב-bash; **אסור** `httpx.AsyncClient` ישיר ל-Paperclip ב-Python.
+- **למה:** ה-skill הרשמי דורש `X-Paperclip-Run-Id` בכל קריאה משנה issue. אצלנו ה-audit trail עבד ממילא דרך JWT claims (`runId: runIdHeader || claims.run_id`), אבל ה-helper מבטיח עקביות + תאימות ל-board API keys (long-lived) שלא נושאות JWT claims.
+
+### Cross-company agent sync — אחרי כל שינוי הגדרות
+- יש 14 סוכנים = 7 × 2 חברות (CMP=1xxx, CMPA=8xxx). Paperclip מחייב `agents.company_id NOT NULL` — אין shared agents.
+- **Master = CMP (1xxx)**, **Mirror = CMPA (8xxx)**.
+- אחרי כל שינוי ב-`adapter_config`, `runtime_config`, `budget_monthly_cents`, או skills של סוכן ב-master (UI, SQL, או API), **חובה להריץ:**
+  ```bash
+  PAPERCLIP_BOARD_API_KEY=$(...infisical...) \
+    python ~/legal-ai/scripts/sync_agents_across_companies.py --verify  # לבדיקה
+  PAPERCLIP_BOARD_API_KEY=$(...) \
+    python ~/legal-ai/scripts/sync_agents_across_companies.py --apply   # לסנכרן
+  ```
+- הסקריפט מסנן local skills שלא קיימים ב-CMPA (מציג אזהרה), משתמש ב-API (לא DB ישיר), יוצר revisions, idempotent.
+- שאלות ה-skill הרשמי של Paperclip — `paperclip` skill תחת `paperclipai/paperclip`.
+
+### Webhook יוצא — עדכון סטטוס תיק לפלאגין
+
+כשסטטוס תיק משתנה דרך `PUT /api/cases/{case_number}`, הבקאנד שולח webhook אסינכרוני לפלאגין:
+
+```
+PUT /api/cases/{case_number}  →  emit_case_status_webhook() [BackgroundTask]
+  →  POST /api/plugins/marcusgroup.legal-ai/webhooks/case-status
+  →  plugin-legal-ai/onWebhook()
+  →  comment בעברית על issue + CEO wakeup (כשסטטוס = qa_failed)
+```
+
+- הקוד ב-`web/paperclip_api.py` (`emit_case_status_webhook`), fire-and-forget, timeout 5s
+- הפלאגין שומר idempotency key ב-state עם TTL 5 דקות למניעת spam על retry
+- `GET /api/cases/stale?days=N` — תיקים שלא עודכנו N ימים; מוחרגים: `new`, `final`, `exported`
+- `GET /api/chair-feedback/weekly-summary` — סיכום פידבק YU"R לשבוע האחרון
+
+### Scheduled Jobs (plugin-legal-ai)
+
+| Job | לוח זמנים | מה עושה |
+|-----|-----------|---------|
+| `stale-case-reminder` | יומי 08:00 | שולח comment אזהרה על תיקים תקועים >3 ימים |
+| `weekly-feedback-analysis` | ראשון 19:00 | מעיר CEO לניתוח פידבק YU"R ועדכון `docs/legal-decision-lessons.md` |
+| `sync-case-status` | כל 30 דק' | מסנכרן סטטוסי תיקים בין legal-ai ל-Paperclip |
+
+CEO שמתעורר מ-`weekly-feedback-job` כותב לקובץ בלבד — **אין לו issueId, אל תנסה לפרסם comment או לסגור issue**.
+
+### External adapters — `deepseek_local`
+- מיקום ה-package: [adapters/deepseek-paperclip-adapter/](adapters/deepseek-paperclip-adapter/) (לא ב-`node_modules`).
+- רישום ב-Paperclip: רשומה ב-`~/.paperclip/adapter-plugins.json` (נטען אוטומטית ב-startup דרך `buildExternalAdapters`). אין צורך בעריכת `node_modules`.
+- **מה ה-adapter עושה**: spawnל-`hermes chat` עם `HERMES_HOME=/home/chaim/.hermes/profiles/deepseek` כך שה-CLI טוען את `config.yaml` (`base_url=https://api.deepseek.com/v1`, `provider=custom`, `key_env=DEEPSEEK_API_KEY`) ואת `.env` (שמכיל את ה-key).
+- **מודלים זמינים** (lookup ב-DeepSeek `/v1/models`): `deepseek-v4-pro` (default), `deepseek-v4-flash`. יופיעו כדרופ-דאון ב-UI.
+- **התקנה מחדש / עדכון**: `curl -X POST -H "Authorization: Bearer pcapi_legal_install_key_2026" -H "Content-Type: application/json" -d '{"packageName":"/home/chaim/legal-ai/adapters/deepseek-paperclip-adapter","isLocalPath":true}' http://localhost:3100/api/adapters/install`. לעדכון hot — `POST /api/adapters/deepseek_local/reload`.
+- **⚠ Cross-company sync**: `sync_agents_across_companies.py` **מדלג** על סוכנים עם `adapter_type` שונה בין CMP ל-CMPA. כשעוברים סוכן ל-`deepseek_local` חובה להחיל ידנית בשתי החברות לפני sync.
+- **תוספת adapters עתידיים** (OpenAI ישיר, Anthropic ישיר, וכו'): אותו דפוס. ה-package הראשי חייב לייצא `createServerAdapter()` שמחזיר `{ type, label, models, agentConfigurationDoc, execute, testEnvironment, sessionCodec, listSkills, syncSkills, ... }`. ראה את [adapters/deepseek-paperclip-adapter/dist/index.js](adapters/deepseek-paperclip-adapter/dist/index.js) כתבנית.
+
+### External adapters — Hermes Curator (`curator-cmp` / `curator-cmpa`)
+- פרופילי Hermes נפרדים לסוכן `hermes-curator` — מנתח החלטות סופיות ומציע עדכוני SKILL.md/lessons.md
+- מיקום: `~/.hermes/profiles/curator-cmp/` + `~/.hermes/profiles/curator-cmpa/`
+- מופעל אחרי export סופי; אינו מעדכן קבצים ישירות
+- **תהליך אישור הצעות:** הצעות ה-curator מגיעות כ-comment ב-Paperclip → חיים בוחן ומאשר ידנית → commits ל-`SKILL.md` ו-`docs/legal-decision-lessons.md`
+
+---
+
+## עקרונות כתיבה קריטיים
 
 1. **"מבחן השופט"** — כל החלטה חייבת להיות קריאה לשופט שלא מכיר את התיק
 2. **"רקע ניטרלי"** — בלוק ו = עובדות בלבד. אין ציטוטים מצדדים, אין מילות שיפוט
@@ -159,7 +330,14 @@ cd ~/legal-ai && claude --worktree <slug>     # או, בתוך סשן: "עבוד
 5. **ארכיטקטורת 12 בלוקים** — ראה `docs/block-schema.md`
 6. **צ'קליסט תוכן** — בלוק י מקבל צ'קליסט תוכן אוטומטי לפי סוג הערר (ראה `lessons.py: CONTENT_CHECKLISTS`)
 
-> **הערות יו"ר (Chair Feedback):** מנגנון תיעוד הערות דפנה — טבלת `chair_feedback`, API `/api/feedback`, MCP `record_chair_feedback`/`list_chair_feedback`, UI `/feedback`. פירוט: [`docs/operations-runbook.md`](docs/operations-runbook.md).
+## הערות יו"ר (Chair Feedback)
+
+מנגנון לתיעוד הערות דפנה על טיוטות:
+- **DB**: טבלת `chair_feedback` (case_id, block_id, feedback_text, category, lesson_extracted)
+- **API**: `GET/POST /api/feedback`, `PATCH /api/feedback/{id}/resolve`
+- **MCP tools**: `record_chair_feedback`, `list_chair_feedback`
+- **UI**: דף ניהול ב-`/feedback` (ב-Next.js)
+- **קטגוריות**: missing_content, wrong_tone, wrong_structure, factual_error, style, other
 
 ## יו"ר: עו"ד דפנה תמיר
-מדריך סגנון מלא: [`skills/decision/SKILL.md`](skills/decision/SKILL.md).
+- מדריך סגנון מלא: `skills/decision/SKILL.md`

Dockerfile

@@ -74,9 +74,6 @@ COPY skills/decision/SKILL.md ./skills/decision/SKILL.md
 COPY docs/legal-decision-lessons.md ./docs/legal-decision-lessons.md
 COPY docs/corpus-analysis.md ./docs/corpus-analysis.md
 
-# Scripts catalog surfaced read-only at /scripts (GET /api/scripts/catalog).
-COPY scripts/SCRIPTS.md ./scripts/SCRIPTS.md
-
 # Make mcp-server source available to web/app.py (it does sys.path.insert for legal_mcp)
 ENV PYTHONPATH=/app/mcp-server/src
 

adapters/deepseek-paperclip-adapter/dist/index.js

@@ -60,8 +60,7 @@ with \`HERMES_HOME\` pointed at a DeepSeek profile (\`config.yaml\` declares
 | verbose | boolean | false | Enable verbose Hermes logs. |
 | extraArgs | string[] | [] | Extra CLI args appended after standard flags. |
 | env | object | {} | Extra environment variables passed to Hermes. \`HERMES_HOME\` here overrides \`hermesProfileHome\`. |
-| instructionsFilePath | string | (none) | Absolute path to a versioned prompt file (e.g. under \`.claude/agents/\`). When set, its contents become the prompt template — single source of truth, parity with \`claude_local\`/\`gemini_local\`. Takes precedence over \`promptTemplate\`. If set but unreadable, execution fails loudly (no silent fallback). The file still flows through the template renderer, so \`{{…}}\` placeholders work. |
+| promptTemplate | string | (default) | Override the default Paperclip wakeup prompt. |
-| promptTemplate | string | (default) | Inline prompt override. Used only when \`instructionsFilePath\` is unset. |
 | paperclipApiUrl | string | \`http://127.0.0.1:3100/api\` | Paperclip API URL injected into the prompt template. |
 
 ## Available template variables

adapters/deepseek-paperclip-adapter/dist/server/execute.js

@@ -9,7 +9,6 @@
  * and toolsets from <HERMES_HOME>/config.yaml + <HERMES_HOME>/.env.
  */
 
-import { readFileSync } from "node:fs";
 import {
   runChildProcess,
   buildPaperclipEnv,
@@ -85,37 +84,8 @@ Address the comment, POST a reply if needed, then continue working.
 3. If nothing to do, report briefly what you checked.
 {{/noTask}}`;
 
-/**
- * Resolve the prompt template, preferring a versioned file over an inline DB
- * string. Precedence: instructionsFilePath > promptTemplate > DEFAULT.
- *
- * This brings deepseek_local into line with claude_local / gemini_local, whose
- * system prompts live as files under .claude/agents/. Keeping the prompt in one
- * git-versioned place (not split between a file and an inline DB column) is the
- * single-source-of-truth the other adapters already enforce.
- *
- * Fail loud: if instructionsFilePath is set but unreadable we throw rather than
- * silently falling back — a wrong/missing prompt file must surface as an error,
- * not run the agent on a stale inline copy. The loaded file still flows through
- * renderTemplate(), so {{wakeReason}}/{{#taskId}}/… placeholders keep working.
- */
-export function resolveTemplate(config) {
-  const filePath = cfgString(config.instructionsFilePath);
-  if (filePath) {
-    try {
-      return readFileSync(filePath, "utf8");
-    } catch (err) {
-      throw new Error(
-        `deepseek_local: instructionsFilePath is set ("${filePath}") but could not be read: ${err.message}. ` +
-          `Refusing to fall back to promptTemplate/default — fix the path or unset instructionsFilePath.`,
-      );
-    }
-  }
-  return cfgString(config.promptTemplate) || DEFAULT_PROMPT_TEMPLATE;
-}
-
 function buildPrompt(ctx, config) {
-  const template = resolveTemplate(config);
+  const template = cfgString(config.promptTemplate) || DEFAULT_PROMPT_TEMPLATE;
   const taskId = cfgString(ctx.context?.taskId);
   const taskTitle = cfgString(ctx.context?.taskTitle) || "";
   const taskBody = cfgString(ctx.context?.taskBody) || "";

docs/anti-hallucination-gate.md

@@ -1,62 +0,0 @@
-# שער anti-hallucination — הגנה משותפת מפני הזיות (INV-AH)
-
-> **מקור-אמת אחד לכל הסוכנים.** כל סוכן נוגע-מהות מפנה לכאן (דרך [HEARTBEAT.md](.claude/agents/HEARTBEAT.md)
-> ובלוק "קרא לפני פעולה" שלו). אל תשכפל את הכללים בקובץ-סוכן — הפנה לכאן (G2 — בלי מסלולים מקבילים).
-> זהו המקבילה התוכנית ל-INV-AG1 (קריאת-ספ): כמו שאינך פועל "מהזיכרון" לגבי התנהגות-המערכת, אינך
-> מצטט פסיקה/חוק/הלכה/מספר "מהזיכרון".
-
-## למה זה קיים
-כלי-AI משפטיים מובילים (Lexis+ AI, Westlaw) **הוזים פסיקה ב-17%–33%** גם עם RAG — זו לא בעיה
-שנעלמת מעצמה ("RAG ≠ hallucination-free"). בתחום מעין-שיפוטי, ציטוט-שווא של פסק-דין/סעיף/הלכה הוא
-כשל קריטי הניתן לביקורת שיפוטית. חמש הטכניקות למטה הן הקונצנזוס המקצועי להפחתת הזיות, מותאם לתחום.
-
----
-
-## חמש הטכניקות הקשיחות (חלות על כל סוכן נוגע-מהות)
-
-**AH-1 · עיגון-מקור (grounding) — אפס ציטוט מהזיכרון.**
-כל אזכור של פסק-דין / מספר-תיק / סעיף-חוק / הלכה / מקדם / "מתודה שמאית" / נתון כמותי חייב לבוא
-ממקור מאומת: **תוצאת כלי-אחזור** (`search_precedent_library`, `search_internal_decisions`,
-`search_case_documents`, `search_decisions`, `find_similar_cases`, `precedent_library_get`,
-`halacha_review`) **או מסמך בתיק**. אם לא הרצת חיפוש/לא קראת מסמך — אין לך את הפריט. *(Stanford RegLab / Magesh et al., JELS 2025; Anthropic — ground in retrieved sources.)*
-
-**AH-2 · Quote-or-retract.**
-לכל אזכור-מקור צרף את הציטוט/מזהה המדויק שהמקור החזיר (`supporting_quote`/headnote/ציטוט מהמסמך).
-**אין ציטוט מאשר → הסר את האזכור.** *(Anthropic — retract if no supporting quote; RAGAS faithfulness — כל טענה חייבת להיות נתמכת ב-context.)*
-
-**AH-3 · Abstention — "לא יודע" עדיף על המצאה.**
-לא נמצא מקור? כתוב מפורשות **"לא נמצא בקורפוס/בתיק — דורש אימות חיצוני"**. אסור לסגור פער בהשערה
-שנכתבת כעובדה. *(Anthropic — give the model an out.)*
-
-**AH-4 · תיוג-ודאות.** סמן כל טענה לא-טריוויאלית:
-`[מאומת]` (מקור+ציטוט) · `[טעון-אימות]` (סביר/עולה מהמסמכים, אך לא אותר מקור מאשר) · `[ספקולציה]`
-(השערה אנליטית — מותרת רק כשאלה/הסתייגות, לא כקביעה). *(NIST AI RMF GenAI Profile — explainability/קליברציה; RAGAS — atomic-claim grounding.)*
-
-**AH-5 · Chain-of-Verification (CoVe) — מעבר-אימות לפני סיום.**
-אחרי הטיוטה, פרק כל טענה עובדתית/אזכור לרשימה, ולכל אחת שאל "מאיזה מקור מאומת זה מגיע?".
-כל מה שאין לו עוגן — **הסר או הורד ל-`[ספקולציה]`**. *(Chain-of-Verification — Dhuliawala et al., arXiv:2309.11495, 2023.)*
-
-> **ההבחנה שמכריעה הכל — "פער" מותר, "המצאה" אסורה:**
-> ✅ "אזכרתי את X — חיפשתי ולא מצאתי בקורפוס; דורש אימות." (פער לגיטימי) ·
-> ❌ "הנה תקדים Y רלוונטי" כש-Y לא הגיע מכלי-אחזור. (המצאה)
-
----
-
-## יישום לפי תפקיד
-| סוכן | איך השער חל |
-|------|-------------|
-| **analyst / researcher** | מייצרי-מהות — עיגון-קורפוס מלא, log שאילתות + negative evidence, "מקור: כתבי טענות → דורש אימות". (כבר נהוג; כעת אחיד ומעוגן-מקור.) |
-| **writer** | **צרכן read-only** של פלט-המנתח המעוגן. **אסור** להוסיף פסיקה/סעיף/הלכה שלא הגיעו מהמנתח/הקורפוס. ציטוט בהחלטה = רק מ-`supporting_quote` מאומת. |
-| **qa** | **אוכף** את AH-1…AH-5 כשער-איכות: כל אזכור בטיוטה — האם מאומת-מקור? אם לא — `needs_revision`. |
-| **ceo** | מנתב ומסכם — לא ממציא מקורות; אם מצטט, מצטט ממה שהסוכנים אימתו. |
-| **proofreader** | תיקון-OCR בלבד — **אל "תתקן" לכיוון מונח משפטי סביר** (שם-תקדים/מספר-תיק/סכום): שמר את לשון-המקור; ספק → סמן, לא "תקן". |
-| **exporter** | מכני (DOCX) — אפס מהות חדשה. |
-| **hermes-curator** | הצעות בלבד (G10) — מעוגן-מקור, לא מזין שכבת-קול עם מהות (INV-LRN5). |
-| **שטן מליץ (Gemini)** | מימוש-הייחוס המלא של השער (`legal-analyst-gemini-critique.md`) — לידים-לא-הכרעות ליו"ר (human-in-the-loop, NIST). |
-
-## מקורות מקצועיים
-1. Magesh, Surani, Dahl, Suzgun, Manning, Ho — *Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools*, J. Empirical Legal Studies (2025), Stanford RegLab/HAI — שיעורי-הזיה 17–33% גם עם RAG.
-2. Anthropic — *Reduce hallucinations* (docs.anthropic.com): allow "I don't know" · cite quotes/sources · retract-if-no-quote · chain-of-thought.
-3. Dhuliawala et al. — *Chain-of-Verification Reduces Hallucination in LLMs*, arXiv:2309.11495 (2023).
-4. Es et al. — *RAGAS: Automated Evaluation of RAG*, arXiv:2309.15217 — faithfulness = יחס הטענות הנתמכות-בקונטקסט.
-5. NIST — *AI RMF: Generative AI Profile* (NIST-AI-600-1, 2024) — human-in-the-loop oversight ב-high-stakes.

docs/block-schema.md

@@ -320,25 +320,10 @@ Conclusion → Rule → Explanation → Application → Conclusion.
 **Content model:**
 - Types: narrative, citation-block
 - Elements: section-heading, numbered-para, blockquote (ציטוט מהוראות תכנית)
-- Sources: הוראות תכנית (PDF), נספחי בינוי, החלטות מרכזות, **מרשם-התכניות** (טבלת `plans` — זהות+תוקף קנוניים, מאושרי-יו"ר; ראה להלן)
+- Sources: הוראות תכנית (PDF), נספחי בינוי, החלטות מרכזות
-
-**משפט-ציטוט-תכנית (קנוני — נוסח דפנה):**
-לכל תכנית, חלק **הזהות והתוקף** נכתב בנוסח אחיד ודטרמיניסטי הנגזר ממרשם-התכניות
-(`db.format_plan_citation`), כך שתאריך-הפרסום ומספר-הילקוט לעולם אינם מנוסחים מחדש
-(ובכך גם לא מהוזים — INV-AH). התבנית (רשומות בלבד; חלקים בסוגריים = לפי-זמינות):
-
-> `{שם-התכנית} פורסמה למתן תוקף ברשומות ביום {D.M.YYYY}[, י"פ {מס'}][ — {ייעוד}].`
-
-דוגמאות-אמת מהקורפוס: *"תכנית מי/820 פורסמה למתן תוקף ביום 9.8.2001 — משנה את הוראות
-תכנית מי/200…"* · *"תכנית הל/435 פורסמה למתן תוקף ביום 8.11.2007…"*. הניתוח התכנוני
-(ייעוד, פרשנות) מנוסח בסגנון דפנה; **תאריך-התוקף ומספר-הילקוט — מהמרשם, ככתבם.**
-תכנית שזוהתה בתיק אך **חסרה במרשם או טרם אושרה** מוזכרת בלי תאריך-תוקף (לא מנחשים).
-המרשם מוזן ע"י `extract_plans` / `backfill_plans_registry.py`, ונכנס לשימוש רק
-אחרי אישור-יו"ר (`plan_review`, review_status=approved — G10).
 
 **Constraints:**
 - MUST: ציטוט ישיר מהוראות תכנית עם הדגשת (bold) מילים מכריעות
-- MUST: לזהות+תוקף של תכנית — להשתמש במשפט-הציטוט הקנוני מהמרשם (לעיל); אסור להמציא תאריך-פרסום/מס'-ילקוט
 - MUST NOT: ניתוח מעמיק (→ block-yod), הכרעה בין פרשנויות
 - Dependencies: block-chet (מספור), block-vav (הגדרות תכניות)
 - Condition: **אופציונלי** — רק כשיש מורכבות תכנונית (תכניות סותרות, תמ"א 38 + שימור, פרשנות)

docs/corpus-graph.md

@@ -1,70 +0,0 @@
-# מפת הקורפוס — גרף ציטוטים אינטראקטיבי (`/graph`)
-
-תצוגת‑רשת אינטראקטיבית של קורפוס הפסיקה, בסגנון Obsidian Graph View, **מוטמעת נייטיב ב‑web‑ui**. כל פריט הוא נקודה, קישורים הם קווים, וגודל הנקודה משקף חשיבות — כך שאפשר להתמקד בנושא ולראות מה קשור אליו.
-
-## למה נייטיב ולא Obsidian (G2)
-
-הרעיון המקורי היה לייצא את הקורפוס ל‑Obsidian vault. **נדחה** — vault הוא **עותק מקביל של הקורפוס שמתיישן**, בדיוק כשל‑השורש ש‑[G2](spec/00-constitution.md) (מקור‑אמת יחיד, ללא מסלול מקביל) בא לייבש. הגרף הנייטיב קורא את ה‑DB החי → **אפס drift**, ומתחבר לדפים הקיימים (`/precedents`, `/missing-precedents`, `/digests`).
-
-**התובנה המאפשרת:** כל קשתות הגרף כבר היו קיימות בטבלאות — הגרף רק חושף אותן. הוא **projection קריא‑בלבד** (SELECT בלבד), ולכן אינו יכול לסטות מהמקור. הוא **אינו מסלול אחזור** ([03-retrieval](spec/03-retrieval.md)) — מחזיר טופולוגיה (nodes+edges+מטריקות), לא תוצאות חיפוש מדורגות.
-
-## שכבות (כולן opt‑in דרך toggles, מלבד הבסיס)
-
-| שכבה | נקודות | קשתות | מקור הדאטה |
-|------|--------|-------|------------|
-| **בסיס** | פסיקה (`cl:`) · נושא (`tag:`) · תחום (`pa:`) | `cites` · `same_chain` · `tagged` · `in_area` | `case_law`, `precedent_internal_citations`, `case_law_relations`, `subject_tags` |
-| **הלכות** | הלכה (`hal:`) | `extracted_from` · `corroborates` · `equivalent` | `halachot`, `halacha_citation_corroboration`, `equivalent_halachot` |
-| **חוסרי מחקר** | gap (`gap:`) — חלול/מקווקו | `cites` (פסיקה→gap) | `precedent_internal_citations` (cited_case_law_id IS NULL) + העשרה מ‑`missing_precedents` |
-| **יומונים** | יומון (`dig:`) — טורקיז | `covers` (יומון→פסיקה/gap) | `digests` |
-
-**גודל נקודה** = חשיבות: ציטוטים נכנסים (פסיקה), אזכורים (הלכה), מספר מצטטים (gap). **צבע** (color‑by, ברירת‑מחדל "סוג"): סוג · תחום · דרגת‑סמכות · **אשכול** (community) · עדכניות.
-
-## אנליטיקה (Graph Analysis)
-
-`metrics=true` מפעיל חישוב **in‑memory** (ללא DB) ב‑[`web/graph_metrics.py`](../web/graph_metrics.py) — pure, ללא תלויות (אין networkx):
-- **PageRank** (power‑iteration) — השפעה גלובלית.
-- **Betweenness** (Brandes) — "גשריות" (פסיקות שמחברות אשכולות).
-- **Community** (label‑propagation דטרמיניסטי + fallback ל‑connected‑components) — אשכולות תמטיים.
-
-מחושב על **תת‑גרף הפסיקות בלבד** (cites/same_chain) — קשתות hub/gap/digest/halacha מוחרגות. ב‑UI: בוררי "צביעה לפי" / "גודל לפי" + פאנל דירוג ("המשפיעות" / "גשרים").
-
-## ניווט וחוויה
-
-- **Deep‑link** `/graph?focus=cl:<id>` — לינק שיתופי; כפתור **"הצג בגרף"** בכל דף פסיקה.
-- **Local graph** — לחיצה על נקודה → התמקדות בשכניה (BFS, סליידר עומק 1–3).
-- **ייצוא PNG** · פאנל עשיר (headnote/summary) · מקרא נקודות+קשתות · סינון מטא‑דאטה (בית‑משפט/דרגה/יו״ר/מחוז/שנים).
-
-## API
-
-קריאה‑בלבד, `response_model` מפורש (UI2). מוגדר ב‑[`web/app.py`](../web/app.py) (~`/api/graph/*`), לוגיקה ב‑[`web/graph_api.py`](../web/graph_api.py):
-
-| endpoint | תיאור |
-|----------|-------|
-| `GET /api/graph/corpus` | הגרף המלא. params: `node_types` (csv), `metrics`, `practice_area`/`source`/`court`/`precedent_level`/`chair`/`district`/`year_from`/`year_to`, `min_citations`, `q`, `limit` (cap 400, max 1500) |
-| `GET /api/graph/node/{id}/neighborhood` | Local graph: צומת + שכנים בעומק 1–3 |
-| `GET /api/graph/facets` | ערכי סינון ייחודיים (courts/levels/chairs/districts) |
-
-## קבצים
-
-- **Backend:** [`web/graph_api.py`](../web/graph_api.py) (הרכבת nodes/edges, helpers `_edges_and_hubs`/`_gap_nodes_and_edges`/`_digest_nodes_and_edges`/`_halacha_nodes_and_edges`) · [`web/graph_metrics.py`](../web/graph_metrics.py) (מטריקות) · endpoints ב‑[`web/app.py`](../web/app.py).
-- **Frontend:** [`web-ui/src/app/graph/page.tsx`](../web-ui/src/app/graph/page.tsx) · [`web-ui/src/components/graph/`](../web-ui/src/components/graph/) (`graph-view` orchestrator · `graph-canvas` ציור react‑force‑graph‑2d · `graph-filter-panel` · `graph-node-panel`) · hooks ב‑[`web-ui/src/lib/api/graph.ts`](../web-ui/src/lib/api/graph.ts).
-
-## איך מוסיפים שכבה חדשה
-
-1. הוסף ערך ל‑`VALID_NODE_TYPES` ב‑`graph_api.py` (לא ל‑`DEFAULT_NODE_TYPES` אם רוצים שיהיה כבוי).
-2. כתוב `_X_nodes_and_edges(conn, prec_ids)` — SELECT בלבד; חבר nodes לפסיקות שבתצוגה.
-3. חבר בשתי פונקציות הבנייה (`build_corpus_graph` + `build_node_neighborhood`) מאחורי `if "X" in types`.
-4. **dangling‑edge invariant:** כל קשת — שני קצותיה חייבים להיות nodes בתצוגה (סנן מול `prec_ids`/קבוצת ה‑ids).
-5. Frontend: toggle ב‑`graph-filter-panel` · צבע/רינדור ב‑`graph-canvas` (`NODE_COLORS`/`colorForNode`/`linkColor`) · ענף בפאנל ב‑`graph-node-panel`.
-6. אם גדל מודל התגובה — אחרי deploy: `cd web-ui && npm run api:types`.
-
-## Invariants
-
-- **G2** — projection קריא‑בלבד דרך `db.get_pool()`; אפס כתיבות; מטריקות in‑memory. ללא store מקביל.
-- **G5** — כל פילטר server‑side, parameterized.
-- **UI2** — `response_model` מפורש בכל endpoint; **UI4** — שגיאות UI מוצגות, לא נבלעות.
-- **טופולוגיה ≠ אחזור** — מבנה הקורפוס, לא תוצאות חיפוש.
-
-## היסטוריית מימוש
-
-PR #113 (בסיס) · #118 (תיקון תוויות) · #126 (מטא‑דאטה) · #129 (אנליטיקה) · #131 (gaps) · #132 (יומונים) · #134 (ניווט) · #137 (הלכות) · #139 (api:types).

docs/ia-audit-redesign.md

@@ -1,146 +0,0 @@
-# IA-Audit & Redesign — מפת משטח-ההפעלה, כפילויות, וניווט-יעד
-
-> **מה זה.** אבחון שיטתי של **משטח-ההפעלה** של המערכת (כל דף/טאב/drawer/פונקציה) — מה כל אחד עושה, מה כפול, מה מת, מה מציג נתון שגוי, ואיך הכול מסתנכרן — ו**תכנון-מחדש** של ארכיטקטורת-המידע (IA). נכתב לפי בקשת חיים (2026-06-11): *"המערכת מסובכת מדי לתפעול… כל הדפים האלה מפוזרים ואין לי מושג מה כל אחד עושה והאם יש כפילויות."*
->
-> **היקף:** משטח-ההפעלה (1א). ה-backend נכלל רק היכן שהוא גורם לכפילות/נתון-שגוי ב-UI. תוצר-אחות: ספ-היעד [`docs/spec/X17-information-architecture.md`](spec/X17-information-architecture.md). יוזמה: TaskMaster `legal-ai` **#127**.
->
-> **איך הופק:** סריקת-עומק רב-סוכנית (18 סוכנים, 6 אשכולות × 3 שלבים — קטלוג → אימות-אדוורסרי מול הקוד → תכנון-יעד מגובה-מקורות). כל ממצא אומת ב-`file:line`; כל עקרון-תכנון מגובה ב-≥3 מקורות סמכותיים (ראה [X17 §מקורות](spec/X17-information-architecture.md)).
-
-## יחס למסמכים קיימים (דאבל-צ'ק — לא לכפול)
-- **[`ui-audit.md`](spec/ui-audit.md)** — ביקורת-קוד פר-רכיב (enums כפולים, טיפוסים, helpers → FU-10). **שכבה אחרת.** מסמך זה הוא בשכבת ה-**IA/הפעלה** (אילו משטחים, מה כל אחד עושה, סנכרון, ניווט). חופף נקודתית ב-UI-C1 (3 דפי-פסיקה חופפים) ו-UI-D2/D3 (שקיפות-מקור) — מורחב כאן.
-- **[`gap-audit.md`](spec/gap-audit.md)** — ממצאי-ארכיטקטורה (GAP→FU). מסמך זה ברמת-הדף.
-- **[`X6-ui-api-contract.md`](spec/X6-ui-api-contract.md)** — חוזה UI↔API (UI1–UI6). X17 מוסיף שכבת invariants מעל X6.
-
----
-
-## 1. תקציר-מנהלים — 5 מחלות-השורש
-
-הסריקה אימתה **37 ממצאים** על פני 34 משטחים. כולם נופלים ל-5 דפוסים:
-
-| # | מחלת-שורש | כמה | מהות |
-|---|-----------|-----|------|
-| **D1** | **פערי-סנכרון ב-cache** | 16 | mutation מבטל רק את ה-queryKey המקומי, לא את ה-aggregator/האח/ה-namespace השני → מונה/נתון תקוע ב-0–60ש' בין דפים. זהו G2 בשכבת ה-TanStack-Query cache. |
-| **D2** | **משטחי-כתיבה/אישור כפולים** | 6 (dup) + 2 confusing | אותו datum נערך/מאושר ב-2 מקומות שכותבים ל-2 ערוצים. החריף: **שני שערי-למידה** (decision_lessons מול promote) ו-**מתודולוגיה** (PUT מול promote כותבים לאותה שורה — מירוץ lost-update). זו בדיוק ה"למה 2 שערים" של חיים. |
-| **D3** | **נתונים-שגויים/מטעים** | 6 | KPI סופר דגל אינפורמטיבי-בלבד (`applied_to_skill`/`findings_applied` — "מזויף"); `signature_phrases` עם תווית-קרדינליות שקרית; מונה-תור שמתעלם מחברה לא-זמינה. |
-| **D4** | **משטחים/פונקציות מתים** | 5 | endpoint `queue/pending` ללא צרכן; כפתור `applied_to_skill`; ז'רגון `T7/T15`; `AuthorityBadge` חסר בחיפוש. |
-| **D5** | **כפילות-ניווט** | — | הערות-יו"ר ב-2 דפים; `/operations`+`/diagnostics` אותו intent; `precedents` מול `precedent-library`. |
-
-**התובנה המאחדת:** רוב המחלות הן ביטוי-UI אחד של עקרון-על מופר — **G2 (מקור-אמת יחיד / אין מסלולים מקבילים)** — שמעולם לא הורחב לשכבת-ה-UI (cache + משטחים). זה בדיוק מה שחיים חווה כ"מסובך לתפעול": אותו מספר בשני מקומות, שני שערים לאותה החלטה, ומספרים שלא מתעדכנים.
-
-### ניווט-היעד (תמצית — מלא ב-X17)
-שלושה משטחי-**intent** עם בעלים-יחיד, במקום פיזור-לפי-פורמט:
-1. **`/approvals` = תיבת-ההחלטות-האנושית היחידה** — המקום היחיד שבו פועלים על שער. דפים אחרים **מצביעים** למונה, לא משכפלים אותו.
-2. **`/operations` = משטח-הקריאה-בלבד היחיד** ("מה המכונה עושה") — בולע את `/diagnostics`.
-3. **`/settings` = משטח-התצורה היחיד.**
-ובתוך-התחום: **החלטה=workspace אחד** · **למידה=תיבה+ערוץ+שער אחד** · **`/methodology`=עורך-הכללים היחיד** · **פסיקה=3 קורפוסים נפרדים אך מתפעלים אחיד**.
-
-> **כל ההצעות שומרות 100% מהשערים-האנושיים (G10/INV-LRN1).** מסירים משטח/ערוץ **כפול**, לא שער. זו ההתאמה בין "פשטות-הפעלה" ל-G10.
-
----
-
-## 2. ממצאים לפי אשכול
-
-לכל אשכול: משטחים שקוטלגו · ממצאים מאומתים (file:line) · כיוון-היעד. הפירוט המלא (כל אלמנט + כל מקור) נשמר בפלט-הסריקה ([`data/audit/`](../data/audit/)).
-
-### 2.1 תיקים (`/`, `/archive`, `/cases/[n]`, `/compose`)
-**3 משטחים · 2 ממצאים.** מחלה: תוכן-ההחלטה מפוצל ל-2 משטחי-כתיבה עצמאיים + עורך-compose שלישי.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| CAS-1 | sync-gap | `DraftsPanel` (העלאת DOCX) לא מבטל `['decision-blocks']` → `DecisionBlocksPanel` מציג `source_of_truth='blocks'` תקוע; אזהרת-הסטייה לא מופיעה עד רענון ידני | exports.ts:103-107 מול decision-blocks.ts:46-49; app.py:2673 | add-invalidation |
-| CAS-2 | sync-gap | `useExportDocx` לא מבטל `['decision-blocks']` — אותו שורש | exports.ts:80-82 | add-invalidation |
-
-**יעד:** workspace-החלטה אחד (block-editing + DOCX-פעיל) עם **מחוון-מקור-אמת אחד** בבעלות-המערכת ו-cache-slice משותף; אזור "השלמה והעברה" אחד לכל שערי-סיום-התיק.
-
-### 2.2 אישורים + הערות-יו"ר (`/approvals`, `/feedback`)
-**3 משטחים · 6 ממצאים.** מחלה: `/api/chair/pending` גוזר 4 מונים, אך כל משטח-משימה מבטל רק את ה-cache שלו ולא את ה-aggregator → התיבה והתג-בסרגל תקועים עד 60ש'.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| APR-1 | sync-gap | פתרון הערה ב-`/feedback` לא מבטל `['chair','pending']` → מונה `/approvals` והתג תקועים | feedback.ts:105; chair.ts:36; app-shell.tsx:336 | add-invalidation |
-| APR-2 | duplication | הערות-יו"ר ב-2 caches (`['feedback']` מול `['chair','pending']`) ללא הצלבה — שני endpoints על אותה `chair_feedback WHERE NOT resolved` | app.py:5650,5654 | add-invalidation |
-| APR-3 | wrong-data | דגימת-ההערות ב-`/approvals` יכולה להראות 5 ישנות בעוד המונה כבר 0 | app.py:5650-5654; chair.ts:36 | fix-data |
-| APR-4 | sync-gap | `ApprovalsBadge` בסרגל תקוע אחרי פתרון-הערה/אישור-הלכה/העלאת-פסיקה | app-shell.tsx:336; feedback.ts:105; missing-precedents.ts:256-258; precedent-library.ts:648,668 | add-invalidation |
-| APR-5 | sync-gap | אישור-הלכה לא מבטל `['chair','pending']` | precedent-library.ts:648,668; app.py:5619-5620 | add-invalidation |
-| APR-6 | sync-gap | העלאת/סגירת פסיקה-חסרה לא מבטל `['chair','pending']` | missing-precedents.ts:256-258; app.py:5636-5637 | add-invalidation |
-
-**יעד:** `/approvals` = תיבת-הגייטים הקנונית היחידה; `['chair','pending']` = מקור-אמת יחיד ל"מה ממתין"; התג בסרגל = המונה היחיד; **הערות-יו"ר יורד מהניווט-הראשי** והופך לכרטיס-משימה מתוך התיבה.
-
-### 2.3 פסיקה (`/precedents`, `/missing-precedents`, `/digests`, `/precedents/[id]`, `/graph`)
-**13 משטחים · 5 ממצאים.** מחלה: 3 קורפוסים אמיתיים ושונים — אך **מתפעלים שונה** ומבלבלים בשמות.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| PRE-1 | confusing | שני namespaces כמעט-זהים: `/api/precedents/search` (typeahead לתיק) מול `/api/precedent-library/search` (חיפוש-קורפוס) | app.py:3109 מול 6057 | clarify (rename/label) |
-| PRE-2 | dead | `GET /api/precedent-library/queue/pending` — אפס צרכני-frontend (רק digests משתמש ב-queue/pending) | app.py:6282 | delete |
-| PRE-3 | wrong-data | `AuthorityBadge` (binding/persuasive, DERIVED) מוצג בתור-הביקורת אך **נשמט בחיפוש** | library-search-panel.tsx:26-73 מול halacha-review-panel.tsx:109 | fix-data |
-| PRE-4 | confusing | תג "ממתין" ב-`/digests` נראה לחיץ אך אינו (ב-`/precedents` הוא טאב-תור אמיתי) | digests/page.tsx:23-35 | clarify |
-| PRE-5 | dead | `HalachaCard` בחיפוש לא מרנדר authority אף שהשדה על החוט | library-search-panel.tsx:26-73 | fix-data |
-
-**יעד:** 3 הקורפוסים נשארים נפרדים (גבול אמיתי — G2/INV-DIG1) אך **מתפעלים אחיד**: שם-חיפוש עקבי לכל קורפוס, תבנית-"ממתין" אחת, authority מוצג בכל מקום. מחיקת ה-endpoint המת.
-
-### 2.4 למידה + סגנון (`/training` — 6 טאבים + CorpusDetailDrawer) ⚠️ האשכול הקריטי
-**8 משטחים · 10 ממצאים.** מחלה: "לקח" חי ב-2 namespaces ומאושר ב-2 מקומות שכותבים ל-2 ערוצי-כותב; 3 KPI על דגלים-ללא-צרכן.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| LRN-1 | sync-gap | כפתור `applied_to_skill` ("אומץ לסקייל") **אינפורמטיבי-בלבד** — לא כותב ל-SKILL.md; היו"ר מאמין שהפעולה הושלמה | lessons-tab.tsx:12-14; app.py:1471-1475 | fix-data (להסיר) |
-| LRN-2 | confusing | למידה מפוצלת ל-`/api/learning` + `/api/training` לאותה ישות | learning.ts; training.ts; app.py:1448,4616 | clarify (לאחד) |
-| LRN-3 | confusing | **שני שערי-אישור ללא יחס אכוף** — `promote` מתעלם מ-`review_status` לגמרי | learning-panel.tsx:89-150; lessons-tab.tsx:168-179; app.py:4574 | clarify (שער אחד) |
-| LRN-4 | wrong-data | `StyleReportPanel`: "12 מתוך 487 שחולצו" — `signature_phrases` ו-`total_patterns` מחושבים עצמאית; אין יחס-תת-קבוצה | style-report-panel.tsx:87-90 | fix-data |
-| LRN-5 | wrong-data | `findings_applied` ("ממצאים שאומצו ל-SKILL: 42") סופר דגל-אינפורמטיבי → KPI "מזויף" | curator-portrait-panel.tsx:85-86; app.py:1300-1302 | fix-data |
-| LRN-6 | sync-gap | מחיקת-קורפוס לא מאפסת בחירת `ComparePanel` → submit מחזיר 404 | compare-panel.tsx:119-120; training.ts:172-174 | fix-data |
-| LRN-7 | keep | `FullTextLazy` ב-raw-fetch מחוץ ל-Query — שביר לעתיד, לא באג חי | corpus-detail-drawer.tsx:320-348 | keep |
-| LRN-8 | sync-gap | מחיקת-קורפוס מייתמת צ'אטים (`style_corpus_id→NULL`) בשקט, ללא אזהרה | corpus-panel.tsx:45-54; db.py:234 | add-invalidation |
-| LRN-9 | keep | סינון `PatternsForSubtype` stubbed (אין endpoint) — fallback חינני | corpus-detail-drawer.tsx:351-353 | keep |
-| LRN-10 | sync-gap | `usePromoteLearning` מבטל רק `learningKeys`, לא `lessonsKeys.forCorpus` → LessonsTab תקוע | learning.ts:104-115; training.ts:499-502 | add-invalidation |
-
-**יעד:** תיבת-אישור-למידה אחת (מקובצת לפי זוג draft↔final) · **ערוץ-כותב אחד + סטטוס "זורם-לכותב" אחד** (`review_status='approved'`) · **הסרת `applied_to_skill`** (אוצרות SKILL.md = מעשה-git ידני, לא כפתור) · כל artifact תלוי בזוג שלו (progressive disclosure) · תיקון 2 ה-KPI.
-
-### 2.5 מתודולוגיה (`/methodology` — 5 טאבים)
-**2 משטחים · 8 ממצאים.** מחלה: כללי-הכותב נערכים מ-2 משטחים שכותבים לאותה שורה `appeal_type_rules(_global, …, 'universal')` — מירוץ lost-update + פער-cache.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| MET-1 | sync-gap | `promote` מבטל `['learning']` בלבד; `/methodology` (`['methodology',cat]`, staleTime 30ש') תקוע אחרי אישור | learning.ts:113; methodology.ts:26-28; app.py:4629-4631 | add-invalidation |
-| MET-2 | duplication | `discussion_rules['universal']` נכתב ב-2 מקומות (PUT מול promote) — כתיבה-שנייה דורסת בשקט | discussion-rules-panel.tsx:35-36; learning-panel.tsx:138-139; app.py:4491-4495,4629; db.py:290 | fix-data |
-| MET-3 | duplication | `transition_phrases['universal']` — אותו מירוץ | methodology/page.tsx:45-49; learning-panel.tsx:125-129; app.py:4631 | fix-data |
-| MET-4 | confusing | `universal` מוצג כדלי-תוצאה אח, אך בפועל **מוקדם (prepended)** לכל התוצאות — אין מודל-מנטלי | discussion-rules-panel.tsx:16-22; lessons.py:376-379 | clarify |
-| MET-5 | dead | ז'רגון `T15`/`T7` בטקסט-העזר — מזהי-משימות פנימיים חסרי-משמעות למפעיל | methodology/page.tsx:48,55 | fix-data |
-| MET-6 | wrong-data | עורך-צ'קליסטים מציג 5 סוגי-ערר ללא מיפוי איזה `appeal_type` צורך כל אחד | content-checklists-panel.tsx:17-31; app.py:4414 | clarify |
-| MET-7 | confusing | 3 מושגי-"כלל" מתערבבים (ratios/rules/checklists) ללא מודל-תחולה | methodology/page.tsx:16-19; block_writer.py:912-923 | clarify |
-| MET-8 | sync-gap | סדר-callbacks ב-promote → toast-הצלחה אחרי invalidation לא-מספק | learning.ts:112-113; learning-panel.tsx:138-143 | add-invalidation |
-
-**יעד:** `/methodology` = העורך הקנוני **היחיד** (כל כתיבה דרך PUT אחד, עם תג-מקור "ידני/מאומץ-מלמידה"); הלמידה **מנותבת דרכו** (לא כותבת-במקביל) ומבטלת את שני ה-caches; explainer-תחולה inline; קופי בעברית-פשוטה (בלי T7/T15).
-
-### 2.6 תפעול + אבחון + הגדרות (`/operations`, `/diagnostics`, `/settings`, `/skills`)
-**5 משטחים · 6 ממצאים.** מחלה: 4 משטחים שמריצים שאילתות-מקור זהות בלי cache משותף + נתונים-מתים/מטעים.
-
-| ID | סוג | ממצא | file:line | תיקון |
-|----|-----|------|-----------|-------|
-| ADM-1 | sync-gap | `halacha_backlog` מוחזר מה-backend אך **נזרק** ב-frontend (אין בטיפוס, לא מרונדר) | app.py:2253; system.ts:21-32; diagnostics/page.tsx | fix-data (לרנדר/להסיר) |
-| ADM-2 | sync-gap | מוני-הלכות כפולים ב-`/operations` ו-`/approvals` ללא קישור-cache | operations.ts:60; chair.ts:36; app.py:6520,5619-5633 | add-invalidation (consolidate) |
-| ADM-3 | sync-gap | מוני-פסיקה-חסרה כפולים ב-`/operations` ו-`/approvals` | operations.ts:60; app.py:6521,5636-5647 | add-invalidation (consolidate) |
-| ADM-4 | confusing | `court_fetch`: "בתור" כולל failed, מטשטש pending מול queued | operations/page.tsx:286-304; app.py:6562 | clarify |
-| ADM-5 | sync-gap | עריכת env ב-Coolify לא מרעננת את ערך-ה-Container ולא מזהירה על staleness עד redeploy | env-var-row.tsx:76-96; settings.ts:135 | fix-data |
-| ADM-6 | wrong-data | מוני-סוכנים מסכמים רק חברות-Paperclip זמינות → עומק-תור מוקטן בשקט כשחברה לא-נטענת | app.py:6667-6689; operations/page.tsx:461-465 | clarify (להציג חלקיות) |
-
-**יעד:** **`/approvals`=תיבת-ההחלטות** (כל גייט נפעל רק כאן; `/operations` מצביע ולא משכפל) · **`/operations`=משטח-קריאה יחיד** (בולע את `/diagnostics`, מרנדר `halacha_backlog`, מתקן queued/pending, מציג חלקיות) · **`/settings`=תצורה** (עריכת-env שמשלימה-את-עצמה: סימון-staleness + redeploy באותה שורה).
-
----
-
-## 3. עדכוני-ספ מומלצים (מתועדים ב-X17)
-הסריקה זיהתה ש-X6 לא מכסה את שכבת-ה-UI-state, וש-07-learning מסנקצן בטעות שני-ערוצים. ההמלצות (כל אחת מגובת-מקורות ב-X17):
-1. **X6 — invariants חדשים בשכבת-UI:** (א) aggregate-נגזר = מקור-אמת; כל mutation לטבלת-מקור חייב לבטל את ה-queryKey שלו; אסור מונה-מתחרה client-side. (ב) למונה-גייט בעלים-משטח-יחיד; אחרים מצביעים. (ג) שדה ב-OpenAPI-response — לרנדר או להסיר (אסור לזרוק בשקט). (ד) אסור להציג aggregate מדויק כש-partial-failure השמיט תורם — להציג חלקיות.
-2. **07-learning §0.4/§0.6:** שער-אישור **אחד**, טרנזקציית-כותב **אחת**, `applied_to_skill` מוסר; לקחים-מאושרים נכתבים רק דרך מסלול-המתודולוגיה היחיד.
-3. **00-constitution G2 "הפרות ידועות":** להוסיף את תאום-המתודולוגיה (`discussion_rules['universal']` נכתב ע"י PUT וגם promote).
-
----
-
-## 4. הבא — בקלוג-איחוד (פאזה F)
-מסמך זה **ממפה ומאבחן**; הוא אינו משנה קוד. הבקלוג המתועדף (TaskMaster, מקושר לכל ממצא) נגזר ב-#127.6 ומחולק ל-3 גלים:
-- **גל-1 (זול, גבוה-ערך):** הוספת-invalidation ל-16 פערי-הסנכרון + תיקון 6 הנתונים-השגויים + מחיקת המתים. תיקון מקומי, אין הגירת-IA.
-- **גל-2 (איחוד-משטחים):** תיבת-אישור אחת · ערוץ-למידה אחד (הסרת `applied_to_skill`, איחוד שני-השערים) · `/operations`⊇`/diagnostics`.
-- **גל-3 (ניווט):** הורדת `/feedback` מהראשי · שמות-חיפוש עקביים · X17 ל-canonical.
-
-**הכרעת-יו"ר נדרשת לפני גל-2/3** (3א — עוצרים על המסמך).

docs/legal-decision-lessons.md

@@ -463,7 +463,6 @@ The draft's biggest structural error was adding the "נבאר" doctrinal paragra
 - **Problem:** legal-writer updates `decision_blocks` in the DB, but legal-qa reads from `drafts/decision.md` on disk. In CMPA-62 the writer reported updating block headers in DB but the file did not re-sync, causing QA-2 to fail on exactly the same issue twice.
 - **Lesson:** Single source of truth is mandatory — either the writer must write to BOTH the DB and the decision.md file in one atomic step, or there must be an automatic `regenerate-draft` hook that runs after every block update so the file always reflects the latest DB state. Two unsynchronized sources will keep producing the same false-fail loop.
 - **Owner:** Infrastructure task — not a writer/QA prompt fix.
-- **✅ RESOLVED (GAP-88, 2026-06-06):** `block_writer._update_draft_file` is now an automatic regenerate hook called from `store_block` (every persist) **and** `renumber_all_blocks` — so `drafts/decision.md` always reflects `decision_blocks`. legal-qa already validates against the DB; both sides are now identical.
 
 ---
 

docs/operations-runbook.md

@@ -1,203 +0,0 @@
-# Operations Runbook — עוזר משפטי
-
-> תוכן תפעולי-עומק שהוצא מ-[`CLAUDE.md`](../CLAUDE.md) כדי לרזות את ההקשר הנטען בכל סשן (TaskMaster #107.1).
-> ה-CLAUDE.md מחזיק את **הכללים הקריטיים בקצרה**; כאן נמצאים הפרטים המלאים, הפקודות, וטבלאות-הייחוס.
-> כשעובדים על Deploy, Paperplip-ops, או adapters — לקרוא את הסעיף הרלוונטי כאן.
-
----
-
-## שרת Nautilus (158.178.131.193)
-
-| שירות | תפקיד | כתובת |
-|-------|--------|-------|
-| Coolify | ניהול containers | `http://158.178.131.193:8000` |
-| PostgreSQL + pgvector | בסיס נתונים ראשי | `legal-ai-postgres` (`localhost:5433`, user `legal_ai`) |
-| Redis | תור משימות | `legal-ai-redis` |
-| Gitea | מאגר קוד | `gitea.nautilus.marcusgroup.org/ezer-mishpati` |
-| ezer-mishpati-web | ממשק העלאת מסמכים (Docker/Coolify) | `legal-ai.nautilus.marcusgroup.org` |
-| Paperclip | סוכן AI — מריץ Claude Code agents (pm2, מקומי) | `localhost:3100` |
-| legal-chat-service | גשר claude CLI לטאב הצ'אט ב-/training (pm2, loopback) | `127.0.0.1:8770` |
-| Infisical | ניהול סודות | `secret.dev.marcus-law.co.il` |
-
----
-
-## ארכיטקטורת Deploy — חובה לקרוא
-
-שלושה מודלי-הרצה דרים יחד. ערבוב ביניהם הוא הטעות הנפוצה ביותר.
-
-### עוזר משפטי (Legal-AI) — Docker container דרך Coolify
-- UUID: `gyjo0mtw2c42ej3xxvbz8zio` (build_pack: `dockerimage`, **לא** `dockerfile`)
-- שינוי קוד ב-`web/` או `web-ui/` **לא נכנס לתוקף** עד ש:
-  1. עושים `git commit` + `git push origin main`
-  2. Gitea Actions בונה image → דוחף ל-registry → מפעיל redeploy ב-Coolify (`mcp__coolify__deploy`)
-  3. ממתינים ~2-4 דקות לבנייה
-- **אסור** לנסות להריץ uvicorn / `next dev` מקומית — אין סביבת Python על המכונה
-- ה-container מריץ Next.js (`:3000`, חשוף) + FastAPI (`:8000`, פנימי)
-- בדיקה: `curl https://legal-ai.nautilus.marcusgroup.org/api/health`
-- runbook מלא של ה-pipeline: `~/CI-CD-MIGRATION-GUIDE.md`
-
-### Paperclip — מקומית דרך pm2
-- פורט: `localhost:3100`, DB: `localhost:54329` (Postgres embedded)
-- שינויי קוד נכנסים לתוקף אחרי `pm2 restart paperclip`
-- **אין צורך ב-Docker או Coolify** (מיגרציה ל-Coolify נוסתה 2026-04-04 והוחזרה 2026-04-08)
-- תרגום/RTL: `~/.paperclip/hebrew/` → `bash ~/.paperclip/hebrew/apply-hebrew.sh && pm2 restart paperclip`
-
-### legal-chat-service — מקומית דרך pm2 (מאפריל 2026)
-- פורט: `127.0.0.1:8770` (loopback בלבד)
-- שירות aiohttp קצר שעוטף את `claude` CLI ב-streaming + session continuation, ומשרת את הטאב "שיחה" בדף `/training`. הקונטיינר משדל אליו proxy דרך `host.docker.internal:8770`.
-- קוד: [`mcp-server/src/legal_mcp/chat_service/`](../mcp-server/src/legal_mcp/chat_service/)
-- התקנה: `pm2 start /home/chaim/legal-ai/scripts/legal-chat-service.config.cjs && pm2 save`
-- בריאות: `curl http://127.0.0.1:8770/health` → `{"ok":true,...}`
-- שינויי קוד: `pm2 restart legal-chat-service`
-- **אפס עלות API** — claude CLI משתמש ב-claude.ai subscription של chaim. הנחת היסוד של `claude_session.py` (claude CLI מקומי בלבד) נשמרת.
-- Coolify dependency: ה-Service Definition של legal-ai חייב להכיל `extra_hosts: host.docker.internal:host-gateway` (אחרת ה-proxy יקבל ConnectError).
-
----
-
-## מבנה תיקיות
-
-```
-/home/chaim/legal-ai/
-├── CLAUDE.md                          ← אינדקס דק (כללים קריטיים + מצביעים)
-├── docs/operations-runbook.md         ← הקובץ הזה (עומק תפעולי)
-├── Dockerfile                         ← Docker build
-├── docs/                              ← תיעוד + לקחים
-│   ├── architecture.md                   ארכיטקטורה
-│   ├── block-schema.md                   12 בלוקים (המסמך החשוב ביותר)
-│   ├── migration-plan.md                 תוכנית מעבר vault → DB
-│   ├── legal-decision-lessons.md         לקחים מ-3 החלטות
-│   └── memory.md                         הקשר כללי — skills, פרויקטים
-├── skills/                            ← כלי עבודה ומדריכים
-│   ├── decision/                         מדריך סגנון + references + 12 בלוקים
-│   ├── assistant/                        קטלוג מסמכים
-│   ├── docx/                             עיצוב DOCX
-│   ├── dafna-decision-template/          export DOCX לפי תבנית Word של דפנה
-│   └── new-company-setup/               blueprint הוספת חברה חדשה
-├── .claude/
-│   └── agents/                        ← הוראות סוכנים + HEARTBEAT.md (symlinks ב-Paperclip)
-│       ├── HEARTBEAT.md                  checklist הפעלה משותף לכל הסוכנים
-│       ├── legal-ceo.md                  תזמורן + בקרת זרימה
-│       ├── legal-writer.md               כתיבת בלוקים בסגנון דפנה
-│       ├── legal-analyst.md              ניתוח משפטי + חילוץ טענות
-│       ├── legal-researcher.md           חיפוש תקדימים
-│       ├── legal-qa.md                   7 שערי איכות
-│       ├── legal-proofreader.md          תיקון OCR
-│       ├── legal-exporter.md             ייצוא DOCX סופי
-│       └── hermes-curator.md            סוכן Hermes לניתוח סגנון post-export
-├── data/
-│   ├── training/                      ← 4 החלטות לאימון (DOCX)
-│   ├── exports/                       ← טיוטות DOCX מיוצאות
-│   └── cases/{case-number}/           ← תיקי עררים (מבנה שטוח, סטטוס ב-DB)
-├── web/                               ← FastAPI backend (Python): 75+ API endpoints
-│   ├── app.py                            ← API ראשי
-│   ├── paperclip_api.py                  ← אינטגרציית Paperclip: `pc_request()` + `emit_case_status_webhook()`
-│   ├── paperclip_client.py               ← legacy client (ישן — השתמש ב-paperclip_api.py)
-│   └── gitea_client.py                   ← אינטגרציית Gitea
-├── web-ui/                            ← Next.js frontend (TypeScript/React): ממשק המשתמש
-│   └── next.config.ts                    ← proxy: /api/* → FastAPI :8000
-├── mcp-server/                        ← MCP server + services + tools
-├── adapters/                          ← Paperclip external adapters
-│   └── deepseek-paperclip-adapter/      ← `deepseek_local` (Hermes-pinned ל-DeepSeek profile)
-└── scripts/                           ← סקריפטים וכלי עזר (ראה scripts/SCRIPTS.md)
-    └── .archive/                      ← סקריפטים שהושלמו (לא להריץ)
-```
-
----
-
-## Paperclip — כללי אינטגרציה (פירוט מלא)
-
-> הכללים הקריטיים בתמצית נמצאים ב-[`CLAUDE.md`](../CLAUDE.md). כאן הפירוט המלא, הדוגמאות, וה-"למה".
-
-### Wakeup API — תמיד דרך API, לעולם לא דרך DB
-- **הנתיב הנכון**: `POST /api/agents/{agent-id}/wakeup` (לא `/wake`!)
-- **⚠️ אסור**: `INSERT INTO agent_wakeup_requests` ישירות — זה יוצר רק רשומה בלי `heartbeat_run`, והסוכן **לא יתעורר לעולם**
-- **⚠️ חובה לשלוח `payload` עם `issueId`** — בלי זה הסוכן מתעורר בלי הקשר (בלי תיק, בלי issue, בלי cwd נכון)
-- דוגמה נכונה:
-  ```json
-  {"source": "automation", "triggerDetail": "system", "reason": "...",
-   "payload": {"issueId": "...", "mutation": "comment", "commentId": "..."}}
-  ```
-- **Board API Key**: שמור ב-DB (`board_api_keys`), auth: `Authorization: Bearer pbk_...`
-
-### ניתוב comments דרך CEO
-- כשמשתמש כותב תגובה על issue ב-Paperclip, הפלאגין (`plugin-legal-ai`) מעיר את ה-CEO דרך `ctx.agents.invoke()`
-- ה-CEO קורא את ה-comment, מחליט על ניתוב, ויוצר issue לסוכן המתאים
-- כל הסוכנים חייבים לקרוא comments אחרונים לפני שהם מתחילים לעבוד (HEARTBEAT שלבים 2b-2c)
-
-### קריאות API — תמיד דרך helper, לעולם לא `curl` ישיר
-- **bash (סוכנים):** `~/legal-ai/scripts/pc.sh <METHOD> <PATH> [BODY_JSON]` — מוסיף Authorization, X-Paperclip-Run-Id, Content-Type, base URL. ראה `HEARTBEAT.md §0`.
-- **Python (FastAPI):** `from web.paperclip_api import pc_request; await pc_request("POST", "/api/...", json={...})` — שימוש ב-board API key.
-- **אסור** `curl ... $PAPERCLIP_API_URL` ישיר ב-bash; **אסור** `httpx.AsyncClient` ישיר ל-Paperclip ב-Python.
-- **למה:** ה-skill הרשמי דורש `X-Paperclip-Run-Id` בכל קריאה משנה issue. אצלנו ה-audit trail עבד ממילא דרך JWT claims (`runId: runIdHeader || claims.run_id`), אבל ה-helper מבטיח עקביות + תאימות ל-board API keys (long-lived) שלא נושאות JWT claims.
-
-### Cross-company agent sync — אחרי כל שינוי הגדרות
-- יש 14 סוכנים = 7 × 2 חברות (CMP=1xxx, CMPA=8xxx). Paperclip מחייב `agents.company_id NOT NULL` — אין shared agents.
-- **Master = CMP (1xxx)**, **Mirror = CMPA (8xxx)**.
-- אחרי כל שינוי ב-`adapter_config`, `runtime_config`, `budget_monthly_cents`, או skills של סוכן ב-master (UI, SQL, או API), **חובה להריץ:**
-  ```bash
-  PAPERCLIP_BOARD_API_KEY=$(...infisical...) \
-    python ~/legal-ai/scripts/sync_agents_across_companies.py --verify  # לבדיקה
-  PAPERCLIP_BOARD_API_KEY=$(...) \
-    python ~/legal-ai/scripts/sync_agents_across_companies.py --apply   # לסנכרן
-  ```
-- הסקריפט מסנן local skills שלא קיימים ב-CMPA (מציג אזהרה), משתמש ב-API (לא DB ישיר), יוצר revisions, idempotent.
-- שאלות ה-skill הרשמי של Paperclip — `paperclip` skill תחת `paperclipai/paperclip`.
-
-### Webhook יוצא — עדכון סטטוס תיק לפלאגין
-כשסטטוס תיק משתנה דרך `PUT /api/cases/{case_number}`, הבקאנד שולח webhook אסינכרוני לפלאגין:
-
-```
-PUT /api/cases/{case_number}  →  emit_case_status_webhook() [BackgroundTask]
-  →  POST /api/plugins/marcusgroup.legal-ai/webhooks/case-status
-  →  plugin-legal-ai/onWebhook()
-  →  comment בעברית על issue + CEO wakeup (כשסטטוס = qa_failed)
-```
-
-- הקוד ב-`web/paperclip_api.py` (`emit_case_status_webhook`), fire-and-forget, timeout 5s
-- הפלאגין שומר idempotency key ב-state עם TTL 5 דקות למניעת spam על retry
-- `GET /api/cases/stale?days=N` — תיקים שלא עודכנו N ימים; מוחרגים: `new`, `final`, `exported`
-- `GET /api/chair-feedback/weekly-summary` — סיכום פידבק YU"R לשבוע האחרון
-
-### Scheduled Jobs (plugin-legal-ai)
-| Job | לוח זמנים | מה עושה |
-|-----|-----------|---------|
-| `stale-case-reminder` | יומי 08:00 | שולח comment אזהרה על תיקים תקועים >3 ימים |
-| `weekly-feedback-analysis` | ראשון 19:00 | מעיר CEO לניתוח פידבק YU"R ועדכון `docs/legal-decision-lessons.md` |
-| `sync-case-status` | כל 30 דק' | מסנכרן סטטוסי תיקים בין legal-ai ל-Paperclip |
-
-CEO שמתעורר מ-`weekly-feedback-job` כותב לקובץ בלבד — **אין לו issueId, אל תנסה לפרסם comment או לסגור issue**.
-
-### External adapters — `deepseek_local`
-- מיקום ה-package: [`adapters/deepseek-paperclip-adapter/`](../adapters/deepseek-paperclip-adapter/) (לא ב-`node_modules`).
-- רישום ב-Paperclip: רשומה ב-`~/.paperclip/adapter-plugins.json` (נטען אוטומטית ב-startup דרך `buildExternalAdapters`). אין צורך בעריכת `node_modules`.
-- **מה ה-adapter עושה**: spawnל-`hermes chat` עם `HERMES_HOME=/home/chaim/.hermes/profiles/deepseek` כך שה-CLI טוען את `config.yaml` (`base_url=https://api.deepseek.com/v1`, `provider=custom`, `key_env=DEEPSEEK_API_KEY`) ואת `.env` (שמכיל את ה-key).
-- **מודלים זמינים** (lookup ב-DeepSeek `/v1/models`): `deepseek-v4-pro` (default), `deepseek-v4-flash`. יופיעו כדרופ-דאון ב-UI.
-- **התקנה מחדש / עדכון**: `curl -X POST -H "Authorization: Bearer pcapi_legal_install_key_2026" -H "Content-Type: application/json" -d '{"packageName":"/home/chaim/legal-ai/adapters/deepseek-paperclip-adapter","isLocalPath":true}' http://localhost:3100/api/adapters/install`. לעדכון hot — `POST /api/adapters/deepseek_local/reload`.
-- **⚠ Cross-company sync**: `sync_agents_across_companies.py` **מדלג** על סוכנים עם `adapter_type` שונה בין CMP ל-CMPA. כשעוברים סוכן ל-`deepseek_local` חובה להחיל ידנית בשתי החברות לפני sync.
-- **תוספת adapters עתידיים** (OpenAI ישיר, Anthropic ישיר, וכו'): אותו דפוס. ה-package הראשי חייב לייצא `createServerAdapter()` שמחזיר `{ type, label, models, agentConfigurationDoc, execute, testEnvironment, sessionCodec, listSkills, syncSkills, ... }`. ראה את [`adapters/deepseek-paperclip-adapter/dist/index.js`](../adapters/deepseek-paperclip-adapter/dist/index.js) כתבנית.
-
-### External adapters — Hermes Curator (`curator-cmp` / `curator-cmpa`)
-- פרופילי Hermes נפרדים לסוכן `hermes-curator` — מנתח החלטות סופיות ומציע עדכוני SKILL.md/lessons.md
-- מיקום: `~/.hermes/profiles/curator-cmp/` + `~/.hermes/profiles/curator-cmpa/`
-- מופעל אחרי export סופי; אינו מעדכן קבצים ישירות
-- **תהליך אישור הצעות:** הצעות ה-curator מגיעות כ-comment ב-Paperclip → חיים בוחן ומאשר ידנית → commits ל-`SKILL.md` ו-`docs/legal-decision-lessons.md`
-
----
-
-## הערות יו"ר (Chair Feedback)
-
-מנגנון לתיעוד הערות דפנה על טיוטות:
-- **DB**: טבלת `chair_feedback` (case_id, block_id, feedback_text, category, lesson_extracted)
-- **API**: `GET/POST /api/feedback`, `PATCH /api/feedback/{id}/resolve`
-- **MCP tools**: `record_chair_feedback`, `list_chair_feedback`
-- **UI**: דף ניהול ב-`/feedback` (ב-Next.js)
-- **קטגוריות**: missing_content, wrong_tone, wrong_structure, factual_error, style, other
-
----
-
-## ניהול משימות — TaskMaster AI (פירוט)
-
-- קובץ המשימות הקנוני: `~/legal-ai/.taskmaster/tasks/tasks.json` (יחסי ל-project root, **לא** `~/.taskmaster/tasks/tasks.json`). מכיל את כל ה-tags של legal-ai (`master`, `legal-ai`).
-- פקודות עיקריות: `get_tasks`, `next_task`, `add_task`, `update_task`, `expand_task`
-- לפני התחלת עבודה → `next_task`; אחרי סיום → `update_task` עם status=done; משימה מורכבת → `expand_task`
-- **⚠️ מלכוד cwd ב-CLI:** הדגל `--tag` בוחר קבוצה לוגית *בתוך* הקובץ — הוא **לא** בוחר לאיזה `tasks.json` לכתוב. ה-CLI מאתר את הקובץ לפי ה-cwd. תמיד `cd ~/legal-ai` לפני `task-master add-task` או כל פקודה משנה, ואז אמת ב-MCP `get_tasks`. כשלא בטוחים — לערוך את `~/legal-ai/.taskmaster/tasks/tasks.json` ישירות.

docs/paperclip-quirks.md

@@ -155,123 +155,3 @@ CEO צריך להעביר את ה-issue ל-`in_review` (לא `in_progress`) כש
 ### סטטוס
 
 - **תיקון בכל הסקייל** (CLAUDE.md זיכרון: `reference_paperclip_wakeup.md`)
-
----
-
-## 5. מחיקת npx cache → crash-loop בהפעלה (השרת מנצח את הפאטצ')
-
-### מה קורה
-
-Paperclip מופעל דרך `exec npx -y paperclipai@<version> run` ב-[start-paperclip.sh](../../.paperclip/scripts/start-paperclip.sh). npx **עושה reuse** ל-cache שכבר חולץ (`~/.npm/_npx/<hash>/node_modules/@paperclipai/server/`) — הוא **לא** מחלץ מחדש בכל הפעלה. כל עוד ה-cache קיים, הפאטצ'ים שהוחלו עליו פעם אחת נשמרים על פני ריסטארטים.
-
-הבעיה מתחילה כש-ה-cache **נמחק** (`npm cache clean`, prune, או ניקוי ידני) בזמן שהתהליך רץ. אז נוצרות שתי תקלות נפרדות:
-
-1. **התהליך הישן ממשיך "online" אבל שבור** — המודולים של node כבר טעונים בזיכרון, אז `/api/health` עדיין מחזיר 200, אבל `GET /` קורא את `ui-dist/index.html` **מהדיסק בכל בקשה** (`readFileSync`) → `ENOENT` → **HTTP 500** (`{"error":"Internal server error"}`). גם ה-URL הציבורי `pc.nautilus...` מחזיר 500.
-2. **בריסטארט נכנסים ל-crash-loop** — npx מחלץ עותק **טרי ולא-מתוקן**. השרת מריץ `assertCloudDatabaseContract()` (ראה patch §4 ב-start script) שמסרב ל-embedded PG במצב authenticated/public → **קורס מיד**, לפני שלולאת-הרקע (5/20/60ש') מספיקה להחיל את פאטץ' ה-bypass. כל ריסטארט מחלץ-וקורס מחדש ⇒ עשרות ריסטארטים, שום דבר לא מאזין על 3100.
-
-### ראיה אמפירית — 06/06/26
-
-```
-# התהליך הישן: online 5D אבל GET / נכשל
-GET / 500 — ENOENT: no such file or directory,
-  open '.../@paperclipai/server/ui-dist/index.html'
-/api/health → 200          # שורד כי לא קורא קבצים
-
-# אחרי restart: crash-loop
-pm2 describe paperclip → status: "waiting restart", restarts: 36, nothing on :3100
-ERROR log → "Paperclip server failed to start.
-  authenticated public deployments require DATABASE_URL ...;
-  refusing embedded PostgreSQL fallback"
-```
-
-הורדת החבילה איטית (~30ש', native builds) — מה שמחמיר את ה-loop: `min_uptime` של PM2 קוטע את ה-npx **באמצע ההורדה** לפני שהוא מסיים לחלץ, כך שה-cache לעולם לא מתמלא.
-
-### ההשפעה על הצינור שלנו
-
-Paperclip מושבת לגמרי — ה-UI לא עולה לאף משתמש, וכל סוכני Paperclip (14 הסוכנים) לא יכולים לרוץ כי הם חולקים את התהליך הזה.
-
-### תיקון — שער סינכרוני לפני הפעלת השרת
-
-**שורש הבעיה:** פאטץ' ה-cloud-db-bypass חייב להיות על הדיסק **לפני** שהשרת רץ; לולאת-הרקע מאוחרת מדי. ב-[start-paperclip.sh](../../.paperclip/scripts/start-paperclip.sh) נוספה `ensure_patched_before_run()` (06/06/26) שרצה סינכרונית לפני `exec`:
-
-1. בודקת אם `@paperclipai/server/ui-dist/index.html` קיים ב-cache (ראה "מלכודות בדרך" — זה הסמן הנכון, לא `dist/index.js`).
-2. אם לא — מריצה `npx -y paperclipai@<version> --help`. זה מאלץ את npx **לחלץ את כל החבילה** (כולל `ui-dist/`) כדי להריץ את ה-CLI, שמדפיס help ו**יוצא לבד ב-exit 0** — **לא** מפעיל שרת ולא תופס את 3100 (אומת). אין תהליך-רקע, אין שרת לא-מתוקן מוקדם, ואין מה להרוג.
-3. מחילה את **כל** הפאטצ'ים (כולל bypass) על ה-cache המחולץ — עם guard שלא מפיל את ה-wrapper אם patch נכשל.
-4. רק אז `exec npx ... run` — npx עושה reuse ל-cache המתוקן והשרת עולה נקי.
-
-לולאת-הרקע (post-exec) נשמרה כרשת-ביטחון idempotent.
-
-**אומת מקצה-לקצה (06/06/26):** מחיקת ה-cache בכוונה + `pm2 restart` → השער חילץ אוטומטית דרך `--help` (~64ש'), תיקן, והשרת עלה ל-200 ב-~72ש'. מונה הריסטארטים של PM2 **לא זז** (אפס crash-loop).
-
-> **מלכודות שהתגלו בדרך (גרסה ראשונה של הפיקס נכשלה):**
-> 1. **סמן חילוץ שגוי** — `dist/index.js` נכתב ~שניות **לפני** `ui-dist/`. שער שממתין ל-`dist` ומריץ מיד → ui-dist עדיין חסר → 500. הסמן הנכון הוא `ui-dist/index.html` (הקובץ האחרון, וגם זה שגרם ל-500 המקורי).
-> 2. **`set -e` + patch כושל** — אם `apply-hebrew.sh` רץ בלי ui-dist הוא מחזיר שגיאה, ותחת `set -e` ה-wrapper מת → crash-loop חדש. הפתרון: `apply_all_patches || echo WARNING`.
-> 3. **`pkill -f "paperclipai@..."` תופס את עצמו** — מחרוזת הדפוס מופיעה ב-command line של ה-shell שמריץ את ה-pkill, אז הוא הורג את עצמו (exit 144). זו הסיבה שגישת spawn-`run`-then-`pkill` ננטשה לטובת `--help` שיוצא לבד. אם בכל זאת צריך להרוג — לפי PID (`kill $PID; pkill -P $PID`), לא לפי `-f`.
-
-**שחזור** — עם הפיקס פרוס, מספיק `pm2 restart paperclip` וה-`ensure_patched_before_run()` מתאושש לבד. אם צריך לעשות זאת ידנית (fix אחר, דיבוג):
-```bash
-pm2 stop paperclip                                     # לעצור loop אם קיים
-export PATH=/home/chaim/.nvm/versions/node/v24.14.0/bin:$PATH
-npx -y paperclipai@2026.529.0 --help >/dev/null 2>&1   # חילוץ נקי שיוצא לבד (לא מפעיל שרת)
-find ~/.npm/_npx -path "*@paperclipai/server/ui-dist/index.html" -type f   # לאמת חילוץ מלא
-# להחיל פאטצ'ים על ה-cache, ובמיוחד ה-bypass:
-bash ~/.paperclip/hermes-patches/apply-cloud-db-bypass.sh
-bash ~/.paperclip/hebrew/apply-hebrew.sh
-bash ~/.paperclip/hermes-patches/apply-hermes-fixes.sh
-bash ~/.paperclip/hermes-patches/apply-deepseek-reaper-fix.sh
-grep -q HEBREW_PATCH_BYPASS_CLOUD_DB \
-  ~/.npm/_npx/*/node_modules/@paperclipai/server/dist/index.js && echo "BYPASS OK"
-pm2 start paperclip && pm2 save                         # reuse ל-cache המתוקן
-```
-> אל תשתמש ב-`pkill -f "paperclipai@..."` / `-f "@paperclipai/server"` — הדפוס תופס את ה-shell של עצמך (exit 144). אם חייבים להרוג תהליך — לפי PID.
-
-### סטטוס
-
-- **תוקן ב-start script** ע"י `ensure_patched_before_run()` (06/06/26) — שער סינכרוני שמחלץ+מתקן לפני exec.
-- **הערה מטעה תוקנה**: ההערה הישנה בראש ה-script טענה ש-`npx run` מחלץ-מחדש בכל הפעלה (לכן הסתמכו על לולאת-הרקע בלבד) — זה לא נכון, npx עושה reuse ל-cache תקין; הסכנה היא cache **מחוק**.
-- **לקח כללי**: כל patch שה-target שלו הוא assert בזמן-startup חייב להיות מוחל לפני `exec`, לא בלולאת-רקע.
-
----
-
-## 6. `issue.comment.created` — מזהה-ה-issue ב-`entityId`, לא ב-`payload.issueId`
-
-### מה קורה
-
-ל-event `issue.comment.created` שה-host שולח לפלאגין, **מזהה-ה-issue נמצא ב-`event.entityId`** (ה"ישות הראשית" של ה-event), ולא ב-`payload`. ה-`payload` נושא דווקא:
-- `commentId` — מזהה התגובה
-- `bodySnippet` — גוף **קצוץ** (לא הטקסט המלא)
-- `reopened` / `reopenedFrom` — נדלקים כשהתגובה פתחה-מחדש issue ב-`done`
-
-**אין** `payload.issueId` ו**אין** `payload.body` מלא. מקור-אמת: `@paperclipai/plugin-sdk` `index.d.ts` — `issueId: event.entityId`.
-
-### ראיה אמפירית — תיק 8124-09-24, CMPA (17/06/26)
-
-תגובת-משתמש על sub-issue של המנתח המשפטי (במצב `done`) **לא הגיעה ל-CEO**. הניתוב ב-`plugin-legal-ai/src/worker.ts` קרא `payload.issueId` (תמיד `undefined`) ולכן דילג בשקט:
-
-```
-WARN [plugin] issue.comment.created event missing issueId in payload, skipping
-  { entityId: "6eb905ea-…",           ← זה ה-issue id האמיתי
-    payload: { commentId: "31e35676-…", bodySnippet: "…", reopened: true,
-               reopenedFrom: "done", identifier: "CMPA-94", … } }   ← אין issueId
-```
-
-### ההשפעה על הצינור שלנו
-
-הניתוב **"תגובת-משתמש → CEO"** (CLAUDE.md §"ניתוב comments דרך CEO") היה **מת בשקט** — כל תגובה דולגה. במקרה של תגובה על issue בבעלות ה-CEO זה "עבד" רק במקרה דרך מנגנון reopen-on-comment הנייטיב של Paperclip (פותח-מחדש `done` ומעיר את הסוכן-המשויך). על sub-issue של סוכן אחר, ה-wake הנייטיב כיוון לסוכן הלא-נכון וריצת-ה-CEO בתור בוטלה עם `errorCode: issue_assignee_changed` ("the new owner will be woken instead" — וה"בעלים" ב-`done` ⇒ כלום).
-
-### תיקון — בצד שלנו (PR ezer-mishpati/plugin-legal-ai#2)
-
-ב-handler של `issue.comment.created`:
-1. `issueId = event.entityId` (fallback ל-`payload.issueId` לעמידות מול גרסאות-host).
-2. גוף-תגובה מלא: התאמת `payload.commentId` מתוך `listComments` (ה-payload נושא רק snippet); fallback ל-latest/snippet.
-3. **guard לדה-דופ:** אם התגובה פתחה-מחדש issue **שכבר משויך ל-CEO** (`issue.assigneeAgentId === ceoAgentId && payload.reopened`), ה-wake הנייטיב כבר מטפל — מדלגים כדי לא להריץ את ה-CEO פעמיים. לכל issue אחר עדיין מנתבים ל-CEO.
-
-### אימות (17/06/26)
-
-תגובת-בדיקה על אותו sub-issue של המנתח (`543f997b`, `done`) לאחר deploy → לוג `Routed user comment to CEO agent` עם `runId`, וריצת-CEO `succeeded` (לא `cancelled`).
-
-### סטטוס
-
-- **תוקן בצד שלנו** (PR #2, נפרס דרך `npm run build` + `pm2 restart paperclip` — הפלאגין נטען מ-`/home/chaim/plugin-legal-ai` לפי `package_path`).
-- **לקח כללי**: ל-events של הפלאגין — מזהה-הישות-הראשית הוא תמיד `event.entityId`; אל תניח ששדות נמצאים ב-`payload` בלי לאמת מול ה-`.d.ts` של ה-SDK או מול לוג חי.
-- TaskMaster: `legal-ai` #149.

docs/research/hermes-nous-feasibility.md

@@ -1,123 +0,0 @@
-# מחקר-היתכנות: Hermes של Nous Research — האם להטמיע, והאם זה יעזור ללולאת רכישת-הסגנון
-
-> **TaskMaster #123** (tag `legal-ai`) · תאריך: 2026-06-11 · סטטוס: מחקר הושלם → המלצה להכרעה
-> **שאלת-העל:** האם הסוכן/מסגרת ה-self-learning של Nous Research — שחיים התכוון אליו במקור בהקמת מנהל-הידע — ניתן ורצוי להטמעה אצלנו, והאם ישפר את לולאת רכישת-הסגנון מעבר לקיים.
-> **הכרעה בתמצית:** **לדחות אימוץ-מסגרת; לאמץ רעיון אחד ממוקד — GEPA/DSPy (אבולוציית-פרומפט רפלקטיבית) כ-*מַצִּיע* בתת-מערכת רכישת-הסגנון, נמוך-עדיפות, לכשיצטברו זוגות draft↔final.**
->
-> **המשך:** מה אנחנו *באמת* מריצים מ-Hermes היום (ה-CLI כ-runtime, ה-self-learning כבוי), חקירה פורנזית של ה-state, ו-playbook להפעלה-מלאה עתידית → [hermes-runtime-and-self-learning-state.md](hermes-runtime-and-self-learning-state.md) (#126).
-
----
-
-## 0. הרקע — מה חשבנו שזה, ומה זה באמת
-
-הסוכן "הרמס" אצלנו הוא **שם-פרסונה בלבד**: בפועל זהו `deepseek_local` (DeepSeek-V4-Pro) עם פרומפט-קבוע ([hermes-curator.md](../../.claude/agents/hermes-curator.md)), שמנתח החלטות סופיות ו**מציע** עדכוני-לקחים. קוד של Nous מעולם לא שולב (grep=0). הנחת-המוצא של המשימה הייתה שצריך לבדוק אם ה-"self-learning" של Nous הוא מנגנון fine-tuning שמתנגש באילוץ "מודל סגור".
-
-**הממצא המרכזי הופך את ההנחה:** ה-self-learning של Nous **אינו** fine-tuning, ובמבנה-הממשל שלו הוא **מתכנס כמעט במדויק לארכיטקטורה שכבר בנינו** (propose-only, human-review, semantic-preservation). השאלה האמיתית אינה "האם זה תואם" אלא "**האם זה מוסיף משהו שאין לנו**". התשובה: רעיון אחד — אופטימיזציית-פרומפט אבולוציונית-רפלקטיבית (GEPA).
-
----
-
-## א. מה Hermes-agent של Nous *באמת* עושה (מאומת מול ה-repos, לא מהזיכרון)
-
-יש **שני** repos נפרדים תחת `NousResearch`, שניהם **MIT**:
-
-### א.1 `NousResearch/hermes-agent` — מסגרת-סוכן (agent framework)
-"The self-improving AI agent… the only agent with a built-in learning loop." רכיבים (מאומת מ-README + docs):
-
-| רכיב | מה זה |
-|------|-------|
-| **Closed-loop skill learning** | מזקק "Skills" לשימוש-חוזר אוטומטית בסיום כל משימה, שומר בזיכרון מתמיד. תואם תקן פתוח `agentskills.io` (Skills Hub — portable/shareable). |
-| **Three-layer memory** | זיכרון רב-שכבתי שזוכר העדפות/הרגלים לאורך סשנים. |
-| **Dialectic user modeling (Honcho)** | בונה מודל מתפתח של "מי אתה" לרוחב סשנים. |
-| **Agent-curated memory + periodic nudges** | הסוכן "מנדנד" לעצמו לשמר ידע; חיפוש-סשנים FTS5 + סיכום-LLM. |
-| **Orchestration** | 40+ כלים, מספר terminal backends (local/Docker/SSH/Modal/Daytona), תת-סוכנים מבודדים, scheduler/cron מובנה, ריבוי-פלטפורמות-הודעות (Telegram/Discord/Slack/WhatsApp/Signal/CLI). |
-| **Model-agnostic** | "Use any model you want — switch with `hermes model`, no code changes." עובד מול Nous Portal / OpenRouter (200+) / OpenAI / **Anthropic** / HF / endpoint מותאם. **אין דרישה למודל פתוח, אין fine-tuning של משקולות.** |
-
-המסקנה: זוהי **מסגרת-תזמור-סוכנים מלאה** (orchestrator + memory + scheduler + ערוצי-הודעות + skill-hub) — מתחרה מבנית ל-Paperclip, **לא** רכיב-למידה נקודתי.
-
-### א.2 `NousResearch/hermes-agent-self-evolution` — לב ה-"self-learning"
-זהו ה-repo שעושה את האבולוציה-העצמית (מאומת מ-README):
-
-- **מה הוא ממטב:** קבצי-skill (`SKILL.md`), תיאורי-כלים, מקטעי-system-prompt, וקוד-מימוש-כלים. (Phase 1 = קבצי-skill.)
-- **אלגוריתם:** **DSPy + GEPA** (Genetic-Pareto Prompt Evolution). GEPA מנתח **traces של ריצה**, מבין *סיבות-כשל* ברפלקציה בשפה-טבעית, ומציע שיפורים ממוקדים — לא רק מזהה כשל.
-- **דרישות-אימון:** **אין GPU, אין fine-tuning.** הכול דרך קריאות-API ("mutating text, evaluating results, selecting best variants"). עלות מוערכת **$2–10 לריצת-אופטימיזציה**.
-- **הערכת-מועמדים (guardrails):** כל variant חייב לעבור — מערך-בדיקות מלא, מגבלת-גודל (skills ≤15KB), תאימות-caching, **שימור-סמנטי של המטרה המקורית**, ו**סקירת-PR אנושית**.
-- **החלת-שינויים:** **אין auto-apply.** כל variant עובר "**human review, never direct commit**" ומוצע כ-PR נגד `hermes-agent`.
-
-**זו ההפתעה:** המודל התפעולי של Nous (propose → guardrails → human-PR → never auto-commit, עם שימור-סמנטי) הוא **שחזור כמעט-מילה-במילה של INV-LRN1/G10 + INV-LRN5 שלנו.** לא צריך "להתאים" אותו — הוא כבר חושב כמונו.
-
----
-
-## ב. טבלת-תאימות מול ארבעת האילוצים (פסיקה לכל אחד)
-
-| # | אילוץ | אימוץ-מסגרת (`hermes-agent`) | אימוץ-רעיון (GEPA כמַצִּיע) | פסיקה |
-|---|-------|------------------------------|-----------------------------|-------|
-| 1 | **מודל-סגור** (Opus/DeepSeek/Gemini, לא fine-tuning — [project_style_acquisition_goal]) | ✅ model-agnostic, ללא fine-tuning | ✅ GEPA ממטב **טקסט** (פרומפט/skill), לא משקולות; API-only, $2–10 | ✅ **תואם** — זהו בדיוק ה-"prompt-optimization במקום weight-update" שהמשימה זיהתה כהכי-תואם |
-| 2 | **G12 — שער-הפלטפורמה** ([X15](../spec/X15-agent-platform-port.md), INV-PORT1) | ❌ **מתנגש** — מסגרת-תזמור שלמה (memory/scheduler/ערוצים/subagents) = פלטפורמת-סוכנים מקבילה ל-Paperclip → drift-רוחב, בדיוק מה ש-G12/G2 מייבשים | ✅ חי בשכבת-האינטליגנציה/רכישת-הסגנון, מזין את שער-היו"ר; **אינו** פלטפורמה, אינו נוגע ב-Port | ❌ למסגרת / ✅ לרעיון |
-| 3 | **INV-LRN1/G10 — אין auto-commit** | ⚠️ ה-memory האוטו-נדנד + יצירת-skill אוטונומית מפרים *אם* ב-auto-commit | ✅ self-evolution **תוכנן** propose-only (human-PR) — זהה למודל שלנו | ✅ **תואם** (הרעיון); ⚠️ המסגרת דורשת גידור |
-| 4 | **INV-LRN5 — טוהר-הקול** (אין מהות ספציפית) | ⚠️ 3-layer memory + dialectic modeling שומרים תוכן-משתמש ספציפי לרוחב סשנים → זיהום שכבת-הקול | ⚠️ תקין **רק אם** מטריקת-ההערכה היא **מרחק-סגנון** (לא שחזור-מהות), והפלט הוא סגנון/שיטה. יש לנו את המטריקה (`style_distance`, שלב [7] MEASUREMENT) | ⚠️ **בר-ניהול** — חייב metric=style-distance + distillation שמפריד במקור (כבר קיים) |
-
----
-
-## ג. מה זה יפתור שלא קיים? (מול מה שכבר בנינו)
-
-| יכולת ב-Nous | מקבילה אצלנו | פער-אמיתי? |
-|--------------|--------------|-------------|
-| Closed-loop skill distillation | `hermes-curator` + `ingest_final_version` (Opus distillation) + `final_learning_pipeline` | לא — קיים, ומגודר טוב יותר (פאנל דו/תלת-מודלי, #121) |
-| Three-layer memory / FTS5 recall | קורפוס-סגנון + pgvector + RAG ([03-retrieval](../spec/03-retrieval.md)) | לא — האחזור שלנו עשיר יותר ומכוון-דומיין |
-| Skill-Hub (agentskills.io) | `skills/decision` + `legal-decision-lessons.md` | לא — שיתוף-קהילתי לא רלוונטי לדומיין-סגור |
-| Dialectic user modeling | פרופיל-סגנון של דפנה (`/methodology`) | לא — ובמכוון: INV-LRN5 אוסר מידול-מהות |
-| **GEPA reflective prompt-evolution** | **אין מקבילה** — אנו מתקנים פרומפטים ידנית, ללא אופטימיזציה שיטתית מול eval | ✅ **כן — זה הפער היחיד** |
-
-**הפער היחיד שמוסיף ערך:** אנו אוספים זוגות `draft↔final` (`draft_final_pairs`, INV-LRN4) אבל **לא ממנפים אותם כ-eval-set שיטתי לשיפור פרומפטי-הכתיבה/פרופיל-הסגנון.** GEPA הוא בדיוק הכלי לכך: לוקח traces (טיוטות שלנו), reflects על *למה* הן רחוקות מהסופי של דפנה, ומציע שיפורי-פרומפט — מדיד מול `style_distance`.
-
----
-
-## ד. חלופות קוד-פתוח שקולות (≥3 מקורות סמכותיים)
-
-| גישה | מה היא | התאמה לאילוץ מודל-סגור | רלוונטיות לנו |
-|------|--------|------------------------|---------------|
-| **GEPA** (Agrawal et al., arXiv:2507.19457, **ICLR 2026 oral**) | אבולוציית-פרומפט רפלקטיבית; reflects על traces בשפה-טבעית | ✅ מושלמת — טקסט בלבד | **גבוהה** — מנצח GRPO (RL) ב-6–20% עם פי-35 פחות rollouts; מנצח MIPROv2 ב-10%+. `pip install gepa` / `dspy.GEPA` |
-| **DSPy (MIPROv2)** | אופטימיזציית-פרומפט מבוססת-מטריקה | ✅ טובה | בינונית — GEPA עדיף לפי המאמר |
-| **Reflexion** (Shinn et al., NeurIPS 2023) | "verbal RL" — רפלקציה מילולית בזיכרון-אפיזודי | ✅ טובה | נמוכה — per-task, לא משפר artifact מתמשך |
-| **Voyager** (Wang et al., 2023) | skill-library מצטברת (Minecraft, lifelong) | ✅ טובה | נמוכה — כבר יש לנו skill-library מגודרת; הרעיון מובנה |
-| **Generative Agents** (Park et al., 2023) | memory-stream + reflection + retrieval | ✅ | נמוכה — INV-LRN5 אוסר מידול-מהות מתמשך |
-| **LangGraph long-term memory** | checkpointing + store | ✅ | כבר ב-[X16](../spec/X16-pipeline-durability.md) (התשתית קיימת) |
-
-**מסקנת-ההשוואה:** מבין כל החלופות, **GEPA היא היחידה שמציעה יכולת חדשה תואמת-אילוץ** (אופטימיזציה שיטתית של artifacts-טקסט מול eval, ללא משקולות). השאר או מובנים כבר אצלנו, או מתנגשים ב-INV-LRN5, או per-task ולא-מתמשכים.
-
----
-
-## ה. המלצה מנומקת
-
-### דחה: אימוץ מסגרת `hermes-agent` כפלטפורמה
-**נימוק:** זוהי פלטפורמת-תזמור-סוכנים מלאה (orchestrator/memory/scheduler/ערוצים) המתחרה מבנית ב-Paperclip. אימוצה = **מסלול-פלטפורמה מקביל** המפר G12/INV-PORT1 ([X15](../spec/X15-agent-platform-port.md)) ויוצר את drift-הרוחב שכל הספ מייבש. כבר הכרענו (יוזמת X15/X16): Paperclip = מעטפת ניתנת-להחלפה מאחורי Port; אין מקום לפלטפורמה שנייה.
-
-### דחה: אימוץ שכבת-ה-memory/dialectic-modeling
-**נימוק:** שמירת תוכן-משתמש ספציפי לרוחב סשנים מתנגשת ב-INV-LRN5 (טוהר-הקול). פרופיל-הסגנון שלנו במכוון מופשט.
-
-### ✅ אמץ-רעיון: GEPA/DSPy כ-*מַצִּיע* בתת-מערכת רכישת-הסגנון
-**הרעיון הספציפי:** אופטימיזציית-פרומפט רפלקטיבית-אבולוציונית של **פרומפטי-הכתיבה ו/או פרופיל-הסגנון**, ממוטבת מול eval-set של זוגות `draft↔final` (INV-LRN4), עם **מטריקה = `style_distance`** (שלב [7] MEASUREMENT, [07-learning §0.3](../spec/07-learning.md)).
-
-**למה זה נכנס נקי (לא מסלול-מקביל):**
-1. **מודל-סגור** ✅ — טקסט בלבד, Opus/DeepSeek דרך adapter, $2–10/ריצה.
-2. **G12** ✅ — חי ב-`mcp-server/src` / style-acquisition; אינו פלטפורמה; אם צריך wakeup → דרך ה-Port.
-3. **INV-LRN1/G10** ✅ — מַצִּיע בלבד: GEPA מפיק *variant מוצע* → שער-יו"ר (כמו ה-curator היום). **אין auto-commit.** זה גם המודל של Nous עצמם (human-PR).
-4. **INV-LRN5** ✅ (מגודר) — eval=style-distance, output=סגנון/שיטה; ה-distillation הקיים מפריד מהות במקור.
-
-### כיצד זה נכנס דרך ה-Port (אם/כשמאשרים) — תת-משימות מוצעות
-1. **תנאי-סף (gate על הכדאיות):** לאסוף **N≥~15–20 זוגות `draft↔final` מנותחים** (`analyzed`/`lessons_folded`) — eval-set מינימלי ל-GEPA. כיום הקורפוס ~48 החלטות אך זוגות-מנותחים מעטים → **לכן עדיפות נמוכה כעת**; לפתוח כשהפנקס מתמלא.
-2. **PoC מבודד:** `scripts/gepa_style_optimize.py` (מקומי, כמו `final_learning_pipeline`) — `dspy.GEPA` ממטב את פרומפט-הכתיבה מול `style_distance`; פלט = variant מוצע + דו"ח-שיפור.
-3. **שער-יו"ר:** ה-variant מוצג ב-`/training` / כ-comment (דרך ה-Port), דפנה/חיים מאשרים → commit ידני ל-skill/prompt. אכיפת INV-LRN1.
-4. **מדידה:** השוואת `style_distance` לפני/אחרי על holdout — לאמת שיפור-אמת לפני קיבוע.
-
-**עדיפות:** נמוכה (priority=low במשימה תואם). זהו שדרוג-איכות עתידי לרכישת-הסגנון, לא חוסר קריטי. **להחליט להפעיל רק כשמצטבר eval-set של זוגות.** הכרעת-תקציב/עדיפות — של חיים.
-
----
-
-## מקורות
-- `NousResearch/hermes-agent` (README + https://hermes-agent.nousresearch.com/docs/) — מסגרת-הסוכן, MIT, model-agnostic.
-- `NousResearch/hermes-agent-self-evolution` (README) — DSPy+GEPA, API-only, propose-only/human-PR, MIT.
-- Agrawal et al., **"GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning"**, arXiv:2507.19457 (ICLR 2026 oral) — 6–20% מעל GRPO, פי-35 פחות rollouts.
-- `dspy.GEPA` (dspy.ai) · `CerebrasResearch/gepa` (standalone `pip install gepa`).
-- Shinn et al., **Reflexion** (NeurIPS 2023) · Wang et al., **Voyager** (2023) · Park et al., **Generative Agents** (2023) — להשוואה.
-- ספ-פנימי: [07-learning.md](../spec/07-learning.md) (INV-LRN1/4/5) · [X15](../spec/X15-agent-platform-port.md) (G12) · [X16](../spec/X16-pipeline-durability.md) · [hermes-curator.md](../../.claude/agents/hermes-curator.md).

docs/research/hermes-runtime-and-self-learning-state.md

@@ -1,106 +0,0 @@
-# Hermes כ-runtime אצלנו, וה-self-learning האינרטי — חקירה + playbook להפעלה מלאה
-
-> **TaskMaster #126** (המשך ל-[#123](hermes-nous-feasibility.md)) · תאריך: 2026-06-11
-> **למה המסמך קיים:** כדי שאם אי-פעם נרצה להפעיל את **סוכן ה-Hermes המלא** (עם לולאת ה-self-learning), לא נצטרך לחזור על החקירה הזו. מתעד מה אנחנו מריצים בפועל היום, מה דלוק-אך-אינרטי, ומה צריך כדי להדליק אותו נכון.
-
----
-
-## 1. מה אנחנו מריצים בפועל היום
-
-הסוכן "הרמס" אצלנו = ה-adapter `deepseek_local` שמריץ את **ה-CLI האמיתי של Nous Hermes** כ-runtime, מכוון ל-DeepSeek:
-
-```
-hermes chat -q "<prompt>" -Q -m deepseek-v4-pro --provider custom -t <toolsets> --source tool --yolo
-```
-
-| רכיב | ערך | מקור |
-|------|-----|------|
-| בינארי | `hermes` (`HERMES_CLI`) | `adapters/deepseek-paperclip-adapter/dist/shared/constants.js:9` |
-| תווית-adapter | **"DeepSeek (via Hermes)"** (`deepseek_local`) | `constants.js:5-6` |
-| מודל | `deepseek-v4-pro` (provider `custom` → `api.deepseek.com/v1`) | `config.yaml` של הפרופיל |
-| `HERMES_HOME` | `~/.hermes/profiles/curator-cmp` (CMP) · `curator-cmpa` (CMPA) | adapterConfig.env (per-company) |
-| invocation | חד-פעמי `-q ... -Q` (quiet, non-interactive), ללא gateway חי | `dist/server/execute.js:240-249` |
-| חיבור MCP | `mcp_servers.legal-ai` בקונפיג → ה-CLI יכול לקרוא לכלי-MCP שלנו | `config.yaml` |
-
-**מסקנה חשובה:** Hermes כאן הוא ה-**runtime/harness** (terminal + לולאת-כלים + provider→DeepSeek + MCP), **לא** "המוח הלומד". ההצהרה ב-#123 "grep=0, קוד Nous לא שולב" נכונה לגבי **לולאת ה-self-learning** — לא לגבי ה-CLI כ-runtime, שכן משמש.
-
-### זהות הסוכן ב-Paperclip
-- שם-הסוכן ב-Paperclip כבר **"מנהל ידע"** (role `qa`) — **לא** "Hermes".
-- ה-wakeup הוא לפי **UUID** (`CURATOR_AGENTS[company_id]` ב-`web/paperclip_client.py:50-53`: CMP=`60dce831…`, CMPA=`d6f7c55d…`) — **לא לפי שם**. ⇒ שינוי-שם-תצוגה אינו שובר את ה-wakeup.
-- ה-persona "Hermes" יושב רק ב: שדה ה-`description` ("Knowledge Curator (Hermes…)"), טקסט ה-system-prompt ב-[hermes-curator.md](../../.claude/agents/hermes-curator.md), שם-הקובץ, ופרוזה בתיעוד.
-
----
-
-## 2. ה-self-learning דלוק ב-config — אבל אינרטי
-
-ב-`~/.hermes/profiles/curator-cmp/config.yaml` ו-`curator-cmpa/config.yaml` (שורות ~296-328) הפיצ'רים **דלוקים כברירת-מחדל**:
-
-```yaml
-memory:
-  memory_enabled: true        # זיכרון 3-שכבתי
-  user_profile_enabled: true  # מידול-משתמש (dialectic / Honcho)
-  nudge_interval: 10
-skills:
-  creation_nudge_interval: 15 # נדנוד ליצירת-skills
-curator:
-  enabled: true               # ה-curator הפנימי של Hermes (אוצר זיכרון, כל 168 שעות)
-```
-
-**אבל הם לא רצים בפועל**, כי:
-- ה-adapter מפעיל את ה-CLI **חד-פעמית** (`-q … -Q`) בכל יקיצה ואז יוצא — אין gateway/דמון חי.
-- ה-curator-הפנימי (interval 168h), flush-הזיכרון (`flush_min_turns`), ונדנוד-ה-skills תלויים בתהליך מתמשך/רב-תור — שלא קיים.
-
-### עדות פורנזית (state.db של ה-curator-ים)
-`~/.hermes/profiles/curator-cmp/state.db` (15M) · `curator-cmpa/state.db` (4.6M). טבלאות:
-
-| יש | אין |
-|----|-----|
-| `messages` (555 / 159) — תמלילי-ריצה | ❌ `memories` (זיכרון מזוקק) |
-| `sessions` (60 / 5) — מטא + billing | ❌ `user_profile` (מודל-דפנה) |
-| `messages_fts*` — אינדקס FTS5 | ❌ `skills` שנוצרו אוטומטית |
-
-- התוכן היחיד = **תמלילי-הריצות של ה-curator** (קרא טיוטה↔סופי, רשם ממצאים, הציג interaction) — בדיוק הפלט שכן צרכנו (comments + `decision_lesson`).
-- סשנים ללא כותרות, `$0.00` עלות מתועדת, חלקם 0-2 הודעות (יקיצות-סרק).
-- טווח-פעילות: **2026-05-05 → 2026-05-26** (CMP), עד 8.6 (CMPA). רדום מאז.
-
-**שורה תחתונה:** משלושת הדיפרנציאטורים של Hermes (memory / user-model / skill-acquisition) נוצרו **אפס שורות**. מה ש"לא צרכנו" = לוגים תמימים, לא ידע מזוקק. ⇒ מ-self-learning מקבלים **אפס** ערך; מנצלים את ה-harness בלבד.
-
----
-
-## 3. ההחלטה (מיושמת ב-#126)
-
-| פעולה | נימוק |
-|------|-------|
-| **כיבוי self-learning** בשני config.yaml (`memory_enabled/user_profile_enabled/curator.enabled=false`, skill-nudge off) | מסיר config-מת, הופך את "אנחנו לא מריצים self-learning" לאמיתי, מיישר ל-INV-LRN1/LRN5. הפיך (גיבוי שמור). |
-| **ניקוי persona** Hermes→Curator בטקסט-הפרומפט + description + תיעוד | השם נעשה כן: סוכן **Curator/אוצֵר-ידע** שרץ על runtime DeepSeek-via-Hermes. |
-| **שמירת** `HERMES_HOME`/`HERMES_CLI`/"via Hermes" | זה ה-runtime ונכון — סריקה עיוורת של "hermes" הייתה שוברת את ה-adapter. |
-
-ה-learning האמיתי שלנו נשאר הצינור הדטרמיניסטי המגודר (`final_learning_pipeline` + פאנלים + שער-יו"ר), לא ה-self-learning של Hermes.
-
----
-
-## 4. ⭐ Playbook: איך להפעיל את סוכן ה-Hermes המלא (אם נרצה בעתיד)
-
-זה מה שיידרש כדי להפוך את ה-curator מ"runtime דק" ל-"סוכן Hermes לומד" — ולמה לא עשינו זאת:
-
-### 4.1 שכבת-ה-runtime (טכני)
-1. **gateway מתמשך במקום one-shot.** היום `hermes chat -q … -Q` יוצא אחרי תור אחד. צריך תהליך-Hermes חי (`hermes gateway`/דמון) או `--resume` עקבי עם session מתמשך כך שה-memory-flush, ה-curator-הפנימי, ונדנוד-ה-skills יוכלו לרוץ. ⇒ שינוי ב-`deepseek-paperclip-adapter` (לא רק config).
-2. **session persistence.** לוודא ש-`persistSession` + `sessionId` נשמרים בין יקיצות-ה-curator של אותו תיק/חברה (ה-adapter תומך — `execute.js:251-252,376-378` — אך תלוי שמירת `sessionParams` ב-Paperclip).
-3. **הדלקת הפיצ'רים** ב-config.yaml: להחזיר `memory_enabled/user_profile_enabled/curator.enabled=true` + לכוון `nudge_interval`/`flush_min_turns`. (Honcho ל-dialectic-modeling דורש הגדרת `honcho:` — כרגע ריק.)
-
-### 4.2 שכבת-הממשל (חובה לפני — אחרת מפר את החוקה)
-4. **INV-LRN1/G10 (אין auto-commit):** memory/skills של Hermes שמשנים את עצמם אוטומטית **אסורים** כשער-ידע. כל פלט-למידה חייב להישאר *הצעה* לשער-יו"ר. ⇒ אם מדליקים, לגדר כך שה-memory/skills של Hermes לא יוזרקו לכתיבה בלי אישור.
-5. **INV-LRN5 (טוהר-הקול):** ה-3-layer memory + user-model שומרים תוכן-תיק ספציפי. אסור שמהות (הלכה/עובדה) תדלוף לשכבת-הקול. ⇒ צריך distillation שמפריד סגנון↔מהות *לפני* שנכנס לזיכרון-Hermes, או לבודד את זיכרון-Hermes מהקורפוס.
-6. **G12 (שער-הפלטפורמה):** Hermes כ-runtime מותר (מאחורי ה-adapter/Port). אבל אם מפעילים את ה-orchestration/scheduler/ערוצים שלו — זו פלטפורמת-סוכנים מקבילה ל-Paperclip ⇒ אסור (ראה [#123 §ב](hermes-nous-feasibility.md)).
-
-### 4.3 ההכרעה הנוכחית
-**לא להפעיל.** הסיבה (מ-#123 + החקירה כאן): ה-self-learning של Hermes מתנגש בממשל שלנו (4-6), והערך שלו מושג כבר ע"י הצינור המגודר שלנו + רעיון-GEPA (#123). ה-runtime נשאר; ה-"מוח" כבוי.
-
----
-
-## 5. מקורות-קוד / הפניות
-- runtime: `adapters/deepseek-paperclip-adapter/dist/{shared/constants.js,server/execute.js}` · `~/.hermes/profiles/curator-{cmp,cmpa}/config.yaml`
-- זהות+wakeup: `web/paperclip_client.py:50-53` (CURATOR_AGENTS), `:1188-1245` (wake_curator_for_final)
-- persona/prompt: `.claude/agents/hermes-curator.md`
-- ספ: [07-learning.md](../spec/07-learning.md) (INV-LRN1/4/5) · [X15](../spec/X15-agent-platform-port.md) (G12) · [#123 feasibility](hermes-nous-feasibility.md)
-- זיכרון: `reference_hermes_home_gotcha`

docs/spec/00-constitution.md

@@ -78,14 +78,13 @@
 
 אלה החוקים החוצים את כל המערכת — לב החוקה. הם נחלקים לשני סוגים לפי **מקור-הסמכות**:
 
-- **G1–G10, G12 — invariants הנדסיים** (תכנון/בניית האפליקציה): כל אחד מגובה ב-**≥3 סמכויות
+- **G1–G10 — invariants הנדסיים** (תכנון/בניית האפליקציה): כל אחד מגובה ב-**≥3 סמכויות
   טכניות מוכרות** (נספח §8). ביחד הם מייבשים את כשל-השורש החוזר: מסלולים/קורפוסים
-  מקבילים שמתפצלים (drift) בלי שכבה שמגדירה ואוכפת "תקין". (G12 — שער-הפלטפורמה — מוסף
+  מקבילים שמתפצלים (drift) בלי שכבה שמגדירה ואוכפת "תקין".
-  במחזור-3; ראה [X15](X15-agent-platform-port.md).)
 - **G11 — invariant תוכן-משפטי:** הסמכות עליו היא **היו"ר (דפנה) + מסמכי-הפרויקט**, לא
   מקורות חיצוניים, ואינו כפוף לפרוטוקול ≥3-המקורות.
 
-### 5א. Invariants הנדסיים (G1–G10, G12)
+### 5א. Invariants הנדסיים (G1–G10)
 
 ### INV-G1: מזהה קנוני מנורמל בכתיבה
 **כלל:** לכל ישות יש מזהה קנוני יחיד, **מנורמל בנקודת-הכתיבה** (לא תיקון-סלחני בקריאה
@@ -109,11 +108,6 @@ Fowler (Canonical Data Model) · SSOT (Single Source of Truth) | סטטוס: ver
 `ingest_internal_decision`) שמתפצלים — לדוגמה: המסלול החיצוני מתזמן חילוץ metadata
 (`request_metadata_extraction`), והמסלול הפנימי לא — ולכן ערן סופר 8046/24 נקלטה בלי
 metadata → ממצא ל-[audit](../audit-report.md).
-**הפרה ידועה (תאום-מתודולוגיה, MET-2/3 — מותנה בגל-2 #131):** `discussion_rules['universal']`
-ו-`transition_phrases['universal']` ב-`appeal_type_rules` נכתבים ע"י **שני** מסלולים — עורך-המתודולוגיה
-(PUT, overwrite) ו-promote-הלמידה (append). **מותן:** ה-append רץ בטרנזקציה אחת נעולה (FOR UPDATE) +
-promote מבטל את ה-cache של /methodology (גל-1 MET-1), כך שעורך-המתודולוגיה הוא העורך-הקנוני שעורך
-תמיד מצב פוסט-append. שאריות (עריכה בטאב באמת-stale) מקובלות בכלי-יחיד-משתמש; ראה [X17 INV-IA3](X17-information-architecture.md), [ia-audit-redesign.md](../ia-audit-redesign.md) §2.5.
 
 ### INV-G3: ingest אחיד ו-idempotent
 **כלל:** קליטה היא **אחידה ו-idempotent** — upsert על מפתח דטרמיניסטי. קליטה חוזרת של
@@ -202,22 +196,6 @@ Hellyer (Law Library Journal 110:4, 2018, open-access) — טיפול-שיפוט
 **הפרה ידועה:** 10/19 הלכות מאושרות, התגלה במקרה — שער ידני שקוף בלי נראות backlog →
 ממצא ל-[audit](../audit-report.md).
 
-### INV-G12: שער-הפלטפורמה — Paperclip מאחורי Port יחיד
-**כלל:** פלטפורמת-הסוכנים (Paperclip) נגישה אך-ורק דרך **ה-Platform Port**
-(`web/agent_platform_port.py` + `.claude/agents/HEARTBEAT.md` לפרומפטים). שכבת-האינטליגנציה
-— `mcp-server/src` וה-skills של ההחלטה/הסגנון — מכילה **אפס** סמלים ספציפיים-לפלטפורמה
-(שם-מוצר, wakeup/heartbeat, pc.sh/pc_request, X-Paperclip-Run-Id, enums של הפלטפורמה).
-פרומפטי-הסוכנים אינם משכפלים את פרוטוקול-הריצה — הם מצביעים ל-HEARTBEAT.md בלבד. כל מגע
-חדש עם הפלטפורמה עובר דרך ה-Port — כך המעטפת נשארת ניתנת-להחלפה בלי לגעת באינטליגנציה.
-**מקורות:** Alistair Cockburn — *Hexagonal Architecture (Ports & Adapters)* · Robert C.
-Martin — *Clean Architecture* (The Dependency Rule) · Eric Evans — *Domain-Driven Design*
-(Anti-Corruption Layer) | סטטוס: verified
-**אכיפה:** רשימת-ה-Port + leak-guard ב-[scripts/spec-guard.sh](../../scripts/spec-guard.sh)
-(מול baseline) + fitness-test ב-CI על `mcp-server/src` + הצהרת-G12 בתבנית-ה-PR; מפורט ב-
-[X15-agent-platform-port.md](X15-agent-platform-port.md).
-**הפרה ידועה:** `web/app.py` קורא ל-`pc_*` inline בלוגיקת מחזור-חיים; 10 פרומפטי-סוכנים
-משכפלים את פרוטוקול-הריצה במקום להצביע ל-HEARTBEAT (baseline ב-[X15](X15-agent-platform-port.md) §3 → R1–R4).
-
 ### 5ב. Invariant תוכן-משפטי (G11)
 
 ### INV-G11: תוכן החלטה מנומקת
@@ -249,11 +227,11 @@ Martin — *Clean Architecture* (The Dependency Rule) · Eric Evans — *Domain-
 
 ## 7. אינדקס הספ
 
-> הערה: כל קבצי הספ (00, 01–07, X1–X17) קיימים. החוקה היא שער-הכניסה; כל קובץ-תחום כפוף לה.
+> הערה: כל קבצי הספ (00, 01–07, X1–X10) קיימים. החוקה היא שער-הכניסה; כל קובץ-תחום כפוף לה.
 
 | קובץ | תפקיד | אוכף invariants |
 |------|--------|-----------------|
-| [00-constitution.md](00-constitution.md) | חוקה — ייעוד, invariants גלובליים, כללי-הנדסה, אינדקס | G1–G12 |
+| [00-constitution.md](00-constitution.md) | חוקה — ייעוד, invariants גלובליים, כללי-הנדסה, אינדקס | G1–G11 |
 | [01-ingest.md](01-ingest.md) | קליטה מאוחדת: מסמכי-תיק / פסיקה חיצונית / החלטות-ועדה — חוזה מסלול-יחיד | G2, G3 |
 | [02-data-model.md](02-data-model.md) | אחסון: ישויות (cases, case_law, documents, chunks, halachot…) + חוזה-שלמות לכל ישות | G1, G4, G6 |
 | [03-retrieval.md](03-retrieval.md) | 3 קורפוסים + כלי-חיפוש · hybrid/RRF · attribution · eval harness | G4, G5, G6, G7, G8, G9 |
@@ -272,12 +250,6 @@ Martin — *Clean Architecture* (The Dependency Rule) · Eric Evans — *Domain-
 | [X9-mcp-tool-contract.md](X9-mcp-tool-contract.md) | חוזה 71 כלי-ה-MCP: envelope · שמות · idempotency · extract/get-symmetry · שלמות-הרשאות | G2, G3, G10 |
 | [X10-deploy-env-secrets.md](X10-deploy-env-secrets.md) | env-catalog SSoT · מקור-config יחיד (Coolify) · ללא hardcode · secrets · drift | G2, G4, G9 |
 | [X11-citation-corroboration.md](X11-citation-corroboration.md) | citator פנימי — תיקוף הלכות בטיפול-שיפוטי מצטבר · תיקון-G10 מבוקר · סף-corroboration · התאמה-להלכה | G9, G10 |
-| [X12-digests-radar.md](X12-digests-radar.md) | יומונים כשכבת-גילוי (radar) — מקור-משני המצביע על הפסק המקורי · לא קורפוס-ציטוט רביעי · לא מצוטט/לא מחלץ-הלכות | G2, G4, G9 |
-| [X13-court-fetch.md](X13-court-fetch.md) | אחזור-פסיקה אוטומטי מנט המשפט — 3 שכבות (עליון/מנהלי/skip) · שירות-מארח · reCAPTCHA · שער-אנושי | G2, G3, G4, G5, G9, G10 |
-| [X14-storage-minio.md](X14-storage-minio.md) | אחסון-אובייקטים (MinIO/S3) · `storage.py` כמסלול-I/O יחיד · git=טקסט/MinIO=בינאריים · WORM סופי | G2, G9 |
-| [X15-agent-platform-port.md](X15-agent-platform-port.md) | שער-הפלטפורמה — Paperclip מאחורי Port יחיד · baseline-דליפה · R0–R4 · leak-guard | G2, G12 |
-| [X16-pipeline-durability.md](X16-pipeline-durability.md) | עמידות-פייפליין — LangGraph כספרייה · checkpointing/replay · `_pipeline_runtime.py` משותף | G3 |
-| [X17-information-architecture.md](X17-information-architecture.md) | ארכיטקטורת-מידע — משטח-ההפעלה (דפים/תורים/ניווט/cache) · INV-IA1–IA6 מרימים G2/G10 לשכבת-UI · #127/#130–132 | G2, G10 |
 
 > **X6–X10 (מחזור-2):** מכסים את 8 משטחי-האפליקציה שמחוץ לצינור-הליבה (אינטגרציה, web-ui, מילוי-שדות,
 > אחסון-ניתוחים, כלי-MCP, deploy/env). הממצאים ב-[gap-audit.md](gap-audit.md) (GAP-24..62 → FU-9..15)

docs/spec/02-data-model.md

@@ -30,7 +30,6 @@
 | `chair_feedback` | הערת-יו"ר על טיוטה | `id`; FK→`cases` | `block_id`, `feedback_text`, `category`, `lesson_extracted`, `resolved` (`db.py:452-462`) |
 | `missing_precedents` | תקדים חסר שהתבקש ולא נמצא | `id` | (`db.py:806`) — backlog ל-quality-at-source |
 | `style_corpus` | קורפוס-סגנון של דפנה (אימון) | `id`; FK→`documents` | `decision_number`, `full_text`, `practice_area`, `appeal_subtype` (`db.py:118-131`) |
-| `plans` | מרשם-תכניות — זהות+תוקף של תב"ע, שימוש חוזר בין תיקים (V38) | `plan_number` מנורמל (`UNIQUE`) | `display_name`, `aliases`, `plan_type`, `gazette_date`, `yalkut_number`, `purpose`, `citation_formatted`, `review_status`, provenance (`source_case_number`/`source_document_id`/`model_used`), `discrepancies` (SCHEMA_V38) |
 
 > שכבות-עזר נוספות (`document_image_embeddings`, `precedent_image_embeddings` — multimodal,
 > `db.py:707,726`; `case_law_relations` — שרשרת-תיק, `db.py:754`; `precedent_internal_citations`
@@ -88,7 +87,6 @@ proceeding_type)`. לכן המזהה הקנוני הוא **(`case_number` מנו
 | `legal_arguments` (+`legal_argument_propositions`) | OPUS (`aggregate_claims_to_arguments`) | **חסר** (בניגוד ל-halachot) | `cited_precedents TEXT[]` (לא-FK) |
 | `appraiser_facts` | OPUS (`extract_appraiser_facts`) | — | `document_id` (FK); `appraiser_side` default `''` |
 | `halachot` | OPUS (`halacha_extractor`) | **`review_status`** ✓ | `case_law_id` (FK); `quote_verified` |
-| `plans` | claude-local (`plans_extractor`) / ידני-יו"ר (`plan_upsert`) | **`review_status`** ✓ (כמו halachot, INV-DM5/G10) | `source_document_id` (FK); `source_case_number`; `discrepancies` (סתירת-תוקף מול שורה מאושרת — לא-דורס, §6) |
 | `decision_blocks` / `decision_paragraphs` | Opus/script (`write_block`) | `status` | `model_used` + audit-event provenance (FU-7); `citations JSONB` ללא-FK |
 
 ---
@@ -157,14 +155,6 @@ RAG freshness (Lewis et al., 2020, NeurIPS) | סטטוס: verified
 **אכיפה:** CHECK על enums; FK על `cited_precedents`/`decision_paragraphs.citations`; איחוד `case_precedents`↔`case_law`.
 **הפרה ידועה:** 20+ enums כ-TEXT חופשי; `legal_arguments.cited_precedents TEXT[]` ללא-FK (הזיות-LLM נבלעות); `case_precedents` מול `case_law` מקבילות ([gap-audit GAP-40/42/43](gap-audit.md)).
 
-### INV-DM7: סיווג-הלכה — סמכות (נגזרת) ⊥ תפקיד-כלל (מסווג). שני צירים, לא enum אחד
-**כלל:** ל-`halachot` שני צירי-סיווג **אורתוגונליים** שאסור לערבב בשדה אחד:
-- **סמכות (`authority`) — נגזרת בלבד, לא מאוחסנת, לא מנוחשת ע"י LLM.** `binding` (מקור מחייב את הוועדה: עליון/מנהלי) מול `persuasive` (מקור משכנע: ועדת-ערר אחרת). נגזרת דטרמיניסטית מ-`case_law.precedent_level` (`עליון`/`מנהלי`→binding; `ועדת_ערר_מחוזית`→persuasive). מקור-אמת יחיד — מחושבת בקריאה, אין עמודה כפולה ([G1](00-constitution.md#inv-g1-נרמול-במקור-לא-תיקון-בקריאה)/[G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)).
-- **תפקיד-כלל (`rule_type`/rule_role) — מסווג ע"י ה-LLM.** `holding` (עיקרון מהותי הכרחי להכרעה — ratio/Wambaugh) · `interpretive` (פרשנות חוק/מונח/תכנית) · `procedural` (סדר-דין: סמכות/מועדים/נטל) · `application` (החלה תלוית-עובדות — לרוב לא-הלכה) · `obiter` (אמרת-אגב). **`binding`/`persuasive` אינם ערכי תפקיד** — הם סמכות-מקור.
-**הנדסי.** מופע של [G1](00-constitution.md#inv-g1-נרמול-במקור-לא-תיקון-בקריאה) (נרמול במקור: המחלץ מסווג תפקיד, לא ממציא סמכות נגזירה) ו-[G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים).
-**מקורות:** OASIS LegalRuleML v1.0 (`appliesAuthority`/`Strength` כ-metadata אורתוגונלי, נפרד מלוגיקת-הכלל) · SemEval-2023 Task 6 LegalEval (rhetorical-roles לפי תפקיד, סמכות נשמרת בנפרד) · Bluebook signals (משקל-סמכות = ציר נפרד מהפרופוזיציה) | סטטוס: verified (≥3 מקורות).
-**ההפרה שתוקנה:** `halacha_extractor` סיווג `rule_type` לפי bindingness-של-המקור (`_coerce_halacha(is_binding)`, ברירת-מחדל `binding`/`persuasive`, guard binding→persuasive) — כלומר חישב **סמכות** במסווה של **תפקיד**. אומת אמפירית על מדגם-הזהב: `binding` שימש 19/19 פסקים חיצוניים ו-0 ועדות; `persuasive` 13/13 ועדות ו-0 חיצוניים → סיווג-לפי-מקור, התאמה לתיוג-אנושי 58% בלבד. התיקון מעביר סמכות לציר-נגזר ומשחרר את ה-LLM לסווג תפקיד נטו.
-
 ---
 
 ## 4. מצב קיים מול יעד — audit-findings

docs/spec/03-retrieval.md

@@ -35,13 +35,6 @@
 (`search_precedent_library_semantic`/`_lexical`) — לכן הפרדת-הקורפוס היא **תנאי-סינון בתוך אותה שאילתה**,
 ושם נולדת ההפרה ב-§5.
 
-> **שכבת-גילוי — יומונים, לא קורפוס-ציטוט.** מעל 3 הקורפוסים יושבת שכבת-radar נפרדת: **יומונים**
-> (סיכומי עפר-טויסטר), בטבלה פיזית נפרדת `digests` עם כלי `search_digests`. היומון הוא **מקור משני
-> המצביע** על הפסק המקורי — **אינו** קורפוס-ציטוט רביעי, **אינו** עקיב-בפלט ([INV-RET5](#inv-ret5-כל-span-מוחזר-עקיב-למקורו)),
-> ו**אינו** נוגע ב-`case_law`/`document_chunks`. ההפרדה כאן **פיזית** (טבלה נפרדת), לא תנאי-סינון —
-> ולכן [INV-RET1](#inv-ret1-הפרדת-קורפוס-נאכפת-ב-100-ממסלולי-ה-query) מתקיים טריוויאלית. מלא ב-
-> [X12-digests-radar.md](X12-digests-radar.md) (INV-DIG1–DIG3).
-
 ---
 
 ## 2. עיצוב ה-hybrid retrieval
@@ -183,4 +176,3 @@ re-embed; בדיקת-בריאות מגלה embeddings מיושנים. אוכף
 - [02-data-model.md](02-data-model.md) — חוזה-השלמות (searchable) + re-index שהאחזור מסנן לפיהם.
 - [05-qa-review.md](05-qa-review.md) — שער-הלכה הידני (`review_status`) שמגדיר אילו הלכות searchable.
 - [X5-audit-provenance.md](X5-audit-provenance.md) — עקיבוּת-מקור מלאה של כל span מוחזר (בסיס ל-INV-RET5).
-- [X12-digests-radar.md](X12-digests-radar.md) — שכבת-הגילוי (יומונים) שמעל הקורפוסים — מצביעה, לא מצוטטת.

docs/spec/04-analysis-writing.md

@@ -72,13 +72,6 @@
 — שם §4. **טיוטת-ביניים** (Pre-Ruling Draft) בוחרת תת-קבוצת בלוקים (ו, ט, ז, ח) —
 block-schema.md §7; שלב-החילוץ השמאי שלה (`extract_appraiser_facts`) מזין את בלוק ט.
 
-> **ציטוט-תכנית קנוני (בלוק ט):** הזהות והתוקף של תכנית (תאריך פרסום למתן תוקף
-> ברשומות + מס' ילקוט-הפרסומים) נכתבים בנוסח אחיד **דטרמיניסטי** מ**מרשם-התכניות**
-> (`plans`, [02-data-model](02-data-model.md)) דרך `db.format_plan_citation` — לא
-> מנוסחים מחדש ע"י ה-LLM, ובכך לא מהוזים ([anti-hallucination-gate](../anti-hallucination-gate.md),
-> INV-AH). הנוסח עצמו הוא תוכן-משפטי באחריות היו"ר ([block-schema.md](../block-schema.md)
-> בלוק ט); המרשם נכנס לשימוש רק אחרי אישור-יו"ר (`review_status`, G10).
-
 > **התמקדות לפי feedback היו"ר:** הסיוע מתמקד בבלוקים המהותיים (ו–יב); בלוקים א–ד
 > ממולאים מ-template ואינם דורשים ניתוח. ראה `MEMORY.md` → "התעלם מכותרות".
 

docs/spec/07-learning.md

@@ -43,9 +43,7 @@
 `mark-final` → [1] INTAKE (snapshot של הטיוטה) → [2] PAIRING (בלוק↔בלוק) → [3] ALIGNMENT (diff פר-בלוק) → [4] DISTILLATION (מפריד סגנון↔מהות) → [5] CURATION (Hermes + שער-יו"ר) → [6] FEEDBACK (ניתוב לערוץ A/B/C) → [7] MEASUREMENT (מדד-מרחק-סגנון).
 
 ### 0.4 ניהול ב-UI
-`/methodology` = **עורך-הפרופיל היחיד** (declarative: יחסי-זהב, כללי-דיון, צ׳קליסטים, ביטויי-מעבר, אנטי-דפוסים, voice-invariants). `/training` = **שולחן-הלמידה** (קורפוס, פורטרט-סגנון, השוואת draft↔final, curator, מדד-מרחק, פנקס-התאמה).
+`/methodology` = **עורך-הפרופיל** (declarative: יחסי-זהב, כללי-דיון, צ׳קליסטים, ביטויי-מעבר, אנטי-דפוסים, voice-invariants). `/training` = **שולחן-הלמידה** (קורפוס, פורטרט-סגנון, השוואת draft↔final, curator, מדד-מרחק, פנקס-התאמה).
-
-**שער-אישור אחד · טרנזקציית-כותב אחת (INV-IA3 → [X17](X17-information-architecture.md)):** ל-`decision_lesson` יש **סטטוס-יחיד** שקובע "זורם-לכותב" — `review_status='approved'` (INV-LRN1/G10). הדגל `applied_to_skill` **הוסר** (היה אינפורמטיבי-בלבד, נכתב-לשומקום → בלבל את היו"ר ב"שני שערים"; גל-2 #131). לקח שהיו"ר מחבר ידנית נוצר כבר כ-`approved`; לקח-פאנל נוצר כ-`proposed` וממתין לשער. promote של זוג draft↔final מטמיע את הלקחים/הביטויים שהיו"ר בחר **דרך appeal_type_rules בטרנזקציה אחת נעולה (FOR UPDATE)** — מסלול-כתיבה-יחיד, ללא read-modify-write מתפצל מול עורך-המתודולוגיה (MET-2/3, להלן G2 הפרות-ידועות).
 
 ### 0.5 Invariants חדשים
 **INV-LRN4 (ניגוד-אמת → G10/G9):** למידת-קול מבוססת **pairing draft↔final ברמת-בלוק**, לא קריאת-final בלבד. כל החלטה אינה "סגורה" עד שהושוותה מול הסופי; כל סופי מנותח מול הטיוטה. נשמר פנקס-התאמה (`draft_final_pairs`) עם מצב-חיים `draft_done → final_received → analyzed → lessons_folded`.
@@ -54,18 +52,6 @@
 **INV-LRN5 (טוהר-הקול → G4/G11):** שכבת-ידע-הקול (voice-fingerprint, style_patterns, exemplars) **לא תכיל הלכות/עובדות ספציפיות** — רק סגנון ושיטה. מהות מנותבת ל-precedent_library/halacha. ה-distillation מפריד במקור.
 *מקורות:* quality-at-source (Data Mesh) · separation-of-concerns. *סטטוס: verified.*
 
-### 0.6 מסלול-העלאת-סופי נקי + פאנלים אוטומטיים (מדורג)
-היו"ר מעלה את **ההחלטה החתומה שלה** דרך מסלול ייעודי — `POST /api/cases/{case}/final/upload` (כפתור "העלאת החלטה סופית של היו"ר" בלשונית-הטיוטות). **נבדל** מ-`exports/upload` (גרסה-מתוקנת-שלנו+retrofit) ומ-`mark-final` (סימון export-שלנו), ולכן אינו מסלול-מקביל (G2) אלא יכולת חסרה.
-הקליטה (סינכרונית ב-endpoint) מבצעת את **לולאת-צמיחת-הקורפוס** (§1.3) במלואה:
-1. **קורפוס-הסגנון** (voice) תחת ה-`case_number` **המלא** (בל"מ≠ערר — מונע התנגשות-מספר) + פתיחת `draft_final_pairs` (`final_received`, INV-LRN4).
-2. **ספריית-הפסיקה** — ההחלטה נכנסת ל-`case_law` כ-`internal_committee` **תמיד** (כדי שתהיה ברת-ציטוט בהחלטות עתידיות). `chair_name` נקבע **דטרמיניסטית** (תיק → ברירת-מחדל-ועדה, לעולם לא ריק — אילוץ `case_law_internal_chair_check`); לא נשען על חילוץ-LLM. מטה-דאטה נוסף (תאריך/צדדים) מועשר אסינכרונית ע"י מחלץ-Gemini.
-3. **בדיקת-ציטוטים** — `extract_internal_citations` מקשר את הפסיקה שההחלטה מצטטת לספרייה; כל ציטוט שאינו בספרייה **מסומן אוטומטית** כ-`missing_precedent` (open) להעלאה ע"י היו"ר.
-4. הציטוטים-המקושרים מזינים את **לולאת-ה-corroboration** (X11): ציטוט-נכנס מההחלטה שלנו מחזק את ההלכות של התקדים המצוטט (`corroboration_rebuild`).
-ואז שני שלבים אוטומטיים נפרדים (`run-learning` / `run-halacha`) המעירים worker מקומי (claude/DeepSeek/Gemini מקומיים בלבד):
-- **למידה:** `ingest_final_version` (Opus distillation) → **פאנל-סגנון דו-סוכני** (DeepSeek+Gemini, "למידה כפולה") שמצביע על כל לקח-style_method; הסכמה 2/2 → `decision_lesson` (`source=panel:deepseek+gemini`); פיצול → ליו"ר.
-- **הלכות:** `extract_internal_citations` → `precedent_extract_halachot` → `corroboration_rebuild` → **פאנל-הלכות תלת-סוכני** (`halacha_panel_approve.py --apply`).
-שני הפאנלים **הפיכים** (גיבוי-CSV ל-`data/audit/`) ומסלימים מחלוקות. ההטמעה הסופית ל-`SKILL.md`/`legal-decision-lessons.md` נשארת **אישור-יו"ר ידני** (INV-LRN1/G10) — הפאנל יוצר *הצעות* בלבד.
-
 ---
 
 ## 1. שלוש לולאות-המשנה

docs/spec/README.md

@@ -3,12 +3,9 @@
 זהו מקור-האמת הקנוני ל"מהו תקין" במערכת. שער-הכניסה: [00-constitution.md](00-constitution.md).
 כל invariant מגובה ב-≥3 מקורות סמכותיים; פריט לא-מאומת מסומן ⚠ UNVERIFIED ומועלה ליו"ר.
 
-מבנה: 00 חוקה · 01–07 מחזור-חיים · X1–X17 חוצי-שלבים. ראה אינדקס מלא בחוקה.
+מבנה: 00 חוקה · 01–07 מחזור-חיים · X1–X10 חוצי-שלבים. ראה אינדקס מלא בחוקה.
 - X1–X5: מזהים · רב-חברתי · אינטגרציה+deploy · סוכנים · audit.
 - X6–X10 (מחזור-2, 8 משטחי-האפליקציה): חוזה UI↔API · לקוח-Paperclip · מילוי-שדות · חוזה כלי-MCP · deploy/env/secrets.
-- X11–X14 (הרחבות-תחום): citator פנימי (תיקוף-הלכות) · יומונים כשכבת-גילוי (radar) · אחזור-פסיקה אוטומטי מנט המשפט (שירות) · אחסון-אובייקטים (MinIO/S3, הגירת `data/`).
-- X15–X16 (ארכיטקטורת-יסוד): שער-הפלטפורמה (Paperclip מאחורי Port — G12, מיישם G2) · עמידות-פייפליין (LangGraph כספרייה — checkpointing/replay, מחזק G3).
-- X17 (ארכיטקטורת-מידע): [X17-information-architecture.md](X17-information-architecture.md) — משטח-ההפעלה (דפים/תורים/ניווט/cache); INV-IA1–IA6 מרימים את G2 ו-G10 לשכבת-ה-UI. מיישם feedback_operational_simplicity.
 
-מפות-ממצאים: [gap-audit.md](gap-audit.md) (GAP-01..62 → FU-1..15; מחזור-1 ✅ הושלם, מחזור-2 פתוח) · [ui-audit.md](ui-audit.md) (ביקורת 13 דפי-UI, שכבת-קוד) · [ia-audit-redesign.md](../ia-audit-redesign.md) (34 משטחים, 37 ממצאים, שכבת-IA/הפעלה → X17, #127).
+מפות-ממצאים: [gap-audit.md](gap-audit.md) (GAP-01..62 → FU-1..15; מחזור-1 ✅ הושלם, מחזור-2 פתוח) · [ui-audit.md](ui-audit.md) (ביקורת 13 דפי-UI).
 בסיס-עיצוב: docs/superpowers/specs/2026-05-30-system-spec-design.md

docs/spec/X1-identifiers.md

@@ -37,26 +37,6 @@
 > (`cases.proceeding_type`, `db.py:912`). כך "ערר 8137/24" ו-"בל\"מ 8137/24" הם שתי
 > רשומות מובחנות בעלות אותו `case_number=8137-24` ו-`proceeding_type` שונה.
 
-### 1א. אורך-הסידורי — אות לסוג-ההליך (נוהל-יו"ר, 2026-06-11)
-
-מבנה ה-`case_number` הוא `<סידורי>-<חודש>-<שנה>` (serial-month-year). **אורך הסידורי מקודד
-את סוג-ההליך:**
-
-| אורך סידורי | סוג-הליך | דוגמה | הערה |
-|-------------|----------|-------|------|
-| 4 ספרות | **ערר** | `1230-04-26` | הליך עיקרי |
-| 5 ספרות | **בל"מ** | `85074-09-24` | בקשה להארכת מועד |
-
-- **הספרה הראשונה ממשיכה לקודד את התחום בשני האורכים** — `1→רישוי`, `8→היטל השבחה`,
-  `9→פיצויים ס'197` (INV-DM/practice_area). תיק בל"מ `85074` → תחום היטל-השבחה.
-- **הכלל חד-כיווני:** סידורי בן 5 ספרות **הוא** בל"מ (אות אוטומטי, `is_blam_by_number`,
-  `practice_area.py`). סידורי בן 4 ספרות **אינו** מחייב ערר — בל"מ-מורשת בן 4 ספרות עדיין
-  מזוהה מהנושא (`is_blam_subject`). הרקע: ירושלים אימצה מספור 5-ספרתי לבל"מ רק עכשיו; ת"א
-  מזה זמן (למשל `81002-01-21`).
-- **פתיחת תיק חדש מחייבת את צורת serial-month-year המלאה** (כולל חודש) — ולידציית-הכתיבה
-  (`web-ui/src/lib/schemas/case.ts`) דוחה את צורת המורשת ללא-חודש. ההתאמה-הסלחנית-בקריאה
-  (§3) עדיין בולעת רשומות-מורשת בנות שתי-חוליות לצורך *חיפוש*, לא לצורך *יצירה*.
-
 **נרמול-בכתיבה הוא המנגנון הראשי; התאמה-סלחנית-בקריאה היא נוחות משנית בלבד.** כלל-ההנדסה
 "נרמול לא תיקון-תסמין" (חוקה §6) קובע: מתקנים את הנתון במקור, לא מטליאים בקריאה. אם רשומה
 נשמרה בצורה לא-קנונית — היעד הוא לנרמל אותה במיגרציה/בכתיבה, **לא** לסמוך על מנוע-קריאה

docs/spec/X12-digests-radar.md

@@ -1,185 +0,0 @@
-# X12 — יומונים כשכבת-גילוי (Digests Radar)
-
-קובץ-תחום זה כפוף ל-[חוקת המערכת](00-constitution.md). הוא מגדיר **שכבת-גילוי (discovery/radar)**
-מעל קורפוסי-הפסיקה: קליטה וחיפוש של **יומונים** — סיכומי-עמוד-אחד של משרד עפר טויסטר ("כל יום —
-היומון לענייני תכנון ובנייה") על פסק-דין/החלטה בודדים. היומון הוא **מקור משני** המצביע על פסק-הדין
-המקורי; הוא **אינו** נכנס לאף אחד מ-3 קורפוסי-הציטוט, **אינו** מצוטט בהחלטה, ו**אינו** מחלץ הלכות.
-הוא נשען על [INV-G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)
-(אין מסלול מקביל), [INV-G4](00-constitution.md#inv-g4-חוזה-שלמות-לפני-שמיש--ניתן-לחיפוש)
-(שלמות + אין בליעה שקטה) ו-[INV-G9](00-constitution.md#inv-g9-עקיבוּת-מקור--audit-trail-ל-ai)
-(עקיבוּת-מקור), ומובחן מ-3 הקורפוסים של [03-retrieval.md](03-retrieval.md).
-
-> **TARGET, לא תיאור-מצב.** התת-מערכת כולה היא יעד — אין כיום טבלת `digests`, כלי-`digest_*`,
-> ולא אינטגרציית-חוקר. כל רכיב מסומן מפורשות כ-audit-finding לבנייה (§6). כל טענה על הקוד `file:line`.
-
----
-
-## 1. הרעיון — radar, לא קורפוס-ציטוט
-
-חיים מקבל כמעט יומית מייל עם **יומון**: PDF של עמוד אחד שמסכם פסק-דין/החלטה בודדים בתחום
-רישוי-ובנייה / היטל-השבחה / פיצויים(ס'197). היומון אינו הטקסט המשפטי המקורי — הוא **ניתוח של צד
-שלישי** (עפר טויסטר), הנושא הבהרה מודפסת: *"האמור הוא מידע ראשוני בלבד ואין הוא תחליף לייעוץ
-משפטי"*. במונחי-מחקר-משפטי זהו **מקור משני (secondary authority)**: כלי-איתור והכוונה, לא סמכות
-שמצטטים בהחלטה.
-
-הערך שלו עצום דווקא כ-**radar**: כל יומון הוא *headnote + תג-נושא כתובים-מראש בידי מומחה*, המצביע
-על פסק-דין מקורי. כשמנסחים החלטה, `search_digests` מחזיר את היומון הרלוונטי → החוקר קורא את ניתוח
-טויסטר **כרקע** → מחלץ את מראה-המקום של פסק-הדין המקורי → מביא את הפסק עצמו לקורפוס-הפסיקה הקיים
-(הזמינות גבוהה) → ומצטט **משם**. היומון מצביע; הציטוט תמיד נשען על המקור.
-
----
-
-## 2. מה היומון מכיל
-
-מבנה קבוע (אומת מול הקבצים ב-`data/precedents/incoming/`, יומון 5158/5159/5160/5163):
-
-| רכיב | דוגמה | תפקיד |
-|------|-------|-------|
-| מספר-יומון + תאריך-גיליון | `יומון מס' 5163  7 ביוני 2026` | מפתח-upsert + `digest_date` |
-| תג-מושג | `"שיקול הדעת המצומצם"` | ציר-נושא לחיפוש |
-| כותרת-הלכה | `ביהמ"ש - שיקול דעת הוועדה המחוזית אינו מצומצם...` | הסיכום בשורה |
-| גוף-ניתוח (1–2 עמ') | ניתוח עפר-טויסטר | רקע + מקור-embedding |
-| מראה-מקום בתחתית | `עת"מ 46111-12-22 יכין-אפק... ניתן 3.6.26... שופטת: יעל טויסטר ישראלי` | **השדה הקריטי** — הגשר לפסק המקורי |
-
-`underlying_date` (מתן הפסק) שונה מ-`digest_date` (גיליון היומון) — מקור-באגים נפוץ; חילוץ-המטא-דאטה
-מבחין ביניהם מפורשות.
-
-**`digest_kind` (סיווג-גיליון, V32):** רוב הגיליונות הם `decision` (סיכום פס"ד → `underlying_citation`),
-אך חלקם `announcement` — עדכון/הודעה ללא הכרעה (חקיקה, נוהל, ברכת-שנה) שאין לו מראה-מקום. החילוץ
-מסווג כל גיליון ותמיד מחלץ `concept_tag`/`headline`/`summary` (קיימים לכל סוג); `underlying_citation`
-רק ל-`decision`. **שימוש קריטי:** הגדרת-"כשל" של ה-drain self-heal היא `completed` **עם
-`digest_kind=''`** (מעולם לא סווג) — כך הודעה (kind=`announcement`, בלי citation) **אינה** נחשבת כשל
-ואינה מנוסה-מחדש לנצח. ההיוריסטיקה הישנה ("שני השדות ריקים") טיפלה בהודעות בטעות כ-retry אינסופי.
-
-### 2.1 מקור שני ל-radar — העלון החודשי "עו"ד על נדל"ן"
-
-פרסום **נפרד** מהיומון היומי: עלון חודשי ממוספר (משרדי צבי שוב + רונית אלפר), **רב-נושאי** — מאמר-עומק,
-עדכוני-חקיקה, וסט מצביעי-פסיקה מקובצים לפי נושא. נקלט **לאותה טבלת `digests`** (לא קורפוס מקביל — G2),
-מובחן ע"י `publication='עו"ד על נדל"ן'` (מול `'כל יום'`). עלון אחד **מתפצל ל-N שורות** דרך
-`bulletin_splitter` (LLM, local-only) → `bulletin_library.ingest_bulletin`:
-- **מצביעי-פסיקה** → `digest_kind='decision'` — מצטרפים ל-radar ומקושרים לפסק (autolink + X13 כמו היומון).
-- **מאמרים** → `digest_kind='article'` — טקסט-מלא + embedding לחיפוש-עומק; **רקע בלבד, INV-DIG1 חל** (לא מצוטט).
-- **עדכוני-חקיקה — לא נקלטים** (החלטת יו"ר).
-
-מפתח-הדדאפ לפריט-עלון הוא **`content_hash` (per-פריט)**, כי `yomon_number` ריק (ה-upsert על yomon-number
-לא חל; `uq_digests_content_hash` תופס re-runs). אידמפוטנטי. סקריפט: `scripts/ingest_bulletins.py`.
-
----
-
-## 3. למה זה לא קורפוס-ציטוט רביעי (הקושיה המרכזית — G2)
-
-[03-retrieval.md §1](03-retrieval.md#1-שלושת-הקורפוסים-וכלי-החיפוש) מגדיר 3 **קורפוסי-ציטוט**:
-מסמכי-תיק+סגנון-דפנה, פסיקה-חיצונית, החלטות-ועדה. השאלה: האם יומונים = רביעי, ובכך הפרת
-[INV-G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)?
-
-**לא — בתנאי המסגור הנכון.** G2 אוסר *מסלול מקביל ליכולת קיימת*. יומונים אינם עוד-מסלול-לאחזור-
-פסיקה אלא **bounded context נפרד**: ישות נפרדת (`digests`, לא `case_law`), מטרה נפרדת (הצבעה ולא
-ציטוט), וחוזה נפרד. ההבחנה הקנונית: 3 הקורפוסים הם **עקיבים-בפלט** (כל ציטוט בהחלטה חוזר אליהם —
-[INV-RET5](03-retrieval.md#inv-ret5-כל-span-מוחזר-עקיב-למקורו)/[G9](00-constitution.md#inv-g9-עקיבוּת-מקור--audit-trail-ל-ai)).
-היומון **לעולם אינו עקיב-אליו בפלט** (INV-DIG1) — ולכן אינו קורפוס-ציטוט רביעי, אלא שכבה
-**מקדימה** לקורפוסים. הפרדת-הקורפוס מ-[INV-RET1](03-retrieval.md#inv-ret1-הפרדת-קורפוס-נאכפת-ב-100-ממסלולי-ה-query)
-מתקיימת אוטומטית: `search_digests` שואל **רק** את `digests`, ואף כלי-חיפוש-פסיקה אינו נוגע בה
-(הפרדה פיזית בטבלה, לא תנאי-סינון).
-
----
-
-## 4. המנגנון (TARGET)
-
-```
-קליטה (מסלול קצר עצמאי — INV-DIG2):
-  יומון PDF → extract_text → content_hash (idempotent, INV-G3)
-           → חילוץ-LLM: תג-מושג / כותרת-הלכה / תקציר / מראה-מקום / שני-תאריכים / תחום / תגיות
-           → INSERT digests → embedding יחיד (תג+כותרת+תקציר+ניתוח) לחיפוש סמנטי בלבד
-           → try_autolink(underlying_citation → case_law)            [INV-DIG3]
-  ⚠ ללא precedent_chunks, ללא halacha-extraction, ללא precedent metadata-extractor.
-
-חיפוש + שימוש (radar — INV-DIG1):
-  legal-researcher: search_digests(סוגיה)
-    → קורא ניתוח טויסטר + כותרת-הלכה  =  רקע/orientation בלבד
-    → מחלץ את מראה-המקום של הפסק המקורי
-    → הפסק בקורפוס?  כן → אמת+צטט כרגיל (precedent_attach) + digest_link
-                      לא → missing_precedent_create על *הפסק המקורי*
-                           (notes="זוהה דרך יומון מס' NNNN")           [INV-DIG3]
-    → היומון לעולם אינו נרשם דרך precedent_attach ואינו supporting_quote.  [INV-DIG1]
-```
-
----
-
-## 5. Invariants של התחום
-
-### INV-DIG1: היומון מצביע, לא מצוטט
-**כלל:** רשומת-`digest` לעולם אינה משמשת כ-`supporting_quote`/provenance בפלט-החלטה; כל ציטוט
-בהחלטה נגזר מקורפוס-ציטוט (`case_law`/`document_chunks`). היומון הוא מקור משני — כלי-איתור,
-לא סמכות-מצוטטת. החוקר רושם אותו כ-radar (סעיף-דוח נפרד), לא דרך `precedent_attach`.
-**מקור-סמכות:** היו"ר + ההבהרה המודפסת ביומון ("מידע ראשוני בלבד... אינו תחליף לייעוץ משפטי") —
-invariant תוכן-משפטי/תפעולי, **קשור** ל-[G9](00-constitution.md#inv-g9-עקיבוּת-מקור--audit-trail-ל-ai).
-**מקורות (פתוחים, להבחנת מקור-ראשוני↔משני):** Georgetown Law Library — *Secondary Sources research
-guide* (*"secondary sources... are not the law"*) · Amy E. Sloan, *Basic Legal Research: Tools and
-Strategies* — primary vs. persuasive/secondary authority · *The Bluebook: A Uniform System of
-Citation* — סיווג סמכות-ראשונית מול משנית | סטטוס: verified
-**אכיפה:** היעדר FK מ-`decision_blocks`/ציטוטים ל-`digests`; ולידציית-QA ([05-qa-review.md](05-qa-review.md))
-שדוחה ציטוט שמקורו digest; הוראת-חוקר מפורשת ([X4-agents.md](X4-agents.md), `legal-researcher.md`).
-**הפרה ידועה:** — (תת-מערכת חדשה)
-
-### INV-DIG2: מסלול-קליטה נפרד-בכוונה — לא מסלול-פסיקה מקביל
-**כלל:** קליטת-יומון היא **bounded context נפרד**, ואינה עוברת ב-precedent pipeline
-([01-ingest.md](01-ingest.md)): אין `precedent_chunks`, אין halacha-extraction, אין
-precedent-metadata-extractor. מסלול קצר עצמאי (`digest_library.ingest_digest`) הבונה
-embedding-יחיד לחיפוש סמנטי בלבד. הצהרה זו היא מה ש**מונע** הפרת-G2 — היומון אינו ישות-אחות
-של `case_law` ואינו מתפצל ממסלולו.
-**מקורות:** Eric Evans, *Domain-Driven Design* (2003) — Bounded Context (הקשרים שונים = מודלים
-מובחנים) · Martin Kleppmann, *DDIA* (2017) — system-of-record מובחן מ-derived/index data · Martin
-Fowler — Bounded Context / Canonical Data Model | סטטוס: verified
-**אכיפה:** טבלה פיזית נפרדת `digests`; `ingest_digest` עושה reuse לשירותים אטומיים בלבד
-(`extractor.extract_text`, `embeddings.embed_texts`) ולא ל-`ingest.ingest_document`; ביקורת-
-ארכיטקטורה. אוכף את [G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)
-+ כלל-הנדסה "סימטריה" (§6). **מקור-אמת יחיד:** מצב-הקליטה נשמר אך-ורק בטבלת `digests` (סטטוס +
-`content_hash` ל-idempotency); תיקיות-קבצים (`incoming/`) הן staging בלבד, **לא** state.
-**הפרה ידועה (תוקנה 2026-06-07):** `ingest_digests_batch.py` העביר קבצים ל-`data/digests/processed/`
-— state מבוסס-תיקיות מקביל ל-DB. הוסר; הסקריפט מסתמך על dedup ב-content_hash (G2).
-
-### INV-DIG3: קישור-לפסק-המקורי הוא הגשר — חוסר-קישור הוא פער גלוי
-**כלל:** לכל `digest` שדה `linked_case_law_id` (FK ל-`case_law`, nullable). כשהפסק המקורי בקורפוס —
-היומון מקושר אליו (אוטומטית בקליטה לפי מראה-המקום, או ידנית ב-`digest_link`). כל עוד אינו בקורפוס,
-הקישור ריק ו**הפער מוצף** דרך `missing_precedent_create` על הפסק המקורי — לא נבלע בשקט.
-**מקורות:** E.F. Codd — referential integrity (foreign keys, CACM 13(6), 1970) · ISO 8000 —
-completeness (פער-ידע מתועד) · DAMA-DMBOK2 — data linkage / lineage | סטטוס: verified
-**אכיפה:** שדה-FK `digests.linked_case_law_id` + `try_autolink` בקליטה + כלי `digest_link`/
-`digest_relink`; חוסר-קישור → `missing_precedent_create` (כלל-הנדסה "אין בליעה שקטה", §6). אוכף את
-[G4](00-constitution.md#inv-g4-חוזה-שלמות-לפני-שמיש--ניתן-לחיפוש) +
-[G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים).
-**הפרה ידועה:** — (תת-מערכת חדשה)
-
----
-
-## 6. מצב קיים מול יעד — audit-findings
-
-התת-מערכת כולה TARGET; אין כיום מימוש. רכיבים לבנייה:
-
-- **טבלת `digests` + פונקציות-DB** — לא קיימות. יעד: `SCHEMA_V30` ב-`db.py` (טבלה + ivfflat/GIN/FTS
-  אינדקסים + UNIQUE חלקי על `yomon_number`/`content_hash` ל-idempotent) + `create_digest`/`search_digests`/
-  `link_digest_to_case_law` (§4, INV-DIG2/DIG3).
-- **שירות + חילוץ-LLM** — `services/digest_library.py` + `services/digest_metadata_extractor.py`
-  לא קיימים. החילוץ נשען על `claude_session` (local-only — ייבוא lazy בתוך `ingest_digest` בלבד,
-  לא רץ בקונטיינר; תואם [claude_session local-only]).
-- **כלי-MCP `digest_*`** — לא קיימים. יעד: `tools/digests.py` + רישום ב-`server.py`, מעטפת-envelope
-  אחידה לפי [X9-mcp-tool-contract.md](X9-mcp-tool-contract.md) (`search_digests` מובחן בשם מ-6 כלי-
-  החיפוש הקיימים — INV-TOOL2).
-- **אינטגרציית-חוקר** — `legal-researcher.md` ללא `search_digests`/`digest_link` ב-`tools:` וללא שלב-
-  radar. יעד: שלב סריקת-יומונים לפני האימות + סעיף-דוח נפרד "radar — לא ציטוט" (INV-DIG1).
-- **UI** — אין דף `/digests`. יעד: דף נפרד (לא כרטיסייה ב-`/precedents`, לשמור גבול סמכותי/משני),
-  אחרי `npm run api:types` ([X6-ui-api-contract.md](X6-ui-api-contract.md)).
-- **אוטומציית-קליטה (Gmail) + עלון-חודשי רב-נושאי** — שלב עתידי; שלב-1 ידני (drop ל-
-  `data/digests/incoming/` → `scripts/ingest_digests_batch.py`).
-
----
-
-## 7. הפניות-אחיות
-
-- [00-constitution.md](00-constitution.md) — G2 (אין מסלול מקביל), G4 (שלמות/אין-בליעה), G9 (עקיבוּת).
-- [03-retrieval.md](03-retrieval.md) — 3 קורפוסי-הציטוט שהיומון מובחן מהם (§3); הפרדת-קורפוס.
-- [01-ingest.md](01-ingest.md) — צינור-הפסיקה הקנוני שהיומון **אינו** עובר בו (INV-DIG2).
-- [02-data-model.md](02-data-model.md) — `case_law` (יעד-הקישור של `linked_case_law_id`).
-- [05-qa-review.md](05-qa-review.md) — שער-QA שדוחה ציטוט שמקורו digest (INV-DIG1).
-- [X4-agents.md](X4-agents.md) — סוכן החוקר שצורך את ה-radar.
-- [X9-mcp-tool-contract.md](X9-mcp-tool-contract.md) — חוזה כלי-ה-`digest_*`.

docs/spec/X13-court-fetch.md

@@ -1,180 +0,0 @@
-# X13 — אחזור-פסיקה אוטומטי מנט המשפט (Court Verdict Fetch)
-
-> כפוף ל-[חוקת המערכת](00-constitution.md). תת-מערכת **שירות** (לא קורפוס) שמורידה פסקי-דין
-> ציבוריים של בתי-משפט ומזרימה אותם ל**צינור-הקליטה הקנוני** של ספריית-הפסיקה. אחות-מושגית
-> ל-[X12 — Digests Radar](X12-digests-radar.md) (הטריגר העיקרי) ול-[01-ingest](01-ingest.md)
-> (היעד). אינה קורפוס רביעי ואינה מסלול-ingest מקביל.
-
----
-
-## 0. ייעוד והקשר
-
-יומון (digest) מצביע על פסק-דין נושא (`underlying_citation`, למשל `עת"מ 46111-12-22`). כשהפסק
-אינו בקורפוס, המערכת **מאחזרת אותו אוטומטית** ממקור ציבורי, מחלצת טקסט, וקולטת אותו דרך
-`precedent_library_upload` → `ingest_precedent`. כך הופך פסק-דין מ"מצוטט-בלבד" ל"שמיש לחיפוש
-וחילוץ-הלכות".
-
-**הבחנת-מקור קריטית:** רק **פסקי-דין של בתי-משפט** ניתנים לאחזור ציבורי. **החלטות ועדת-ערר**
-אינן זמינות ציבורית (נדרש נבו) — מסומנות כפער ולא נשלחות לאחזור.
-
-**דרכי-מקור ציבוריות (ניתוב לפי זמינות-פורמט-נט, לא לפי ערכאה):**
-- **נט המשפט** (מציג-התיקים) משרת **כל הערכאות** — מחוזי/שלום *וגם עליון* — כל עוד יש מספר
-  בפורמט תיק-חודש-שנה. ASP.NET WebForms (`__doPostBack`/VIEWSTATE), anti-bot של F5, מסמכים
-  בצופה-עמודים (turn.js). מחייב **דפדפן-אמת** (host-side) → שירות-מארח ב-pm2 (כדפוס
-  `legal-chat-service`). **זהו המסלול הראשי המאומת.**
-- **עליון בפורמט-סדרתי** (עע"מ/בג"ץ NNNN/YY, ללא חודש — לא ניתן לחיפוש בנט) → `supremedecisions.court.gov.il`
-  (httpx, ללא CAPTCHA, ללא דפדפן). **פוענח ואומת (2026-06-08):** `POST Home/SearchVerdicts` עם
-  `document` מובנה (`{Year:"YYYY", CaseNum, OldMainNumFormat:true, SearchText:[…]}`) + כותרת
-  **`X-Requested-With: XMLHttpRequest`** → רשומות; `GET Home/Download?path=&fileName=&type=4` → PDF.
-  בוחר מסמך best-first (פסק-דין→מספר-עמודים) ומדלג על מסמכי published-report החסומים (`s`-prefix).
-  תיקים ישנים-מאוד שלא דיגיטצו (למשל 389/87) → `manual`.
-
-> **אומת end-to-end (2026-06-07) על עת"מ 46111-12-22** — פס"ד 34 עמ' הורד **אוטונומית מלא,
-> נטו קוד-פתוח, ללא כרטיס-חכם וללא פתרון-CAPTCHA**. ממצאי-המפתח מהכיול:
-> - **החיפוש והניווט לתיק — ללא reCAPTCHA כלל.** מסלול: דף-בית → `btnExternalSearchCases`
->   → מילוי `BamaCaseNumberTextBoxH`(=מס' תיק) + `BamaMonthYearTextBoxHT`(="MM-YY") →
->   `CaseDetails.aspx` → לשונית "פסקי דין" → `DecisionList.aspx` → צופה `NGCSViewerPage.aspx`.
-> - **reCAPTCHA קיים רק בצופה ורק על שמירה/הדפסה מפורשת** — *לא* על הצגת המסמך. הצופה
->   מגיש את העמודים כ-PNG דרך PageMethod **`GetImages`** (4 עמ'/batch) **ללא CAPTCHA**.
->   אחזור = לכידת `documentNumber` מהקריאה הראשונה + משיכת כל ה-batches ב-`fetch` עם הכותרת
->   **`X-Requested-With: XMLHttpRequest`** (חובה — ה-WAF חוסם AJAX בלעדיה) → הרכבת PDF (Pillow).
-> - דפדפן: **Camoufox דרך חבילת-הפייתון** (`camoufox.async_api`, in-process — לא שרת-Node).
->   על שרת ללא-מסך נדרש **Xvfb** (אחרת Firefox קורס). פותר-ה-reCAPTCHA האודיו (Whisper) נשמר
->   כ-fallback למסלול-השמירה-המפורש בלבד; מסלול-התמונות אינו זקוק לו.
-
----
-
-## 1. ארכיטקטורה — שלוש שכבות (tiered)
-
-```
-underlying_citation → [classifier] → {tier, האם יש פורמט-נט (תיק-חודש-שנה)}
-  skip(ערר/בל"מ)        → missing_precedent (נבו ידני)              — לא אחזור
-  ── ניתוב לפי זמינות-פורמט-נט, לא לפי קידומת (נט המשפט משרת כל הערכאות) ──
-  פורמט-נט קיים (עמ"נ/עת"מ/עליון-בפורמט-נט כמו בר"מ 72182-06-25)
-       → Tier 1: legal-court-fetch-service (host/pm2 + Xvfb)        — אוטונומי, מאומת
-            → Camoufox(python) → external-search → CaseDetails → פסקי דין
-            → NGCSViewerPage → GetImages(X-Requested-With) → PNGs → PDF
-  עליון סדרתי-בלבד (בג"ץ/בר"מ NNNN/YY, בלי חודש)
-       → Tier 0: httpx → supremedecisions (SearchVerdicts+Download) — מפוענח ומאומת
-  כשל אוטונומי → Tier 2: missing_precedent + התראה (VNC עתידי)      — שער-אנושי
-  (כל ה-tiers)        → precedent_library_upload(source_type=court_ruling) → ingest_precedent
-                          → chunks+embeddings+halachot(pending) → relink digest / close gap
-```
-
-מצב-העבודה מנוהל בטבלת-תור `court_fetch_jobs` (idempotent, נצפה, retryable). הניקוז
-האוטומטי: `legal-court-fetch-drain` (pm2 cron שעתי) → `orchestrator.drain_pending`.
-
----
-
-## 2. Invariants
-
-### INV-CF1: מסלול-קליטה יחיד — אין ingest מקביל
-**כלל:** כל ה-tiers מתנקזים ל**צינור-הקליטה הקנוני היחיד** (`precedent_library_upload` →
-`ingest_precedent`). המאחזר מספק קובץ+מטא בלבד; אסור לו לכתוב `case_law`/`precedent_chunks`/
-`halachot` ישירות או לשכפל לוגיקת-chunking/embedding.
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G2](00-constitution.md#inv-g2) (מקור-אמת יחיד, אין מסלול מקביל) על תת-מערכת זו.
-**אכיפה:** האורקסטרטור קורא רק ל-API/שירות-הקליטה הקיים; ביקורת-ארכיטקטורה ב-PR.
-**הפרה ידועה:** —
-
-### INV-CF2: אין בליעה שקטה — כל אחזור נצפה
-**כלל:** לכל פסק-דין שזוהה לאחזור יש רשומת-job עם סטטוס סופי מפורש
-(`done`/`failed`/`manual`). כישלון-אחזור **לעולם אינו נבלע** — הוא מסומן ומועלה (Tier 2),
-לא נזרק בשקט. `except: pass` אסור.
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G4](00-constitution.md#inv-g4) וכלל-ההנדסה "אין בליעה שקטה" (§6).
-**אכיפה:** טבלת `court_fetch_jobs` (status+error+attempts) + לוג-warning בכל כישלון + Tier-2 gate.
-**הפרה ידועה:** ~~הפער ב-X12 — `try_autolink` שנכשל מחזיר `None` בשקט~~ → **תוקן**: `try_autolink` שנכשל על ציטוט פס"ד-בימ"ש מזניק job ל-`court_fetch_jobs` (status=pending); `court_fetch_drain` מנקז (סדרתי) ומקשר את היומון חזרה בהצלחה.
-
-### INV-CF3: אוטונומי-first, שער-אנושי חובה ב-fallback
-**כלל:** האחזור מנסה אוטונומית; אך כש-N נסיונות נכשלים, **שער-אנושי** (VNC לפתרון-CAPTCHA
-חי / סימון missing_precedent + התראה) הוא **חובה, לא רשות**. המערכת אינה "מוותרת" ואינה
-"מסתירה" — היא מסלימה לאדם.
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G10](00-constitution.md#inv-g10) (המערכת מסייעת; שערים אנושיים = invariant).
-**אכיפה:** מונה-נסיונות בטבלת-התור + מעבר אוטומטי ל-status=`manual` עם נתיב-פעולה ל-chaim.
-**הפרה ידועה:** —
-
-### INV-CF4: אחזור-אחראי (politeness) — סדרתי, מרווח, חתימה-אמיתית
-**כלל:** האחזור מאתר-ממשלתי הוא **אחראי**: סדרתי (לא מקבילי), עם cooldown בין בקשות,
-כיבוד-`robots`/תנאי-שימוש, ו-rate מתון. אסור flooding/parallel-hammering שעלול לחסום IP
-או להעמיס על שירות ציבורי.
-**מקורות:** RFC 9309 (*Robots Exclusion Protocol*, IETF 2022) · Google Search Central —
-*Crawler / crawl-rate guidance* · OWASP — *Automated Threat Handbook* (OAT-021 Denial of
-Service / responsible automation) | סטטוס: verified
-**אכיפה:** האורקסטרטור והשירות אוכפים serial + `INTER_FETCH_COOLDOWN_SEC`; Camoufox מספק
-חתימת-דפדפן אמיתית (לא spoof-חמדני). מראה לדפוס-התור ב-[`precedent_library.py`](../../mcp-server/src/legal_mcp/services/precedent_library.py).
-**הפרה ידועה:** —
-
-### INV-CF5: אחזור idempotent
-**כלל:** אחזור הוא **idempotent** — מפתח-job דטרמיניסטי לפי `case_number` מנורמל. אחזור
-חוזר של אותו תיק אינו יוצר job כפול ואינו קולט פסק-דין פעמיים (upsert על המפתח הקנוני).
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G3](00-constitution.md#inv-g3) (ingest idempotent) ו-[G1](00-constitution.md#inv-g1) (מזהה מנורמל בכתיבה).
-**אכיפה:** אילוץ-ייחודיות על `court_fetch_jobs.case_number_norm`; הקליטה עצמה idempotent דרך `ingest_precedent`.
-**הפרה ידועה:** —
-
-### INV-CF6: שער-סיווג מקור — רק פסקי-דין של בתי-משפט
-**כלל:** רק ציטוט שסווג כ**פסק-דין של בית-משפט** נשלח לאחזור. **ועדת-ערר (ערר/בל"מ) לעולם
-אינה נשלחת לאחזור-ציבורי** (נדרש נבו) — היא מסומנת `missing_precedent` בלבד. הפריט הנקלט
-נושא `source_type=court_ruling`, `source_kind=external_upload`, `precedent_level` לפי הערכאה.
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G5](00-constitution.md#inv-g5) (metadata מלא + הפרדת-קורפוס)
-ותואם את הבחנת-המקור ב-[01-ingest](01-ingest.md) (`court_ruling` מול `appeals_committee`).
-**אכיפה:** המסווג מחזיר `tier=skip` ל-ערר/בל"מ; הקליטה אוכפת `source_type`.
-**הפרה ידועה:** —
-
-### INV-CF7: עקיבוּת-מקור + גבול-ToS
-**כלל:** כל אחזור נושם **provenance** מלא (`source_url`, tier, זמן, מזהה-job) ב-audit-trail.
-האחזור מוגבל ל**מסמכים ציבוריים** הזמינים ללא הזדהות (smart-card); אופי המערכת הוא
-**הורדה-בסיוע** (עם שער-אנושי), לא בוט-סמוי לעקיפת בקרת-גישה.
-**מקור-סמכות:** פרויקטלי-תפעולי — מיישם את [G9](00-constitution.md#inv-g9) (עקיבוּת + audit-trail);
-גבול-ה-ToS מועלה ליו"ר (חיים) כשיקול-מדיניות (עיקרון-עבודה 4: המשתמש הוא הסמכות).
-**אכיפה:** `source_url`+tier נשמרים על `case_law`/`court_fetch_jobs`; שער-אנושי שומר על אופי בסיוע.
-**הפרה ידועה:** —
-
----
-
-## 3. מודל-נתונים — `court_fetch_jobs`
-
-| עמודה | טיפוס | תפקיד |
-|--------|-------|-------|
-| `id` | UUID PK | מזהה-job |
-| `case_number_norm` | TEXT UNIQUE | מפתח-idempotency קנוני (INV-CF5) |
-| `citation_raw` | TEXT | הציטוט המקורי כפי שזוהה |
-| `tier` | TEXT | `supreme` \| `admin` \| `skip` |
-| `court` | TEXT | ערכאה שזוהתה |
-| `status` | TEXT | `pending` \| `running` \| `done` \| `failed` \| `manual` |
-| `attempts` | INT | מונה-נסיונות (ל-Tier 2 gate, INV-CF3) |
-| `error` | TEXT | הודעת-כישלון אחרונה (INV-CF2) |
-| `case_law_id` | UUID FK | הפסק שנקלט (NULL עד done) |
-| `digest_id` | UUID FK | היומון-מקור (NULL לאד-הוק) |
-| `source_url` | TEXT | provenance (INV-CF7) |
-| `created_at` / `updated_at` | TIMESTAMPTZ | |
-
----
-
-## 4. רכיבי-מימוש (מיפוי לקוד)
-
-| רכיב | קובץ | מקור-תבנית / שימוש-חוזר |
-|------|------|------------------------|
-| מסווג | `mcp-server/.../services/court_citation.py` | regex מ-`citation_extractor.py:67-132` |
-| Tier 0 | `services/court_fetch_supreme.py` | httpx; דפוס-cooldown מ-`precedent_library.py:176-186` |
-| Tier 1 שירות | `mcp-server/.../court_fetch_service/server.py` | שכפול `chat_service/server.py` (aiohttp+Bearer+bind 10.0.1.1) |
-| Camoufox client | `court_fetch_service/camofox_client.py` | חיקוי `~/.hermes/.../browser_camofox.py` |
-| reCAPTCHA audio | `court_fetch_service/recaptcha_audio.py` | faster-whisper מקומי |
-| proxy בקונטיינר | `web/court_fetch_proxy.py` | שכפול `web/chat_proxy.py` |
-| pm2 | `scripts/legal-court-fetch-service.config.cjs` | שכפול `legal-chat-service.config.cjs` |
-| אורקסטרטור+תור | `services/court_fetch_orchestrator.py` + `db.py` (SCHEMA_Vxx) | דפוס-תור קיים |
-| כלי-MCP | `tools/court_fetch.py` (`court_verdict_fetch` / `court_fetch_status` / `court_fetch_drain`) | חוזה-envelope [X9](X9-mcp-tool-contract.md) |
-| טריגר אוטומטי | `services/digest_library.py` (`try_autolink` fail → `_enqueue_court_fetch`) → drain ע"י `orchestrator.drain_pending` | X12 |
-| סוד | `COURT_FETCH_SHARED_SECRET` (Infisical + Coolify) | דפוס `LEGAL_CHAT_SHARED_SECRET`, [X10](X10-deploy-env-secrets.md) |
-
----
-
-## 5. סיכונים (R&D — לעקוב)
-- reCAPTCHA נלחם פעיל בפותרי-אודיו → שיעור-כישלון אפשרי גבוה → Tier 2 הוא קו-ההגנה (INV-CF3).
-- F5/anti-bot עלול לחסום IP → politeness סדרתי + Camoufox (INV-CF4).
-- שבירות מול שינויי-אתר → ריכוז selectors במקום אחד + בדיקות-עשן תקופתיות.
-- גבול-ToS על אתר .gov → INV-CF7 + שיקול-יו"ר.
-- ~~**Tier-0 (supremedecisions) טרם מפוענח**~~ → **פוענח ומאומת (2026-06-08)** — עליון בפורמט-סדרתי
-  (בג"ץ/בר"מ NNNN/YY) יורד אוטומטית דרך `Home/SearchVerdicts`+`Home/Download`. מגבלה שנותרה: תיקים
-  ישנים-מאוד שלא דיגיטצו בפורטל (0 רשומות) → `manual`. גם `backfill_missing_precedents.py` מזין את
-  ה-`missing_precedents` הפתוחים (עליון+נט-format) לתור-האחזור.
-- **דליפת-זיכרון מדפדפנים יתומים** (fetch שנתקע/נהרג משאיר `camoufox-bin`) → שלוש שכבות-הגנה:
-  (א) `async with` סוגר את הדפדפן בכל exception; (ב) `asyncio.wait_for` קשיח (`COURT_FETCH_HARD_TIMEOUT_S`, ברירת-מחדל 180ש') מבטל hang + reap; (ג) reaper של `camoufox-bin` יתומים (`ppid=1`) לפני/אחרי כל fetch + דמון `legal-reaper` (pm2) + תקרת `max_memory_restart`. סדרתיות (INV-CF4) מבטיחה שכל דפדפן `ppid=1` הוא שארית בטוחה-להריגה. **הערה:** הדליפה הגדולה בפועל בשרת היא `task-master-mcp` (כלי נפרד), שגם אותו ה-reaper מנקה.

docs/spec/X14-storage-minio.md

@@ -1,146 +0,0 @@
-# X14 — אחסון-אובייקטים (Object Storage: MinIO / S3)
-
-קובץ-תחום זה כפוף ל-[חוקת המערכת](00-constitution.md) והוא ה-deep-dive על **אחסון קבצים בינאריים** —
-מסמכי-מקור, נגזרים, וייצוא — והגירתם ממערכת-קבצים מקומית (`data/`) ל-**MinIO** (object store תואם-S3).
-הוא מגדיר את חוזה-האחסון (שכבה יחידה), סכמת-הדליות-והמפתחות, מודל-האי-שינויוּת המשפטי, ותוכנית-ההגירה.
-
-> **invariant הנדסי + תפעולי-משפטי.** INV-STG1/2/5/6 נשענים על עקרונות מוכרים (S3 API, 12-Factor, presigned-URL,
-> separation blob↔metadata) — ≥3 מקורות (docs.min.io, AWS S3 spec, minio-py). INV-STG3/4/7 הם תפעוליים/משפטיים
-> של *מערכת זו* (גבול-ממשל, WORM להחלטות חתומות, git=טקסט) ונקשרים ל-[G2](00-constitution.md) (מסלול-אחסון יחיד).
-
----
-
-## 1. מצב קיים (מאומת מול הקוד וה-infra, 2026-06-08)
-
-### 1.1 מלאי-הדיסק (`data/`, ללא `backups/`)
-| קטגוריה | נפח | תוכן | סוג |
-|---|---|---|---|
-| `data/cases/{case}/` | 1.2GB | `documents/{originals,extracted,proofread,research,backup}`, `drafts/`, `exports/`, `thumbnails/{doc_uuid}/pNNN.jpg`, `.git` per-case | מקור + נגזר |
-| `data/digests/{reference,incoming}/` | 251MB | יומונים (X12) | מקור |
-| `data/training/{cmp,cmpa}/{raw,proofread}/` | 157MB | קורפוס-קול + `.git` | מקור |
-| `data/precedent-library/{appeals_committee,court_ruling,other}/` | 105MB | פסיקה + `thumbnails/` | מקור |
-| `data/internal-decisions/{region}/` | 45MB | החלטות-פנים לפי מחוז | מקור |
-| `data/exports/` | 216KB | legacy (הוחלף ב-per-case) | נגזר |
-| `data/{audit,eval,logs}/` | ~52MB | CSV/JSON תפעוליים — **לא מסמכים, נשארים בדיסק** | תפעולי |
-
-ספירה (ללא backups): ~9,449 קבצים — 2,473 JPG (thumbnails נגזרים), 883 PDF, 250 TXT (extracted), 155 DOCX, 54 DOC.
-
-### 1.2 הקונטיינר (Coolify)
-legal-ai (`gyjo0mtw2c42ej3xxvbz8zio`) רץ עם **bind-mounts**: host `data/`→`/data`, host `data/cases/`→`/cases`.
-האחסון היום = תיקייה על המארח, חשופה ישירות.
-
-### 1.3 MinIO — **כבר פרוס ובריא** ✅ (שירות Coolify `minio`, `bx2ykvw94xbutsex41hz4vv8`, 2026-06-08)
-- **API:** `https://s3.nautilus.marcusgroup.org` (9000) · **Console:** `https://minio.nautilus.marcusgroup.org` (9001)
-- **Credentials:** `SERVICE_USER_MINIO` / `SERVICE_PASSWORD_MINIO` (סודות מנוהלי-Coolify)
-- **אחסון:** named-volume `minio-data`→`/data` — **Single-Node Single-Drive**; versioning/object-lock **לא** מופעלים עדיין
-- **רשת:** רשת-Docker משלו (`bx2ykvw...`, external), **לא** משותפת ל-legal-ai → דרושה קישוריות (§4 שלב 0)
-
-### 1.4 הקוד — **אין שכבת-אחסון מרכזית** (כשל-השורש שהתחום מייבש)
-ה-I/O מפוזר על ~8 שירותים, נתיבים נבנים inline:
-- העלאה: `tools/documents.py:54` (originals), `:152` (training)
-- חילוץ + thumbnails: `services/processor.py:43,153`
-- staging פסיקה/יומונים/החלטות: `services/ingest.py:69`
-- ייצוא DOCX: `services/docx_exporter.py:462`
-- הגשה (FileResponse): `web/app.py` — 6 endpoints
-- git per-case: `services/git_sync.py` (`git add .` + push ל-Gitea, sweep כל 30ש׳)
-
-### 1.5 עמודות-DB המאחסנות נתיבים (schema inline ב-`db.py`, ללא migrations)
-`documents.file_path` · `cases.active_draft_path` · `case_law.source_document_path` · `digests.source_document_path`
-· `document_image_pages.image_thumbnail_path` · `precedent_image_pages.image_thumbnail_path` · `draft_final_pairs.final_path`
-
-### 1.6 Paperclip — צרכן-API בלבד
-הפלאגין ניגש דרך `listDocuments`/`getDocumentText` ל-API (`plugin-legal-ai/src/legal-api.ts:89`). אינו נוגע בדיסק →
-**הגירה שקופה אליו** כל עוד ה-API יציב.
-
----
-
-## 2. Invariants של התחום
-
-### INV-STG1: שכבת-אחסון יחידה — כל I/O דרך `storage.py`
-**כלל:** קיים מודול-אחסון **יחיד** (`services/storage.py`) שכל קריאה/כתיבה של קובץ בינארי עוברת דרכו
-(`put/get/presign_get/presign_put/delete/list`). אסור `open()`/`shutil.copy()`/`Path.write_bytes()` ישיר על
-נתיב-אחסון מחוץ למודול. **מקיים [G2](00-constitution.md)** — מבטל את ה-I/O המפוזר (§1.4) שהוא מסלול-מקביל-מתפצל.
-
-### INV-STG2: מפתח-אובייקט אטומי; שם עברי במטא בלבד
-**כלל:** מפתח-האובייקט הוא ASCII/UUID (`cases/{case}/originals/{uuid}.pdf`). שם-הקובץ העברי המקורי נשמר ב-DB
-(`*_filename`) וכ-`x-amz-meta-filename` + מוגש דרך `Content-Disposition` ב-presigned-GET. **למה:** תקציב-מפתח
-1024 bytes (255/segment), עברית=2B/תו, ובעיות percent-encoding/XML — נמנעות.
-
-### INV-STG3: דליות לפי גבול-ממשל, prefix לפי קטגוריה/תיק
-**כלל:** versioning/object-lock/replication הם per-bucket → מה שדורש ממשל שונה יושב בדלי נפרד. שלוש דליות
-קבועות (§3.1); תיקים/קטגוריות הם prefixes, **לא** דלי-לכל-תיק.
-
-### INV-STG4: "סופי" = WORM (Object-Lock COMPLIANCE)
-**כלל:** החלטה חתומה/סופית נכתבת לדלי `legal-immutable` עם Object-Lock **COMPLIANCE** + versioning — בלתי-ניתנת
-לשינוי/מחיקה ע"י איש (כולל root) עד תום-תקופת-השמירה. טיוטות חיות בדלי רגיל ו"מקודמות" (copy) לדלי-הסגור עם החתימה.
-**(הכרעת-יו"ר 2026-06-08: סופי בלבד; מסמכי-מקור — versioning ללא נעילה קשיחה.)**
-
-### INV-STG5: pgvector נשאר מקור-האמת לטקסט/embeddings; MinIO = blob בלבד
-**כלל:** טקסט-מחולץ + embeddings נשארים ב-Postgres/pgvector (מקור-אמת לאחזור). MinIO מאחסן את ה-blob המקורי
-(+עותק-ארכיון אופציונלי של ה-extracted text). **אסור** ש-MinIO יהיה מקור-אמת לוקטורים. תואם
-`no-reocr-retrofit` — לא מריצים OCR מחדש בהגירה.
-
-### INV-STG6: הגשה לדפדפן דרך presigned-URL — bytes לא דרך FastAPI
-**כלל:** הורדה/תצוגה/העלאה מהדפדפן עוברות ב-presigned-URL (TTL דקות) מול `s3.nautilus.marcusgroup.org`.
-ה-backend מנפיק את ה-URL בלבד; ה-bytes לא עוברים דרכו. endpoints קיימים שמחזירים FileResponse → 302→presigned.
-
-### INV-STG7: git-per-case שומר טקסט/מטא בלבד; בינאריים ב-MinIO
-**כלל:** `.git` per-case ממשיך לגרסן `case.json`/`notes.md`/`documents/extracted/*.txt`/`research/*.md`. PDF/DOCX/JPG
-מוחרגים מ-tracking (`.gitignore` per-case) ויושבים ב-MinIO. **(הכרעת-יו"ר 2026-06-08.)** `git_sync.py` ו-sweep
-מסתמכים על אותו working-tree → ההחרגה חייבת לקדום לכל קומיט-הגירה כדי לא לשבור היסטוריה.
-
----
-
-## 3. ארכיטקטורת-היעד
-
-### 3.1 דליות ומפתחות
-| דלי | Versioning | Object-Lock | prefixes |
-|---|---|---|---|
-| `legal-documents` | ✅ | ❌ | `cases/{case}/originals/{uuid}.pdf` · `cases/{case}/proofread/{uuid}.txt` · `precedent-library/{type}/{uuid}.pdf` · `internal-decisions/{region}/{uuid}.pdf` · `digests/{uuid}.pdf` · `training/{cmp\|cmpa}/{raw\|proofread}/{uuid}.pdf` |
-| `legal-immutable` | ✅ | ✅ COMPLIANCE | `decisions-final/{case}/{uuid}.docx` (החלטות חתומות בלבד) |
-| `legal-derived` | ❌ | ❌ (+lifecycle) | `thumbnails/{doc_uuid}/pNNN.jpg` · `extracted/{uuid}.txt` (נגזר, ניתן-לשחזור) |
-
-### 3.2 `services/storage.py` (לב ההגירה) — adapter כפול
-```
-put(category, key, data, content_type, meta) -> uri      # category→bucket+prefix
-get(uri) -> bytes
-presign_get(key, ttl) / presign_put(key, ttl) -> url
-delete(key) / list(prefix)
-```
-backend נבחר ב-env `STORAGE_BACKEND ∈ {filesystem, dual, s3}` (ברירת-מחדל filesystem) — מאפשר מעבר הדרגתי ללא
-שינוי-התנהגות. SDK: `aioboto3` (async-native מול `endpoint_url=http://minio:9000`); `minio-py` לסקריפטי-הגירה.
-
-### 3.3 שינויי-DB
-הוספת `*_object_key` (או נרמול ל-`storage_uri` עם סכמה `s3://`/`file://`) לצד העמודות הקיימות (§1.5); backfill;
-דה-קומיישן הנתיב-קובץ. תוספת inline ב-`db.py` בסגנון הקיים (אין migrations).
-
----
-
-## 4. תוכנית-ביצוע בשלבים (→ TaskMaster, tag legal-ai)
-
-| שלב | תוכן | תלות |
-|---|---|---|
-| **0 — תשתית** | חיבור רשת-Docker (minio↔legal-ai); הזרקת credentials ל-env legal-ai (Coolify); `mc alias`; יצירת 3 דליות + הפעלת versioning + Object-Lock (immutable); הוספת `aioboto3` ל-deps | — |
-| **1 — שכבת-אחסון** | `services/storage.py` + adapter כפול (default filesystem). אפס שינוי-התנהגות. PR מצהיר INV-STG1/2/3 | 0 |
-| **2 — חיווט-כתיבה** | הפניית כל נקודות-הכתיבה (§1.4) דרך `storage.py`; כתיבה-כפולה (`STORAGE_BACKEND=dual`) | 1 |
-| **3 — הגירת-נתונים** | `mc mirror --dry-run`→`--overwrite` של 5 הקטגוריות; backfill `*_object_key` ב-DB; אימות count+checksum | 0,2 |
-| **4 — חיווט-קריאה + presigned** | endpoints→302→presigned; thumbnails דרך presigned; dual-read (S3, fallback disk); החרגת בינאריים מ-git per-case (INV-STG7) | 2,3 |
-| **5 — cutover** | `STORAGE_BACKEND=s3`; `mc mirror --watch` עד החלפה; אימות מלא; כיבוי כתיבה-לדיסק | 4 |
-| **6 — git + גיבוי + ניקוי** | קידום-החלטות-סופיות ל-immutable (INV-STG4); `mc mirror`/bucket-replication מתוזמן off-site; דה-קומיישן bind-mount `data/` (השארת audit/eval/logs) | 5 |
-
----
-
-## 5. סיכונים
-- **I/O מפוזר** → INV-STG1 (`storage.py`) חובה לפני כל שאר השלבים, אחרת drift והפרת-G2.
-- **שמות עבריים כמפתחות** → INV-STG2 (UUID-keys + מטא).
-- **רשת נפרדת ל-MinIO** → לאמת קישוריות בשלב 0 לפני הכל.
-- **git-per-case** מצמיד בינאריים ל-Gitea → INV-STG7, ההחרגה חייבת לקדום לכל קומיט.
-- **SNSD ללא erasure-coding** → גיבוי off-site (שלב 6) הוא חובה, לא nice-to-have.
-- **בידוד-worktree + ספ-first** → כל PR מצהיר invariants (G2 + INV-STG*).
-
----
-
-## 6. קישורים
-- חוקה: [00-constitution.md](00-constitution.md) · נתונים: [02-data-model.md](02-data-model.md) · קליטה: [01-ingest.md](01-ingest.md)
-- deploy/env: [X10-deploy-env-secrets.md](X10-deploy-env-secrets.md) · אינטגרציה: [X3-integration-deploy.md](X3-integration-deploy.md)
-- מקורות-MinIO: docs.min.io (community), AWS S3 object-keys/bucket-naming/presigned-URL, github.com/minio/minio-py

docs/spec/X15-agent-platform-port.md

@@ -1,148 +0,0 @@
-# X15 — שער-הפלטפורמה (Agent Platform Port)
-
-> כפוף ל-[00-constitution.md](00-constitution.md). מיישם ומחזק את **INV-G2** (מקור-אמת
-> יחיד — אין מסלולים מקבילים) ברובד הקַשירה (coupling) בין שכבת-האינטליגנציה לפלטפורמת-הסוכנים.
-
-## 0. למה המסמך הזה קיים
-
-פלטפורמת-הסוכנים שלנו היום היא **Paperclip**. היא אינה ליבת-המערכת — היא ה**מעטפת**
-(לוח-issues, סוכנים מתמידים, human-in-the-loop דרך comments, wakeup/heartbeat, תזמון,
-תקציבים per-agent, adapters). ליבת-האינטליגנציה — `mcp-server/src`, ה-skills של
-ההחלטה/הסגנון, ולוגיקת-ההחלטה — היא הנכס שאינו תלוי-פלטפורמה.
-
-**כשל-השורש שהמסמך מייבש:** מגע עם Paperclip שדולף לתוך שכבת-האינטליגנציה הופך את
-המעטפת מ"רכיב ניתן-להחלפה מאחורי חוזה" ל"תלות-רוחב ארוגה בכל הקוד". ככל שהדליפה גדלה,
-"החלפת המעטפת" (או אפילו שדרוג גרסה — ראו ההצמדה ל-opus-4-8) הופכת מ**החלפת-רכיב**
-ל**כתיבה-מחדש**. זוהי הופעה נוספת של כשל-השורש שכל הספ בא לייבש: מסלולים מקבילים
-שמתפצלים (drift), הפעם בציר התלות בין שכבות.
-
-הבסיס התאורטי: **Ports & Adapters / Hexagonal Architecture** (Alistair Cockburn),
-**The Dependency Rule / Clean Architecture** (Robert C. Martin), **Anti-Corruption
-Layer** (Eric Evans, DDD). כולם אומרים את אותו הדבר: התלות זורמת פנימה בלבד; הליבה
-אינה יודעת על העולם החיצון; כל מגע עם מערכת-חוץ עובר דרך שכבת-תרגום אחת (port/adapter).
-
----
-
-## 1. השכבות והתפר
-
-```
-┌────────────────────────────────────────────────────────────────────┐
-│  INTELLIGENCE  (תלוי-פלטפורמה = אסור)                                │
-│  mcp-server/src · skills/decision · skills/style · decision logic    │
-│  · style-acquisition                                                 │
-│  ── חייב להכיל אפס סמלים ספציפיים-Paperclip ──                       │
-└───────────────────────────────┬────────────────────────────────────┘
-                                 │   ה-PORT (שכבת-התרגום היחידה)
-                                 │   • web/agent_platform_port.py  (Python)
-                                 │   • .claude/agents/HEARTBEAT.md (פרומפטים)
-┌───────────────────────────────┴────────────────────────────────────┐
-│  SHELL  (Paperclip-specific — מותר ומוצהר)                           │
-│  web/paperclip_client.py · web/paperclip_api.py · plugin-legal-ai    │
-│  · adapters/* · web-ui settings/paperclip-tab · skills/new-company   │
-└───────────────────────────────┬────────────────────────────────────┘
-                                 │
-                           ┌─────┴─────┐
-                           │ Paperclip │  ← הפלטפורמה. ניתנת-להחלפה.
-                           └───────────┘
-```
-
-**הגדרת-ה-Port:** קבוצת-הקבצים היחידה שמורשית לדבר Paperclip:
-
-| Port surface | תפקיד | מורשה לייבא/להזכיר Paperclip |
-|--------------|-------|------------------------------|
-| `web/agent_platform_port.py` *(לבנייה — R2)* | תרגום אירועי-דומיין → קריאות-פלטפורמה | כן — המודול היחיד שמייבא `paperclip_client`/`paperclip_api` |
-| `web/paperclip_client.py`, `web/paperclip_api.py` | מימוש-הלקוח (מאחורי ה-Port) | כן (זו המעטפת המתוכננת) |
-| `.claude/agents/HEARTBEAT.md` | מקור-אמת יחיד לפרוטוקול-הריצה של הסוכנים | כן |
-| `plugin-legal-ai/*`, `adapters/*` | הגשר מצד-Paperclip | כן |
-| `web-ui` settings/paperclip-tab, agents-tab | UI לניהול-Paperclip עצמו | כן (מוצהר) |
-| `skills/new-company-setup/SKILL.md` | blueprint-הקמה (חייב לדבר Paperclip) | כן — **חריג מוצהר** |
-
-כל קובץ אחר — בפרט תחת `mcp-server/src`, `skills/decision`, `skills/style`,
-ופרומפטי-הסוכנים פרט ל-HEARTBEAT — **אסור** שיכיל סמל ספציפי-Paperclip.
-
----
-
-## 2. ה-invariant
-
-### INV-PORT1 (גלובלי: G12) — שער-הפלטפורמה
-**כלל:** פלטפורמת-הסוכנים (Paperclip) נגישה אך-ורק דרך ה-Platform Port
-(`web/agent_platform_port.py` + `HEARTBEAT.md` לפרומפטים). שכבת-האינטליגנציה —
-`mcp-server/src`, וה-skills של ההחלטה/הסגנון — מכילה **אפס** סמלים ספציפיים-לפלטפורמה
-(שמות-מוצר, wakeup/heartbeat, pc.sh/pc_request, X-Paperclip-Run-Id, enums של הפלטפורמה).
-פרומפטי-הסוכנים אינם משכפלים את פרוטוקול-הריצה — הם מצביעים ל-HEARTBEAT.md בלבד. כל מגע
-חדש עם הפלטפורמה עובר דרך ה-Port.
-**מקורות:** Alistair Cockburn, *Hexagonal Architecture (Ports & Adapters)* · Robert C.
-Martin, *Clean Architecture* (The Dependency Rule) · Eric Evans, *Domain-Driven Design*
-(Anti-Corruption Layer) | סטטוס: verified
-**אכיפה:** (א) ביקורת-ארכיטקטורה + רשימת-ה-Port (§1); (ב) leak-guard אוטומטי — הרחבת
-[scripts/spec-guard.sh](../../scripts/spec-guard.sh) שמשווה מול baseline-הדליפה (§4) ומזהיר
-על דליפה חדשה ב-Edit/Write; (ג) fitness-test ב-CI שנכשל על מונח-Paperclip קשיח חדש תחת
-`mcp-server/src`; (ד) הצהרת-G12 בתבנית-ה-PR.
-**הפרה ידועה:** ראו מצאי-הדליפה ב-§3 — `web/app.py` קורא ל-`pc_*` inline בלוגיקת
-מחזור-חיים של תיקים; 10 פרומפטי-סוכנים משכפלים את פרוטוקול-הריצה במקום להצביע ל-HEARTBEAT.
-
-> **סיווג:** invariant הנדסי (≥3 מקורות חיצוניים, verified). מורחב מ-G1–G10 בתור **G12**,
-> ורשום ברשימת-הגלובליים ובאינדקס של [00-constitution.md](00-constitution.md) §5א (R0b הושלם).
-
----
-
-## 3. מצאי-הדליפה (baseline — נמדד 2026-06-09)
-
-מבחן-נטישה: כמה השכבות חוצות את התפר. הספירה היא בסיס-ההשוואה ל-leak-guard.
-
-| Layer | Paperclip hits | סיווג | מחיר-ניתוק |
-|-------|----------------|-------|------------|
-| `mcp-server/src` (כלים) | 5 — **הערות בלבד** | ✅ נקי (זה הנכס) | ~0 |
-| `skills/` (decision/style) | 36 — רק `new-company-setup` | ✅ נקי (חריג מוצהר) | נמוך |
-| `web/paperclip_client.py` | 116 | ✅ מעטפת מתוכננת | — |
-| `web/paperclip_api.py` | 33 | ✅ מעטפת מתוכננת | — |
-| `web/app.py` | ~33 קריאות `pc_*` + `PAPERCLIP_COMPANIES`×72 | ⚠️ דליפה מבנית (מחזור-חיים) | בינוני |
-| `.claude/agents/*.md` | 288 — פרוטוקול משוכפל ב-10 פרומפטים | ⚠️⚠️ דליפה מכנית | גבוה (בנפח) |
-| `web-ui` (`types.ts`×41, `cases.ts`, `sse.ts`, ...) | ~60 | ⚠️ מושגי-פלטפורמה בחוזי-פרונט | בינוני |
-
-**הממצא המרכזי:** שכבת-האינטליגנציה (`mcp-server/src` + skills של ההחלטה/הסגנון) כבר
-נקייה כמעט-לחלוטין — 5 ההיטים ב-mcp-server הם הערות בלבד (מקור `company_id`). מחיר-הגירושין
-בינוני, מרוכז בשלוש שכבות-נושקות-למעטפת.
-
----
-
-## 4. מפת-התיקון (R-tasks)
-
-| R | תחום | תיאור | סיכון |
-|---|------|-------|-------|
-| **R0** | ספ | המסמך הזה — מגדיר את ה-Port, ה-invariant, ו-baseline-הדליפה | 0 |
-| **R0b** | ספ | רישום G12 ב-[00-constitution.md](00-constitution.md) (רשימת-גלובליים + אינדקס) + שורת G12 בתבנית-ה-PR + מצביע ב-CLAUDE.md | 0 |
-| **R1** | פרומפטים | כל פרוטוקול-הריצה עובר ל-HEARTBEAT.md (מקור יחיד); 10 הפרומפטים מצביעים אליו בלבד. 288→~20 היטים | נמוך |
-| **R2** | web | יצירת `web/agent_platform_port.py` — המודול היחיד שמייבא `paperclip_client`/`paperclip_api`. `app.py` פולט אירוע-דומיין (`case_archived`/`created`/...) שה-Port מתרגם. `PAPERCLIP_COMPANIES`→`company_map` מאחורי ה-Port | בינוני |
-| **R3** | web-ui | `types.ts` → namespace `paperclip.*` נפרד; חוזי case/api כלליים נשארים נקיים. טאבי-ניהול-Paperclip נשארים (מעטפת מוצהרת) | נמוך-בינוני |
-| **R4** | אכיפה | הרחבת `spec-guard.sh` ל-leak-guard מול ה-baseline + fitness-test ב-CI על `mcp-server/src` | 0 |
-
-**עיקרון-מנחה (G2):** R1+R2 הם G2 בלבוש חדש — מאחדים פרוטוקול/מסלול משוכפל למקור אחד.
-הם אינם יוצרים מסלול מקביל; הם מסירים אחד.
-
----
-
-## 5. מנגנון נגד דליפה-עתידית
-
-תיקון חד-פעמי חסר-ערך אם הדליפה תחזור בפיצ'ר הבא. שלוש שכבות-אכיפה, כולן מתחברות
-למנגנונים קיימים (ולא ממציאות מסלול חדש):
-
-1. **invariant (G12)** — מוגדר כאן, נרשם בחוקה (R0b). first-class, לא הערת-שוליים.
-2. **אכיפה-אוטומטית** — `spec-guard.sh` כבר מיירט כל Edit/Write בנתיב-קוד; ה-leak-guard
-   (R4) משווה מול baseline §3 ומזהיר על דליפה חדשה **בזמן-אמת**, לפני ה-review.
-3. **חוזה-תיעוד** — תבנית-ה-PR כבר דורשת הצהרת-invariants; נוסיף שורת-G12 לצ'קליסט
-   ("□ לא הוספתי מגע-Paperclip מחוץ ל-Platform Port"). CLAUDE.md §Paperclip + §פרוטוקול
-   כתיבת-קוד מצביעים לכאן.
-
-> **כלל-זהב לכל פיתוח עתידי:** פיצ'ר חדש שנוגע בפלטפורמה — מוסיף/משנה **רק** קוד תחת
-> רשימת-ה-Port (§1). אם נדרש מגע-פלטפורמה משכבת-האינטליגנציה — זו אינדיקציה לתכנון
-> שגוי: הוסיפו במקום זאת אירוע-דומיין שה-Port יתרגם.
-
----
-
-## 6. ראו גם
-- [00-constitution.md](00-constitution.md) — G2 (שאותו מיישם), G12 (לאחר R0b).
-- [X7-paperclip-client-params.md](X7-paperclip-client-params.md) — פרמטרי לקוח-Paperclip (מתחת ל-Port).
-- [X4-agents.md](X4-agents.md) — מפת-הסוכנים.
-- [X3-integration-deploy.md](X3-integration-deploy.md) — אינטגרציה+deploy.
-- [X16-pipeline-durability.md](X16-pipeline-durability.md) — עמידות-פייפליין (החלטה נפרדת, נושקת).

docs/spec/X16-pipeline-durability.md

@@ -1,96 +0,0 @@
-# X16 — עמידות-פייפליין (Durable Pipeline Execution)
-
-> כפוף ל-[00-constitution.md](00-constitution.md). מחזק את **INV-G3** (idempotency)
-> ב-checkpointing+replay לפייפליינים הדטרמיניסטיים המקומיים. נושק ל-[07-learning.md](07-learning.md)
-> ו-[X11-citation-corroboration.md](X11-citation-corroboration.md).
-
-## 0. הבעיה
-
-שני הפייפליינים המקומיים החד-פעמיים —
-[final_halacha_pipeline.py](../../scripts/final_halacha_pipeline.py) (כפתור run-halacha,
-אימות-הלכות, X11) ו-[final_learning_pipeline.py](../../scripts/final_learning_pipeline.py)
-(כפתור run-learning, למידת-סגנון, 07-learning) — חולקים **צורה זהה**: סקריפט מקומי,
-3–4 שלבים בטור, idempotent, פאנל-LLM ארוך בסוף (CSV-gated, "can take minutes").
-
-היום הם **ליניאריים וחסרי-זיכרון**: קריסה באמצע (ניתוק ל-DeepSeek/Gemini, restart של
-קונטיינר, OOM) → הרצה-מחדש מ-שלב 0. השלבים idempotent ולכן זה **בטוח**, אבל **משלמים שוב**:
-מחלצים, בונים corroboration על כל הקורפוס, ושופטים מחדש הלכות שכבר נשפטו — דקות וקריאות-LLM
-לפח.
-
-**הקשר-סיכון אמיתי:** דליפת task-master (יתומים ppid=1, ~3GB) מסכנת OOM ל-Postgres
-([project_taskmaster_mcp_memory_leak]). אם OOM הורג ריצת-פאנל ארוכה — היום מתחילים מאפס.
-
-**הבחנה מ-idempotency:** idempotency = "בטוח להריץ שוב". durable execution = "בטוח להריץ
-שוב **בלי לשלם שוב**". זה שכלול, לא תחליף.
-
-## 1. ההכרעה
-
-להטמיע **LangGraph כספרייה בתוך הסקריפט** (לא כפלטפורמה מחליפה ל-Paperclip): מנוע-העמידות
-היחיד שהוא state-of-the-art ב-checkpointing+replay+time-travel, בשימוש כ-`import` בתוך
-הסקריפט המקומי. Paperclip לא מושפע — הכפתור עדיין מעיר את Hermes שמריץ את אותו ה-CLI.
-
-> **גבול-תחום מפורש (מתחבר ל-G12/X15):** LangGraph נכנס **רק** כמנוע-פנימי של הסקריפטים
-> המקומיים. אסור להשתמש בו כתחליף-פלטפורמה או כ-orchestrator של הסוכנים — זה ייצור מסלול
-> מקביל ל-Paperclip (הפרת G2) ויערבב עמידות עם פלטפורמה. HITL/ניתוב-יו"ר נשאר מאחורי
-> ה-Port (ראו §4 Phase 3).
-
-**מקורות:** Temporal — *Durable Execution* · Saga / workflow-checkpointing pattern ·
-Martin Kleppmann, *DDIA* (idempotence & exactly-once) · LangGraph checkpointer/replay docs.
-
-## 2. ה-invariant
-
-### INV-DUR1 — עמידות לפייפליינים דטרמיניסטיים
-**כלל:** פייפליין דטרמיניסטי רב-שלבי משמר את התקדמותו ב-checkpoint מתמיד אחרי כל שלב
-שהושלם; הרצה-חוזרת של אותה יחידת-עבודה **מדלגת** על שלבים שכבר הושלמו ומתחילה מנקודת-הכשל
-המדויקת. מימוש-העמידות הוא **משותף** לכל הפייפליינים (`scripts/_pipeline_runtime.py`) —
-לא מימוש-לכל-סקריפט (G2). חוזה-הכניסה (ה-CLI) נשמר ללא-שינוי.
-**מקורות:** Temporal (Durable Execution) · Kleppmann *DDIA* (exactly-once) · Saga pattern
-(workflow checkpointing) | סטטוס: verified
-**אכיפה:** `_pipeline_runtime.py` עם LangGraph + checkpointer; thread_id דטרמיניסטי
-לכל יחידת-עבודה (תיק); בדיקת kill-and-resume שמאמתת ששלבים שהושלמו אינם רצים-מחדש.
-**הפרה ידועה:** היום `final_halacha_pipeline.py` / `final_learning_pipeline.py` ליניאריים
-— קריסה = הרצה-מחדש מלאה (חוזרים על extract/corroboration/panel).
-
-## 3. ארכיטקטורה
-
-```
-scripts/_pipeline_runtime.py   ← מודול-עמידות משותף יחיד (G2)
-  • build_graph(steps)          StateGraph: node לכל שלב
-  • SqliteSaver                 data/checkpoints/<pipeline>.sqlite  (לא Postgres המשותף)
-  • run(thread_id, resume)      מדלג-אוטומטית על nodes ב-checkpoint
-```
-
-**הכרעות-תכנון:**
-
-1. **Checkpointer = SQLite (`langgraph-checkpoint-sqlite`), לא Postgres.** קובץ תחת
-   `data/checkpoints/`: מקומי (תואם "local-only"), פשוט, ו**נמנע מהאזהרה** ב-CLAUDE.md נגד
-   migrations מ-2 worktrees על Postgres המשותף (`localhost:5433`). PostgresSaver = אופציה
-   עתידית אם נדרש ריכוז/observability.
-2. **`thread_id = f"<pipeline>:{case_number}"`.** הרצה-חוזרת של אותו תיק מזהה checkpoint
-   לא-גמור וממשיכה אוטומטית; תיק שהושלם = no-op. idempotency + דילוג-checkpoint מתחברים.
-3. **גרעיניות (מדורגת):**
-   - **גס (P0/P1):** כל שלב = node. קריסה בין-שלבים → המשך מהשלב שנפל. הפאנל node יחיד
-     שרץ-מחדש — אך הוא כבר CSV-backed + idempotent (מדלג פנימית על מה שנשפט).
-   - **עדין (P2, אופציונלי):** פירוק הפאנל ל-map מעל ההלכות/הלקחים (LangGraph `Send`),
-     כל פריט = יחידת-checkpoint → resume תוך-פאנל בלי לשפוט מחדש ברמת-LLM. נשען על ה-CSV
-     הקיים כמקור "כבר-נשפט".
-4. **סמנטיקת-כשל מפורשת.** היום הכל "non-fatal, continue". עם LangGraph: nodes "מייעצים"
-   (extract, corroboration) — catch+record-status וממשיכים; node "קריטי" (panel) — raise
-   בכשל-קשה → עצירה ב-checkpoint → resume.
-5. **שימור-חוזה-הכניסה.** ה-CLI (`--case`/`--limit`/`--dry-run`) זהה; run-halacha/run-learning
-   → Hermes → אותו `python ...pipeline.py --case X` לא משתנה. מוסיפים `--fresh`
-   (ברירת-מחדל: auto-resume אם יש checkpoint לא-גמור לתיק).
-
-## 4. גלגול מדורג
-
-| Phase | תחום | מאמץ |
-|-------|------|------|
-| **P0** | deps ל-`mcp-server/pyproject` (`langgraph` + `langgraph-checkpoint-sqlite`, venv מקומי בלבד → אפס השפעת-קונטיינר). `_pipeline_runtime.py` עם SqliteSaver. עטיפת 4 שלבי-halacha כ-nodes (גס). CLI זהה. test: kill אחרי [1] → resume → assert [0],[1] לא רצו שוב | ~1 יום |
-| **P1** | אותו runtime על `final_learning_pipeline` (3 שלבים) — מימוש-עמידות אחד לשניהם (G2) | חצי יום |
-| **P2** | (אופציונלי) פירוק-פאנל ל-map per-item — resume תוך-פאנל | 1–2 ימים |
-| **P3** | (עתידי) LangGraph `interrupt()` ל-HITL של היו"ר (split→chair, INV-G10) — **רק מאחורי ה-Port** (X15/G12) | — |
-
-## 5. ראו גם
-- [07-learning.md](07-learning.md) · [X11-citation-corroboration.md](X11-citation-corroboration.md)
-- [X15-agent-platform-port.md](X15-agent-platform-port.md) — הגבול מול הפלטפורמה (G12).
-- [scripts/SCRIPTS.md](../../scripts/SCRIPTS.md) — הסקריפטים המושפעים.

docs/spec/X17-information-architecture.md

@@ -1,78 +0,0 @@
-# X17 — ארכיטקטורת-המידע ומשטח-ההפעלה (Information Architecture)
-
-> **מה זה.** ספ-היעד ל**איך** משטח-ההפעלה (דפים/טאבים/תורים/ניווט/cache) צריך להיות מאורגן — שכבה מעל [X6 (חוזה UI↔API)](X6-ui-api-contract.md). X6 קובע ש**טיפוס** נכון (OpenAPI=SSoT, provenance); X17 קובע ש**משטח** נכון (מקור-אמת יחיד לכל datum, שער אחד לכל החלטה, ניווט מבוסס-משימה).
->
-> **למה.** חיים (2026-06-11): *"המערכת מסובכת מדי לתפעול."* האבחון ([`../ia-audit-redesign.md`](../ia-audit-redesign.md), #127) אימת 37 ממצאים שכולם ביטוי-UI של **G2** מופר שלא הורחב לשכבת-ה-UI. X17 מרים את G2 (מקור-אמת יחיד) ו-G10 (שערים-אנושיים) לשכבת-המשטח, ומקודד את [[feedback_operational_simplicity]] (שער/מקום/ערוץ אחד) כ-invariants אכיפים.
->
-> **גבול קשיח (G10):** X17 מסיר משטחים/ערוצים **כפולים**, לעולם לא **שער**. כל שער-אנושי (אישור-הלכה, פתרון-הערה, אישור-לקח, בחירת-תוצאה) נשאר חובה ומפורש. "שער אחד" = מקום-אחד-להחליט, לא אפס-החלטה.
-
----
-
-## INV-IA1 — בעלים-משטח-יחיד לכל datum/מונה (G2 בשכבת-UI)
-ל-aggregate/מונה נגזר-שרת יש **משטח-בעלים יחיד** שמריץ את השאילתה; משטחים אחרים **מצביעים** אליו (deep-link/pointer), ולעולם לא מריצים מונה-מתחרה client-side. *(אכיפה: מונה-הגייטים חי רק ב-`/approvals`+`['chair','pending']`; `/operations` מצביע. תופס APR-2/3, ADM-2/3.)*
-- Maintain Consistency and Adhere to Standards (Heuristic #4) — Nielsen Norman Group — https://www.nngroup.com/articles/consistency-and-standards/
-- 3 Common IA Mistakes (Low Information Scent) — Nielsen Norman Group — https://www.nngroup.com/articles/3-ia-mistakes/
-- Information Architecture: For the Web and Beyond, 4th ed. (Organization & Labeling Systems) — Rosenfeld, Morville & Arango (O'Reilly) — https://www.oreilly.com/library/view/information-architecture-4th/9781491913529/
-
-## INV-IA2 — mutation מבטל כל קורא (no stale cross-surface state)
-כל mutation שמשנה ערך הנקרא במשטח אחר **חייב לבטל כל queryKey שקורא אותו** — כולל aggregators חוצי-namespace. אסור שמשטח יציג ערך תקוע אחרי שינוי במשטח אחר. *(תופס את 16 פערי-הסנכרון: CAS-1/2, APR-1/4/5/6, LRN-6/8/10, MET-1/8, ADM-2/3/5.)*
-- Query Invalidation — TanStack Query (official docs) — https://tanstack.com/query/latest/docs/framework/react/guides/query-invalidation
-- Deriving Client State from Server State — TkDodo (Dominik Dorfmeister, TanStack maintainer) — https://tkdodo.eu/blog/deriving-client-state-from-server-state
-- Visibility of System Status (Heuristic #1) — Nielsen Norman Group — https://www.nngroup.com/articles/visibility-system-status/
-
-## INV-IA3 — שער-אחד / ערוץ-אחד לכל החלטה (G10/INV-LRN1 נשמרים)
-לכל החלטה-אנושית **משטח-יחיד ומסלול-כתיבה-יחיד**. אסור משטח-אישור שני או כותב-מקביל לאותה שורה. הלמידה **מנותבת דרך** העורך הקנוני, לא כותבת-במקביל. *(תופס LRN-1/2/3, MET-2/3 — "שני השערים" של חיים, ומירוץ ה-lost-update.)*
-- Preventing User Errors / Error Prevention (Heuristic #5) — Nielsen Norman Group — https://www.nngroup.com/articles/slips/
-- Do the hard work to make it simple (Government Design Principles) — GOV.UK / GDS — https://www.gov.uk/guidance/government-design-principles
-- Don't Make Me Think, Ch.5 — Omit Needless Words/Controls — Steve Krug (O'Reilly) — https://www.oreilly.com/library/view/dont-make-me/0321344758/ch05.html
-
-## INV-IA4 — ניווט מבוסס-משימה, לא מבוסס-פורמט
-משטחים מאורגנים לפי **מה המשתמש עושה** (לאשר / לנטר / להגדיר / לחבר), לא לפי מקור-הנתונים הטכני (pm2 מול DB מול תורים). דלת-כניסה אחת לכל משימה. *(אכיפה: `/operations`⊇`/diagnostics` — אותו intent-ניטור; הורדת `/feedback` מהראשי. תופס D5, ADM.)*
-- Avoid Format-Based Primary Navigation — Nielsen Norman Group — https://www.nngroup.com/articles/format-based-navigation/
-- Intranet IA Methods (task-based endures over structure-based) — Nielsen Norman Group — https://www.nngroup.com/articles/intranet-ia-methods/
-- Task list pattern (one list of outstanding tasks per service) — GOV.UK Design System — https://design-system.service.gov.uk/components/task-list/
-
-## INV-IA5 — סטטוס-אמיתי מגובה-צרכן
-כל מספר מוצג ממופה ל**צרכן אמיתי** ו**מקור שלם**. אסור KPI שסופר דגל-ללא-צרכן; אסור aggregate מדויק כש-partial-failure השמיט תורם (להציג חלקיות); שדה ב-response — **לרנדר או להסיר**. *(תופס LRN-1/4/5, ADM-1/6, APR-3.)*
-- Visibility of System Status (Heuristic #1) — Nielsen Norman Group — https://www.nngroup.com/articles/visibility-system-status/
-- Design with data (Government Design Principles) — GOV.UK / GDS — https://www.gov.uk/guidance/government-design-principles
-- Minimize Cognitive Load to Maximize Usability — Nielsen Norman Group — https://www.nngroup.com/articles/minimize-cognitive-load/
-
-## INV-IA6 — שפת-מפעיל מובנת-מאליה (no jargon; precedence in-context)
-קופי פונה-למפעיל מתאר את **האפקט המשמעותי**, לא מזהי-משימות פנימיים (T7/T15). התנהגות-תחולה/קדימות (universal מוקדם; checklist→appeal_type) מוצגת **בהקשר** דרך progressive disclosure, לא במסמך נפרד. *(תופס MET-4/5/6/7.)*
-- Don't Make Me Think — Krug's First Law (self-evident) — Steve Krug — https://www.oreilly.com/library/view/dont-make-me/0789723107/ch02.html
-- Plain language / write for users (Design principles) — U.S. Web Design System (USWDS) — https://designsystem.digital.gov/design-principles/
-- Progressive Disclosure — Nielsen Norman Group — https://www.nngroup.com/articles/progressive-disclosure/
-
----
-
-## משטח-היעד (Target IA)
-
-### שלושה משטחי-intent ברמת-העל
-| משטח | intent | בעלים | כלל |
-|------|--------|-------|-----|
-| **`/approvals`** | **לאשר** (החלטה-אנושית) | תיבת-הגייטים הקנונית | המקום **היחיד** שפועלים על שער. כרטיס לכל סוג (הלכות/פסיקה-חסרה/הערות/QA) עם מונה+קישור. |
-| **`/operations`** | **לנטר** (קריאה-בלבד) | משטח-המכונה | בולע את `/diagnostics`. שירותים+תורים+סוכנים+בריאות+`halacha_backlog`. **אפס** שער נפעל כאן; מצביע ל-`/approvals`. |
-| **`/settings`** | **להגדיר** | משטח-התצורה | Paperclip/סוכנים/env/כלים/בלוקים. עריכת-env משלימה-את-עצמה (staleness+redeploy באותה שורה). |
-
-### משטחי-תחום (בעלים-יחיד לכל ישות)
-| תחום | יעד |
-|------|-----|
-| **תיק** | **workspace-החלטה אחד** — block-editing + DOCX-פעיל, מחוון-מקור-אמת אחד בבעלות-המערכת, cache-slice משותף. אזור "השלמה והעברה" אחד לשערי-הסיום. |
-| **למידה** | **תיבת-אישור אחת** (לפי זוג draft↔final) · **ערוץ-כותב אחד + סטטוס "זורם-לכותב" אחד** (`review_status='approved'`) · `applied_to_skill` **מוסר** · כל artifact תלוי-בזוג (progressive disclosure). |
-| **מתודולוגיה** | **`/methodology` = העורך הקנוני היחיד** (PUT אחד; תג-מקור "ידני/מאומץ-מלמידה"); הלמידה מנותבת-דרכו ומבטלת שני-caches; explainer-תחולה inline. |
-| **פסיקה** | 3 קורפוסים **נפרדים** (גבול אמיתי, G2/INV-DIG1) אך **מתפעלים אחיד** — שם-חיפוש עקבי, תבנית-"ממתין" אחת, authority בכל-מקום. |
-
----
-
-## דלתות-ספ (deltas — ✅ קודדו בגל-2 #131)
-> כל שינוי-ספ דורש ≥3 מקורות (לעיל) + אישור-יו"ר. אושר ע"י חיים (2026-06-11, /goal "בצע את כל הגלים").
-
-1. **[X6](X6-ui-api-contract.md):** ✅ נוספו **INV-UI7** (aggregate-נגזר=SSoT; mutation מבטל queryKey; אין מונה-מתחרה — מקדד INV-IA1/IA2) · **INV-UI8** (שדה-response מרונדר-או-מוסר; חלקיות מוצגת — INV-IA5).
-2. **[07-learning §0.4](07-learning.md):** ✅ שער-אישור **אחד** (`review_status='approved'`), טרנזקציית-כותב **אחת** (FOR UPDATE), `applied_to_skill` **הוסר** (מקדד INV-IA3; מיישב את "שני-השערים" של [[feedback_operational_simplicity]]).
-3. **[00-constitution §G2 "הפרות ידועות"](00-constitution.md):** ✅ נוסף תאום-המתודולוגיה (`discussion_rules['universal']` נכתב ע"י PUT וגם promote — MET-2/3) + המיתון (append אטומי FOR UPDATE + invalidation).
-
-## הפניות-אחיות
-- [`../ia-audit-redesign.md`](../ia-audit-redesign.md) — מצב-קיים: 34 משטחים, 37 ממצאים (file:line), כיוון-יעד פר-אשכול.
-- [X6-ui-api-contract.md](X6-ui-api-contract.md) (UI1–UI6 — X17 מעליו) · [ui-audit.md](ui-audit.md) (ממצאי-קוד פר-רכיב — שכבה מתחת).
-- [00-constitution.md](00-constitution.md) — [G2](00-constitution.md) (מקור-אמת יחיד) · G10 (שערים-אנושיים) — X17 מרים אותם לשכבת-המשטח.

docs/spec/X6-ui-api-contract.md

@@ -86,25 +86,6 @@ TanStack Query — *Important Defaults* (staleTime/refetch) (https://tanstack.co
 מוצגים כשדות-עריכה רגילים ללא סימון.
 **הפרה ידועה:** [precedents/[id]/page.tsx](../../web-ui/src/app/precedents/%5Bid%5D/page.tsx) — `summary`/`headnote`/`key_quote` ללא חיווי-מקור; אין חיווי `searchable` ([gap-audit GAP-36](gap-audit.md)).
 
-### INV-UI7: aggregate-נגזר = מקור-אמת יחיד · כל mutation מבטל כל קורא (G2 בשכבת-ה-cache)
-**כלל:** ל-aggregate/מונה נגזר-שרת (למשל `/api/chair/pending`) יש **משטח-בעלים יחיד** שמריץ את השאילתה;
-משטחים אחרים **מצביעים** אליו ולא מריצים מונה-מתחרה client-side. **כל mutation** שמשנה ערך הנקרא במשטח
-אחר **חייב לבטל כל `queryKey` שקורא אותו** — כולל aggregators חוצי-namespace — כך שאף משטח לא יציג ערך
-תקוע אחרי שינוי במשטח אחר. מקדד את **[X17 INV-IA1/IA2](X17-information-architecture.md)**; מופע של
-[G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים) בשכבת-ה-TanStack-Query.
-**מקור-סמכות:** [X17](X17-information-architecture.md) (≥3 מקורות: TanStack Query invalidation · TkDodo "deriving client state" · NN/g consistency); [ia-audit-redesign.md](../ia-audit-redesign.md) §D1.
-**אכיפה:** מונה-הגייטים חי רק ב-`/approvals`+`['chair','pending']`; `/operations` מצביע. כל mutation להלכות/
-פסיקה-חסרה/הערות מבטל `['chair','pending']` (גל-1 #130, PR #207).
-
-### INV-UI8: שדה-response מרונדר-או-מוסר · חלקיות מוצגת
-**כלל:** שדה שמופיע ב-response **לרנדר או להסיר** — אסור לזרוק אותו בשקט ב-frontend (אם אין צרכן —
-להסירו מה-response). KPI מוצג חייב להיות ממופה ל**צרכן אמיתי** (לא דגל אינפורמטיבי-בלבד). aggregate
-מדויק כש-partial-failure השמיט תורם — **להציג חלקיות** ("+"/"חלקי"), לא מספר-מוקטן-כאילו-שלם. מקדד את
-**[X17 INV-IA5](X17-information-architecture.md)**.
-**מקור-סמכות:** [X17](X17-information-architecture.md) (NN/g visibility-of-system-status · GOV.UK design-with-data); [ia-audit-redesign.md](../ia-audit-redesign.md) §D3.
-**אכיפה:** `halacha_backlog` מרונדר ב-/operations (לא נזרק); `findings_approved` (review_status, צרכן אמיתי)
-החליף את `findings_applied` (דגל מת); מוני-סוכנים מסמנים "חלקי" כשחברה לא-נטענה (גל-1 #130).
-
 ---
 
 ## 3. כללי-עיצוב (Design Rules) — נגזרים מה-invariants

docs/spec/X8-field-provenance.md

@@ -92,14 +92,12 @@ NCSC/JTC — *AI in Courts* (verifiable citation) | סטטוס: verified
 **אכיפה:** `proofreader.verify_quote` בעת חילוץ → `quote_verified`.
 **הפרה ידועה:** — (קיים; ה-flag נכתב, אך אין חיווי ב-UI — ראה [X6 INV-UI6](X6-ui-api-contract.md)).
 
-### INV-FP5: חילוץ אסינכרוני, מתור, צד-מארח (לא מהקונטיינר)
+### INV-FP5: חילוץ אסינכרוני דרך claude_session מקומי
-**כלל:** חילוץ-LLM (מטא, הלכות) רץ **אסינכרוני, מתור, מצד-המארח** — לא חוסם את ה-web ולא קורא ל-LLM
+**כלל:** חילוץ-LLM (מטא, הלכות) רץ **אסינכרוני, מתור**, דרך `claude_session` **מקומי בלבד** — לא חוסם את
-מהקונטיינר. **בחירת-מנוע לפי אופי-המשימה (לא מסלול מקביל):** חילוץ-מטא הוא משימה *תחומה* (טקסט→JSON)
+ה-web, ולא קורא ל-LLM מהקונטיינר. מופע של [G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)
-ולכן רץ על **Gemini Flash** (`gemini_session`, structured JSON) — ה-claude CLI ה-agentic פגע ב-
+(מסלול-LLM קנוני יחיד). **פרויקטלי-תפעולי.** תואם זיכרון `feedback_claude_session_local_only`.
-`error_max_turns`; חילוץ-הלכות (רגיש-קול/agentic) נשאר על **`claude_session`** (CLI מקומי, מנוי דפנה).
+**מקור-סמכות:** [ingest.py](../../mcp-server/src/legal_mcp/services/ingest.py) (queue בצעד 12 → `process_pending_extractions`); [legal-ai/CLAUDE.md](../../CLAUDE.md) (claude_session local-only).
-שני המנועים מתנקזים לתור-החילוץ הקנוני היחיד ([G2](00-constitution.md#inv-g2-מקור-אמת-יחיד--אין-מסלולים-מקבילים-מתפצלים)). **פרויקטלי-תפעולי.**
+**אכיפה:** queue + `precedent_process_pending`; קריאות-LLM רק מ-MCP מקומי.
-**מקור-סמכות:** [ingest.py](../../mcp-server/src/legal_mcp/services/ingest.py) (queue → `process_pending_extractions`); [gemini_session.py](../../mcp-server/src/legal_mcp/services/gemini_session.py) (מטא); [legal-ai/CLAUDE.md](../../CLAUDE.md) (claude_session local-only להלכות). `GEMINI_API_KEY` בצד-המארח בלבד — לא בקונטיינר (תואם `feedback_claude_session_local_only`: אין קריאות-LLM מהקונטיינר).
-**אכיפה:** queue + `precedent_process_pending` + drainers מתוזמנים (`legal-metadata-drain`/CEO); קריאות-LLM רק מצד-המארח.
 **הפרה ידועה:** תור-החילוץ **סמוי** (אין הבחנה pending-initial מול pending-review; אין extraction-job table) ([gap-audit GAP-45](gap-audit.md); [X9](X9-mcp-tool-contract.md)).
 
 ---

docs/spec/gap-audit.md

@@ -88,7 +88,7 @@
 | GAP-51 | `set_outcome` enum-mismatch (3≠4); אוצרות-מילים סותרות | INV-TOOL1/UI1 | Medium | `block_writer.py:442` מול `lessons.py:11`, `workflow.py:145` | SSoT יחיד ל-outcome |
 | GAP-52 | רוב הכלים לא-idempotent (case_create/document_upload/precedent_attach) | INV-TOOL3, G3 | Medium | `server.py`, tools/ | upsert/ON CONFLICT |
 | GAP-53 | אין limit-caps (precedent_library_list/search_*/list_chair_feedback) | INV-TOOL5 | Low | tools/ | clamp ל-max |
-| GAP-54 | 3 מסלולי-קליטת-פסיקה ולידציה א-סימטרית; citation-guard לא-מתועד | INV-ING1, G2 | Medium | `precedent_library.py`, `internal_decisions.py` | ✅ **נפתר ע"י FU-1** — שני מסלולי-הפסיקה (library+internal) עוברים דרך `ingest.ingest_document` הקנוני (ולידציית-enums + citation-guard סימטריים, מתועד ב-01-ingest §4); המסלול ה-3 (training→`style_corpus`) הוא קורפוס נפרד במכוון (סגנון, לא פסיקה). מאומת ב-`test_unified_ingest.py` |
+| GAP-54 | 3 מסלולי-קליטת-פסיקה ולידציה א-סימטרית; citation-guard לא-מתועד | INV-ING1, G2 | Medium | `precedent_library.py`, `internal_decisions.py` | איחוד (תואם GAP-01/05) |
 | GAP-55 | Infisical dead-code; מקור-config לא-מתועד (Coolify-only) | INV-ENV2, G2 | Medium | `mcp-server/.../config.py` | לתעד Coolify SSoT / לבודד Infisical |
 | GAP-56 | UUIDs קשיחים (company/agent) — תואם GAP-26 | INV-ENV3/INT5 | High | `web/paperclip_client.py:36-62`, `web/app.py:3976` | config-driven |
 | GAP-57 | creds plaintext בברירת-מחדל (`paperclip:paperclip`) | INV-ENV4, G9, §6 | High | `web/paperclip_client.py:21`, `web/app.py:3789,3964` | default ריק + fail-loud |
@@ -207,7 +207,6 @@
 - **פרוסה 7, 2026-06-06 — ✅ GAP-48 הושלם.** משפחת `drafting` (18 כלים) הומרה ל-envelope. export_docx/revise_draft/apply_user_edit משתמשים ב-`err`-לכשל (כך שהסוכן והמשתמש רואים את הכשל ברמת-המעטפת), כש-`failed_gates` רוכב ב-`data`; 6 צרכני-app.py (get_decision_template/apply_user_edit×2/revise_draft/list_bookmarks/export_docx) חוּוטו עם בדיקת envelope-status; `test_export_qa_gate` עודכן לחוזה (182/182 עוברים). **GAP-48 סגור — כל ~12 המשפחות אחידות.**
 - **פרוסה 8, 2026-06-06 — ✅ GAP-49 (החלק הקריטי).** השם המטעה `precedent_search_library` (ציטוטים מצורפים-לתיק) שונה ל-`search_case_precedents` ובכך בוטל ההיפוך המסוכן מול `search_precedent_library` (ספרייה סמכותית — מקור CREAC). הישן נשמר כ-alias deprecated (ב-server.py) → אפס שבירה לסוכנים חיים. docstrings הובהרו; עודכנו app.py (typeahead) + legal-researcher/legal-writer docs + precedent_library docstring. 5 כלי-החיפוש הנותרים מחפשים קורפוסים מובחנים בשמות סבירים — לא בוצע rename-המוני (churn גבוה, ערך נמוך). 182/182 עוברים. **⚠ אחרי merge+deploy:** סנכרון cross-company של doc-הסוכן (frontmatter `search_case_precedents`). נותר ב-FU-14: GAP-50 (מיזוג כלי-בלוק — נוגע בתהליך-הכתיבה, דורש הכרעת-יו"ר), GAP-54, GAP-47-חלק-ב.
 - **פרוסה 9, 2026-06-06 — ✅ GAP-50 (הכרעת-יו"ר).** מיפוי הראה שכלי-הבלוק אינם "כפילות מיותרת": `write_block`/`write_all_blocks`/`save_block_content`/`write_interim_draft` משרתים זרימות שונות (CLI/initial-draft מול תהליך-ה-writer "התיקון בקובץ, לא ב-DB"). הכפילות האמיתית היחידה — `draft_section` (הקשר לפי-סעיף, כמעט-נטוש) חופף ל-`get_block_context` (לפי-בלוק, קנוני). הוחלט (יו"ר): **draft_section deprecated** (docstring ב-server.py+drafting.py מפנה ל-get_block_context; draft-decision.md עודכן) — בלי הסרה, בלי מיזוג כלי-הכתיבה (שמירת תהליך-הכתיבה המכוון). 182/182 עוברים. **GAP-49+50 סגורים.** נותר ב-FU-14: GAP-54 (איחוד קליטת-פסיקה), GAP-47-חלק-ב (הנחיות-יו"ר→DB).
-- **פרוסה 10, 2026-06-06 — ✅ GAP-54 (נסגר כ-resolved-by-FU-1).** אימות (G2: לא לפתור מחדש): `ingest.ingest_document` הוא המסלול הקנוני; `precedent_library` ו-`internal_decisions` שניהם עוברים דרכו עם ולידציית-enums + citation-guard סימטריים (מתועד ב-01-ingest §4); training→`style_corpus` הוא קורפוס נפרד במכוון. 9/9 `test_unified_ingest` עוברים — אין קוד לכתוב. **FU-14 כמעט-מלא: נותר רק GAP-47-חלק-ב** (העברת הנחיות-יו"ר מ-`analysis-and-research.md` ל-DB) — פיצ'ר UI+זרימת-אנליסט נפרד, לא דחוף.
 
 ### FU-15 — deploy/env/secrets
 - **מכסה:** GAP-55..62 · **invariants:** INV-ENV1–ENV5 · **effort:** M · **תלויות:** —

mcp-server/pyproject.toml

@@ -21,29 +21,6 @@ dependencies = [
     "uvicorn[standard]>=0.30.0",
     "httpx>=0.27.0",
     "infisicalsdk>=1.0.0",
-    "aioboto3>=13.0.0",    # X14 object storage (MinIO/S3) — services/storage.py
-]
-
-[project.optional-dependencies]
-# Tier-1 court-verdict fetch (X13) — host-only. The container can't run a
-# browser, so these are NOT in the base deps; install on the host venv with
-# `pip install -e ".[court-fetch]" && python -m camoufox fetch`. faster-whisper
-# is only for the explicit-PDF-download reCAPTCHA fallback (the primary
-# image-API path needs no solving).
-court-fetch = [
-    "camoufox>=0.4.11",
-    "faster-whisper>=1.0.0",
-    "h2>=4.0.0",          # Tier-0 supremedecisions uses httpx http2
-]
-# Durable execution for the local one-shot pipelines (X16 / INV-DUR1) —
-# final_halacha_pipeline / final_learning_pipeline gain crash/OOM resume via
-# scripts/_pipeline_runtime.py. HOST-ONLY (the pipelines run locally, not in the
-# container): install on the host venv with `pip install -e ".[durable]"`. The
-# runtime degrades gracefully to linear execution when these are absent, so the
-# run-halacha / run-learning buttons keep working until then.
-durable = [
-    "langgraph>=1.0,<2.0",
-    "langgraph-checkpoint-sqlite>=3.0",
 ]
 
 [build-system]

mcp-server/src/legal_mcp/config.py

@@ -54,10 +54,6 @@ REDIS_URL = os.environ.get("REDIS_URL", "redis://127.0.0.1:6380/0")
 # pinned.
 HALACHA_EXTRACT_MODEL = os.environ.get("HALACHA_EXTRACT_MODEL", "claude-opus-4-8")
 HALACHA_EXTRACT_EFFORT = os.environ.get("HALACHA_EXTRACT_EFFORT", "xhigh")
-# Digest (X12) metadata extraction is a simpler, high-volume task (concept tag,
-# headline, underlying citation, tags from a one-page summary) — Sonnet is the
-# speed/cost sweet-spot here, unlike halacha extraction which pins Opus. Tune via env.
-DIGEST_EXTRACT_MODEL = os.environ.get("DIGEST_EXTRACT_MODEL", "claude-sonnet-4-6")
 # Effort for BULK queue-drain extraction (process_pending over many precedents).
 # xhigh is the quality sweet-spot for a single precedent but very slow at scale
 # (a 64-chunk case ≈ 20 min). Bulk drains use a lighter effort to cut wall-clock;
@@ -138,26 +134,12 @@ BM25_HYBRID_ENABLED = (
 )
 
 # Halacha extraction — auto-approve threshold. Halachot with extractor
-# confidence >= this value AND no quality_flags are inserted
+# confidence >= this value are inserted with review_status='approved'
-# review_status='approved' (so they appear immediately in
+# instead of 'pending_review' (so they immediately appear in
-# search_precedent_library). Set > 1.0 to disable auto-approval.
+# search_precedent_library). Set to a value > 1.0 to disable auto-approval.
-#
+# 0.80 baseline: 89% of historical extractions land here, manual spot-check
-# CALIBRATION (#81.8, 2026-06-11) against the 100-item human-labeled gold-set
+# of 10 random samples confirmed quality. Tunable via env if drift is
-# (db.goldset_calibrate, ground_truth='chair'; 93 keep / 7 drop):
+# observed (e.g. raise to 0.90 if false-positives appear).
-#   conf>=0.80 -> precision 0.98, recall 0.53   <- current (errs safe)
-#   conf>=0.75 -> precision 0.96, recall 0.81
-#   conf>=0.70 -> precision 0.94, recall 0.94
-# 0.80 clears the >=0.90 precision target with margin, so we KEEP it — it errs
-# toward the chair (low recall = more items reviewed, never the reverse).
-# Two findings shape the policy:
-#  (a) self-confidence alone is well-calibrated for PRECISION; the rule-based
-#      validators do NOT discriminate keep/drop on the gold-set (P~0.1), so a
-#      "confidence x validators" combined score would only hurt — not adopted.
-#  (b) the real COVERAGE lever is the tri-model panel (halacha_panel_approve):
-#      unanimous-3/3 -> precision 0.988 at 95% coverage, dominating any single
-#      confidence threshold. Lowering this gate to ~0.75 is a governance
-#      tradeoff (more unreviewed auto-approvals, INV-G10) on thin evidence
-#      (7 negatives) -> deferred to chair/panel (TaskMaster #121), not changed here.
 HALACHA_AUTO_APPROVE_THRESHOLD = float(
     os.environ.get("HALACHA_AUTO_APPROVE_THRESHOLD", "0.80")
 )
@@ -172,21 +154,6 @@ HALACHA_AUTO_APPROVE_THRESHOLD = float(
 # principle. Set > 1.0 to disable semantic dedup (exact-quote dedup still runs).
 HALACHA_DEDUP_COSINE = float(os.environ.get("HALACHA_DEDUP_COSINE", "0.93"))
 
-# Halacha dedup TAIL band (#82.3) — the [BAND_COSINE, DEDUP_COSINE) range is too
-# low to auto-skip but suspicious. A halacha whose nearest same-precedent
-# neighbor sits in this band AND has high LEXICAL overlap (Jaccard/Levenshtein
-# on rule_statement) is flagged 'near_duplicate' (blocks auto-approve → review),
-# not skipped — catching paraphrases the cosine threshold misses without
-# dropping a possibly-distinct principle unreviewed. 0.83 from the same cleanup.
-HALACHA_DEDUP_BAND_COSINE = float(os.environ.get("HALACHA_DEDUP_BAND_COSINE", "0.83"))
-
-# Halacha review-queue clustering (#84.2) — when the review queue is requested
-# with cluster=true, halachot of the SAME precedent whose rule-embeddings are
-# within this cosine are grouped into ONE review card (canonical + variants), so
-# the chair judges near-identical principles once instead of repeatedly. Display
-# only — never merges/deletes. 0.90 = "same principle, reworded".
-HALACHA_CLUSTER_COSINE = float(os.environ.get("HALACHA_CLUSTER_COSINE", "0.90"))
-
 # Halacha NLI entailment validator (#81.3) — after extraction, a claude_session
 # judge checks each halacha's rule_statement is entailed by its supporting_quote.
 # Non-entailed (neutral/contradiction) → quality flag 'nli_unsupported' that
@@ -216,32 +183,6 @@ EXPORTS_DIR = DATA_DIR / "exports"  # legacy exports only
 # Cases directory — flat structure: data/cases/{case_number}/
 CASES_DIR = DATA_DIR / "cases"
 
-# ── Object storage (X14 / MinIO) ───────────────────────────────────
-# Single storage layer (services/storage.py) replaces the scattered file
-# I/O across ~8 services (INV-STG1 / G2). Backend selector:
-#   "filesystem" (default) — disk under DATA_DIR; current behaviour, no change.
-#   "dual"                 — write disk + S3, read S3→disk fallback (migration).
-#   "s3"                   — MinIO only.
-# See docs/spec/X14-storage-minio.md.
-STORAGE_BACKEND = os.environ.get("STORAGE_BACKEND", "filesystem").strip().lower()
-# Endpoint reached server-side (internal Docker network: http://minio:9000).
-MINIO_ENDPOINT = os.environ.get("MINIO_ENDPOINT", "http://minio:9000")
-# Public endpoint used when MINTING presigned URLs for the browser (INV-STG6) —
-# the browser cannot resolve the internal hostname. Falls back to the internal
-# endpoint when unset (e.g. local dev).
-MINIO_PUBLIC_ENDPOINT = os.environ.get("MINIO_PUBLIC_ENDPOINT", MINIO_ENDPOINT)
-MINIO_ACCESS_KEY = os.environ.get("MINIO_ACCESS_KEY", "")
-MINIO_SECRET_KEY = os.environ.get("MINIO_SECRET_KEY", "")
-MINIO_REGION = os.environ.get("MINIO_REGION", "us-east-1")
-# Logical bucket → name. Governance boundaries (INV-STG3): documents
-# (versioned), immutable (versioned + Object-Lock COMPLIANCE for final
-# decisions, INV-STG4), derived (thumbnails/extracted text — regenerable).
-MINIO_BUCKET_DOCUMENTS = os.environ.get("MINIO_BUCKET_DOCUMENTS", "legal-documents")
-MINIO_BUCKET_IMMUTABLE = os.environ.get("MINIO_BUCKET_IMMUTABLE", "legal-immutable")
-MINIO_BUCKET_DERIVED = os.environ.get("MINIO_BUCKET_DERIVED", "legal-derived")
-# Default presigned-URL TTL (seconds). SigV4 hard max is 7 days; keep short.
-MINIO_PRESIGN_TTL = int(os.environ.get("MINIO_PRESIGN_TTL", "900"))
-
 
 def find_case_dir(case_number: str) -> Path:
     """Return the case directory for a given case number."""
@@ -362,34 +303,3 @@ def parse_llm_json(raw: str):
                 except json.JSONDecodeError:
                     pass
     return None
-
-
-# ── Committee chair — single source of truth (INV-G2) ─────────────────
-# internal_committee rows REQUIRE a non-empty chair_name (DB constraint
-# case_law_internal_chair_check). Our committee (CMP 1xxx, CMPA 8/9xxx) is
-# chaired by Dafna Tamir; map by case-number prefix so adding a future chair
-# stays a one-line local change. This resolver is the ONE place both the
-# FastAPI final-upload path (web/app.py) and the MCP learning path
-# (tools/workflow.py + services/db.create_case) derive the chair from — so
-# the two cannot drift into parallel logic. Override via env for another
-# committee.
-COMMITTEE_CHAIR_DEFAULT = os.environ.get("DEFAULT_CHAIR_NAME", "דפנה תמיר")
-COMMITTEE_CHAIR_BY_PREFIX = {
-    "1": COMMITTEE_CHAIR_DEFAULT,
-    "8": COMMITTEE_CHAIR_DEFAULT,
-    "9": COMMITTEE_CHAIR_DEFAULT,
-}
-
-
-def committee_chair_for_case(case: dict | None, case_number: str) -> str:
-    """Resolve the chair for one of OUR decisions deterministically (no LLM):
-    the case's own chair_name, else the committee default by case-number prefix.
-
-    Never returns empty for a valid case number — this is how chair_name is
-    normalised at the source (INV-G1) so internal_committee corpus copies of
-    finals never silently fail the DB chair constraint.
-    """
-    existing = ((case or {}).get("chair_name") or "").strip()
-    if existing:
-        return existing
-    return COMMITTEE_CHAIR_BY_PREFIX.get((case_number or "")[:1], COMMITTEE_CHAIR_DEFAULT)

mcp-server/src/legal_mcp/court_fetch_service/__init__.py

@@ -1,7 +0,0 @@
-"""Host-side Tier-1 verdict fetch service (X13).
-
-Runs on the host under pm2 (it needs a real browser, which the legal-ai
-container can't run). Drives a Camoufox stealth browser against נט המשפט to
-download administrative/district-court verdicts the Supreme portal (Tier 0)
-doesn't carry. See docs/spec/X13-court-fetch.md.
-"""

mcp-server/src/legal_mcp/court_fetch_service/camofox_client.py

@@ -1,314 +0,0 @@
-"""Camoufox driver for נט המשפט — calibrated, proven flow (X13, Tier 1).
-
-Open-source, zero-API-cost: drives a **Camoufox** stealth browser (a Firefox
-fork with C++ fingerprint spoofing) via its official Python package
-(``camoufox.async_api``) — in-process, no separate Node server. The full flow
-was reverse-engineered and validated end-to-end against עת"מ 46111-12-22
-(2026-06-07): a 34-page verdict PDF retrieved with **no smart-card and no
-CAPTCHA-solving**.
-
-The proven path:
-  1. homepage → DOM-click ``btnExternalSearchCases`` ("תיקים לפי מס' תיק מקור").
-  2. Fill the visible header case-locator: ``BamaCaseNumberTextBoxH`` = case
-     number, ``BamaMonthYearTextBoxHT`` = "MM-YY"; click ``SearchHeaderCaseButton``.
-     → lands on ``FolderCaseDetails/CaseDetails.aspx`` for the case.
-  3. Click the "פסקי דין" sidebar tab → ``Decisions/DecisionList.aspx``.
-  4. Click the document → popup ``Viewer/NGCSViewerPage.aspx?DocumentNumber=…``.
-  5. The viewer renders pages as PNG images via the ``GetImages`` PageMethod —
-     **served without reCAPTCHA** (the reCAPTCHA on the viewer only gates the
-     explicit save/print, which we don't use). Capture the internal
-     ``documentNumber`` from the viewer's first ``GetImages`` call, then pull
-     every 4-page batch via ``fetch`` **with header ``X-Requested-With:
-     XMLHttpRequest``** (required — the F5 WAF blocks AJAX calls without it).
-  6. Decode the base64 PNGs → assemble a PDF (Pillow). The existing ingest
-     pipeline OCRs it (Google Vision) → text → corpus.
-
-Operational requirements (see scripts/legal-court-fetch-service.config.cjs):
-  * a virtual display — Camoufox/Firefox crashes headless on this server
-    without one. Set ``DISPLAY`` to a running Xvfb (e.g. ``:99``).
-  * RAM — a Firefox content process loading the heavy ASP.NET pages needs
-    ~0.5–1 GB; keep the box from swapping.
-
-reCAPTCHA note: ``recaptcha_audio`` (local Whisper) remains as a fallback for
-the explicit-PDF-download path, but the primary image-API path needs no
-solving, so it is normally unused.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import base64
-import io
-import json
-import logging
-import os
-import re
-
-logger = logging.getLogger(__name__)
-
-NGCS_HOME = "https://www.court.gov.il/ngcs.web.site/homepage.aspx"
-
-# Headless Camoufox needs a virtual display on this server.
-_DISPLAY = os.environ.get("DISPLAY", "")
-_NAV_TIMEOUT_MS = int(float(os.environ.get("COURT_FETCH_BROWSER_TIMEOUT_S", "60")) * 1000)
-_PAGE_BATCH = 4          # the viewer's GetImages batch size
-_MAX_PAGES = 400         # hard cap on a single document
-# Hard wall-clock cap on a single fetch so a hung browser can't pin a Firefox
-# process forever (anti-leak; INV-CF4 politeness). The async-with cleanup runs
-# on the resulting CancelledError, tearing the browser down.
-_FETCH_HARD_TIMEOUT_S = float(os.environ.get("COURT_FETCH_HARD_TIMEOUT_S", "180"))
-
-
-def _reap_orphan_browsers() -> int:
-    """Kill any ``camoufox-bin`` orphaned to ``ppid=1`` before we launch.
-
-    Fetching is serial (INV-CF4), so any browser not owned by a live parent is
-    a leftover from a prior crashed/killed fetch. Pure /proc, best-effort —
-    never raises into the fetch path.
-    """
-    killed = 0
-    try:
-        for pid in os.listdir("/proc"):
-            if not pid.isdigit():
-                continue
-            try:
-                with open(f"/proc/{pid}/status", "rb") as f:
-                    status = f.read().decode("utf-8", "replace")
-                with open(f"/proc/{pid}/cmdline", "rb") as f:
-                    cmd = f.read().decode("utf-8", "replace")
-            except OSError:
-                continue
-            if "camoufox-bin" not in cmd:
-                continue
-            ppid = 0
-            for line in status.splitlines():
-                if line.startswith("PPid:"):
-                    try: ppid = int(line.split()[1])
-                    except (IndexError, ValueError): pass
-                    break
-            if ppid == 1:
-                try:
-                    os.kill(int(pid), 9)
-                    killed += 1
-                except OSError:
-                    pass
-    except OSError:
-        pass
-    if killed:
-        logger.warning("reaped %d orphaned camoufox-bin before fetch", killed)
-    return killed
-
-
-class CamofoxUnavailable(RuntimeError):
-    """Camoufox (or its virtual display) isn't available."""
-
-
-class NgcsFlowError(RuntimeError):
-    """A step in the נט-המשפט flow failed (navigation / not found / blocked)."""
-
-
-def is_enabled() -> bool:
-    """True if the Camoufox package imports (browser binary present)."""
-    try:
-        import camoufox.async_api  # noqa: F401
-        return True
-    except Exception:
-        return False
-
-
-async def health() -> dict:
-    return {"camoufox_import": is_enabled(), "display": _DISPLAY or "(none)"}
-
-
-async def _fill_visible(page, id_substr: str, value: str) -> bool:
-    for el in await page.locator(f"input[id*='{id_substr}']").all():
-        try:
-            if await el.is_visible() and await el.is_editable():
-                await el.fill(value)
-                return True
-        except Exception:
-            continue
-    return False
-
-
-async def _reach_viewer(page, *, case_number: str, month_year: str):
-    """Drive home → search → case → פסקי דין → viewer popup. Returns the popup page."""
-    await page.goto(NGCS_HOME, wait_until="domcontentloaded", timeout=_NAV_TIMEOUT_MS)
-    await page.wait_for_timeout(2500)
-    await page.eval_on_selector(
-        "#Header1_UpperMenu1_btnExternalSearchCases", "el => el.click()"
-    )
-    try:
-        await page.wait_for_load_state("domcontentloaded", timeout=_NAV_TIMEOUT_MS)
-    except Exception:
-        pass
-    await page.wait_for_timeout(4500)
-
-    if not await _fill_visible(page, "BamaCaseNumberTextBoxH", case_number):
-        raise NgcsFlowError("שדה מספר-תיק לא נמצא בעמוד החיפוש")
-    my_filled = False
-    for el in await page.locator("input[id*='BamaMonthYearTextBoxHT']").all():
-        if await el.is_visible():
-            await el.click()
-            await page.keyboard.type(month_year, delay=60)
-            my_filled = True
-            break
-    if not my_filled:
-        raise NgcsFlowError("שדה חודש-שנה לא נמצא")
-    clicked = False
-    for b in await page.locator("[id*='SearchHeaderCaseButton']").all():
-        if await b.is_visible():
-            await b.click()
-            clicked = True
-            break
-    if not clicked:
-        raise NgcsFlowError("כפתור החיפוש לא נמצא")
-    await page.wait_for_timeout(6000)
-    if "CaseDetails" not in page.url:
-        raise NgcsFlowError(
-            f"לא הגענו לעמוד-התיק (URL={page.url[:80]}) — ייתכן שהתיק לא נמצא/לא פתוח לעיון"
-        )
-
-    # פסקי דין tab → DecisionList
-    psak = page.locator("a:has-text('פסקי דין')")
-    opened = False
-    for i in range(await psak.count()):
-        el = psak.nth(i)
-        if await el.is_visible():
-            await el.click()
-            opened = True
-            break
-    if not opened:
-        raise NgcsFlowError("לשונית 'פסקי דין' לא נמצאה בעמוד-התיק")
-    await page.wait_for_timeout(6000)
-
-    # open the verdict document viewer (popup)
-    viewers = page.locator(
-        "a[href*='Viewer'],[onclick*='Viewer'],a[href*='Document'],a:has-text('צפייה')"
-    )
-    async with page.context.expect_page(timeout=15000) as pop:
-        clicked = False
-        for i in range(await viewers.count()):
-            el = viewers.nth(i)
-            if await el.is_visible():
-                await el.click()
-                clicked = True
-                break
-        if not clicked:
-            raise NgcsFlowError("לא נמצא מסמך פסק-דין לצפייה")
-    return await pop.value
-
-
-async def fetch_admin_verdict(
-    *, file_number: str, month: str, year: str, case_number: str, court: str
-) -> dict:
-    """Fetch an admin/district court verdict as a PDF. Returns
-    ``{content: bytes, filename, source_url, court}``; raises on failure.
-
-    ``file_number``/``month``/``year`` are the נט-המשפט triple (e.g. 46111/12/22).
-    """
-    try:
-        from camoufox.async_api import AsyncCamoufox
-    except Exception as e:
-        raise CamofoxUnavailable(
-            "חבילת camoufox אינה מותקנת/זמינה. הרץ `pip install camoufox` ו-"
-            "`python -m camoufox fetch`. ראה docs/spec/X13-court-fetch.md."
-        ) from e
-    if not _DISPLAY:
-        # Headless Firefox crashes here without a virtual display.
-        raise CamofoxUnavailable(
-            "אין DISPLAY — Camoufox דורש Xvfb על שרת ללא מסך. הפעל Xvfb (למשל :99) "
-            "והגדר DISPLAY (ראה pm2 config)."
-        )
-
-    month_year = f"{int(month):02d}-{year[-2:]}"
-
-    # Belt-and-suspenders against browser leaks: kill any orphaned browser from
-    # a prior crashed fetch before we launch a new one (serial → safe).
-    _reap_orphan_browsers()
-
-    async def _run() -> dict:
-        doc_num = {"v": None}
-
-        async def on_resp(resp):
-            if "GetImages" in resp.url and not doc_num["v"]:
-                try:
-                    doc_num["v"] = json.loads(resp.request.post_data).get("documentNumber")
-                except Exception:
-                    pass
-
-        async with AsyncCamoufox(
-            headless=True, geoip=False, humanize=True, locale="he-IL"
-        ) as browser:
-            page = await browser.new_page()
-            page.context.on("response", lambda r: asyncio.create_task(on_resp(r)))
-            vp = await _reach_viewer(page, case_number=file_number, month_year=month_year)
-            source_url = vp.url
-            await vp.wait_for_timeout(9000)
-            if not doc_num["v"]:
-                raise NgcsFlowError("לא נלכד documentNumber מהצופה (ייתכן שהמסמך לא נטען)")
-
-            # Pull every page batch through fetch() with X-Requested-With (WAF-safe).
-            imgs = await vp.evaluate(
-                """async (args) => {
-                    const [dn, maxPages, batch] = args;
-                    const url = window.location.href.split('?')[0] + '/GetImages';
-                    const out = {};
-                    for (let f = 0; f < maxPages; f += batch) {
-                        let d;
-                        try {
-                            const r = await fetch(url, {method:'POST', credentials:'include',
-                                headers:{'Content-Type':'application/json; charset=utf-8',
-                                         'X-Requested-With':'XMLHttpRequest'},
-                                body: JSON.stringify({documentNumber:dn, fromIndex:f, toIndex:f+batch-1})});
-                            if (!r.ok) break;
-                            const j = await r.json(); d = (j.d !== undefined) ? j.d : j;
-                        } catch (e) { break; }
-                        if (!Array.isArray(d) || d.length === 0) break;
-                        d.forEach((html, k) => { if (html) out[f+k] = html; });
-                        if (d.length < batch) break;
-                        await new Promise(r => setTimeout(r, 350));
-                    }
-                    return out;
-                }""",
-                [doc_num["v"], _MAX_PAGES, _PAGE_BATCH],
-            )
-
-        if not imgs:
-            raise NgcsFlowError("לא התקבלו עמודי-מסמך מ-GetImages")
-        from PIL import Image
-
-        pages = []
-        for idx in sorted(imgs, key=lambda x: int(x)):
-            m = re.search(r"base64,([A-Za-z0-9+/=]+)", imgs[idx] or "")
-            if not m:
-                continue
-            pages.append(Image.open(io.BytesIO(base64.b64decode(m.group(1)))).convert("RGB"))
-        if not pages:
-            raise NgcsFlowError("עמודי-המסמך לא ניתנים לפענוח (base64)")
-
-        buf = io.BytesIO()
-        pages[0].save(buf, format="PDF", save_all=True, append_images=pages[1:])
-        content = buf.getvalue()
-        logger.info("נט המשפט: fetched %s — %d pages, %d bytes",
-                    case_number, len(pages), len(content))
-        return {
-            "content": content,
-            "filename": f"{case_number}.pdf",
-            "source_url": source_url,
-            "court": court or "בית משפט מחוזי",
-            "pages": len(pages),
-        }
-
-    # Hard wall-clock cap: on a hung browser, the timeout cancels _run(); the
-    # async-with __aexit__ tears the browser down, and the reap below sweeps any
-    # process that outlived the cancellation.
-    try:
-        return await asyncio.wait_for(_run(), _FETCH_HARD_TIMEOUT_S)
-    except asyncio.TimeoutError:
-        _reap_orphan_browsers()
-        raise NgcsFlowError(
-            f"אחזור עבר את מגבלת-הזמן ({_FETCH_HARD_TIMEOUT_S:.0f}ש') ובוטל"
-        )
-    finally:
-        _reap_orphan_browsers()

mcp-server/src/legal_mcp/court_fetch_service/mavat_client.py

@@ -1,266 +0,0 @@
-"""Camoufox driver for mavat (מנהל התכנון) — pull תב"ע identity + validity.
-
-mavat sits behind an F5 BIG-IP ASM bot-wall: a scripted curl/httpx gets a
-302→maintenance, but a real JS-executing browser on this server clears the
-challenge (verified 2026-06-17). So, like X13's נט-המשפט flow, we drive a
-**Camoufox** stealth browser over Xvfb — same engine, same host service, no
-second port/secret (G2).
-
-The proven flow (validated end-to-end on 101-1031020 → י"פ 13697 and
-101-1053933 → י"פ 13836, two stable runs):
-  1. goto the SPA home; it redirects to ``/SV1`` once the F5 JS challenge
-     resolves (TS* cookies set) — that is the normal landed state.
-  2. Type the plan number into ``#sv3-search__input`` (the only visible text
-     input) and press Enter. The SPA POSTs ``/rest/api/sv3/Search`` with a
-     reCAPTCHA token it supplies transparently — so reCAPTCHA must stay enabled
-     (blocking it kills the token and results never render). For a unique plan
-     number the SPA then **auto-navigates** to ``/SV4/1/<MMI_ENTITY_ID>/310``.
-  3. That navigation fires ``GET /rest/api/SV4/1?mid=<mid>&guid=0`` (~55 KB
-     JSON). It returns 200 only in the in-app navigation context, so we capture
-     it off the SPA's own request (a standalone replay 404s).
-  4. Parse identity from ``planDetails`` and validity from ``rsInternet``: the
-     row ``LIS_DESC == "פרסום לאישור ברשומות"`` carries ``ED_PUBLICATION_FILE``
-     (= yalkut number) and a ``DETAILS`` string with date + page. The separate
-     "פרסום להפקדה ברשומות" row is the deposit (ignored).
-
-Driver-crash workaround (required): the SV4 navigation throws an uncaught SPA
-error that crashes the playwright-firefox driver (it reads
-``pageError.location.url``). An init-script swallowing ``window.onerror`` +
-``error``/``unhandledrejection`` (preventDefault) keeps the driver alive.
-
-INV-AH: ``source_url`` is the mavat plan page; a field mavat doesn't expose comes
-back empty, never guessed. This module only returns a candidate — the chair gates
-it (review_status) before block-ט cites it.
-
-Operational requirements (shared with camofox_client): a virtual display
-(``DISPLAY``=:99 via Xvfb) and ~0.5–1 GB RAM for the Firefox content process.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import logging
-import os
-import re
-
-# Reuse the X13 orphan-browser reaper (same camoufox-bin binary) — G2, no copy.
-from legal_mcp.court_fetch_service.camofox_client import _reap_orphan_browsers
-
-logger = logging.getLogger(__name__)
-
-MAVAT_HOME = "https://mavat.iplan.gov.il/"
-_SV4_RESP_RE = re.compile(r"/rest/api/SV4/1\?mid=", re.IGNORECASE)
-
-_DISPLAY = os.environ.get("DISPLAY", "")
-_NAV_TIMEOUT_MS = int(float(os.environ.get("PLAN_FETCH_BROWSER_TIMEOUT_S", "60")) * 1000)
-_FETCH_HARD_TIMEOUT_S = float(os.environ.get("PLAN_FETCH_HARD_TIMEOUT_S", "180"))
-
-# Proven waits (both verification runs passed; the search box is absent before
-# the F5 + Angular boot, and the SV4 XHR lands a few seconds after Enter).
-_HOME_WAIT_MS = 8000
-_SEARCH_WAIT_MS = 9000
-_SV4_POLL_TRIES = 8
-_SV4_POLL_MS = 4000
-
-_SEARCH_INPUT = "#sv3-search__input"
-
-# The gazette/yalkut status row vs the (ignored) deposit row.
-_GAZETTE_LIS_DESC = "פרסום לאישור ברשומות"
-
-# Swallow the SPA's uncaught SV4 error so the playwright-firefox driver survives.
-_CRASH_GUARD_JS = """
-window.addEventListener('error', function (e) { try { e.preventDefault(); } catch (x) {} }, true);
-window.addEventListener('unhandledrejection', function (e) { try { e.preventDefault(); } catch (x) {} }, true);
-window.onerror = function () { return true; };
-"""
-
-_DATE_RE = re.compile(r"תאריך\s*פרסום\s*:?\s*(\d{1,2})/(\d{1,2})/(\d{4})")
-_PAGE_RE = re.compile(r"עמוד\s*:?\s*(\d{1,6})")
-_YALKUT_DETAILS_RE = re.compile(r"ילקוט\s*פרסומים\s*:?\s*(\d{2,6})")
-
-
-class MavatUnavailable(RuntimeError):
-    """Camoufox / its virtual display isn't available."""
-
-
-class MavatFlowError(RuntimeError):
-    """A step in the mavat flow failed (blocked / not found / not parsed)."""
-
-
-def is_enabled() -> bool:
-    try:
-        import camoufox.async_api  # noqa: F401
-        return True
-    except Exception:
-        return False
-
-
-async def health() -> dict:
-    return {"camoufox_import": is_enabled(), "display": _DISPLAY or "(none)"}
-
-
-# ─── payload parsing ──────────────────────────────────────────────────────────
-
-def _s(v) -> str:
-    return v.strip() if isinstance(v, str) else ""
-
-
-def _yalkut_str(v) -> str:
-    """ED_PUBLICATION_FILE comes as a float (13697.0) — render as a clean int."""
-    if isinstance(v, (int, float)):
-        return str(int(v))
-    s = _s(v)
-    m = re.search(r"\d{2,6}", s)
-    return m.group(0) if m else ""
-
-
-def _parse_sv4(sv4: dict, plan_number: str, source_url: str) -> dict:
-    """Map an SV4 plan-detail JSON object to our registry-candidate fields.
-
-    Identity lives in ``planDetails``; validity in the top-level ``rsInternet``.
-    """
-    pd = sv4.get("planDetails") if isinstance(sv4, dict) else None
-    pd = pd if isinstance(pd, dict) else {}
-
-    number = _s(pd.get("NUMB")) or plan_number
-    # display_name is the clean citation surface form — "תכנית <number>". mavat's
-    # E_NAME is a long descriptive title (the plan's substance), which belongs in
-    # purpose, NOT in the name block-ט cites. Keep E_NAME only as a purpose
-    # fallback so its content isn't lost when GOALS is empty.
-    e_name = _s(pd.get("E_NAME"))
-    display_name = f"תכנית {number}" if number else e_name
-    auth = _s(pd.get("AUTH"))
-    subtype = _s(pd.get("ENTITY_SUBTYPE"))
-    plan_type = f"{auth} ({subtype})" if auth and subtype else (auth or subtype)
-    purpose = _s(pd.get("GOALS")) or e_name
-
-    gazette_date, yalkut_number, yalkut_page = "", "", ""
-    rows = sv4.get("rsInternet") if isinstance(sv4, dict) else None
-    rows = rows if isinstance(rows, list) else []
-    for row in rows:
-        if not isinstance(row, dict) or _s(row.get("LIS_DESC")) != _GAZETTE_LIS_DESC:
-            continue
-        yalkut_number = _yalkut_str(row.get("ED_PUBLICATION_FILE"))
-        details = _s(row.get("DETAILS"))
-        md = _DATE_RE.search(details)
-        if md:
-            d, mo, y = md.groups()
-            gazette_date = f"{int(y):04d}-{int(mo):02d}-{int(d):02d}"
-        if not gazette_date:
-            # fall back to the structured row date (EIS_DATE: ISO-ish or dd/mm/yyyy)
-            ed = _s(row.get("EIS_DATE"))
-            m2 = re.search(r"(\d{4})-(\d{2})-(\d{2})", ed) or re.search(
-                r"(\d{1,2})/(\d{1,2})/(\d{4})", ed)
-            if m2 and "-" in ed:
-                gazette_date = m2.group(0)[:10]
-            elif m2:
-                d, mo, y = m2.groups()
-                gazette_date = f"{int(y):04d}-{int(mo):02d}-{int(d):02d}"
-        if not yalkut_number:
-            my = _YALKUT_DETAILS_RE.search(details)
-            if my:
-                yalkut_number = my.group(1)
-        mp = _PAGE_RE.search(details)
-        if mp:
-            yalkut_page = mp.group(1)
-        break
-
-    return {
-        "plan_number": number,
-        "display_name": display_name,
-        "plan_type": plan_type,
-        "purpose": purpose,
-        "gazette_date": gazette_date,
-        "yalkut_number": yalkut_number,
-        "yalkut_page": yalkut_page,
-        "source_url": source_url,
-    }
-
-
-# ─── driver ───────────────────────────────────────────────────────────────────
-
-async def fetch_plan(plan_number: str) -> dict:
-    """Drive mavat for one plan; return the registry-candidate dict.
-
-    Raises ``MavatUnavailable`` (no browser/display) or ``MavatFlowError``
-    (blocked / not found / not parsed).
-    """
-    plan_number = (plan_number or "").strip()
-    if not plan_number:
-        raise MavatFlowError("חסר מספר-תכנית")
-    try:
-        from camoufox.async_api import AsyncCamoufox
-    except Exception as e:
-        raise MavatUnavailable(
-            "חבילת camoufox אינה מותקנת/זמינה. ראה docs/spec/X13-court-fetch.md."
-        ) from e
-    if not _DISPLAY:
-        raise MavatUnavailable(
-            "אין DISPLAY — Camoufox דורש Xvfb על שרת ללא מסך (למשל :99)."
-        )
-
-    _reap_orphan_browsers()
-
-    async def _run() -> dict:
-        captured: dict = {"sv4": None, "sv4_url": ""}
-
-        async def on_resp(resp):
-            if captured["sv4"] is not None or not _SV4_RESP_RE.search(resp.url):
-                return
-            try:
-                captured["sv4"] = await resp.json()
-                captured["sv4_url"] = resp.url
-            except Exception:  # a racing/non-JSON response must not kill the flow
-                pass
-
-        async with AsyncCamoufox(
-            headless=True, geoip=False, humanize=True, locale="he-IL"
-        ) as browser:
-            page = await browser.new_page()
-            await page.add_init_script(_CRASH_GUARD_JS)
-            page.context.on("response", lambda r: asyncio.create_task(on_resp(r)))
-
-            # 1) home → let F5 ASM resolve (lands on /SV1; search box appears).
-            await page.goto(MAVAT_HOME, wait_until="domcontentloaded", timeout=_NAV_TIMEOUT_MS)
-            await page.wait_for_timeout(_HOME_WAIT_MS)
-
-            # 2) type the plan number + Enter → sv3/Search → SPA auto-navigates to SV4.
-            box = page.locator(_SEARCH_INPUT)
-            try:
-                await box.wait_for(state="visible", timeout=_NAV_TIMEOUT_MS)
-                await box.fill(plan_number)
-                await box.press("Enter")
-            except Exception as e:
-                raise MavatFlowError(f"שדה-החיפוש ({_SEARCH_INPUT}) לא נמצא/לא נגיש: {e}")
-            await page.wait_for_timeout(_SEARCH_WAIT_MS)
-
-            # 3) the SV4 GET is captured by on_resp; poll until it lands.
-            for _ in range(_SV4_POLL_TRIES):
-                if captured["sv4"] is not None:
-                    break
-                await page.wait_for_timeout(_SV4_POLL_MS)
-
-        sv4 = captured["sv4"]
-        if sv4 is None:
-            raise MavatFlowError(
-                "לא נלכד SV4 מ-mavat — ייתכן שהתכנית לא נמצאה, ריבוי-תוצאות, או חסימת-F5."
-            )
-        parsed = _parse_sv4(sv4, plan_number, captured["sv4_url"] or MAVAT_HOME)
-        if not parsed["display_name"]:
-            raise MavatFlowError("SV4 נלכד אך ללא שם-תכנית (planDetails.E_NAME) — פענוח נכשל.")
-        logger.info(
-            "mavat: fetched %s — name=%r gazette=%s yalkut=%s",
-            plan_number, parsed["display_name"], parsed["gazette_date"],
-            parsed["yalkut_number"],
-        )
-        return parsed
-
-    try:
-        return await asyncio.wait_for(_run(), _FETCH_HARD_TIMEOUT_S)
-    except asyncio.TimeoutError:
-        _reap_orphan_browsers()
-        raise MavatFlowError(
-            f"משיכת-התכנית עברה את מגבלת-הזמן ({_FETCH_HARD_TIMEOUT_S:.0f}ש') ובוטלה"
-        )
-    finally:
-        _reap_orphan_browsers()

mcp-server/src/legal_mcp/court_fetch_service/recaptcha_audio.py

@@ -1,80 +0,0 @@
-"""Open-source reCAPTCHA v2 audio-challenge solver (X13, Tier 1).
-
-Pure open-source, zero-API-cost: switch the reCAPTCHA widget to its **audio**
-challenge, download the mp3, transcribe it with a **local Whisper** model
-(``faster-whisper``), and submit the transcript. This is the well-known
-"Buster"-style technique. It is intentionally a *best-effort* solver —
-reCAPTCHA actively fights audio solving, so a non-trivial failure rate is
-expected and handled by the Tier-2 human fallback (INV-CF3), never hidden.
-
-Model is loaded lazily and cached; ``WHISPER_MODEL`` (default ``small``) and
-``WHISPER_DEVICE`` (default ``cpu``) tune it. The dependency is optional — if
-``faster-whisper`` isn't installed, ``transcribe_audio`` raises a clear error
-so the caller falls back to a human solve rather than crashing the service.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import tempfile
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-_WHISPER_MODEL_NAME = os.environ.get("WHISPER_MODEL", "small")
-_WHISPER_DEVICE = os.environ.get("WHISPER_DEVICE", "cpu")
-_model = None
-
-
-class AudioSolveUnavailable(RuntimeError):
-    """faster-whisper isn't installed — cannot solve audio locally."""
-
-
-def _get_model():
-    global _model
-    if _model is not None:
-        return _model
-    try:
-        from faster_whisper import WhisperModel  # type: ignore
-    except ImportError as e:
-        raise AudioSolveUnavailable(
-            "faster-whisper אינו מותקן — לא ניתן לפתור reCAPTCHA אודיו מקומית. "
-            "התקן `pip install faster-whisper` או הסתמך על fallback אנושי (VNC)."
-        ) from e
-    logger.info("loading whisper model %s on %s", _WHISPER_MODEL_NAME, _WHISPER_DEVICE)
-    _model = WhisperModel(
-        _WHISPER_MODEL_NAME, device=_WHISPER_DEVICE, compute_type="int8"
-    )
-    return _model
-
-
-async def download_audio(audio_url: str) -> bytes:
-    async with httpx.AsyncClient(timeout=30, follow_redirects=True) as c:
-        r = await c.get(audio_url)
-        r.raise_for_status()
-        return r.content
-
-
-def transcribe_audio(mp3_bytes: bytes) -> str:
-    """Transcribe a reCAPTCHA audio clip to its (English) digit/word phrase.
-
-    Raises ``AudioSolveUnavailable`` if the local model isn't installed.
-    """
-    model = _get_model()
-    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=True) as f:
-        f.write(mp3_bytes)
-        f.flush()
-        # reCAPTCHA audio is English regardless of page locale.
-        segments, _info = model.transcribe(f.name, language="en")
-        text = " ".join(seg.text for seg in segments).strip()
-    # Normalise: reCAPTCHA expects the bare phrase, lower-case, no punctuation.
-    cleaned = "".join(ch for ch in text.lower() if ch.isalnum() or ch.isspace())
-    return " ".join(cleaned.split())
-
-
-async def solve_from_audio_url(audio_url: str) -> str:
-    """Convenience: download + transcribe an audio-challenge URL."""
-    mp3 = await download_audio(audio_url)
-    return transcribe_audio(mp3)

mcp-server/src/legal_mcp/court_fetch_service/server.py

@@ -1,479 +0,0 @@
-"""Host-side HTTP bridge for Tier-1 verdict fetching (X13).
-
-Mirrors ``legal_mcp.chat_service.server`` — the proven host-side pattern: an
-aiohttp app, bound to the docker bridge gateway, Bearer-auth, that does the one
-thing the container can't (here: drive a real browser against נט המשפט).
-
-Endpoints:
-    POST /fetch    body {file_number, month, year, case_number, court}
-                   → {ok, content_b64, filename, source_url, court, reason}
-                   REQUIRES Authorization: Bearer <COURT_FETCH_SHARED_SECRET>.
-    GET  /health   liveness (no auth); reports camofox + VNC URL if available.
-    GET  /pm2      read-only pm2 status of legal-* / paperclip services (no auth).
-    POST /pm2/control body {name, action: restart|stop|start} → run pm2 on a
-                   whitelisted legal-* process. REQUIRES Bearer (mutating).
-
-Run with pm2:
-    pm2 start scripts/legal-court-fetch-service.config.cjs
-
-Security posture (identical rationale to legal-chat-service):
-  1. Bind defaults to ``10.0.1.1`` (docker0 bridge gateway) — reachable from
-     the host + containers on docker bridges, invisible to outside networks.
-  2. ``/fetch`` requires a Bearer token (constant-time compare); the service
-     refuses to start without ``COURT_FETCH_SHARED_SECRET`` set.
-  3. ``/health`` is unauthenticated and spawns nothing.
-"""
-
-from __future__ import annotations
-
-import argparse
-import base64
-import hmac
-import json
-import logging
-import os
-import sys
-import time
-
-import aiohttp
-from aiohttp import web
-
-_pkg_root = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
-if _pkg_root not in sys.path:
-    sys.path.insert(0, _pkg_root)
-
-from legal_mcp.court_fetch_service import camofox_client  # noqa: E402
-from legal_mcp.court_fetch_service import mavat_client  # noqa: E402
-from legal_mcp.services import usage_limits  # noqa: E402
-from legal_mcp.services import script_runner  # noqa: E402
-
-logger = logging.getLogger("legal_court_fetch_service")
-
-_SHARED_SECRET: str = ""
-
-
-async def health(request: web.Request) -> web.Response:
-    info = {"ok": True, "service": "legal-court-fetch-service",
-            "camofox_enabled": camofox_client.is_enabled()}
-    if camofox_client.is_enabled():
-        try:
-            info["camofox"] = await camofox_client.health()
-        except Exception as e:  # health must never throw
-            info["camofox_error"] = str(e)
-    return web.json_response(info)
-
-
-# Background services we surface on the /operations dashboard. pm2 jlist is a
-# host-only capability (the legal-ai container can't run pm2), so the container's
-# FastAPI proxies this read-only endpoint over the docker bridge. No secret:
-# pm2 status (names/cpu/mem) carries nothing sensitive and the bind (10.0.1.1)
-# is already host/container-only.
-_PM2_PREFIXES = ("legal-", "paperclip")
-
-
-def _trim_service(a: dict) -> dict:
-    """Project a pm2 jlist app entry into the fields the dashboard needs."""
-    env = a.get("pm2_env", {}) or {}
-    return {
-        "name": a.get("name", ""),
-        "status": env.get("status", ""),
-        "restarts": env.get("restart_time", 0),
-        "uptime_ms": env.get("pm_uptime", 0),
-        "cpu": (a.get("monit") or {}).get("cpu", 0),
-        "memory_bytes": (a.get("monit") or {}).get("memory", 0),
-        "cron": env.get("cron_restart") or "",
-        "autorestart": env.get("autorestart", True),
-    }
-
-
-async def _pm2_run(*args: str, timeout: float = 10) -> tuple[int, bytes, bytes]:
-    """Run a pm2 subcommand; returns (returncode, stdout, stderr)."""
-    import asyncio as _asyncio
-
-    proc = await _asyncio.create_subprocess_exec(
-        "pm2", *args,
-        stdout=_asyncio.subprocess.PIPE, stderr=_asyncio.subprocess.PIPE,
-    )
-    out, err = await _asyncio.wait_for(proc.communicate(), timeout=timeout)
-    return proc.returncode or 0, out, err
-
-
-# /operations polls every 5s; the usage endpoint 429s if hit that often (it's
-# meant for a status bar, not a poll loop). Cache the last good payload and only
-# re-fetch when older than this — Anthropic sees ~1 req/min regardless of how
-# many dashboards poll. The 5-hour window moves slowly, so 60s is plenty fresh.
-_USAGE_TTL_SEC = 60.0
-_usage_cache: dict = {"ts": 0.0, "data": None}
-
-
-async def usage_status(request: web.Request) -> web.Response:
-    """Proxy the claude.ai subscription usage % (host-only — needs the local
-    OAuth token), cached for _USAGE_TTL_SEC. On a fetch failure (e.g. the
-    endpoint's own 429) serve the last good payload if we have one, so a
-    transient limit doesn't blank the dashboard.
-
-    The raw OAuth read is the SHARED single source of truth
-    (legal_mcp.services.usage_limits.subscription_usage) — the SAME reader the
-    halacha drain + supervisor gate on (G1/G2; no triplicated endpoint/creds/UA
-    constants). It's synchronous urllib, so run it in a thread to keep the aiohttp
-    event loop responsive."""
-    now = time.monotonic()
-    if _usage_cache["data"] is not None and (now - _usage_cache["ts"]) < _USAGE_TTL_SEC:
-        return web.json_response(_usage_cache["data"])
-
-    import asyncio as _asyncio
-    # subscription_usage returns None on ANY failure (creds missing / endpoint
-    # 429 / network) — it never throws; serve stale if we have it.
-    data = await _asyncio.get_event_loop().run_in_executor(
-        None, usage_limits.subscription_usage)
-    if data is None:
-        if _usage_cache["data"] is not None:
-            return web.json_response(_usage_cache["data"])
-        return web.json_response({"error": "usage unavailable"}, status=502)
-
-    _usage_cache["ts"] = now
-    _usage_cache["data"] = data
-    return web.json_response(data)
-
-
-async def pm2_status(request: web.Request) -> web.Response:
-    """Return a trimmed ``pm2 jlist`` for the legal-ai background services."""
-    try:
-        rc, out, err = await _pm2_run("jlist")
-        if rc != 0:
-            return web.json_response(
-                {"error": f"pm2 jlist failed: {err.decode('utf-8','replace')[:200]}"},
-                status=502,
-            )
-        apps = json.loads(out.decode("utf-8", "replace"))
-    except FileNotFoundError:
-        return web.json_response({"error": "pm2 not found on PATH"}, status=502)
-    except Exception as e:  # never throw
-        return web.json_response({"error": f"pm2 error: {e}"}, status=502)
-
-    services = [
-        _trim_service(a) for a in apps
-        if any(str(a.get("name", "")).startswith(p) for p in _PM2_PREFIXES)
-    ]
-    services.sort(key=lambda s: s["name"])
-    return web.json_response({"services": services})
-
-
-# Process control (restart/stop/start) for the dashboard's "Windows-services"
-# panel. Mutating, so it requires the Bearer secret (unlike read-only /pm2).
-# Whitelisted to ``legal-`` names only — never paperclip or arbitrary processes.
-_PM2_ACTIONS = {"restart", "stop", "start"}
-
-# Our own pm2 process name. Restarting/stopping ourselves kills this process
-# mid-reply, so those self-actions are detached (see pm2_control).
-_OWN_PM2_NAME = os.environ.get("COURT_FETCH_SERVICE_PM2_NAME", "legal-court-fetch-service")
-
-
-async def pm2_control(request: web.Request) -> web.Response:
-    """Run ``pm2 <action> <name>`` for a whitelisted legal-* process."""
-    unauth = _check_bearer(request)
-    if unauth is not None:
-        return unauth
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        return web.json_response({"error": "invalid JSON body"}, status=400)
-
-    name = str(body.get("name", "")).strip()
-    action = str(body.get("action", "")).strip()
-    if action not in _PM2_ACTIONS:
-        return web.json_response(
-            {"error": f"action must be one of {sorted(_PM2_ACTIONS)}"}, status=400
-        )
-    if not name.startswith("legal-"):
-        return web.json_response(
-            {"error": "name must be a legal-* process"}, status=403
-        )
-
-    # Self restart/stop kills this process before it can reply (client sees a
-    # dropped connection / 502) even though pm2 does perform the action. Detach
-    # it with a brief delay so the HTTP response flushes first, then report
-    # success optimistically.
-    if name == _OWN_PM2_NAME and action in ("restart", "stop"):
-        import asyncio as _asyncio
-
-        await _asyncio.create_subprocess_shell(f"sleep 1; pm2 {action} {name} --silent")
-        return web.json_response(
-            {"ok": True, "action": action, "deferred": True, "service": None}
-        )
-
-    try:
-        rc, out, err = await _pm2_run(action, name, "--silent", timeout=30)
-        if rc != 0:
-            return web.json_response(
-                {"ok": False,
-                 "error": f"pm2 {action} {name} failed: "
-                          f"{err.decode('utf-8','replace')[:200]}"},
-                status=502,
-            )
-        # Re-read just this process so the UI settles on the real new state.
-        rc2, out2, _ = await _pm2_run("jlist")
-        svc = None
-        if rc2 == 0:
-            for a in json.loads(out2.decode("utf-8", "replace")):
-                if a.get("name") == name:
-                    svc = _trim_service(a)
-                    break
-        return web.json_response({"ok": True, "action": action, "service": svc})
-    except FileNotFoundError:
-        return web.json_response({"error": "pm2 not found on PATH"}, status=502)
-    except Exception as e:  # never throw
-        return web.json_response({"ok": False, "error": f"pm2 error: {e}"}, status=502)
-
-
-def _check_bearer(request: web.Request) -> web.Response | None:
-    auth = request.headers.get("Authorization", "")
-    expected = "Bearer " + _SHARED_SECRET
-    if not auth or not hmac.compare_digest(auth, expected):
-        return web.json_response(
-            {"error": "unauthorized: missing or invalid Bearer token"}, status=401
-        )
-    return None
-
-
-async def fetch(request: web.Request) -> web.Response:
-    unauth = _check_bearer(request)
-    if unauth is not None:
-        return unauth
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        return web.json_response({"error": "invalid JSON body"}, status=400)
-
-    required = ("file_number", "month", "year")
-    if not all(body.get(k) for k in required):
-        return web.json_response(
-            {"ok": False, "reason": f"missing one of {required}"}, status=400
-        )
-
-    try:
-        result = await camofox_client.fetch_admin_verdict(
-            file_number=str(body["file_number"]),
-            month=str(body["month"]),
-            year=str(body["year"]),
-            case_number=str(body.get("case_number", "")),
-            court=str(body.get("court", "")),
-        )
-        return web.json_response({
-            "ok": True,
-            "content_b64": base64.b64encode(result["content"]).decode("ascii"),
-            "filename": result.get("filename", ""),
-            "source_url": result.get("source_url", ""),
-            "court": result.get("court", ""),
-        })
-    except (camofox_client.CamofoxUnavailable, camofox_client.NgcsFlowError) as e:
-        # Expected, recoverable failure → orchestrator escalates (INV-CF3).
-        return web.json_response({"ok": False, "reason": str(e)}, status=200)
-    except Exception as e:  # noqa: BLE001
-        logger.exception("fetch failed")
-        return web.json_response({"ok": False, "reason": f"unexpected: {e}"}, status=200)
-
-
-async def plan_fetch(request: web.Request) -> web.Response:
-    """Fetch one תב"ע's identity + validity from mavat (מנהל התכנון).
-
-    Body ``{plan_number}`` → ``{ok, plan: {...}, reason}``. Same Bearer + bind as
-    /fetch. The browser work (Camoufox over Xvfb past F5 ASM) lives in
-    ``mavat_client``; expected failures (not found / blocked) come back ok=false
-    at HTTP 200 so the caller renders a reason rather than treating it as a 5xx.
-    """
-    unauth = _check_bearer(request)
-    if unauth is not None:
-        return unauth
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        return web.json_response({"error": "invalid JSON body"}, status=400)
-
-    plan_number = str(body.get("plan_number", "")).strip()
-    if not plan_number:
-        return web.json_response({"ok": False, "reason": "missing plan_number"}, status=400)
-
-    try:
-        plan = await mavat_client.fetch_plan(plan_number)
-        return web.json_response({"ok": True, "plan": plan})
-    except (mavat_client.MavatUnavailable, mavat_client.MavatFlowError) as e:
-        # Expected, recoverable (browser unavailable / plan not found / blocked).
-        return web.json_response({"ok": False, "reason": str(e)}, status=200)
-    except Exception as e:  # noqa: BLE001
-        logger.exception("plan_fetch failed")
-        return web.json_response({"ok": False, "reason": f"unexpected: {e}"}, status=200)
-
-
-# ─── adapter-migration: host-side runner for scripts/migrate_agent_adapter.py ───
-# The legal-ai container can't perform the migration itself (it needs the host
-# filesystem — generated instruction copies, the gemini settings file — plus the
-# embedded board DB), so the dashboard proxies the action here. Mutating, so it
-# requires the Bearer secret like /pm2/control. We launch exactly one fixed,
-# in-repo script with create_subprocess_exec (no shell) and an action allowlist;
-# every other argument is passed through opaque and validated by the script
-# itself. Kept deliberately symbol-light so this host bridge stays generic.
-_MIGRATE_SCRIPT = "/home/chaim/legal-ai/scripts/migrate_agent_adapter.py"
-_MIGRATE_PYTHON = "/home/chaim/legal-ai/mcp-server/.venv/bin/python"
-_MIGRATE_ACTIONS = {"check", "apply", "revert", "verify"}
-
-
-async def adapter_migration(request: web.Request) -> web.Response:
-    """Run scripts/migrate_agent_adapter.py on the host and relay its result."""
-    unauth = _check_bearer(request)
-    if unauth is not None:
-        return unauth
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        return web.json_response({"error": "invalid JSON body"}, status=400)
-
-    action = str(body.get("action", "")).strip()
-    if action not in _MIGRATE_ACTIONS:
-        return web.json_response(
-            {"error": f"action must be one of {sorted(_MIGRATE_ACTIONS)}"}, status=400
-        )
-
-    argv = [_MIGRATE_PYTHON, _MIGRATE_SCRIPT, f"--{action}"]
-    agent = str(body.get("agent", "")).strip()
-    target = str(body.get("to", "")).strip()
-    model = str(body.get("model", "")).strip()
-    if action in ("check", "apply", "revert"):
-        if not agent:
-            return web.json_response({"error": "agent required"}, status=400)
-        argv += ["--agent", agent]
-    if action in ("check", "apply"):
-        if not target:
-            return web.json_response({"error": "to (target) required"}, status=400)
-        argv += ["--to", target]
-        if model:
-            argv += ["--model", model]
-        if bool(body.get("relax_tools")):
-            argv += ["--relax-tools"]
-
-    import asyncio as _asyncio
-
-    env = {**os.environ, "HOME": "/home/chaim"}
-    try:
-        proc = await _asyncio.create_subprocess_exec(
-            *argv, cwd="/home/chaim/legal-ai", env=env,
-            stdout=_asyncio.subprocess.PIPE, stderr=_asyncio.subprocess.PIPE,
-        )
-        out, err = await _asyncio.wait_for(proc.communicate(), timeout=180)
-    except _asyncio.TimeoutError:
-        return web.json_response({"ok": False, "error": "migration timed out"}, status=504)
-    except Exception as e:  # never throw — relay the failure
-        return web.json_response({"ok": False, "error": f"launch failed: {e}"}, status=502)
-
-    # 200 regardless of exit code: a non-zero --check (preflight refusal) is an
-    # informative result the caller renders, not a transport error.
-    return web.json_response({
-        "ok": (proc.returncode == 0),
-        "exit_code": proc.returncode,
-        "stdout": out.decode("utf-8", "replace"),
-        "stderr": err.decode("utf-8", "replace"),
-    })
-
-
-# ─── run-script: host-side runner for read-only/audit scripts (#4) ─────────────
-# Same shape as /adapter-migration but for the SCRIPT_RUN_ALLOWLIST — a fixed set
-# of read-only scripts each with a hard-coded safe argv. The request body's only
-# meaningful field is ``name``; arguments are NEVER taken from the caller (so no
-# --apply/--force injection). Allowlist enforcement lives here, on the host.
-async def run_script(request: web.Request) -> web.Response:
-    """Run an allowlisted read-only script on the host and relay its result."""
-    unauth = _check_bearer(request)
-    if unauth is not None:
-        return unauth
-    try:
-        body = await request.json()
-    except json.JSONDecodeError:
-        return web.json_response({"error": "invalid JSON body"}, status=400)
-
-    name = str(body.get("name", "")).strip()
-    argv = script_runner.build_argv(name)
-    if argv is None:
-        return web.json_response(
-            {"ok": False, "error": f"script not runnable (not in allowlist): {name!r}"},
-            status=403,
-        )
-
-    import asyncio as _asyncio
-
-    env = {**os.environ, "HOME": "/home/chaim"}
-    try:
-        proc = await _asyncio.create_subprocess_exec(
-            *argv, cwd="/home/chaim/legal-ai", env=env,
-            stdout=_asyncio.subprocess.PIPE, stderr=_asyncio.subprocess.PIPE,
-        )
-        out, err = await _asyncio.wait_for(proc.communicate(), timeout=600)
-    except _asyncio.TimeoutError:
-        return web.json_response({"ok": False, "error": "script timed out"}, status=504)
-    except Exception as e:  # never throw — relay the failure
-        return web.json_response({"ok": False, "error": f"launch failed: {e}"}, status=502)
-
-    # best-effort audit trail — one line per run
-    try:
-        os.makedirs("/home/chaim/legal-ai/data/logs", exist_ok=True)
-        stamp = time.strftime("%Y-%m-%dT%H:%M:%S%z")
-        with open("/home/chaim/legal-ai/data/logs/script-runs.log", "a") as fh:
-            fh.write(f"{stamp}\t{name}\texit={proc.returncode}\n")
-    except Exception:
-        pass
-
-    # 200 regardless of exit code — a non-zero audit result is informative output
-    # the caller renders, not a transport error.
-    return web.json_response({
-        "ok": (proc.returncode == 0),
-        "exit_code": proc.returncode,
-        "stdout": out.decode("utf-8", "replace"),
-        "stderr": err.decode("utf-8", "replace"),
-    })
-
-
-def build_app() -> web.Application:
-    app = web.Application(client_max_size=64 * 1024 * 1024)
-    app.router.add_get("/health", health)
-    app.router.add_get("/pm2", pm2_status)
-    app.router.add_get("/usage", usage_status)
-    app.router.add_post("/pm2/control", pm2_control)
-    app.router.add_post("/fetch", fetch)
-    app.router.add_post("/plan-fetch", plan_fetch)
-    app.router.add_post("/adapter-migration", adapter_migration)
-    app.router.add_post("/run-script", run_script)
-    return app
-
-
-def main() -> int:
-    parser = argparse.ArgumentParser(description="legal-court-fetch-service")
-    parser.add_argument("--port", type=int, default=8771)
-    parser.add_argument("--host", default="10.0.1.1",
-                        help="bind address; default = docker0 bridge gateway")
-    parser.add_argument("--log-level", default="INFO")
-    args = parser.parse_args()
-
-    logging.basicConfig(level=args.log_level.upper(),
-                        format="%(asctime)s %(name)s %(levelname)s %(message)s")
-
-    secret = os.environ.get("COURT_FETCH_SHARED_SECRET", "").strip()
-    if not secret:
-        logger.error(
-            "COURT_FETCH_SHARED_SECRET is empty; refusing to start. Set it in "
-            "/home/chaim/.legal-court-fetch-service.env (loaded by pm2) and "
-            "mirror it as a Coolify env var on the legal-ai app."
-        )
-        return 2
-    if len(secret) < 24:
-        logger.error("COURT_FETCH_SHARED_SECRET too short (>=32 chars expected).")
-        return 2
-    global _SHARED_SECRET
-    _SHARED_SECRET = secret
-
-    app = build_app()
-    logger.info("legal-court-fetch-service listening on %s:%d", args.host, args.port)
-    web.run_app(app, host=args.host, port=args.port, print=lambda _m: None)
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

mcp-server/src/legal_mcp/models.py

@@ -9,18 +9,10 @@ from uuid import UUID
 from pydantic import BaseModel, Field
 
 
-# Core case lifecycle — kept in sync with STATUS_ORDER in tools/cases.py and the
-# frontend SSoT web-ui/src/lib/api/case-status.ts. Trimmed from 17 → 10 (the
-# decorative mid-stage markers that no pipeline code ever set were removed).
 class CaseStatus(str, enum.Enum):
     NEW = "new"
-    PROCESSING = "processing"
+    IN_PROGRESS = "in_progress"
-    DOCUMENTS_READY = "documents_ready"
-    OUTCOME_SET = "outcome_set"
-    DIRECTION_APPROVED = "direction_approved"
-    QA_REVIEW = "qa_review"
     DRAFTED = "drafted"
-    EXPORTED = "exported"
     REVIEWED = "reviewed"
     FINAL = "final"
 

mcp-server/src/legal_mcp/server.py

@@ -58,9 +58,6 @@ from legal_mcp.tools import (  # noqa: E402
     missing_precedents as mp_tools,
     citations as cit_tools,
     training_enrichment as train_tools,
-    digests as digest_tools,
-    court_fetch as cf_tools,
-    plans as plans_tools,
 )
 
 
@@ -103,7 +100,7 @@ def _clamp_limit(limit: int, hard_max: int = _MAX_LIMIT) -> int:
 
 @mcp.tool()
 async def case_list(status: str = "", limit: int = 50) -> str:
-    """רשימת תיקי ערר. סינון אופציונלי לפי סטטוס (new/processing/documents_ready/outcome_set/direction_approved/qa_review/drafted/exported/reviewed/final)."""
+    """רשימת תיקי ערר. סינון אופציונלי לפי סטטוס (new/in_progress/drafted/reviewed/final)."""
     return await cases.case_list(status, _clamp_limit(limit))
 
 
@@ -343,81 +340,6 @@ async def search_precedent_library(
     )
 
 
-# Digests radar (X12) — secondary discovery layer; NOT a citation corpus.
-@mcp.tool()
-async def digest_upload(
-    file_path: str,
-    yomon_number: str = "",
-    digest_date: str = "",
-    practice_area: str = "",
-    appeal_subtype: str = "",
-    subject_tags: list[str] | None = None,
-) -> str:
-    """העלאת יומון ("כל יום") לקורפוס-הגילוי (radar) + חילוץ מטא-דאטה אוטומטי. היומון הוא מקור-משני המצביע על הפסק המקורי — אינו מצוטט בהחלטה ואינו מחלץ הלכות (INV-DIG1/2). practice_area: rishuy_uvniya / betterment_levy / compensation_197."""
-    return await digest_tools.digest_upload(
-        file_path, yomon_number, digest_date, practice_area,
-        appeal_subtype, subject_tags,
-    )
-
-
-@mcp.tool()
-async def digest_list(
-    practice_area: str = "",
-    concept_tag: str = "",
-    linked: bool | None = None,
-    search: str = "",
-    limit: int = 100,
-) -> str:
-    """רשימת יומונים בקורפוס-הגילוי, עם פילטרים. linked=false → יומונים שהפסק המקורי שלהם עוד לא נקלט לספריית הפסיקה (פער-ידע גלוי, INV-DIG3)."""
-    return await digest_tools.digest_list(
-        practice_area, concept_tag, linked, search, _clamp_limit(limit),
-    )
-
-
-@mcp.tool()
-async def digest_get(digest_id: str) -> str:
-    """יומון ספציפי לפי מזהה (כולל מראה-מקום, ניתוח, וקישור לפסק המקורי אם קיים)."""
-    return await digest_tools.digest_get(digest_id)
-
-
-@mcp.tool()
-async def digest_link(digest_id: str, case_law_id: str) -> str:
-    """קישור ידני של יומון לפסק הדין המקורי בספריית הפסיקה (INV-DIG3). idempotent."""
-    return await digest_tools.digest_link(digest_id, case_law_id)
-
-
-@mcp.tool()
-async def digest_relink(digest_id: str) -> str:
-    """ניסיון-קישור מחדש: בודק אם פסק הדין המקורי של היומון כבר בספרייה ומקשר אוטומטית."""
-    return await digest_tools.digest_relink(digest_id)
-
-
-@mcp.tool()
-async def digest_delete(digest_id: str) -> str:
-    """מחיקת יומון מקורפוס-הגילוי."""
-    return await digest_tools.digest_delete(digest_id)
-
-
-@mcp.tool()
-async def search_digests(
-    query: str,
-    practice_area: str = "",
-    subject_tag: str = "",
-    concept_tag: str = "",
-    limit: int = 10,
-) -> str:
-    """חיפוש סמנטי בקורפוס-הגילוי (יומוני "כל יום") — מצפן-מחקר (radar). מחזיר את היומון הרלוונטי + מראה-המקום של הפסק המקורי. ⚠️ היומון אינו מצוטט בהחלטה (INV-DIG1) — הצטט מהפסק המקורי דרך search_precedent_library. החוקר משתמש בזה בשלב 2ב.0 לפני האימות."""
-    return await digest_tools.search_digests(
-        query, practice_area, subject_tag, concept_tag, _clamp_limit(limit),
-    )
-
-
-@mcp.tool()
-async def digest_process_pending(limit: int = 20) -> str:
-    """ריקון תור היומונים שהועלו מה-UI וממתינים לעיבוד-LLM מקומי. מריץ חילוץ-מטא-דאטה + embedding + autolink על כל יומון 'pending' (מקומית עם CLI). חלופת-MCP ל-scripts/ingest_digests_batch.py."""
-    return await digest_tools.digest_process_pending(_clamp_limit(limit))
-
-
 @mcp.tool()
 async def halacha_review(
     halacha_id: str,
@@ -707,64 +629,6 @@ async def get_appraiser_facts(case_number: str) -> str:
     return await drafting.get_appraiser_facts(case_number)
 
 
-# ── Planning-schemes registry (V38) — מרשם-התכניות ─────────────────
-# SSOT לזהות+תוקף של תכנית, נעשה שימוש חוזר בין תיקים (G2). פלט-LLM נכנס
-# pending_review וממתין לאישור-יו"ר (plan_review, G10) לפני שמשמש בבלוק ט.
-
-@mcp.tool()
-async def extract_plans(case_number: str) -> str:
-    """חילוץ תכניות ותוקפן מכל מסמכי התיק אל מרשם-התכניות (pending_review). ה-extract היקר."""
-    return await plans_tools.extract_plans(case_number)
-
-
-@mcp.tool()
-async def plan_fetch(plan_number: str) -> str:
-    """משיכת זהות+תוקף של תב"ע מ-מנהל-התכנון (mavat) — מועמד-לאישור, לא כתיבה. כל ערך נושא source_url (INV-AH)."""
-    return await plans_tools.plan_fetch(plan_number)
-
-
-@mcp.tool()
-async def plan_get(plan_number: str) -> str:
-    """קריאת תכנית מהמרשם לפי מספר (מנורמל; נופל ל-alias). ה-get הזול."""
-    return await plans_tools.plan_get(plan_number)
-
-
-@mcp.tool()
-async def plan_search(query: str, limit: int = 20) -> str:
-    """חיפוש fuzzy במרשם-התכניות לפי מספר/שם/ייעוד."""
-    return await plans_tools.plan_search(query, limit)
-
-
-@mcp.tool()
-async def plan_list(review_status: str = "", limit: int = 500) -> str:
-    """רשימת תכניות במרשם, אופציונלית מסוננת לפי review_status (תור-אישור)."""
-    return await plans_tools.plan_list(review_status, limit)
-
-
-@mcp.tool()
-async def plan_upsert(
-    plan_number: str,
-    display_name: str = "",
-    plan_type: str = "",
-    gazette_date: str = "",
-    yalkut_number: str = "",
-    purpose: str = "",
-    review_status: str = "approved",
-    aliases: str = "",
-) -> str:
-    """כתיבה/עריכה ידנית מבוקרת של תכנית במרשם (ברירת-מחדל approved — קלט-יו"ר). מנרמל בכתיבה (G1)."""
-    return await plans_tools.plan_upsert(
-        plan_number, display_name, plan_type, gazette_date,
-        yalkut_number, purpose, review_status, aliases,
-    )
-
-
-@mcp.tool()
-async def plan_review(plan_id: str, status: str) -> str:
-    """שער-היו"ר (G10): אישור/דחייה/איפוס של תכנית במרשם (approved/rejected/pending_review)."""
-    return await plans_tools.plan_review(plan_id, status)
-
-
 @mcp.tool()
 async def write_interim_draft(case_number: str, instructions: str = "") -> str:
     """כתיבת ארבעת הבלוקים לטיוטת ביניים (רקע, תכניות+היתרים, טענות, הליכים) — אותו skill וטמפלט."""
@@ -1031,28 +895,6 @@ async def missing_precedent_close(
     )
 
 
-# ── Court verdict auto-fetch (X13) ────────────────────────────────
-@mcp.tool()
-async def court_verdict_fetch(citation: str) -> str:
-    """אחזור אוטומטי של פסק-דין בית-משפט מנט המשפט/פורטל-העליון וקליטה לקורפוס.
-
-    מסווג את הציטוט (עליון→Tier0 / מנהלי→Tier1 / ערר→skip), מוריד וקולט דרך
-    צינור-הקליטה הקנוני. דוגמה: 'עת"מ 46111-12-22'. כלי מקומי בלבד."""
-    return await cf_tools.court_verdict_fetch(citation)
-
-
-@mcp.tool()
-async def court_fetch_status(case_number: str = "", status_filter: str = "") -> str:
-    """סטטוס תור-אחזור הפסיקה. case_number לפריט יחיד, או status_filter (pending/failed/manual/done)."""
-    return await cf_tools.court_fetch_status(case_number, status_filter)
-
-
-@mcp.tool()
-async def court_fetch_drain(limit: int = 10) -> str:
-    """ריקון תור-אחזור הפסיקה — מוריד וקולט jobs ממתינים שהיומונים מילאו, וקושר חזרה ליומון. מקומי בלבד."""
-    return await cf_tools.court_fetch_drain(limit)
-
-
 # ── Internal citations graph (TaskMaster #34) ─────────────────────
 
 

mcp-server/src/legal_mcp/services/analysis_docx_exporter.py

@@ -21,7 +21,6 @@ Output: data/cases/{case_number}/exports/ניתוח-משפטי-v{N}.docx
 
 from __future__ import annotations
 
-import io
 import re
 from pathlib import Path
 from typing import Any
@@ -35,7 +34,7 @@ from docx.text.paragraph import Paragraph
 from docx.text.run import Run
 
 from legal_mcp import config
-from legal_mcp.services import db, research_md, storage
+from legal_mcp.services import db, research_md
 
 
 def _mark_run_rtl(run: Run) -> None:
@@ -495,19 +494,10 @@ async def build_analysis_docx(case_number: str) -> Path:
                 continue
             _emit_content_line(doc, raw)
 
-    # Save versioned through the storage layer (INV-STG1). export_dir.mkdir +
+    # Save versioned
-    # the glob in _next_version still read disk (correct under filesystem/dual;
-    # storage-native versioning is a cutover concern). out_path is always under
-    # DATA_DIR, so the bytes land exactly where they did before.
     export_dir = case_dir / "exports"
     export_dir.mkdir(parents=True, exist_ok=True)
     version = _next_version(export_dir)
     out_path = export_dir / f"ניתוח-משפטי-v{version}.docx"
-    buf = io.BytesIO()
+    doc.save(str(out_path))
-    doc.save(buf)
-    await storage.put_bytes(
-        out_path.relative_to(config.DATA_DIR).as_posix(), buf.getvalue(),
-        bucket=storage.Bucket.DOCUMENTS,
-        content_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    )
     return out_path

mcp-server/src/legal_mcp/services/appraiser_facts_extractor.py

@@ -103,7 +103,7 @@ async def extract_facts_from_document(
             f"שמאי: {appraiser_name}{chunk_label}\n\n"
             f"--- תחילת שומה ---\n{chunk}\n--- סוף שומה ---"
         )
-        result = await claude_session.query_json(prompt, tools="")  # no tool_use → no error_max_turns
+        result = await claude_session.query_json(prompt)
         if not isinstance(result, list):
             logger.warning(
                 "extract_facts_from_document: chunk %d returned non-list (%s) for doc=%s",

mcp-server/src/legal_mcp/services/argument_aggregator.py

@@ -147,7 +147,7 @@ async def _aggregate_party(
     prompt = _build_prompt(party, propositions)
 
     try:
-        raw_result = await claude_session.query_json(prompt, tools="")  # no tool_use → no error_max_turns
+        raw_result = await claude_session.query_json(prompt)
     except RuntimeError as e:
         # Surface CLI-unavailable specifically so the caller can report
         # cleanly instead of crashing the whole job.
@@ -335,30 +335,18 @@ async def get_legal_arguments(
                 case_id,
             )
 
-        # Pull supporting claims (id + full text) for each argument in one
+        # Pull supporting claim ids for each argument in one round-trip.
-        # round-trip. ``supporting_claims`` stays id-only for backwards compat
-        # (counts, MCP consumers); ``supporting_propositions`` carries the text
-        # so the UI can show the raw propositions without an extra fetch.
         arg_ids = [r["id"] for r in rows]
         supporting: dict[UUID, list[str]] = {}
-        propositions: dict[UUID, list[dict]] = {}
         if arg_ids:
             joins = await conn.fetch(
-                """SELECT lap.argument_id, lap.claim_id,
+                """SELECT argument_id, claim_id
-                          c.claim_text, c.source_document, c.claim_index
+                   FROM legal_argument_propositions
-                   FROM legal_argument_propositions lap
+                   WHERE argument_id = ANY($1::uuid[])""",
-                   JOIN claims c ON c.id = lap.claim_id
-                   WHERE lap.argument_id = ANY($1::uuid[])
-                   ORDER BY c.claim_index""",
                 arg_ids,
             )
             for j in joins:
                 supporting.setdefault(j["argument_id"], []).append(str(j["claim_id"]))
-                propositions.setdefault(j["argument_id"], []).append({
-                    "id": str(j["claim_id"]),
-                    "text": j["claim_text"],
-                    "source_document": j["source_document"],
-                })
 
     out: list[dict] = []
     for r in rows:
@@ -366,6 +354,5 @@ async def get_legal_arguments(
         d["id"] = str(d["id"])
         d["case_id"] = str(d["case_id"])
         d["supporting_claims"] = supporting.get(r["id"], [])
-        d["supporting_propositions"] = propositions.get(r["id"], [])
         out.append(d)
     return out

mcp-server/src/legal_mcp/services/block_writer.py

@@ -18,10 +18,8 @@ import re
 from datetime import date
 from uuid import UUID
 
-from pathlib import Path
-
 from legal_mcp import config
-from legal_mcp.services import db, embeddings, claude_session, audit, storage
+from legal_mcp.services import db, embeddings, claude_session, audit
 from legal_mcp.services.lessons import (
     OUTCOME_LABELS_HE,
     PRACTICE_AREA_OVERRIDES,
@@ -196,11 +194,6 @@ BLOCK_PROMPTS = {
 1. **תכניות חלות** — מבנה הירכי: תכניות ארציות → מחוזיות → מקומיות. ציטוט ישיר מהוראות תכנית עם **הדגשה** של מילים מכריעות.
 2. **תת-פרק היתרים** — כותרת משנה "היתרים" (או "היתרי בנייה שניתנו במקרקעין"). פירוט ההיתרים הרלוונטיים על פי השומות שהוגשו לתיק.
 
-## ציטוט תכנית ותוקפה (קריטי — מרשם-התכניות):
-- לכל תכנית, לחלק **הזהות והתוקף** (מספר-התכנית + מתי פורסמה למתן תוקף ברשומות + מס' ילקוט-הפרסומים) — השתמש **ככתבו** במשפט-הציטוט הקנוני המופיע תחת "מרשם-התכניות" למטה. **אל תמציא** תאריך-פרסום או מספר-ילקוט.
-- את הייעוד והניתוח התכנוני אתה רשאי לנסח בסגנון דפנה; את תאריך-התוקף ומספר-הילקוט — לעולם לא.
-- אם תכנית זוהתה בתיק אך **חסרה במרשם או טרם אושרה** — הזכר את התכנית בלי לקבוע תאריך-תוקף, ואל תנחש תאריך.
-
 ## כללי ציון סתירות בין שמאים (קריטי):
 - אם שני שמאים או יותר מסרו מידע שונה על אותה תכנית או היתר — חובה לסמן זאת במפורש בנוסח ניטרלי, למשל:
   > "יצוין כי שמאי הוועדה ציין כי תכנית פלונית חלה על המקרקעין במלואה, בעוד שמאי העורר סבר כי חלקה של התכנית בלבד חל"
@@ -220,9 +213,6 @@ BLOCK_PROMPTS = {
 ## תכניות שזוהו (ממטא-דאטה של מסמכים):
 {plans_context}
 
-## מרשם-התכניות — משפטי-ציטוט קנוניים (מקור-אמת לתוקף; השתמש ככתבם):
-{plans_registry_context}
-
 ## עובדות שמאיות שחולצו (תכניות + היתרים, פרק לכל שמאי):
 {appraiser_facts_context}
 
@@ -341,7 +331,6 @@ async def write_block(
     claims_context = await _build_claims_context(case_id)
     direction_context = _build_direction_context(decision)
     plans_context = await _build_plans_context(case_id)
-    plans_registry_context = await _build_plans_registry_context(case_id)
     daphna_style_exemplars, case_law_citations, _precedent_case_law_ids = (
         await _build_precedents_context(case_id, block_id)
     )
@@ -380,7 +369,6 @@ async def write_block(
         claims_context=claims_context,
         direction_context=direction_context,
         plans_context=plans_context,
-        plans_registry_context=plans_registry_context,
         daphna_style_exemplars=daphna_style_exemplars,
         case_law_citations=case_law_citations,
         style_context=style_context,
@@ -422,7 +410,7 @@ async def write_block(
     # Call Claude via Claude Code session (no API)
     model_key = block_cfg["model"]
     timeout = claude_session.LONG_TIMEOUT if model_key == "opus" else claude_session.DEFAULT_TIMEOUT
-    content = await claude_session.query(prompt, timeout=timeout, tools="")  # prose gen — no tool_use → no error_max_turns
+    content = await claude_session.query(prompt, timeout=timeout)
 
     sources = await _collect_block_sources(case_id, block_id)
     sources["case_law_ids"] = _precedent_case_law_ids
@@ -590,60 +578,6 @@ async def _build_plans_context(case_id: UUID) -> str:
     return "(לא זוהו תכניות)"
 
 
-async def _build_plans_registry_context(case_id: UUID) -> str:
-    """Render chair-APPROVED canonical plan citation sentences from the registry (V38).
-
-    The identity+validity clause is deterministic (db.format_plan_citation), so the
-    writer never invents publication dates or ילקוט numbers (INV-AH). Plans seen in
-    the case but absent from the registry — or present yet not approved — are listed
-    explicitly as gaps, never silently dropped (חוקה §6, אין בליעה שקטה).
-    """
-    idents: set[str] = set()
-    for f in await db.list_appraiser_facts(case_id, fact_type="plan"):
-        if f.get("identifier"):
-            idents.add(f["identifier"])
-    for doc in await db.list_documents(case_id):
-        metadata = doc.get("metadata") or {}
-        if isinstance(metadata, str):
-            metadata = json.loads(metadata)
-        for p in (metadata.get("references", {}) or {}).get("plans", []):
-            name = (p.get("plan_name") or "").strip()
-            if name:
-                idents.add(name)
-
-    if not idents:
-        return "(לא זוהו תכניות בתיק. הרץ extract_plans ואשר אותן במרשם-התכניות.)"
-
-    approved: list[dict] = []
-    unapproved: list[dict] = []
-    missing: list[str] = []
-    seen_numbers: set[str] = set()
-    for ident in sorted(idents):
-        plan = await db.get_plan_by_number(ident)
-        if plan is None:
-            missing.append(ident)
-            continue
-        if plan["plan_number"] in seen_numbers:
-            continue
-        seen_numbers.add(plan["plan_number"])
-        (approved if plan["review_status"] == "approved" else unapproved).append(plan)
-
-    lines: list[str] = []
-    if approved:
-        lines.append("### משפטי-ציטוט קנוניים (מאושרים — השתמש בהם ככתבם לזהות+תוקף):")
-        for p in approved:
-            lines.append(f"- {p.get('citation_formatted') or db.format_plan_citation(p)}")
-    if unapproved:
-        lines.append('\n### תכניות במרשם שטרם אושרו (אל תצטט מהן תוקף — ממתינות לאישור-יו"ר):')
-        for p in unapproved:
-            lines.append(f"- {p['display_name'] or p['plan_number']} (status={p['review_status']})")
-    if missing:
-        lines.append("\n### תכניות שזוהו בתיק אך חסרות במרשם (הרץ extract_plans ואשר):")
-        for ident in missing:
-            lines.append(f"- {ident}")
-    return "\n".join(lines)
-
-
 APPRAISER_SIDE_LABEL_HE = {
     "committee": "שמאי הוועדה המקומית",
     "appellant": "שמאי העורר",
@@ -1067,7 +1001,6 @@ async def get_block_context(case_id: UUID, block_id: str, instructions: str = ""
     claims_context = await _build_claims_context(case_id)
     direction_context = _build_direction_context(decision)
     plans_context = await _build_plans_context(case_id)
-    plans_registry_context = await _build_plans_registry_context(case_id)
     daphna_style_exemplars, case_law_citations, _ = (
         await _build_precedents_context(case_id, block_id)
     )
@@ -1102,7 +1035,6 @@ async def get_block_context(case_id: UUID, block_id: str, instructions: str = ""
         claims_context=claims_context,
         direction_context=direction_context,
         plans_context=plans_context,
-        plans_registry_context=plans_registry_context,
         daphna_style_exemplars=daphna_style_exemplars,
         case_law_citations=case_law_citations,
         style_context=style_context,
@@ -1156,45 +1088,37 @@ async def save_block_content(case_id: UUID, block_id: str, content: str) -> dict
     result["generation_type"] = "claude-code"
     result["model_used"] = "claude-code"
 
-    await store_block(UUID(decision["id"]), result)  # store_block syncs the file (#35)
+    await store_block(UUID(decision["id"]), result)
     await db.mark_blocks_stale(case_id, False)
 
+    # Also write/update the draft file on disk
+    await _update_draft_file(case_id, UUID(decision["id"]))
+
     return result
 
 
-async def _update_draft_file(decision_id: UUID) -> None:
+async def _update_draft_file(case_id: UUID, decision_id: UUID) -> None:
-    """Rebuild drafts/decision.md from all blocks in DB — the single
+    """Rebuild drafts/decision.md from all blocks in DB."""
-    regenerate-draft hook (lessons #35 / GAP-88). Called after EVERY
+    from pathlib import Path
-    decision_blocks mutation (store_block, renumber) so the on-disk file never
+
-    drifts from the DB. legal-qa validates against the DB; export and the chair
+    case = await db.get_case(case_id)
-    read the file — keeping them identical kills the "QA fails twice on the same
+    if not case:
-    already-fixed issue" loop (CMPA-62). Resolves case from decision_id so no
+        return
-    caller has to thread case_id through."""
+
+    case_dir = config.find_case_dir(case["case_number"])
+    draft_dir = case_dir / "drafts"
+    draft_dir.mkdir(parents=True, exist_ok=True)
+
     pool = await db.get_pool()
     async with pool.acquire() as conn:
-        case_row = await conn.fetchrow(
-            "SELECT c.case_number FROM decisions d JOIN cases c ON c.id = d.case_id "
-            "WHERE d.id = $1",
-            decision_id,
-        )
-        if not case_row:
-            return
         rows = await conn.fetch(
             "SELECT content FROM decision_blocks WHERE decision_id = $1 AND content != '' ORDER BY block_index",
             decision_id,
         )
 
-    draft_dir = config.find_case_dir(case_row["case_number"]) / "drafts"
-    draft_dir.mkdir(parents=True, exist_ok=True)
     draft_path = draft_dir / "decision.md"
-    draft_text = "\n\n".join(row["content"] for row in rows if row["content"])
+    draft_path.write_text("\n\n".join(row["content"] for row in rows if row["content"]), encoding="utf-8")
-    draft_path.write_text(draft_text, encoding="utf-8")  # noqa: STG1 — sealed below
+    logger.info("Draft file updated: %s (%d blocks)", draft_path, len(rows))
-    try:
-        _dkey = draft_path.resolve().relative_to(Path(config.DATA_DIR).resolve()).as_posix()
-        await storage.mirror(_dkey, draft_text.encode("utf-8"), bucket=storage.Bucket.DOCUMENTS)
-    except ValueError:
-        pass
-    logger.info("Draft file synced: %s (%d blocks)", draft_path, len(rows))
 
 
 # ── Renumbering ───────────────────────────────────────────────────
@@ -1248,11 +1172,6 @@ async def renumber_all_blocks(decision_id: UUID) -> dict:
                 )
             updated += 1
 
-    # #35 — renumber mutates content via raw UPDATE (bypasses store_block), so
-    # sync the draft file here too, otherwise the file keeps stale numbering.
-    if updated:
-        await _update_draft_file(decision_id)
-
     return {"total_paragraphs": current_num - 1, "blocks_updated": updated}
 
 
@@ -1285,9 +1204,6 @@ async def store_block(decision_id: UUID, block_result: dict) -> None:
             block_result["model_used"],
             block_result["temperature"],
         )
-    # #35 — regenerate the on-disk draft on every persist so DB and file stay
-    # identical (legal-qa reads DB; export/chair read the file).
-    await _update_draft_file(decision_id)
 
 
 async def write_and_store_block(

mcp-server/src/legal_mcp/services/brainstorm.py

@@ -134,7 +134,7 @@ async def generate_directions(
 {doc_context or '(אין מסמכים בתיק)'}
 """
 
-    result = await claude_session.query_json(user_content, tools="")  # no tool_use → no error_max_turns
+    result = await claude_session.query_json(user_content)
     if result is None:
         logger.warning("Failed to parse brainstorm response")
         return {

mcp-server/src/legal_mcp/services/bulletin_library.py

@@ -1,121 +0,0 @@
-"""Ingest a monthly "עו"ד על נדל"ן" bulletin into the digests radar (X12).
-
-A bulletin PDF is multi-topic: it EXPLODES into several digest rows — one per
-case-law pointer (digest_kind='decision') and one per article (digest_kind=
-'article'), all tagged publication='עו"ד על נדל"ן' to distinguish them from the
-daily "כל יום" issues. This reuses the existing radar (no parallel corpus — G2):
-the case pointers join search_digests / the /digests page and autolink to the
-underlying ruling exactly like a daily digest; articles are deep-context only.
-
-LOCAL-ONLY (LLM split + embedding) — host scripts/MCP, never the container path.
-Idempotent: each item's content_hash (hash of its analysis_text) is the dedup
-key, so re-running a bulletin skips already-ingested items.
-"""
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-from legal_mcp.services import db, embeddings, extractor
-from legal_mcp.services import bulletin_splitter, digest_library
-
-logger = logging.getLogger(__name__)
-
-PUBLICATION = 'עו"ד על נדל"ן'
-SOURCE_FIRM = "צבי שוב + רונית אלפר, עורכי דין"
-
-
-async def _store_and_embed(digest_row: dict) -> None:
-    """Compute + store the single radar embedding for a freshly created item."""
-    emb_text = digest_library._embedding_text(digest_row)
-    if not emb_text:
-        return
-    try:
-        vecs = await embeddings.embed_texts([emb_text], input_type="document")
-        if vecs:
-            await db.store_digest_embedding(digest_row["id"], vecs[0])
-    except Exception as e:  # §6 — surfaced, not swallowed
-        logger.warning("bulletin item embedding failed for %s: %s", digest_row.get("id"), e)
-
-
-async def _create_item(*, analysis_text: str, kind: str, concept_tag: str,
-                       headline: str, summary: str, citation: str, court: str,
-                       practice_area: str, subject_tags: list[str], src: str) -> dict | None:
-    """Create one digest row from a bulletin item. Returns the row, or None if it
-    already exists (idempotent skip) or the insert raced on content_hash."""
-    content_hash = db._content_hash(analysis_text)
-    if await db.get_digest_by_content_hash(content_hash):
-        return None
-    try:
-        return await db.create_digest(
-            analysis_text=analysis_text,
-            publication=PUBLICATION,
-            source_firm=SOURCE_FIRM,
-            concept_tag=concept_tag,
-            headline_holding=headline,
-            summary=summary,
-            underlying_citation=citation,
-            underlying_court=court,
-            practice_area=practice_area,
-            subject_tags=subject_tags,
-            source_document_path=src,
-            extraction_status="completed",
-            digest_kind=kind,
-        )
-    except Exception as e:
-        # uq_digests_content_hash race (concurrent run) → treat as already-present.
-        if "uq_digests_content_hash" in str(e):
-            return None
-        raise
-
-
-async def ingest_bulletin(file_path: str, model: str | None = None) -> dict:
-    """Split a bulletin PDF into digest rows (case pointers + articles).
-
-    Returns counts: {cases, articles, created, skipped, linked}. Idempotent.
-    """
-    path = str(file_path)
-    raw_text, _pages, _meta = await extractor.extract_text(path)
-    split = await bulletin_splitter.split(raw_text, model=model)
-    cases, articles = split.get("cases", []), split.get("articles", [])
-
-    out = {"file": Path(path).name, "cases": len(cases), "articles": len(articles),
-           "created": 0, "skipped": 0, "linked": 0}
-
-    for c in cases:
-        # analysis_text bundles the pointer's substance → stable per-item hash.
-        atext = "\n".join(p for p in (
-            c["concept_tag"], c["headline_holding"], c["summary"], c["underlying_citation"]
-        ) if p).strip()
-        row = await _create_item(
-            analysis_text=atext, kind="decision", concept_tag=c["concept_tag"],
-            headline=c["headline_holding"], summary=c["summary"],
-            citation=c["underlying_citation"], court=c["underlying_court"],
-            practice_area=c["practice_area"], subject_tags=c["subject_tags"], src=path,
-        )
-        if row is None:
-            out["skipped"] += 1
-            continue
-        out["created"] += 1
-        await _store_and_embed(row)
-        linked = await digest_library.try_autolink(row["id"], c["underlying_citation"])
-        if linked:
-            out["linked"] += 1
-
-    for a in articles:
-        # The article body is the substance; prefix authors into the summary.
-        body = a["body"] or a["summary"]
-        summary = (f"מאת {a['authors']}. " if a["authors"] else "") + (a["summary"] or "")
-        atext = "\n".join(p for p in (a["title"], summary, body) if p).strip()
-        row = await _create_item(
-            analysis_text=atext, kind="article", concept_tag=a["title"],
-            headline=a["title"], summary=summary, citation="", court="",
-            practice_area=a["practice_area"], subject_tags=a["subject_tags"], src=path,
-        )
-        if row is None:
-            out["skipped"] += 1
-            continue
-        out["created"] += 1
-        await _store_and_embed(row)
-
-    return out

mcp-server/src/legal_mcp/services/bulletin_splitter.py

@@ -1,147 +0,0 @@
-"""Split a monthly "עו"ד על נדל"ן" bulletin into typed radar items (X12).
-
-The monthly bulletin (a SEPARATE publication from the daily "כל יום" digest) is
-multi-topic: it bundles a featured ARTICLE, a list of legislative updates, and a
-set of CASE-LAW pointers grouped by topic. The chair chose to catalog the
-**case-law pointers** (each → a digest, like the daily issue) and the
-**articles** (deep-context background) — legislative updates are skipped.
-
-This module is the LLM splitter only. ``bulletin_library.ingest_bulletin`` turns
-its output into digest rows. Like the daily extractor it is LOCAL-ONLY (claude
-CLI) and MUST NOT be imported from the FastAPI container path.
-"""
-from __future__ import annotations
-
-import logging
-
-from legal_mcp import config
-
-logger = logging.getLogger(__name__)
-
-_VALID_PRACTICE_AREAS = {"rishuy_uvniya", "betterment_levy", "compensation_197"}
-
-BULLETIN_SPLIT_PROMPT = """\
-אתה מקבל טקסט מלא של **עלון חודשי "עו"ד על נדל"ן"** (פרסום מקצועי רב-נושאי בתחום
-תכנון ובנייה, מקרקעין, היטל השבחה, פיצויים והתחדשות עירונית). פצל אותו לפריטים.
-
-העלון בנוי משלושה חלקים: (א) **מאמר** מקצועי ארוך אחד או יותר; (ב) **עדכוני חקיקה**
-(תיקוני-חוק, אישורי-תכניות, חוזרים) — **התעלם מהם, אל תחלץ**; (ג) **עדכוני פסיקה**
-מקובצים לפי נושא — כל פריט = מראה-מקום של פסק דין/החלטה + שורת-תקציר.
-
-**אל תמציא** — חלץ רק מה שמופיע בטקסט. שדה חסר → מחרוזת ריקה.
-
-## פלט נדרש
-החזר JSON אחד (object), ללא markdown:
-
-{
-  "cases": [
-    {
-      "underlying_citation": "מראה-המקום המלא של הפסק כפי שמופיע, מילה במילה (למשל 'ערר 8018-02-22 הועדה המקומית בת ים נ' קבוצת מזרחי ובניו השקעות בע\\"מ'). השדה הקריטי.",
-      "concept_tag": "הנושא/הכותרת שתחתיה מופיע הפריט (למשל 'היטל השבחה', 'הפקעות', 'פירוק שיתוף').",
-      "headline_holding": "שורת-התקציר/הכותרת של הפריט — מה נקבע/השאלה (למשל 'חוסר וודאות בין תכנית קודמת לבין ההקלה').",
-      "summary": "תקציר ניטרלי קצר אם יש פירוט נוסף בגוף; אחרת חזור על headline_holding.",
-      "underlying_court": "הערכאה אם מצוינת (למשל 'בית המשפט המחוזי', 'ועדת ערר').",
-      "practice_area": "אחד מ: 'rishuy_uvniya' / 'betterment_levy' / 'compensation_197' — אם ברור מהנושא; אחרת ריק.",
-      "subject_tags": ["2-5 תגיות snake_case בעברית"]
-    }
-  ],
-  "articles": [
-    {
-      "title": "כותרת המאמר (למשל 'הפקעת קרקעות כיום - על המחוקק לתקן את העיוות שנוצר').",
-      "authors": "שמות המחברים (למשל 'עו\\"ד צבי שוב, עו\\"ד רונית אלפר').",
-      "summary": "2-4 משפטים: על מה המאמר ומה הטענה המרכזית.",
-      "body": "הטקסט המלא של המאמר (כל הפסקאות), לצורך embedding וחיפוש-עומק.",
-      "practice_area": "אחד מ-3 אם ברור; אחרת ריק.",
-      "subject_tags": ["2-5 תגיות snake_case"]
-    }
-  ]
-}
-
-## כללים
-1. **underlying_citation** — חלץ במלואו ובדיוק; הוא הגשר לפסק. פריט-פסיקה בלי מראה-מקום ברור → דלג עליו.
-2. **cases** — כל מצביעי-הפסיקה בעלון, גם אם תחת נושאים שונים. אל תאחד פריטים נפרדים.
-3. **articles** — רק מאמרי-עומק (לא רשימת עדכונים). body = הטקסט המלא.
-4. **עדכוני חקיקה/אישורי-תכניות/חוזרים — לא לחלץ כלל.**
-5. אם אין מאמר או אין פסיקה — החזר מערך ריק לאותו מפתח.
-"""
-
-
-def _norm_str(d: dict, key: str) -> str:
-    v = d.get(key)
-    return v.strip() if isinstance(v, str) else ""
-
-
-def _norm_tags(d: dict) -> list[str]:
-    tags = d.get("subject_tags")
-    if not isinstance(tags, list):
-        return []
-    return [str(t).strip() for t in tags if str(t).strip()][:8]
-
-
-def _norm_pa(d: dict) -> str:
-    pa = _norm_str(d, "practice_area")
-    return pa if pa in _VALID_PRACTICE_AREAS else ""
-
-
-async def split(raw_text: str, model: str | None = None) -> dict:
-    """Return ``{"cases": [...], "articles": [...]}`` extracted from a bulletin.
-
-    Empty lists on any failure (surfaced as a warning, never raised) so the
-    batch keeps going. Each item is type-normalized; malformed items are dropped.
-    """
-    from legal_mcp.services import claude_session
-
-    text = (raw_text or "").strip()
-    if not text:
-        return {"cases": [], "articles": []}
-
-    try:
-        result = await claude_session.query_json(
-            text,
-            system=BULLETIN_SPLIT_PROMPT,
-            model=(model or config.DIGEST_EXTRACT_MODEL or None),
-            tools="",  # pure text→JSON; disable tools (avoids error_max_turns)
-        )
-    except Exception as e:  # §6 — surfaced, not swallowed
-        logger.warning("bulletin_splitter: query failed: %s", e)
-        return {"cases": [], "articles": []}
-
-    if not isinstance(result, dict):
-        logger.warning("bulletin_splitter: expected dict, got %s", type(result).__name__)
-        return {"cases": [], "articles": []}
-
-    cases: list[dict] = []
-    for c in result.get("cases") or []:
-        if not isinstance(c, dict):
-            continue
-        citation = _norm_str(c, "underlying_citation")
-        if not citation:  # rule 1: no anchor → skip
-            continue
-        cases.append({
-            "underlying_citation": citation,
-            "concept_tag": _norm_str(c, "concept_tag"),
-            "headline_holding": _norm_str(c, "headline_holding"),
-            "summary": _norm_str(c, "summary") or _norm_str(c, "headline_holding"),
-            "underlying_court": _norm_str(c, "underlying_court"),
-            "practice_area": _norm_pa(c),
-            "subject_tags": _norm_tags(c),
-        })
-
-    articles: list[dict] = []
-    for a in result.get("articles") or []:
-        if not isinstance(a, dict):
-            continue
-        title = _norm_str(a, "title")
-        body = _norm_str(a, "body")
-        if not (title or body):
-            continue
-        articles.append({
-            "title": title,
-            "authors": _norm_str(a, "authors"),
-            "summary": _norm_str(a, "summary"),
-            "body": body,
-            "practice_area": _norm_pa(a),
-            "subject_tags": _norm_tags(a),
-        })
-
-    return {"cases": cases, "articles": articles}

mcp-server/src/legal_mcp/services/chunker.py

@@ -22,25 +22,8 @@ from legal_mcp import config
 # court rulings use slightly different vocabulary (פסק דין, נימוקים, סוף דבר).
 SECTION_PATTERNS = [
     (r"רקע\s*עובדתי|רקע\s*כללי|העובדות|הרקע", "facts"),
-    # parties_claims: bilateral section common in Supreme Court / administrative
+    (r"טענות\s*העוררי[םן]|טענות\s*המערערי[םן]|עיקר\s*טענות\s*העוררי[םן]", "appellant_claims"),
-    # court decisions ("טענות הצדדים", "טיעוני הצדדים"). Not split by side.
+    (r"טענות\s*המשיבי[םן]|תשובת\s*המשיבי[םן]|עיקר\s*טענות\s*המשיבי[םן]", "respondent_claims"),
-    (
-        r"(?:טענות|טיעוני|עמדות)\s*הצדדים",
-        "parties_claims",
-    ),
-    # appellant_claims: covers singular (עורר/עוררת, מערער/מערערת) and plural
-    # (עוררים/עוררין, מערערים), plus court-format verb "טיעוני".
-    (
-        r"(?:טענות|עיקר\s*טענות|טיעוני)\s*ה(?:עוררי[םן]|עורר[ת]?|מערערי[םן]|מערער[ת]?)",
-        "appellant_claims",
-    ),
-    # respondent_claims: covers singular (משיב/משיבה) and plural (משיבים/משיבין),
-    # plus verb forms תשובת/תגובת/טיעוני. "טענות המשיבה:" (feminine singular) was
-    # the root cause of halacha 8181-21 index-11 being extracted from party claims.
-    (
-        r"(?:טענות|תשובת|תגובת|עיקר\s*טענות|טיעוני)\s*ה(?:משיבי[םן]|משיב[ה]?)",
-        "respondent_claims",
-    ),
     (r"דיון\s*והכרעה|דיון|הכרעה|ניתוח\s*משפטי|המסגרת\s*המשפטית|נימוקים", "legal_analysis"),
     (r"מסקנ[הות]|סיכום|סוף\s*דבר", "conclusion"),
     (r"פסק[- ]?דין|החלטה|לפיכך\s*אני\s*מחליט|התוצאה", "ruling"),

mcp-server/src/legal_mcp/services/claims_extractor.py

@@ -135,7 +135,7 @@ async def _extract_chunk(
     last_err: Exception | None = None
     for attempt in range(CHUNK_RETRY_ATTEMPTS + 1):
         try:
-            claims = await claude_session.query_json(prompt, tools="")  # no tool_use → no error_max_turns
+            claims = await claude_session.query_json(prompt)
         except Exception as e:
             last_err = e
             logger.warning(

mcp-server/src/legal_mcp/services/claude_session.py

@@ -29,7 +29,6 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
-import os
 
 from legal_mcp.config import parse_llm_json
 
@@ -41,63 +40,14 @@ logger = logging.getLogger(__name__)
 DEFAULT_TIMEOUT = 1800
 LONG_TIMEOUT = 3600  # opus block writing on full case context
 
-# #85 — two complementary hardenings for the same symptom (`claude -p` failing
+# #85 — `claude -p` fails intermittently with a fast non-zero exit and empty
-# with a fast non-zero exit + empty stderr on large/slow cold prompts: CEO
+# stderr (observed on large/slow cold prompts: CEO write_interim_draft,
-# write_interim_draft, learning_loop distillation):
+# learning_loop distillation). The SAME prompt succeeds on retry, so the bail is
-#
+# transient — retry with linear backoff. Timeouts and "CLI not found" are
-# 1. CLEAN ENV (defensive): a running Claude Code session exports markers into
+# deterministic and are NOT retried.
-#    child processes; a *nested* ``claude -p`` inherits them. Stripping them lets
-#    every nested invocation launch as a clean top-level session. Could not be
-#    reproduced deterministically, so it's a suspect, not a proven cause. Auth/
-#    config (CLAUDE_CONFIG_DIR, ANTHROPIC_*, PATH, HOME) are kept.
-# 2. RETRY (the real fix): the SAME large prompt that exits 1 once succeeds on a
-#    plain retry — the bail is transient. Retry with linear backoff. Timeouts and
-#    "CLI not found" stay deterministic and are NOT retried.
-# See TaskMaster legal-ai #85.
-_SESSION_MARKER_PREFIXES = ("CLAUDECODE", "CLAUDE_CODE_", "CLAUDE_AGENT_")
-_SESSION_MARKER_EXACT = frozenset({"AI_AGENT", "CLAUDE_EFFORT"})
-
 MAX_RETRIES = 3
 RETRY_BACKOFF_BASE = 5  # seconds; sleep = base * attempt_number
 
-# Phrases the CLI emits as the "result" of an exit-0 run that actually hit a
-# usage/rate limit (a refusal NOTICE, not a real answer). Matched only against a
-# result that is NOT structured output (doesn't start with [ or {), so a genuine
-# JSON extraction containing these words as content is never mis-flagged.
-_LIMIT_NOTICE_MARKERS = (
-    "usage limit",
-    "rate limit",
-    "limit reached",
-    "limit will reset",
-    "try again later",
-)
-
-
-def _looks_like_limit_notice(data: dict) -> bool:
-    """True if an exit-0 ``result`` is really a usage/rate-limit refusal."""
-    result = data.get("result")
-    if not isinstance(result, str):
-        return False
-    stripped = result.lstrip()
-    # Structured output (JSON array/object) is a real answer, never a notice.
-    if stripped.startswith(("[", "{")):
-        return False
-    low = result.lower()
-    return any(m in low for m in _LIMIT_NOTICE_MARKERS)
-
-
-def _clean_subprocess_env() -> dict[str, str]:
-    """Copy the current env minus Claude Code session markers.
-
-    Lets a nested ``claude -p`` start fresh instead of detecting it is
-    already inside a Claude Code session (#85).
-    """
-    env = dict(os.environ)
-    for key in list(env):
-        if key in _SESSION_MARKER_EXACT or key.startswith(_SESSION_MARKER_PREFIXES):
-            del env[key]
-    return env
-
 
 async def query(
     prompt: str,
@@ -107,7 +57,6 @@ async def query(
     system: str | None = None,
     model: str | None = None,
     effort: str | None = None,
-    tools: str | None = None,
 ) -> str:
     """Send a prompt to Claude Code headless and return the text response.
 
@@ -130,12 +79,6 @@ async def query(
         effort: Optional effort level (``low``/``medium``/``high``/``xhigh``/
             ``max``). When set, passed as ``--effort``. Pairs with ``model``;
             an empty string is treated as "unset" (CLI default).
-        tools: Optional available-tools spec, passed as ``--tools``. Pass an
-            empty string (``""``) to disable ALL tools — for pure text→JSON
-            extraction the model has no reason to call a tool, and leaving
-            tools enabled makes it occasionally emit ``stop_reason: tool_use``
-            which trips ``--max-turns 1`` → ``error_max_turns`` and forces a
-            retry (slow). ``None`` leaves the CLI default (all tools).
 
     Returns:
         The text response from Claude.
@@ -158,8 +101,6 @@ async def query(
         cmd += ["--model", model]
     if effort:
         cmd += ["--effort", effort]
-    if tools is not None:  # "" → disable all tools (no tool_use → no max-turns trip)
-        cmd += ["--tools", tools]
 
     size_info = f"; prompt_len={len(full_prompt):,} chars" if len(full_prompt) > 100_000 else ""
     last_err = "unknown error"
@@ -171,8 +112,6 @@ async def query(
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.PIPE,
-                env=_clean_subprocess_env(),
-                cwd=os.path.expanduser("~"),
             )
         except FileNotFoundError:
             # Deterministic — never retry.
@@ -200,11 +139,8 @@ async def query(
             raise RuntimeError(f"Claude CLI timed out after {timeout}s")
 
         if proc.returncode != 0:
-            # The CLI sometimes writes its diagnostic to stdout (or nowhere)
+            stderr = stderr_b.decode("utf-8", errors="replace").strip()[:500] or "unknown error"
-            # rather than stderr (#85) — surface whichever is present.
+            last_err = f"exit {proc.returncode}: {stderr}"
-            stderr = stderr_b.decode("utf-8", errors="replace").strip()
-            stdout = stdout_b.decode("utf-8", errors="replace").strip()
-            last_err = f"exit {proc.returncode}: {(stderr or stdout or 'no output')[:500]}"
         else:
             stdout = stdout_b.decode("utf-8", errors="replace").strip()
             if stdout:
@@ -212,26 +148,10 @@ async def query(
                 try:
                     data = json.loads(stdout)
                     if isinstance(data, dict) and "result" in data:
-                        # A usage/rate-limit hit can exit 0 with a refusal NOTICE
-                        # as the "result" (is_error / error subtype). Returning it
-                        # as success makes callers treat a throttled run as a real
-                        # empty answer — e.g. the halacha extractor then checkpoints
-                        # the chunk as done-with-0-halachot and a resume skips it
-                        # forever (#138/#144 silent under-extraction). Treat it as a
-                        # transient failure → retry, and raise if it persists so the
-                        # chunk stays un-checkpointed for a real resume.
-                        if data.get("is_error") or _looks_like_limit_notice(data):
-                            last_err = (
-                                f"error result (subtype={data.get('subtype')}): "
-                                f"{str(data.get('result',''))[:200]}"
-                            )
-                        else:
                         return data["result"]
-                    else:
                     return stdout
                 except json.JSONDecodeError:
                     return stdout
-            else:
             last_err = "empty response"
 
         # Transient failure — retry with linear backoff unless this was the last try.
@@ -254,15 +174,13 @@ async def query_json(
     system: str | None = None,
     model: str | None = None,
     effort: str | None = None,
-    tools: str | None = None,
 ) -> dict | list | None:
     """Send a prompt and parse the response as JSON.
 
     Uses parse_llm_json for robust parsing (handles markdown wrapping, truncation).
-    ``model``/``effort``/``tools`` are forwarded to :func:`query` (see its docstring).
+    ``model``/``effort`` are forwarded to :func:`query` (see its docstring).
-    Pure text→JSON extractors should pass ``tools=""`` to avoid ``error_max_turns``.
     """
-    raw = await query(prompt, timeout=timeout, system=system, model=model, effort=effort, tools=tools)
+    raw = await query(prompt, timeout=timeout, system=system, model=model, effort=effort)
     return parse_llm_json(raw)
 
 
@@ -338,7 +256,6 @@ async def query_streaming(
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
             cwd=cwd,
-            env=_clean_subprocess_env(),
         )
     except FileNotFoundError:
         yield {

mcp-server/src/legal_mcp/services/corroboration.py

@@ -88,7 +88,6 @@ async def classify_treatment(cited_citation: str, context: str) -> str:
             user, system=_TREATMENT_PROMPT,
             model=config.HALACHA_EXTRACT_MODEL or None,
             effort=config.HALACHA_EXTRACT_EFFORT or None,
-            tools="",  # pure text→JSON — no tool_use → no error_max_turns
         )
     except Exception as e:
         logger.warning("classify_treatment failed: %s", e)

mcp-server/src/legal_mcp/services/court_citation.py

@@ -1,255 +0,0 @@
-"""Court-citation classifier for the auto-fetch subsystem (X13).
-
-Given a raw citation string (typically a digest's ``underlying_citation``,
-e.g. ``עת"מ 46111-12-22 יכין-אפק נ' הוועדה המחוזית``), decide:
-
-  * **which tier** can fetch it (``supreme`` | ``admin`` | ``skip``), and
-  * the **canonical case number** plus, for נט המשפט, the
-    (file, month, year) triple the public case-search form needs.
-
-Tier mapping (INV-CF6 — only court rulings are auto-fetched; ועדת-ערר is
-never sent to a public fetch, it needs Nevo):
-
-  * ``supreme`` — Supreme Court prefixes (עע"מ/בג"ץ/ע"א/רע"א/דנ"א/בר"מ/בש"א).
-    Fetched directly from ``supremedecisions.court.gov.il`` (Tier 0, no CAPTCHA).
-  * ``admin``   — district / administrative-court prefixes (עת"מ/עמ"נ/…) and
-    the bare נט-המשפט "filed" format ``NNNNN-MM-YY``. Fetched via the
-    host-side stealth browser against נט המשפט (Tier 1).
-  * ``skip``    — ועדת-ערר (ערר/בל"מ). Not publicly fetchable → missing_precedent.
-
-Regex families intentionally mirror ``citation_extractor.py`` (the canonical
-prefix/number patterns) so the two stay in sync — we reuse ``_NUM_RX`` shape
-and ``_normalize_case_number`` semantics rather than inventing a parallel
-parser (INV-CF1 / engineering "symmetry" rule).
-"""
-
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-
-# Canonical number core, identical shape to citation_extractor._NUM_RX:
-# 3-5 digits, optional separator + 2-4 digits, optional third group
-# (the NNNNN-MM-YY "filed" format — 46111-12-22 = file 46111, month 12, yr 22).
-_NUM_RX = r"\d{1,5}(?:[-/]\d{1,4}(?:[-/]\d{2,4})?)?"
-
-# Hebrew gershayim: straight (") or curly (״).
-_Q = r"[\"״]"
-
-# Optional leading one-letter Hebrew preposition/conjunction (ב/ל/ה/ו/כ/מ/ש)
-# attached to the prefix — e.g. "בערר", "וערר", "כפי שקבעתי בערר". Anchored by
-# a lookbehind that forbids a *preceding* Hebrew letter, so we don't match a
-# prefix buried inside a longer word. Regex backtracking lets the preposition
-# match empty when the prefix itself starts with one of these letters (בג"ץ).
-_LEAD = r"(?<![א-ת])(?:[בלהוכמש])?"
-
-# Supreme Court prefixes → Tier 0 (supremedecisions public download API).
-_SUPREME_PREFIXES = [
-    rf"עע{_Q}מ",   # ערעור מנהלי (לעליון)
-    rf"בג{_Q}ץ",   # בג"ץ
-    rf"בג{_Q}צ",   # variant spelling
-    rf"דנג{_Q}ץ",  # דיון נוסף בג"ץ
-    rf"ע{_Q}א",    # ערעור אזרחי
-    rf"רע{_Q}א",   # רשות ערעור אזרחי
-    rf"דנ{_Q}א",   # דיון נוסף אזרחי
-    rf"בר{_Q}מ",   # בקשת רשות ערעור מנהלי (עליון)
-    rf"בש{_Q}א",   # בקשת רשות … (עליון)
-]
-
-# District / administrative-court prefixes → Tier 1 (נט המשפט case viewer).
-_ADMIN_PREFIXES = [
-    rf"עת{_Q}מ",   # עתירה מנהלית (בימ"ש לעניינים מנהליים)
-    rf"עמ{_Q}נ",   # ערעור מנהלי (מחוזי)
-    rf"ת{_Q}א",    # תביעה אזרחית (מחוזי/שלום)
-    rf"ה{_Q}פ",    # המרצת פתיחה
-]
-
-# Appeals-committee → skip (needs Nevo; never auto-fetched).
-_SKIP_PREFIXES = [
-    rf"ערר",
-    rf"בל{_Q}מ",
-]
-
-_SUPREME_RX = re.compile(
-    _LEAD + r"(" + "|".join(_SUPREME_PREFIXES) + r")\s*(" + _NUM_RX + r")",
-    re.UNICODE,
-)
-_ADMIN_RX = re.compile(
-    _LEAD + r"(" + "|".join(_ADMIN_PREFIXES) + r")\s*(" + _NUM_RX + r")",
-    re.UNICODE,
-)
-_SKIP_RX = re.compile(
-    _LEAD + r"(" + "|".join(_SKIP_PREFIXES) + r")" + r"(?:\s*\([^)\n]{0,80}\))?\s*(" + _NUM_RX + r")",
-    re.UNICODE,
-)
-
-# Bare נט-המשפט filed format with no prefix: 46111-12-22 (5/4-digit file,
-# 1-2 digit month, 2-4 digit year). Used when a digest gives just the number.
-_BARE_FILED_RX = re.compile(r"(?<!\d)(\d{1,5})-(\d{1,2})-(\d{2,4})(?!\d)", re.UNICODE)
-
-
-@dataclass
-class CourtCitation:
-    """Result of classifying a citation for auto-fetch routing."""
-
-    tier: str  # "supreme" | "admin" | "skip" | "unknown"
-    court_prefix: str  # e.g. 'עת"מ', or "" for bare/unknown
-    case_number_raw: str  # the matched number as written, e.g. "46111-12-22"
-    case_number_norm: str  # canonical: slashes→dashes, digits/sep only
-    # נט-המשפט form fields (only when the filed format NNNNN-MM-YY is present):
-    file_number: str | None = None
-    month: str | None = None
-    year: str | None = None
-
-    @property
-    def fetchable(self) -> bool:
-        return self.tier in ("supreme", "admin")
-
-
-def normalize_case_number(raw: str) -> str:
-    """Canonicalize a case number for idempotency keys / matching.
-
-    Mirrors ``citation_extractor._normalize_case_number``: strip everything
-    but digits and separators, unify ``/`` → ``-``. Display value is never
-    derived from this.
-    """
-    cleaned = re.sub(r"[^\d/\-]", "", raw or "")
-    return cleaned.replace("/", "-").strip("-")
-
-
-def case_number_from_citation(citation: str) -> str:
-    """Canonical ``case_number`` extracted from a full citation, or ``''``.
-
-    Returns the normalized number token only (e.g. ``85074-04-25``) — NEVER the
-    full citation string with party names / court / date. This is the
-    identifier-field rule from X1 (INV-ID2): a citation like
-    ``ערר (ת"א 85074-04-25) רפאל לוי ואח' נ' הוועדה … - חולון`` yields
-    ``85074-04-25``, not the whole display string.
-
-    Reuses ``classify`` (the one canonical citation parser) so callers that need
-    a case_number out of an arbitrary citation never roll their own regex (#137,
-    G2). Returns ``''`` when no number can be parsed — the caller MUST treat that
-    as "needs a manual case_number" and never fall back to the raw citation.
-    """
-    return classify(citation).case_number_norm
-
-
-def _norm_designator(prefix: str) -> str:
-    """Collapse a court/proceeding prefix to a comparison token.
-
-    Strips gershayim variants and whitespace so ``עע"מ`` / ``עע״מ`` / ``עעמ``
-    all map to the same token, while DISTINCT courts stay distinct.
-    """
-    return re.sub(r"[\s\"״׳']", "", prefix or "")
-
-
-def citation_dedup_key(citation: str) -> str:
-    """Designator-aware dedup key for a citation, or ``''`` if no number.
-
-    Returns ``f"{designator}|{case_number_norm}"`` — e.g.
-    ``בג"ץ 389/87`` → ``בגץ|389-87`` and ``ע"א 389/87`` → ``עא|389-87`` are
-    DISTINCT keys, even though both share docket ``389-87``. This is the safe
-    dedup key for ``missing_precedents`` (#143/#136): deduping on the bare number
-    alone (``case_number_from_citation``) would WRONGLY MERGE the same docket
-    across different courts (18 such collisions already exist in the corpus). A
-    prefix-less citation (bare נט-format / unknown court) yields ``|<number>``.
-    """
-    cit = classify(citation)
-    if not cit.case_number_norm:
-        return ""
-    return f"{_norm_designator(cit.court_prefix)}|{cit.case_number_norm}"
-
-
-def _split_filed(num_norm: str) -> tuple[str, str, str] | None:
-    """Split a normalized NNNNN-MM-YY number into (file, month, year).
-
-    Only the three-group "filed" format yields a נט-המשפט triple; two-group
-    formats (1234-22 / 1234/22) are Supreme-style serials and return None.
-    """
-    m = _BARE_FILED_RX.fullmatch(num_norm)
-    if not m:
-        return None
-    file_no, month, year = m.group(1), m.group(2), m.group(3)
-    # Plausibility: month 1-12, year 2-4 digits. Reject implausible months
-    # (avoids mis-reading a 2-group serial that slipped through).
-    if not (1 <= int(month) <= 12):
-        return None
-    return file_no, month, year
-
-
-def classify(citation: str) -> CourtCitation:
-    """Classify a raw citation string into a fetch tier + parsed number.
-
-    Resolution order: ועדת-ערר (skip) is checked FIRST so an "ערר" prefix is
-    never mis-routed to a court tier; then Supreme prefixes; then admin
-    prefixes; then a bare filed number defaults to ``admin`` (נט המשפט is the
-    only public source for prefix-less district/שלום numbers).
-    """
-    text = (citation or "").strip()
-    if not text:
-        return CourtCitation("unknown", "", "", "")
-
-    # 1. ועדת-ערר → skip (must win over any court match).
-    m = _SKIP_RX.search(text)
-    if m:
-        raw = m.group(2)
-        return CourtCitation(
-            tier="skip",
-            court_prefix=m.group(1),
-            case_number_raw=raw,
-            case_number_norm=normalize_case_number(raw),
-        )
-
-    # 2. Supreme Court prefix → Tier 0. Still parse a נט-format triple when the
-    #    number carries one (e.g. בר"מ 72182-06-25): נט המשפט serves Supreme
-    #    cases too, so a triple lets the orchestrator route to the validated
-    #    Tier-1 flow instead of the serial-only Tier-0.
-    m = _SUPREME_RX.search(text)
-    if m:
-        raw = m.group(2)
-        norm = normalize_case_number(raw)
-        filed = _split_filed(norm)
-        return CourtCitation(
-            tier="supreme",
-            court_prefix=m.group(1),
-            case_number_raw=raw,
-            case_number_norm=norm,
-            file_number=filed[0] if filed else None,
-            month=filed[1] if filed else None,
-            year=filed[2] if filed else None,
-        )
-
-    # 3. District / admin prefix → Tier 1.
-    m = _ADMIN_RX.search(text)
-    if m:
-        raw = m.group(2)
-        norm = normalize_case_number(raw)
-        filed = _split_filed(norm)
-        return CourtCitation(
-            tier="admin",
-            court_prefix=m.group(1),
-            case_number_raw=raw,
-            case_number_norm=norm,
-            file_number=filed[0] if filed else None,
-            month=filed[1] if filed else None,
-            year=filed[2] if filed else None,
-        )
-
-    # 4. Bare filed number (no prefix) → default admin (נט המשפט).
-    m = _BARE_FILED_RX.search(text)
-    if m:
-        raw = m.group(0)
-        norm = normalize_case_number(raw)
-        filed = _split_filed(norm)
-        if filed:
-            return CourtCitation(
-                tier="admin",
-                court_prefix="",
-                case_number_raw=raw,
-                case_number_norm=norm,
-                file_number=filed[0],
-                month=filed[1],
-                year=filed[2],
-            )
-
-    return CourtCitation("unknown", "", "", "")

mcp-server/src/legal_mcp/services/court_fetch_orchestrator.py

@@ -1,327 +0,0 @@
-"""X13 orchestrator — classify → fetch → ingest → record.
-
-The single entry point (`fetch_and_ingest`) wires the three tiers to the
-**canonical** precedent-ingest pipeline (INV-CF1 — no parallel ingest path)
-and keeps the `court_fetch_jobs` row honest at every step (INV-CF2 — a job
-always ends in an explicit terminal state, never a silent drop).
-
-Tier routing (from `court_citation.classify`):
-  * ``skip``    — ועדת-ערר → never fetched; logged as a missing_precedent gap.
-  * ``supreme`` — Tier 0, in-process httpx (`court_fetch_supreme`).
-  * ``admin``   — Tier 1, the host-side stealth-browser service over loopback.
-
-Fallback (INV-CF3): after ``MAX_AUTONOMOUS_ATTEMPTS`` autonomous failures the
-job flips to ``manual`` and a missing_precedent row is opened so the chair
-sees the gap and can solve the CAPTCHA live (VNC) or drop the file manually.
-
-This module runs **in the local MCP server only** — `ingest_precedent` drives
-halacha extraction via the local ``claude`` CLI (see `claude_session.py`). It
-is invoked from the `court_verdict_fetch` MCP tool, not from the container.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import tempfile
-from pathlib import Path
-from uuid import UUID
-
-import httpx
-
-from legal_mcp.services import court_citation, db
-from legal_mcp.services.court_fetch_supreme import (
-    SupremeFetchError,
-    fetch_supreme_verdict,
-)
-
-logger = logging.getLogger(__name__)
-
-# After this many autonomous failures, stop auto-retrying and escalate to a
-# human (INV-CF3). Kept low — the .gov site shouldn't be hammered (INV-CF4).
-MAX_AUTONOMOUS_ATTEMPTS = int(os.environ.get("COURT_FETCH_MAX_ATTEMPTS", "2"))
-
-# The host-side Tier-1 browser service (pm2). It binds the docker0 bridge
-# gateway (10.0.1.1) — same as legal-chat-service — so both the host MCP server
-# and containers can reach it; the host reaches 10.0.1.1 as a local interface.
-# Override with COURT_FETCH_SERVICE_URL.
-COURT_FETCH_SERVICE_URL = os.environ.get(
-    "COURT_FETCH_SERVICE_URL", "http://10.0.1.1:8771"
-)
-_SHARED_SECRET = os.environ.get("COURT_FETCH_SHARED_SECRET", "").strip()
-_TIER1_TIMEOUT_S = float(os.environ.get("COURT_FETCH_TIER1_TIMEOUT_S", "300"))
-
-# Provenance level by tier — Supreme rulings are binding; admin-court verdicts
-# are administrative (set is_binding conservatively True, chair can downgrade).
-_LEVEL_BY_TIER = {"supreme": "עליון", "admin": "מנהלי"}
-
-
-class _Tier1Unavailable(RuntimeError):
-    """The host browser service is not reachable / not configured."""
-
-
-async def _ingest_bytes(
-    *, content: bytes, filename: str, citation: str, tier: str,
-    court: str, source_url: str,
-) -> dict:
-    """Stage bytes to a temp file and run the canonical ingest (INV-CF1)."""
-    from legal_mcp.services import precedent_library
-
-    suffix = Path(filename).suffix or ".pdf"
-    tmp = tempfile.NamedTemporaryFile(
-        prefix="court_fetch_", suffix=suffix, delete=False
-    )
-    try:
-        tmp.write(content)
-        tmp.flush()
-        tmp.close()
-        result = await precedent_library.ingest_precedent(
-            file_path=tmp.name,
-            citation=citation,
-            court=court,
-            source_type="court_ruling",          # INV-CF6
-            precedent_level=_LEVEL_BY_TIER.get(tier, ""),
-            is_binding=True,
-        )
-        # Stamp provenance on the new case_law row (INV-CF7).
-        case_law_id = result.get("case_law_id")
-        if case_law_id and source_url:
-            try:
-                await db.update_case_law(
-                    UUID(str(case_law_id)), source_url=source_url
-                )
-            except Exception:  # provenance is best-effort, never blocks ingest
-                logger.warning("could not stamp source_url on %s", case_law_id)
-        return result
-    finally:
-        try:
-            os.unlink(tmp.name)
-        except OSError:
-            pass
-
-
-async def _fetch_tier1_admin(cit: court_citation.CourtCitation) -> dict:
-    """Call the host-side browser service to fetch an admin-court verdict.
-
-    Returns the service's JSON: ``{ok, content_b64, filename, source_url,
-    court, reason}``. Raises ``_Tier1Unavailable`` if the service can't be
-    reached, ``SupremeFetchError``-style RuntimeError on a fetch failure the
-    service reports.
-    """
-    if not (cit.file_number and cit.month and cit.year):
-        raise RuntimeError(
-            f"מספר-תיק {cit.case_number_norm} אינו בפורמט נט-המשפט (תיק-חודש-שנה)"
-        )
-    headers = {"Authorization": f"Bearer {_SHARED_SECRET}"} if _SHARED_SECRET else {}
-    payload = {
-        "file_number": cit.file_number,
-        "month": cit.month,
-        "year": cit.year,
-        "case_number": cit.case_number_norm,
-        "court": cit.court_prefix,
-    }
-    try:
-        async with httpx.AsyncClient(timeout=_TIER1_TIMEOUT_S) as client:
-            resp = await client.post(
-                f"{COURT_FETCH_SERVICE_URL}/fetch", json=payload, headers=headers
-            )
-    except httpx.ConnectError as e:
-        raise _Tier1Unavailable(
-            f"שירות-האחזור (legal-court-fetch-service) אינו זמין ב-"
-            f"{COURT_FETCH_SERVICE_URL}: {e}"
-        ) from e
-    if resp.status_code != 200:
-        raise RuntimeError(f"שירות-האחזור החזיר {resp.status_code}: {resp.text[:200]}")
-    return resp.json()
-
-
-async def fetch_and_ingest(
-    citation: str, *, digest_id: UUID | None = None
-) -> dict:
-    """Classify a citation, fetch the verdict, ingest it, and record the job.
-
-    Idempotent on the canonical case number (INV-CF5): a case already fetched
-    (job ``done``) is returned without re-fetching.
-    """
-    cit = court_citation.classify(citation)
-
-    # ── skip: ועדת-ערר — never auto-fetched (INV-CF6). Surface as a gap. ──
-    if cit.tier == "skip":
-        await _open_gap(citation, reason="ועדת-ערר — לא ניתן לאחזור ציבורי (נדרש נבו)")
-        return {"status": "skipped", "tier": "skip", "citation": citation,
-                "reason": "appeals_committee — needs Nevo"}
-    if cit.tier == "unknown" or not cit.case_number_norm:
-        return {"status": "unrecognized", "citation": citation}
-
-    # ── idempotent job row ──
-    job = await db.court_fetch_job_upsert(
-        case_number_norm=cit.case_number_norm,
-        citation_raw=citation,
-        tier=cit.tier,
-        court=cit.court_prefix,
-        digest_id=digest_id,
-    )
-    if job.get("status") == "done":
-        return {"status": "already_done", "job": job}
-    if job.get("status") == "manual":
-        return {"status": "awaiting_manual", "job": job}
-
-    job_id = UUID(str(job["id"]))
-    await db.court_fetch_job_update(job_id, status="running", bump_attempts=True)
-
-    # ── fetch ──
-    # Route by what the number lets us do, not just the court prefix: נט המשפט
-    # (Tier 1) serves ALL courts — Supreme included — as long as the citation
-    # carries a נט-format triple (file-month-year). Validated live on both
-    # district (עת"מ 43830-12-24) and Supreme (בר"מ 72182-06-25). Only a serial-
-    # only Supreme number (e.g. עע"מ 5886/24, no month) can't be looked up that
-    # way → fall through to Tier 0 (supremedecisions).
-    has_net_format = bool(cit.file_number and cit.month and cit.year)
-    try:
-        if has_net_format:
-            res = await _fetch_tier1_admin(cit)
-            if not res.get("ok"):
-                raise RuntimeError(res.get("reason") or "אחזור נכשל")
-            import base64
-            content = base64.b64decode(res["content_b64"])
-            filename = res.get("filename") or f"{cit.case_number_norm}.pdf"
-            source_url = res.get("source_url", "")
-            court = res.get("court") or cit.court_prefix
-        elif cit.tier == "supreme":
-            fetched = await fetch_supreme_verdict(
-                citation=citation, case_number_norm=cit.case_number_norm
-            )
-            content, filename = fetched.content, fetched.filename
-            source_url, court = fetched.source_url, fetched.court
-        else:
-            raise RuntimeError(
-                f"מספר-תיק {cit.case_number_norm} אינו בפורמט נט-המשפט ואינו עליון — "
-                "אין מסלול-אחזור ציבורי"
-            )
-    except Exception as e:  # noqa: BLE001 — any fetch error is recorded, never
-        # left hanging in 'running' (INV-CF2). _record_failure escalates to
-        # 'manual' after MAX_AUTONOMOUS_ATTEMPTS (INV-CF3).
-        return await _record_failure(job_id, cit, citation, str(e))
-
-    # ── ingest into the canonical pipeline (INV-CF1) ──
-    try:
-        result = await _ingest_bytes(
-            content=content, filename=filename, citation=citation,
-            tier=cit.tier, court=court, source_url=source_url,
-        )
-    except Exception as e:  # noqa: BLE001 — recorded, never swallowed (INV-CF2)
-        logger.exception("ingest failed for %s", cit.case_number_norm)
-        return await _record_failure(job_id, cit, citation, f"קליטה נכשלה: {e}")
-
-    case_law_id = result.get("case_law_id")
-    await db.court_fetch_job_update(
-        job_id, status="done",
-        case_law_id=UUID(str(case_law_id)) if case_law_id else None,
-        source_url=source_url, error="",
-    )
-    # Close the digest gap (INV-DIG3): if this fetch traces back to a digest,
-    # link it to the freshly-ingested ruling. Best-effort; never fails the job.
-    link_digest_id = digest_id or job.get("digest_id")
-    if case_law_id and link_digest_id:
-        try:
-            await db.link_digest_to_case_law(link_digest_id, UUID(str(case_law_id)))
-            logger.info("linked digest %s → case_law %s", link_digest_id, case_law_id)
-        except Exception:
-            logger.warning("could not relink digest %s after fetch", link_digest_id)
-
-    # Close any open missing-precedent gap this fetch fills (the citation graph
-    # often records the same ruling as a gap). Best-effort.
-    if case_law_id:
-        await _close_matching_gaps(cit.case_number_norm, UUID(str(case_law_id)))
-
-    return {"status": "done", "tier": cit.tier, "case_law_id": case_law_id,
-            "citation": citation, "source_url": source_url, "ingest": result}
-
-
-async def _close_matching_gaps(case_number_norm: str, case_law_id: UUID) -> None:
-    """Close open missing_precedents whose citation matches the fetched case."""
-    try:
-        gaps = await db.list_missing_precedents(status="open", limit=500)
-        for g in gaps:
-            if court_citation.normalize_case_number(g.get("citation", "")) == case_number_norm:
-                await db.close_missing_precedent(
-                    UUID(str(g["id"])), linked_case_law_id=case_law_id,
-                    status="closed", notes="נקלט אוטומטית דרך אחזור-פסיקה (X13)",
-                )
-                logger.info("closed missing_precedent %s", g["id"])
-    except Exception:
-        logger.warning("could not close gaps for %s", case_number_norm)
-
-
-# Politeness between consecutive court fetches in a drain (INV-CF4) — serial,
-# spaced. Mirrors the precedent-extraction queue cadence.
-_INTER_FETCH_COOLDOWN_S = float(os.environ.get("COURT_FETCH_DRAIN_COOLDOWN_S", "20"))
-
-
-async def drain_pending(limit: int = 10) -> dict:
-    """Process queued court-fetch jobs (status pending/failed) serially.
-
-    Drains the ``court_fetch_jobs`` queue the digest trigger fills — fetch +
-    ingest each, link back to its digest. Serial with a cooldown (INV-CF4); a
-    job that fails is recorded and retried next drain until it escalates to
-    ``manual`` (INV-CF3). Local-only (runs the ingest pipeline / claude CLI).
-    """
-    import asyncio
-
-    jobs = await db.court_fetch_job_list(status="pending", limit=limit)
-    jobs += await db.court_fetch_job_list(status="failed", limit=limit)
-    seen, queue = set(), []
-    for j in jobs:
-        k = j["case_number_norm"]
-        if k not in seen:
-            seen.add(k); queue.append(j)
-    results = []
-    for i, j in enumerate(queue[:limit]):
-        if i:
-            await asyncio.sleep(_INTER_FETCH_COOLDOWN_S)
-        digest_id = j.get("digest_id")
-        try:
-            r = await fetch_and_ingest(j["citation_raw"], digest_id=digest_id)
-        except Exception as e:  # noqa: BLE001 — recorded per-job, never aborts the drain
-            logger.exception("drain item failed: %s", j["case_number_norm"])
-            r = {"status": "error", "citation": j["citation_raw"], "error": str(e)}
-        results.append(r)
-    done = sum(1 for r in results if r.get("status") in ("done", "already_done"))
-    return {"processed": len(results), "done": done, "results": results}
-
-
-async def _record_failure(
-    job_id: UUID, cit: court_citation.CourtCitation, citation: str, err: str
-) -> dict:
-    """Record a fetch/ingest failure; escalate to manual after N attempts (INV-CF3)."""
-    job = await db.court_fetch_job_get(cit.case_number_norm)
-    attempts = (job or {}).get("attempts", 1)
-    if attempts >= MAX_AUTONOMOUS_ATTEMPTS:
-        await db.court_fetch_job_update(job_id, status="manual", error=err)
-        await _open_gap(
-            citation,
-            reason=f"אחזור אוטונומי נכשל ({attempts} נסיונות) — נדרשת הורדה ידנית. {err}",
-        )
-        logger.warning("court fetch escalated to manual: %s — %s", citation, err)
-        return {"status": "manual", "citation": citation, "error": err,
-                "attempts": attempts}
-    await db.court_fetch_job_update(job_id, status="failed", error=err)
-    logger.warning("court fetch failed (will retry): %s — %s", citation, err)
-    return {"status": "failed", "citation": citation, "error": err,
-            "attempts": attempts}
-
-
-async def _open_gap(citation: str, *, reason: str) -> None:
-    """Open a missing_precedent gap so the chair sees it (INV-CF2/CF3).
-
-    Best-effort + de-duplicated (designator-aware via citation_norm, #143); a
-    failure here is logged, never raised (it must not mask the original outcome).
-    """
-    try:
-        if await db.find_missing_precedent_by_citation(citation):
-            return
-        await db.create_missing_precedent(
-            citation=citation, notes=reason, discovery_source="court_fetch",
-        )
-    except Exception:
-        logger.warning("could not open missing_precedent for %s", citation)

mcp-server/src/legal_mcp/services/court_fetch_supreme.py

@@ -1,197 +0,0 @@
-"""Tier 0 — Supreme Court verdict fetcher (X13), via supremedecisions.court.gov.il.
-
-Pulls a published Supreme Court verdict PDF from the **public** decisions portal
-— no smart-card, no CAPTCHA, no browser (pure httpx). Used for serial-format
-citations (בג"ץ/בר"מ/עע"מ NNNN/YY) that have no נט-format triple and so can't go
-through the Tier-1 נט-המשפט flow.
-
-The portal is an AngularJS SPA over a small ASP.NET JSON API, reverse-engineered
-and validated live (2026-06-08 on בג"ץ 3483/05 → 75 KB PDF). The flow:
-
-  POST Home/SearchVerdicts
-       body: {"document": {"Year": "YYYY", "CaseNum": "NNNN", "Month": {},
-                           "dateType": 1, "publishDate": 8,
-                           "SearchText": [<empty clause>],
-                           "OldMainNumFormat": true}, "lan": 1}
-       → {"data": [{Path, FileName, CaseName, Type, Pages, VerdictDt, ...}, ...]}
-  GET  Home/Download?path=<Path>&fileName=<FileName>&type=4   → the verdict PDF
-
-Two things are required to get JSON instead of an F5 WAF block (verified):
-  * the **X-Requested-With: XMLHttpRequest** header on every AJAX call;
-  * a **complete** browser header set (UA + Accept + Accept-Language).
-
-A case can have many documents (interim החלטות + the final פסק דין). We pick the
-verdict: prefer a record whose Type contains "פסק דין", else the most-paginated /
-latest one. Politeness (INV-CF4): serial, with a cooldown.
-"""
-
-from __future__ import annotations
-
-import asyncio
-import datetime as _dt
-import logging
-import os
-import re
-import urllib.parse
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-_BASE = "https://supremedecisions.court.gov.il"
-
-_HEADERS = {
-    "User-Agent": (
-        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 "
-        "(KHTML, like Gecko) Chrome/126.0 Safari/537.36"
-    ),
-    "Accept": "application/json, text/plain, */*",
-    "Accept-Language": "he-IL,he;q=0.9,en;q=0.8",
-    "X-Requested-With": "XMLHttpRequest",       # required — F5 WAF blocks AJAX without it
-    "Referer": _BASE + "/",
-}
-
-_REQUEST_TIMEOUT_S = float(os.environ.get("COURT_FETCH_HTTP_TIMEOUT_S", "30"))
-_INTER_REQUEST_COOLDOWN_S = float(os.environ.get("COURT_FETCH_COOLDOWN_S", "2"))
-_DOC_TYPE_PDF = "4"
-
-# Empty search clause the portal expects inside the document.
-_EMPTY_CLAUSE = {
-    "Text": "", "textOperator": 1, "option": 2, "Inverted": False,
-    "Synonym": False, "NearDistance": 3, "MatchOrder": False,
-}
-
-
-class FetchedVerdict:
-    """A downloaded verdict file held in memory, ready for ingest."""
-
-    def __init__(self, content: bytes, filename: str, source_url: str,
-                 court: str = "בית המשפט העליון", case_name: str = ""):
-        self.content = content
-        self.filename = filename
-        self.source_url = source_url
-        self.court = court
-        self.case_name = case_name
-
-
-class SupremeFetchError(RuntimeError):
-    """The public portal returned an unexpected shape / no document. Carries a
-    Hebrew reason for the job row (INV-CF2)."""
-
-
-def _four_digit_year(yy: str) -> str:
-    """2-digit citation year → 4-digit. Pivot on the current year: a 2-digit
-    value above (this year + 4) is last century. e.g. 05→2005, 87→1987, 16→2016."""
-    yy = re.sub(r"\D", "", yy or "")
-    if len(yy) == 4:
-        return yy
-    if len(yy) != 2:
-        return yy
-    n = int(yy)
-    cutoff = (_dt.date.today().year % 100) + 4
-    return f"20{yy}" if n <= cutoff else f"19{yy}"
-
-
-def _parse_serial(case_number_norm: str, citation: str) -> tuple[str, str]:
-    """Extract (CaseNum, YYYY) from a serial citation like 'בג"ץ 3483/05'.
-
-    Works off the normalized number (e.g. '3483-05') with the raw citation as a
-    fallback. Raises SupremeFetchError if it can't find a NNNN/YY pair.
-    """
-    m = re.search(r"(\d{1,5})[-/](\d{2,4})\b", case_number_norm or "")
-    if not m:
-        m = re.search(r"(\d{1,5})/(\d{2,4})", citation or "")
-    if not m:
-        raise SupremeFetchError(
-            f"לא ניתן לפרק '{citation}' למספר-תיק/שנה (פורמט עליון סדרתי)"
-        )
-    return m.group(1), _four_digit_year(m.group(2))
-
-
-def _dt_key(r: dict) -> int:
-    m = re.search(r"/Date\((\d+)", str(r.get("VerdictDt") or ""))
-    return int(m.group(1)) if m else 0
-
-
-def _rank_candidates(records: list[dict]) -> list[dict]:
-    """Order a case's documents by how good a corpus target each is, best first.
-
-    Preference: the reasoned ruling (Type contains 'פסק') over interim החלטות;
-    then more pages (substantive over one-liners); then most recent. We return
-    a *ranked list*, not one pick, because the formally-labeled פסק-דין is
-    sometimes a published-report ('s'-prefix) file that the free Download
-    endpoint blocks (WAF) — the caller tries each until one downloads as a PDF.
-    Records without a Path/FileName are dropped.
-    """
-    usable = [r for r in records if r.get("Path") and r.get("FileName")]
-
-    def _score(r: dict) -> tuple:
-        is_verdict = 1 if "פסק" in str(r.get("Type") or "") else 0
-        return (is_verdict, int(r.get("Pages") or 0), _dt_key(r))
-
-    return sorted(usable, key=_score, reverse=True)
-
-
-async def fetch_supreme_verdict(
-    *, citation: str, case_number_norm: str
-) -> FetchedVerdict:
-    """Fetch a Supreme Court verdict PDF by serial citation. Raises on failure."""
-    case_num, yyyy = _parse_serial(case_number_norm, citation)
-
-    async with httpx.AsyncClient(
-        http2=False, headers=_HEADERS, timeout=_REQUEST_TIMEOUT_S,
-        follow_redirects=True,
-    ) as client:
-        document = {
-            "Year": yyyy, "CaseNum": case_num, "Month": {},
-            "dateType": 1, "publishDate": 8, "SearchText": [dict(_EMPTY_CLAUSE)],
-            "OldMainNumFormat": True,
-        }
-        try:
-            await asyncio.sleep(_INTER_REQUEST_COOLDOWN_S)
-            resp = await client.post(
-                f"{_BASE}/Home/SearchVerdicts", json={"document": document, "lan": 1}
-            )
-            resp.raise_for_status()
-            payload = resp.json()
-        except httpx.HTTPError as e:
-            raise SupremeFetchError(f"חיפוש בפורטל העליון נכשל עבור {citation}: {e}") from e
-        except ValueError as e:
-            raise SupremeFetchError(f"תשובת-חיפוש לא-JSON מהפורטל עבור {citation}") from e
-
-        records = payload.get("data") if isinstance(payload, dict) else None
-        candidates = _rank_candidates(records or [])
-        if not candidates:
-            raise SupremeFetchError(
-                f"לא נמצא מסמך-פסק עבור {citation} בפורטל העליון "
-                f"(תיק {case_num}/{yyyy[-2:]}; ייתכן שאינו פורסם או טרם דיגיטציה)."
-            )
-
-        # Try documents best-first until one downloads as a real PDF. The
-        # formally-labeled פסק-דין is sometimes a published-report file the free
-        # Download endpoint blocks (WAF) — fall back to the next substantive doc.
-        last_reason = ""
-        for rec in candidates[:6]:
-            path, fname = str(rec["Path"]), str(rec["FileName"])
-            qs = urllib.parse.urlencode(
-                {"path": path, "fileName": fname, "type": _DOC_TYPE_PDF}
-            )
-            try:
-                await asyncio.sleep(_INTER_REQUEST_COOLDOWN_S)
-                dl = await client.get(f"{_BASE}/Home/Download?{qs}")
-                dl.raise_for_status()
-            except httpx.HTTPError as e:
-                last_reason = f"הורדה נכשלה ({e})"
-                continue
-            if dl.content[:4] == b"%PDF":
-                return FetchedVerdict(
-                    content=dl.content,
-                    filename=f"{case_number_norm}.pdf",
-                    source_url=f"{_BASE}/Home/Download?{qs}",
-                    case_name=str(rec.get("CaseName") or ""),
-                )
-            last_reason = f"מסמך {fname} חסום/לא-PDF ({len(dl.content)}B)"
-
-        raise SupremeFetchError(
-            f"אף מסמך של {citation} לא ירד כ-PDF ({len(candidates)} מועמדים) — {last_reason}"
-        )

mcp-server/src/legal_mcp/services/digest_library.py

@@ -1,455 +0,0 @@
-"""Orchestrator for the Digests radar (X12).
-
-A digest ("כל יום" daily one-pager) is a SECONDARY source that POINTS at a
-ruling — it is never cited in a decision (INV-DIG1) and never enters the
-precedent/halacha pipeline (INV-DIG2). Ingest reuses only ATOMIC services
-(extract_text, embeddings), NOT the canonical ``ingest.ingest_document``.
-
-Two intake paths share one enrichment core:
-
-  - ``ingest_digest``        (local/MCP, e.g. batch script) — does everything
-                              synchronously: stage → extract_text → create →
-                              LLM enrich → embed → autolink → completed.
-  - ``create_pending_digest`` (CONTAINER-SAFE — the web upload) — stage →
-                              extract_text → create row with status='pending'.
-                              No LLM, no embedding. ``process_pending_digests``
-                              (local/MCP) drains the queue and enriches.
-
-claude_session rule: ``digest_metadata_extractor`` (local CLI) is imported
-LAZILY inside the enrichment core only, so this module stays import-safe from
-the FastAPI container for create_pending / search / list / link / delete
-(DB + voyage only — voyage embedding only runs in the local enrich path).
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import date
-from pathlib import Path
-from typing import Awaitable, Callable
-from uuid import UUID
-
-from legal_mcp import config
-from legal_mcp.services import db, embeddings, extractor, ingest, storage
-
-logger = logging.getLogger(__name__)
-
-ProgressCb = Callable[[str, int, str], Awaitable[None]]
-
-DIGEST_LIBRARY_DIR = Path(config.DATA_DIR) / "digests"
-
-_VALID_PRACTICE_AREAS = frozenset(
-    {"", "rishuy_uvniya", "betterment_levy", "compensation_197"}
-)
-
-
-async def _noop_progress(_status: str, _percent: int, _msg: str) -> None:
-    return None
-
-
-def _coerce_date(v) -> date | None:
-    if v is None or v == "":
-        return None
-    if isinstance(v, date):
-        return v
-    if isinstance(v, str):
-        try:
-            return date.fromisoformat(v[:10])
-        except ValueError:
-            return None
-    return None
-
-
-def _embedding_text(row: dict) -> str:
-    """The single vector indexes the digest as an atomic discovery unit."""
-    parts = [
-        row.get("concept_tag", ""),
-        row.get("headline_holding", ""),
-        row.get("summary", ""),
-        row.get("analysis_text", ""),
-    ]
-    return "\n".join(p for p in parts if p).strip()
-
-
-async def try_autolink(digest_id: UUID | str, underlying_citation: str) -> str | None:
-    """Best-effort link of a digest to the underlying ruling in case_law
-    (INV-DIG3). Returns the case_law_id (str) if linked, else None. Never raises."""
-    citation = (underlying_citation or "").strip()
-    if not citation:
-        return None
-    try:
-        match = await db.find_case_law_by_citation_fuzzy(citation)
-    except Exception as e:
-        logger.warning("digest try_autolink lookup failed for %r: %s", citation, e)
-        return None
-    if not match:
-        # Gap (INV-DIG3): the underlying ruling isn't in the corpus. Surface it —
-        # never drop silently (INV-CF2). Court verdicts (supreme/admin) get an X13
-        # auto-fetch job; ועדת-ערר / unknown — which נט-המשפט can't serve — get a
-        # missing_precedent the chair sees on /missing-precedents (#136). Never
-        # raises.
-        await _handle_unlinked_citation(digest_id, citation)
-        return None
-    await db.link_digest_to_case_law(digest_id, match["id"])
-    return str(match["id"])
-
-
-async def _handle_unlinked_citation(digest_id: UUID | str, citation: str) -> None:
-    """Surface an unlinked digest citation — auto-fetch if possible, else record
-    a missing_precedent. Closes the silent-drop gap (#136, INV-DIG3/CF2).
-
-    Routing via the ONE canonical classifier (``court_citation.classify``):
-      * supreme/admin → ``court_fetch_jobs`` (drained by X13; on fetch failure the
-        orchestrator opens its own missing_precedent, so no double-record here).
-      * skip (ערר/בל"מ) / unknown → ``missing_precedents`` (needs Nevo / manual;
-        נט-המשפט can't serve it). Deduped designator-aware via citation_norm
-        (#143) so re-runs and overlaps don't pile up.
-    """
-    try:
-        from legal_mcp.services import court_citation
-        cit = court_citation.classify(citation)
-        if cit.tier in ("supreme", "admin"):
-            await db.court_fetch_job_upsert(
-                case_number_norm=cit.case_number_norm,
-                citation_raw=citation,
-                tier=cit.tier,
-                court=cit.court_prefix,
-                digest_id=UUID(str(digest_id)),
-            )
-            logger.info("digest %s: enqueued court-fetch for %r (tier=%s)",
-                        digest_id, citation, cit.tier)
-            return
-        # Non-fetchable (ערר/בל"מ/unknown) — open a missing_precedent gap so it's
-        # visible and actionable instead of vanishing. Dedup first (#143).
-        if await db.find_missing_precedent_by_citation(citation):
-            return
-        digest = await db.get_digest(digest_id)
-        yomon = (digest or {}).get("yomon_number") or ""
-        note = (f"זוהה דרך יומון מס' {yomon} (digest_id={digest_id})" if yomon
-                else f"זוהה דרך יומון (digest_id={digest_id})")
-        await db.create_missing_precedent(
-            citation=citation,
-            discovery_source="digest",
-            notes=note,
-        )
-        logger.info("digest %s: opened missing_precedent for %r (tier=%s)",
-                    digest_id, citation, cit.tier)
-    except Exception as e:  # never break digest ingest
-        logger.warning("digest unlinked-citation handling failed for %r: %s",
-                       citation, e)
-
-
-# ── Container-safe creation (web upload) — no LLM, no embedding ──────
-
-async def create_pending_digest(
-    *,
-    file_path: str | Path,
-    yomon_number: str = "",
-    digest_date: date | str | None = None,
-    practice_area: str = "",
-    appeal_subtype: str = "",
-    subject_tags: list[str] | None = None,
-    progress: ProgressCb | None = None,
-) -> dict:
-    """Stage the file, extract text (PyMuPDF — container-safe), and create a
-    digest row with extraction_status='pending'. The LLM metadata extraction,
-    embedding, and autolink are deferred to ``process_pending_digests`` (local).
-
-    Returns {status, digest_id, extraction_status} or {status:'exists', ...}.
-    Idempotent on content_hash (INV-G3).
-    """
-    progress = progress or _noop_progress
-    if practice_area and practice_area not in _VALID_PRACTICE_AREAS:
-        raise ValueError(f"invalid practice_area: {practice_area!r}")
-    src = Path(file_path)
-    if not src.exists():
-        raise ValueError(f"file not found: {file_path}")
-
-    await progress("staging", 10, "מעתיק קובץ")
-    # ``_stage_file`` returns the storage KEY (DATA_DIR-relative path). Resolve a
-    # real local path to read from — on s3-only this downloads to a temp file we
-    # own and remove after extraction (INV-STG1; the key is not guaranteed to be
-    # on local disk).
-    rel_path = await ingest._stage_file(src, DIGEST_LIBRARY_DIR, "incoming")
-    local = await storage.ensure_local(rel_path, bucket=storage.Bucket.DOCUMENTS)
-    local_is_tmp = storage.local_path(rel_path, bucket=storage.Bucket.DOCUMENTS) is None
-
-    await progress("extracting_text", 50, "מחלץ טקסט")
-    try:
-        raw_text, _pc, _off = await extractor.extract_text(str(local))
-    finally:
-        if local_is_tmp:
-            try:
-                local.unlink(missing_ok=True)
-            except OSError as e:  # noqa: BLE001 — temp cleanup, never fatal
-                logger.debug("could not remove temp digest file %s: %s", local, e)
-    raw_text = (raw_text or "").strip()
-    if not raw_text:
-        raise ValueError("no text extracted from digest")
-
-    content_hash = db._content_hash(raw_text)
-    existing = await db.get_digest_by_content_hash(content_hash)
-    if existing:
-        await progress("completed", 100, "יומון זהה כבר קיים")
-        return {"status": "exists", "digest_id": existing["id"],
-                "extraction_status": existing.get("extraction_status")}
-
-    record = await db.create_digest(
-        analysis_text=raw_text,
-        yomon_number=yomon_number.strip(),
-        digest_date=_coerce_date(digest_date),
-        practice_area=practice_area,
-        appeal_subtype=appeal_subtype.strip(),
-        subject_tags=list(subject_tags) if subject_tags else [],
-        source_document_path=rel_path,
-        extraction_status="pending",
-    )
-    await progress("queued", 100, "ממתין לעיבוד מקומי (LLM)")
-    return {"status": "pending", "digest_id": record["id"],
-            "extraction_status": "pending"}
-
-
-# ── Local enrichment core (LLM + embed + autolink) ──────────────────
-
-async def enrich_digest(digest_id: UUID | str, progress: ProgressCb | None = None) -> dict:
-    """Run LLM metadata extraction over a digest's analysis_text, fill ONLY
-    empty fields (preserve user-supplied values), embed, autolink, complete.
-
-    **MCP-tool-only path** (uses the local LLM extractor). Idempotent.
-    """
-    progress = progress or _noop_progress
-    row = await db.get_digest(digest_id)
-    if not row:
-        raise ValueError("digest not found")
-    analysis = (row.get("analysis_text") or "").strip()
-    if not analysis:
-        await db.update_digest(digest_id, extraction_status="failed")
-        return {"status": "no_text", "digest_id": str(digest_id)}
-
-    await db.update_digest(digest_id, extraction_status="processing")
-    await progress("extracting_metadata", 40, "מחלץ מטא-דאטה (LLM)")
-    from legal_mcp.services import digest_metadata_extractor
-    extracted = await digest_metadata_extractor.extract(analysis)
-
-    # Fill only empty fields (preserve user-supplied values from the form).
-    fields: dict = {}
-    for key in ("yomon_number", "concept_tag", "headline_holding", "summary",
-                "underlying_citation", "underlying_court", "underlying_judge",
-                "practice_area", "appeal_subtype"):
-        if not (row.get(key) or "").strip() and extracted.get(key):
-            fields[key] = extracted[key]
-    if row.get("digest_date") is None and extracted.get("digest_date"):
-        fields["digest_date"] = extracted["digest_date"]
-    if row.get("underlying_date") is None and extracted.get("underlying_date"):
-        fields["underlying_date"] = extracted["underlying_date"]
-    if not (row.get("subject_tags") or []) and extracted.get("subject_tags"):
-        fields["subject_tags"] = extracted["subject_tags"]
-    # digest_kind classifies the issue (decision vs announcement). A successful
-    # extraction (any field returned) must end with a non-empty kind — that is the
-    # signal the drain self-heal uses to tell "enriched" from "failed". If the
-    # model omitted it, infer: a ruling citation → decision, else announcement.
-    if extracted and not (row.get("digest_kind") or "").strip():
-        kind = extracted.get("digest_kind")
-        if kind not in ("decision", "announcement", "other"):
-            cite = fields.get("underlying_citation") or row.get("underlying_citation") or ""
-            kind = "decision" if cite.strip() else "announcement"
-        fields["digest_kind"] = kind
-
-    if fields:
-        try:
-            await db.update_digest(digest_id, **fields)
-        except Exception as e:
-            # The same yomon issue can arrive as two different PDFs (re-sent /
-            # forwarded twice → different bytes → content_hash dedup misses it),
-            # but the yomon_number is unique. The extracted number then collides
-            # on uq_digests_yomon_number. This row is a duplicate of an already-
-            # ingested yomon → drop it so it isn't retried forever by the cron.
-            if "uq_digests_yomon_number" in str(e):
-                await db.delete_digest(digest_id)
-                logger.info(
-                    "digest %s is a duplicate yomon (%s) — deleted",
-                    digest_id, fields.get("yomon_number"),
-                )
-                return {"status": "duplicate", "digest_id": str(digest_id),
-                        "yomon_number": fields.get("yomon_number")}
-            raise
-    merged = await db.get_digest(digest_id)
-
-    await progress("embedding", 75, "מחשב embedding")
-    emb_text = _embedding_text(merged)
-    if emb_text:
-        try:
-            vecs = await embeddings.embed_texts([emb_text], input_type="document")
-            if vecs:
-                await db.store_digest_embedding(digest_id, vecs[0])
-        except Exception as e:  # surfaced, not swallowed (§6)
-            logger.warning("digest embedding failed for %s: %s", digest_id, e)
-
-    await progress("linking", 90, "מנסה לקשר לפסק המקורי")
-    linked_id = None
-    if not merged.get("linked_case_law_id"):
-        linked_id = await try_autolink(digest_id, merged.get("underlying_citation", ""))
-
-    await db.update_digest(digest_id, extraction_status="completed")
-    await progress("completed", 100, "הושלם")
-    return {
-        "status": "completed",
-        "digest_id": str(digest_id),
-        "yomon_number": merged.get("yomon_number", ""),
-        "underlying_citation": merged.get("underlying_citation", ""),
-        "linked_case_law_id": merged.get("linked_case_law_id") or linked_id,
-        "fields_filled": sorted(fields.keys()),
-    }
-
-
-async def process_pending_digests(limit: int = 20) -> dict:
-    """Drain the digest extraction queue (rows stamped extraction_status='pending'
-    by the web upload). Local/MCP only — runs the LLM enrichment per row.
-    Sequential (avoids LLM rate-limit storms), mirrors process_pending_extractions."""
-    pending = await db.list_pending_digests(limit=limit)
-    if not pending:
-        return {"status": "no_pending", "processed": 0, "results": []}
-    results = []
-    processed = 0
-    for row in pending:
-        did = row["id"]
-        try:
-            res = await enrich_digest(did)
-            processed += 1
-            results.append({"digest_id": str(did), "status": res.get("status"),
-                            "linked": bool(res.get("linked_case_law_id"))})
-        except Exception as e:
-            logger.exception("process_pending_digests failed for %s: %s", did, e)
-            try:
-                await db.update_digest(did, extraction_status="failed")
-            except Exception:
-                logger.exception("could not mark digest %s failed", did)
-            results.append({"digest_id": str(did), "status": "failed", "error": str(e)})
-    return {"status": "completed", "processed": processed,
-            "total_pending": len(pending), "results": results}
-
-
-# ── Full synchronous ingest (local/MCP, e.g. batch script) ──────────
-
-async def ingest_digest(
-    *,
-    file_path: str | Path,
-    yomon_number: str = "",
-    digest_date: date | str | None = None,
-    practice_area: str = "",
-    appeal_subtype: str = "",
-    subject_tags: list[str] | None = None,
-    progress: ProgressCb | None = None,
-) -> dict:
-    """Ingest one digest synchronously. **MCP-tool-only** (uses the LLM).
-
-    Creates the row (with any user-supplied values) then enriches in place.
-    Idempotent on content_hash (INV-G3).
-    """
-    progress = progress or _noop_progress
-    created = await create_pending_digest(
-        file_path=file_path, yomon_number=yomon_number, digest_date=digest_date,
-        practice_area=practice_area, appeal_subtype=appeal_subtype,
-        subject_tags=subject_tags, progress=progress,
-    )
-    if created.get("status") == "exists":
-        return created
-    digest_id = created["digest_id"]
-    enriched = await enrich_digest(digest_id, progress=progress)
-    return enriched
-
-
-# ── Linking (INV-DIG3) ──────────────────────────────────────────────
-
-async def link_digest(digest_id: UUID | str, case_law_id: UUID | str) -> dict:
-    """Manually link a digest to an underlying ruling (INV-DIG3). Idempotent."""
-    digest = await db.get_digest(digest_id)
-    if not digest:
-        raise ValueError("digest not found")
-    ruling = await db.get_case_law(
-        case_law_id if isinstance(case_law_id, UUID) else UUID(str(case_law_id))
-    )
-    if not ruling:
-        raise ValueError("case_law not found")
-    updated = await db.link_digest_to_case_law(digest_id, case_law_id)
-    return {
-        "linked": True,
-        "digest_id": str(digest_id),
-        "case_law_id": str(case_law_id),
-        "case_number": ruling.get("case_number"),
-        "digest": updated,
-    }
-
-
-async def relink_digest(digest_id: UUID | str) -> dict:
-    """Re-run autolink for an unlinked digest. No-op if already linked / no match."""
-    digest = await db.get_digest(digest_id)
-    if not digest:
-        raise ValueError("digest not found")
-    if digest.get("linked_case_law_id"):
-        return {"linked": True, "digest_id": str(digest_id),
-                "case_law_id": digest["linked_case_law_id"], "changed": False}
-    linked_id = await try_autolink(digest_id, digest.get("underlying_citation", ""))
-    return {
-        "linked": linked_id is not None,
-        "digest_id": str(digest_id),
-        "case_law_id": linked_id,
-        "changed": linked_id is not None,
-    }
-
-
-async def unlink_digest(digest_id: UUID | str) -> dict:
-    """Clear a digest's link to the underlying ruling."""
-    updated = await db.link_digest_to_case_law(digest_id, None)
-    if updated is None:
-        raise ValueError("digest not found")
-    return {"unlinked": True, "digest_id": str(digest_id)}
-
-
-# ── Read / search (container-safe: DB + voyage) ─────────────────────
-
-async def search_digests(
-    query: str,
-    practice_area: str = "",
-    subject_tag: str = "",
-    concept_tag: str = "",
-    limit: int = 10,
-) -> list[dict]:
-    """Semantic search over the digests radar. Container-safe (voyage + DB)."""
-    if not query.strip():
-        return []
-    query_vec = await embeddings.embed_query(query)
-    return await db.search_digests_semantic(
-        query_embedding=query_vec,
-        practice_area=practice_area,
-        subject_tag=subject_tag,
-        concept_tag=concept_tag,
-        limit=limit,
-    )
-
-
-async def get_digest(digest_id: UUID | str) -> dict | None:
-    return await db.get_digest(digest_id)
-
-
-async def list_digests(
-    practice_area: str = "",
-    concept_tag: str = "",
-    linked: bool | None = None,
-    search: str = "",
-    publication: str = "",
-    limit: int = 100,
-    offset: int = 0,
-) -> list[dict]:
-    return await db.list_digests(
-        practice_area=practice_area, concept_tag=concept_tag, linked=linked,
-        search=search, publication=publication, limit=limit, offset=offset,
-    )
-
-
-async def update_digest(digest_id: UUID | str, **fields) -> dict | None:
-    return await db.update_digest(digest_id, **fields)
-
-
-async def delete_digest(digest_id: UUID | str) -> bool:
-    return await db.delete_digest(digest_id)

mcp-server/src/legal_mcp/services/digest_metadata_extractor.py

@@ -1,151 +0,0 @@
-"""Auto-extract catalog metadata from a "כל יום" daily digest (X12).
-
-A digest is a one-page secondary summary (Ofer Toister) of a single ruling.
-This module reads its raw text and asks the local Claude CLI to extract the
-fields the radar needs: yomon number, concept tag, headline holding, a short
-summary, the UNDERLYING ruling's citation (the critical bridge field — INV-DIG3),
-its court / date / judge, practice area and subject tags.
-
-claude_session rule: this module imports ``claude_session`` (the local CLI),
-so it is **MCP-tool-only** — never import it from the FastAPI container. It is
-pulled in lazily inside ``digest_library.ingest_digest`` only.
-
-Unlike ``precedent_metadata_extractor`` (which patches a DB row), this returns
-a plain dict from raw text; ``digest_library`` decides how to merge/store it.
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import date as date_type
-
-from legal_mcp import config
-from legal_mcp.config import parse_llm_json
-from legal_mcp.services import claude_session
-
-logger = logging.getLogger(__name__)
-
-
-_VALID_PRACTICE_AREAS = {"", "rishuy_uvniya", "betterment_levy", "compensation_197"}
-
-
-# Concatenated with f-strings at call time, NOT .format() — the JSON example
-# below contains '{' / '}' which str.format would treat as placeholders and
-# crash (same trap documented in precedent_metadata_extractor).
-DIGEST_EXTRACTION_PROMPT = """אתה מסייע משפטי בכיר. לפניך "יומון" — סיכום עמוד-אחד של משרד עפר טויסטר (עלון "כל יום")
-על **החלטה/פסק דין** אחד, או על **עדכון/הודעה** (חקיקה, נוהל, הודעת-תכנון, ברכת-שנה) בתחום תכנון ובנייה / היטל השבחה / פיצויים (ס' 197). חלץ ממנו מטא-דאטה לקטלוג.
-
-**אל תמציא** — שדה שלא מופיע בטקסט → השאר ריק (מחרוזת ריקה / מערך ריק).
-
-## פלט נדרש
-החזר JSON אחד (object — לא array), ללא markdown וללא הסברים:
-
-{
-  "digest_kind": "סווג את הגיליון: 'decision' = סיכום פסק דין/החלטה (יש מראה-מקום בתחתית) · 'announcement' = עדכון/הודעה ללא הכרעה (חקיקה, נוהל, הודעת-תכנון, ברכה) · 'other' = אחר. **חובה למלא תמיד.**",
-  "yomon_number": "מספר היומון מהכותרת ('יומון מס' 5163' → '5163'). ספרות בלבד. אם אין — ריק.",
-  "digest_date_iso": "YYYY-MM-DD — תאריך גיליון היומון (בכותרת, למשל '7 ביוני 2026' → '2026-06-07').",
-  "concept_tag": "תג-המושג/הכותרת בראש העמוד (למשל 'שיקול הדעת המצומצם', 'Cherry-picking', או 'עדכונים לשנה החדשה' בעדכון). ביטוי קצר אחד. **חלץ תמיד — קיים לכל סוג גיליון.**",
-  "headline_holding": "הכותרת המודגשת מתחת לתג — משפט אחד שמסכם את עיקר הגיליון (מה נקבע בהחלטה, או נושא העדכון). **חלץ תמיד.**",
-  "summary": "תקציר ניטרלי 2-3 משפטים בגוף שלישי: בהחלטה — מה הייתה השאלה ומה הוכרע; בעדכון — מה תוכן/משמעות העדכון. בלי שיפוט. **חלץ תמיד.**",
-  "underlying_citation": "**רק ל-decision** — מראה-המקום של פסק הדין/ההחלטה המקורי, כפי שמופיע בתחתית היומון, מילה במילה (למשל 'עת\\"מ 46111-12-22 יכין-אפק בע\\"מ נ' הוועדה המחוזית'). בעדכון/הודעה — ריק. זהו השדה הקריטי ל-decision — חלץ אותו במלואו ובדיוק.",
-  "underlying_court": "הערכאה שנתנה את פסק הדין המקורי (למשל 'בית המשפט לעניינים מנהליים מרכז-לוד', 'ועדת הערר מחוז ירושלים').",
-  "underlying_date_iso": "YYYY-MM-DD — תאריך מתן פסק הדין/ההחלטה המקורי (לרוב 'ניתן ביום DD.M.YY' בתחתית). שים לב: זה שונה מתאריך גיליון היומון!",
-  "underlying_judge": "שם השופט/ת או יו\\"ר ההרכב שנתן את פסק הדין המקורי (למשל 'יעל טויסטר ישראלי'). בלי תארים ('עו\\"ד', 'כב' השופט').",
-  "practice_area": "אחד מ-3: 'rishuy_uvniya' (רישוי ובנייה/הקלות/שימוש חורג) / 'betterment_levy' (היטל השבחה) / 'compensation_197' (פיצויים ס'197). אם לא ברור — ריק.",
-  "appeal_subtype": "תת-סוג קצר אם בולט (למשל 'הקלה', 'שיקול דעת הוועדה', 'מימוש במכר'). אחרת ריק.",
-  "subject_tags": ["3-7 תגיות בעברית snake_case (שיקול_דעת, הקלה, ועדה_מחוזית, היטל_השבחה, ...)"]
-}
-
-## כללי איכות
-1. **digest_kind** — חובה. אם יש מראה-מקום של פסק דין/החלטה בתחתית → 'decision'. אם זה עדכון/הודעה/נוהל/ברכה ללא הכרעה → 'announcement'.
-2. **concept_tag / headline_holding / summary** — חלץ **תמיד**, לכל סוג גיליון (גם עדכון). אלה לא ייחודיים להחלטות.
-3. **underlying_citation** — רק ל-decision; הוא הגשר לפסק הדין. בעדכון — השאר ריק (זה תקין, לא חוסר).
-4. **הבחן בין שני התאריכים**: digest_date_iso = תאריך גיליון היומון (בכותרת); underlying_date_iso = מועד מתן פסק הדין (בתחתית, 'ניתן ביום...'). אל תבלבל.
-5. **subject_tags** — snake_case, תחום ועדת ערר תכנון ובנייה בלבד.
-6. אם רכיב לא מופיע בבירור — השאר את אותו שדה ריק. אל תנחש.
-"""
-
-
-def _norm_str(result: dict, key: str) -> str:
-    v = result.get(key)
-    return v.strip() if isinstance(v, str) else ""
-
-
-def _norm_date(result: dict, key: str) -> date_type | None:
-    v = result.get(key)
-    if not isinstance(v, str) or not v.strip():
-        return None
-    try:
-        return date_type.fromisoformat(v.strip()[:10])
-    except ValueError:
-        logger.debug("digest_metadata_extractor: ignoring invalid %s=%r", key, v)
-        return None
-
-
-async def extract(raw_text: str, model: str | None = None) -> dict:
-    """Extract digest metadata from raw text. Returns a dict (never raises).
-
-    Keys: yomon_number, digest_date (date|None), concept_tag, headline_holding,
-    summary, underlying_citation, underlying_court, underlying_date (date|None),
-    underlying_judge, practice_area, appeal_subtype, subject_tags (list[str]).
-    Missing/invalid fields are omitted so the caller's merge keeps user values.
-
-    Model: defaults to ``config.DIGEST_EXTRACT_MODEL`` (Sonnet — this is a
-    high-volume, simple extraction; no need for Opus). Override per-call via
-    ``model``.
-    """
-    text = (raw_text or "").strip()
-    if not text:
-        return {}
-
-    user_msg = f"--- תחילת היומון ---\n{text}\n--- סוף היומון ---"
-    try:
-        result = await claude_session.query_json(
-            user_msg, system=DIGEST_EXTRACTION_PROMPT,
-            model=(model or config.DIGEST_EXTRACT_MODEL or None),
-            tools="",  # pure text→JSON: disable tools so the model never emits
-                       # stop_reason=tool_use and trips --max-turns (error_max_turns).
-        )
-    except Exception as e:  # surfaced as warning, not swallowed silently (§6)
-        logger.warning("digest_metadata_extractor: query failed: %s", e)
-        return {}
-
-    if not isinstance(result, dict):
-        logger.warning(
-            "digest_metadata_extractor: expected dict, got %s",
-            type(result).__name__,
-        )
-        return {}
-
-    out: dict = {}
-    for key in (
-        "yomon_number", "concept_tag", "headline_holding", "summary",
-        "underlying_citation", "underlying_court", "underlying_judge",
-        "appeal_subtype",
-    ):
-        s = _norm_str(result, key)
-        if s:
-            out[key] = s
-
-    kind = _norm_str(result, "digest_kind").lower()
-    if kind in ("decision", "announcement", "other"):
-        out["digest_kind"] = kind
-
-    dd = _norm_date(result, "digest_date_iso")
-    if dd is not None:
-        out["digest_date"] = dd
-    ud = _norm_date(result, "underlying_date_iso")
-    if ud is not None:
-        out["underlying_date"] = ud
-
-    pa = _norm_str(result, "practice_area")
-    if pa in _VALID_PRACTICE_AREAS and pa:
-        out["practice_area"] = pa
-
-    tags = result.get("subject_tags")
-    if isinstance(tags, list):
-        clean = [str(t).strip() for t in tags if str(t).strip()]
-        if clean:
-            out["subject_tags"] = clean
-
-    return out

mcp-server/src/legal_mcp/services/docx_exporter.py

@@ -5,7 +5,6 @@
 
 from __future__ import annotations
 
-import io
 import logging
 import re
 from datetime import date
@@ -18,7 +17,7 @@ from docx.oxml import OxmlElement
 from docx.oxml.ns import qn
 
 from legal_mcp import config
-from legal_mcp.services import db, storage
+from legal_mcp.services import db
 
 logger = logging.getLogger(__name__)
 
@@ -475,19 +474,8 @@ async def export_decision(
                 pass
         output_path = str(export_dir / f"{prefix}-v{next_ver}.docx")
 
-    # Persist through the storage layer (INV-STG1). Under the filesystem
-    # backend the bytes land at output_path exactly as before; a caller-
-    # provided path outside DATA_DIR falls back to a direct disk write.
-    buf = io.BytesIO()
-    doc.save(buf)
-    data = buf.getvalue()
-    _docx_ctype = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-    try:
-        key = Path(output_path).resolve().relative_to(Path(config.DATA_DIR).resolve()).as_posix()
-        await storage.put_bytes(key, data, bucket=storage.Bucket.DOCUMENTS, content_type=_docx_ctype)
-    except ValueError:
     Path(output_path).parent.mkdir(parents=True, exist_ok=True)
-        Path(output_path).write_bytes(data)  # noqa: STG1 — storage fallback (output_path outside DATA_DIR)
+    doc.save(output_path)
     logger.info("DOCX exported (mode=%s): %s", mode, output_path)
     return output_path
 

mcp-server/src/legal_mcp/services/docx_retrofit.py

@@ -14,9 +14,6 @@ from __future__ import annotations
 import logging
 import re
 import shutil
-
-from legal_mcp import config
-from legal_mcp.services import storage
 import zipfile
 from io import BytesIO
 from pathlib import Path
@@ -307,17 +304,10 @@ def retrofit_bookmarks(
             end_idx = len(paragraphs) - 1
         ranges.append((name, start_idx, max(start_idx, end_idx)))
 
-    # Backup if overwriting in place — through the storage layer (INV-STG1).
+    # Backup if overwriting in place
     if backup and output_path.resolve() == docx_path.resolve():
         backup_path = docx_path.with_suffix(".pre-retrofit.docx")
-        try:
+        shutil.copy2(str(docx_path), str(backup_path))
-            _bkey = backup_path.resolve().relative_to(
-                Path(config.DATA_DIR).resolve()).as_posix()
-            storage.put_file_sync(
-                docx_path, _bkey, bucket=storage.Bucket.DOCUMENTS,
-                content_type="application/vnd.openxmlformats-officedocument.wordprocessingml.document")
-        except ValueError:
-            shutil.copy2(str(docx_path), str(backup_path))  # noqa: STG1 — storage fallback
 
     # Inject bookmarks, skipping any that already exist
     next_id = _next_bookmark_id(doc_tree)

mcp-server/src/legal_mcp/services/docx_reviser.py

@@ -13,9 +13,6 @@ from __future__ import annotations
 
 import logging
 import shutil
-
-from legal_mcp import config
-from legal_mcp.services import storage
 import zipfile
 from dataclasses import dataclass, field
 from datetime import datetime, timezone
@@ -101,22 +98,6 @@ def _load_docx_xml(docx_path: Path) -> tuple[dict[str, bytes], etree._Element, e
     return members, document_tree, settings_tree
 
 
-_DOCX_CTYPE = "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
-
-
-def _persist_docx_sync(output_path: Path, data: bytes) -> None:
-    """Persist DOCX bytes through the storage layer (INV-STG1); fall back to a
-    direct disk write when output_path is outside DATA_DIR (caller-provided)."""
-    out = Path(output_path)
-    try:
-        key = out.resolve().relative_to(Path(config.DATA_DIR).resolve()).as_posix()
-        storage.put_bytes_sync(key, data, bucket=storage.Bucket.DOCUMENTS,
-                              content_type=_DOCX_CTYPE)
-    except ValueError:
-        out.parent.mkdir(parents=True, exist_ok=True)
-        out.write_bytes(data)  # noqa: STG1 — storage fallback
-
-
 def _save_docx_xml(
     members: dict[str, bytes],
     document_tree: etree._Element,
@@ -132,11 +113,12 @@ def _save_docx_xml(
         settings_tree, xml_declaration=True, encoding="UTF-8", standalone=True
     )
 
+    output_path.parent.mkdir(parents=True, exist_ok=True)
     buffer = BytesIO()
     with zipfile.ZipFile(buffer, "w", zipfile.ZIP_DEFLATED) as zf:
         for name, data in members.items():
             zf.writestr(name, data)
-    _persist_docx_sync(output_path, buffer.getvalue())
+    output_path.write_bytes(buffer.getvalue())
 
 
 def _ensure_track_revisions(settings_tree: etree._Element) -> None:
@@ -529,11 +511,4 @@ def copy_with_revisions(
     source_path: str | Path, output_path: str | Path,
 ) -> None:
     """Copy source → output unchanged (used when revisions list is empty)."""
-    out = Path(output_path)
+    shutil.copy2(str(source_path), str(output_path))
-    try:
-        key = out.resolve().relative_to(Path(config.DATA_DIR).resolve()).as_posix()
-        storage.put_file_sync(source_path, key, bucket=storage.Bucket.DOCUMENTS,
-                              content_type=_DOCX_CTYPE)
-    except ValueError:
-        out.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(str(source_path), str(out))  # noqa: STG1 — storage fallback

mcp-server/src/legal_mcp/services/extractor.py

@@ -23,7 +23,6 @@ from docx import Document as DocxDocument
 from striprtf.striprtf import rtf_to_text
 
 from legal_mcp import config
-from legal_mcp.services import storage
 
 if TYPE_CHECKING:
     from google.cloud import vision
@@ -346,18 +345,6 @@ def render_pages_for_multimodal(
                     max(1, int(img.height * ratio)),
                 )
                 thumb = img.resize(thumb_size, Image.Resampling.LANCZOS)
-                # Persist the thumbnail (a DERIVED, regenerable artifact)
-                # through the storage layer (INV-STG1). Under the filesystem
-                # backend it lands at thumb_path exactly as before.
-                _tbuf = io.BytesIO()
-                thumb.save(_tbuf, "JPEG", quality=75, optimize=True)
-                try:
-                    _tkey = thumb_path.resolve().relative_to(
-                        Path(config.DATA_DIR).resolve()).as_posix()
-                    storage.put_bytes_sync(
-                        _tkey, _tbuf.getvalue(), bucket=storage.Bucket.DERIVED,
-                        content_type="image/jpeg")
-                except ValueError:
                 thumb.save(thumb_path, "JPEG", quality=75, optimize=True)
 
             out.append((img, thumb_path))
@@ -375,24 +362,12 @@ _NEVO_MARKERS = ("ספרות:", "חקיקה שאוזכרה:", "מיני-רציו
 # preamble: bibliography + מיני-רציו). Two families:
 #   - ועדת ערר / district openings (בפנינו / הערר שבנדון / ...)
 #   - COURT-RULING openings (#86.1): a פסק-דין header or the authoring judge's
-#     line. Without these, Nevo court judgments — exactly the ones carrying a
+#     line ("השופט/ת X:", "כב' השופט", "הנשיא"). Without these, Nevo court
-#     מיני-רציו — slipped through unstripped (e.g. בג"ץ 1764/05).
+#     judgments — exactly the ones carrying a מיני-רציו — slipped through unstripped
-#
+#     (e.g. בג"ץ 1764/05), risking that the extractor reads Nevo's answer key.
-# #86.2 hardening — two over-strip bugs found while backfilling:
-#   1. ``פסק-דין`` headers are often markdown-wrapped (``**פסק  דין**``); the old
-#      ``^פסק[- ]דין`` required the keyword to be the very first char of the line
-#      and allowed only one separator, so it missed the header and fell through
-#      to a citation 32K deep (עמ"נ 50567-07-21). We now tolerate leading
-#      markdown/whitespace and 0-3 separators.
-#   2. Bare ``השופט``/``הנשיא`` matched *citations* ("השופט מ' חשין, פסקה 23"),
-#      stripping real decision body. The authoring-judge line ends with a COLON
-#      ("השופט י' עמית:"); citations use a comma. We now require the colon.
 _DECISION_START = re.compile(
-    r"^[ \t>*_#]{0,6}(?:"
+    r"^(בפנינו|לפנינו|לפניי|הערר שבנדון|ועדת הערר לתכנון|רקע עובדתי|עסקינן|"
-    r"בפנינו|לפנינו|לפניי|הערר שבנדון|ועדת הערר לתכנון|רקע עובדתי|עסקינן|"
+    r"פסק[- ]דין|פסק[- ]דינו|כב(?:וד)?['׳]?\s*השופט|המשנה לנשיא|הנשיא|השופט)",
-    r"פסק[ \t\-]{0,3}די(?:ן|נו)|"  # פסק-דין / פסק דין / **פסק  דין** header (final-nun ן vs דינו)
-    r"(?:כב(?:וד)?['׳\"]?\s*)?(?:ה?שופט[ת]?|ה?נשיא[ה]?|המשנה לנשיא)\s+[^\n,]{1,40}:"  # author line → colon
-    r")",
     re.MULTILINE,
 )
 
@@ -413,41 +388,3 @@ def strip_nevo_preamble(text: str) -> str:
         logger.debug("Stripped %d chars of Nevo preamble", m.start())
         return stripped
     return text
-
-
-_RATIO_MARKER = "מיני-רציו:"
-
-
-def extract_nevo_ratio(text: str) -> str:
-    """Return the Nevo מיני-רציו block (editorial holdings summary), or ''.
-
-    The mini-ratio is Nevo's own headnote — a concise, professionally-written
-    list of the holdings. We capture it *before* :func:`strip_nevo_preamble`
-    discards it, to serve as a free gold-set for benchmarking how well our
-    halacha extractor covers the real holdings (#86.3).
-
-    The block runs from the ``מיני-רציו:`` marker to whichever comes first:
-    the decision body (``_DECISION_START``) or the next preamble marker
-    (bibliography / legislation). Returns '' when there is no mini-ratio.
-    """
-    if not text:
-        return ""
-    start = text.find(_RATIO_MARKER)
-    if start == -1:
-        return ""
-    body = text[start + len(_RATIO_MARKER):]
-
-    # End at the earliest of: decision body start, or a following preamble
-    # marker (ספרות: / חקיקה שאוזכרה: / ...). Both are measured relative to
-    # the ratio body so we never run past it into the judgment itself.
-    end = len(body)
-    dm = _DECISION_START.search(body)
-    if dm:
-        end = min(end, dm.start())
-    for marker in _NEVO_MARKERS:
-        if marker == _RATIO_MARKER:
-            continue
-        pos = body.find(marker)
-        if pos != -1:
-            end = min(end, pos)
-    return body[:end].strip()

mcp-server/src/legal_mcp/services/gemini_session.py

@@ -1,106 +0,0 @@
-"""Gemini structured-output helper — a drop-in for ``claude_session.query_json``
-for BOUNDED extraction tasks (text → JSON).
-
-Why a second LLM path: metadata extraction is a single structured call (fill
-case_name/summary/headnote/tags from a verdict's text), not an agentic loop. The
-``claude -p`` CLI behind ``claude_session`` is agentic — it reaches for tools and
-hits ``error_max_turns`` on a task that should be one shot — so it was slow and
-flaky for the precedent metadata queue. Gemini Flash with JSON mode
-(``responseMimeType: application/json``) is the right tool: one call, schema-
-clean JSON, fast, and ~$0.10/1M tokens (negligible for this volume).
-
-Scope: **bounded extraction only** (precedent metadata). The agentic, voice-
-sensitive work — decision writing, analysis, halacha extraction — stays on
-``claude_session`` (Daphna's subscription, zero API cost). This is a deliberate
-per-task provider choice, not a wholesale move off Claude.
-
-Key: ``GOOGLE_GEMINI_API_KEY`` (the canonical host ~/.env / Infisical name, SoT
-nautilus:/external-apis/gemini); ``GEMINI_API_KEY`` is also accepted as an alias.
-Model: ``GEMINI_MODEL`` (default gemini-2.5-flash).
-Direct REST via httpx — no extra SDK dependency.
-"""
-
-from __future__ import annotations
-
-import json
-import logging
-import os
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-_BASE = "https://generativelanguage.googleapis.com/v1beta"
-_DEFAULT_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.5-flash")
-_DEFAULT_TIMEOUT = float(os.environ.get("GEMINI_TIMEOUT_S", "120"))
-
-
-class GeminiError(RuntimeError):
-    """Gemini API call failed or returned an unexpected shape."""
-
-
-def _api_key() -> str:
-    # Accept BOTH names: the canonical Infisical / host-~/.env secret is
-    # ``GOOGLE_GEMINI_API_KEY`` (SoT nautilus:/external-apis/gemini), while older
-    # call sites / container envs may export ``GEMINI_API_KEY``. Reading only the
-    # latter silently broke ALL host metadata extraction (the key is present but
-    # under the canonical name). Prefer GEMINI_API_KEY if set, else the SoT name.
-    key = (
-        os.environ.get("GEMINI_API_KEY", "").strip()
-        or os.environ.get("GOOGLE_GEMINI_API_KEY", "").strip()
-    )
-    if not key:
-        raise GeminiError(
-            "GEMINI_API_KEY/GOOGLE_GEMINI_API_KEY אינו מוגדר (host ~/.env / "
-            "Infisical nautilus:/external-apis/gemini)."
-        )
-    return key
-
-
-async def query_json(
-    prompt: str,
-    timeout: float | int = _DEFAULT_TIMEOUT,
-    *,
-    system: str | None = None,
-    model: str | None = None,
-    # Accepted for drop-in parity with claude_session.query_json; ignored here.
-    effort: str | None = None,
-    tools: str | None = None,
-) -> dict | list | None:
-    """Single structured-output call → parsed JSON. Drop-in for
-    ``claude_session.query_json``. Raises ``GeminiError`` on failure (the caller
-    treats that like any extraction failure — recorded, never silently wrong).
-    """
-    model = model or _DEFAULT_MODEL
-    body: dict = {
-        "contents": [{"role": "user", "parts": [{"text": prompt}]}],
-        "generationConfig": {
-            "responseMimeType": "application/json",
-            "temperature": 0,
-        },
-    }
-    if system:
-        body["system_instruction"] = {"parts": [{"text": system}]}
-
-    url = f"{_BASE}/models/{model}:generateContent"
-    try:
-        async with httpx.AsyncClient(timeout=float(timeout)) as client:
-            resp = await client.post(url, params={"key": _api_key()}, json=body)
-    except httpx.HTTPError as e:
-        raise GeminiError(f"Gemini request failed: {e}") from e
-    if resp.status_code != 200:
-        raise GeminiError(f"Gemini HTTP {resp.status_code}: {resp.text[:200]}")
-
-    data = resp.json()
-    # Surface an explicit safety/finish block rather than returning empty.
-    cand = (data.get("candidates") or [{}])[0]
-    if cand.get("finishReason") in ("SAFETY", "RECITATION", "PROHIBITED_CONTENT"):
-        raise GeminiError(f"Gemini blocked output: finishReason={cand['finishReason']}")
-    try:
-        text = cand["content"]["parts"][0]["text"]
-    except (KeyError, IndexError, TypeError) as e:
-        raise GeminiError(f"Gemini unexpected response: {str(data)[:200]}") from e
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError as e:
-        raise GeminiError(f"Gemini returned non-JSON: {text[:200]}") from e

mcp-server/src/legal_mcp/services/halacha_extractor.py

@@ -6,10 +6,8 @@ structured list of halachot, validates each one against the source text,
 embeds the rule statement, and stores everything as ``pending_review`` in
 the ``halachot`` table.
 
-All extraction is idempotent — calling ``extract(case_law_id, force=True)``
+All extraction is idempotent — calling ``extract(case_law_id)`` twice
-twice drops the precedent's un-reviewed rows and re-extracts. Chair-approved /
+deletes prior rows for that precedent first.
-published halachot are PRESERVED across a re-extract (INV-G10); see
-``db.reset_halacha_extraction``.
 
 Trust model:
     Per chair decision, NO halacha is auto-published. Every extracted
@@ -26,8 +24,6 @@ import logging
 import re
 from uuid import UUID
 
-import asyncpg
-
 from legal_mcp import config
 from legal_mcp.config import parse_llm_json
 from legal_mcp.services import (
@@ -52,34 +48,6 @@ CHUNK_CONCURRENCY = config.HALACHA_CHUNK_CONCURRENCY
 # 4-5 overlapping driver processes × CHUNK_CONCURRENCY each → 12-16 concurrent
 # xhigh `claude -p` procs → load 69 → hard reboot.
 _HALACHA_EXTRACT_LOCK_KEY = 0x48414C41  # 'HALA'
-
-# The advisory lock is a SESSION lock held on a dedicated ``lock_conn`` that
-# sits idle while extraction work runs on OTHER pool connections. A hard crash
-# ("RuntimeError: Event loop is closed", OOM-kill, container restart) skips the
-# ``finally`` that unlocks AND skips ``pool.release`` — so the backend stays
-# alive, idle, holding the lock, and EVERY future extraction gets ``busy``
-# forever (#142: a leaked lock froze all halacha extraction ~4.5 min on
-# 2026-06-14 until a manual ``pg_terminate_backend``). Two mechanisms make the
-# lock self-recovering:
-#   1. KEEPALIVE — a background task touches ``lock_conn`` every
-#      ``_LOCK_KEEPALIVE_INTERVAL`` s, keeping ``pg_stat_activity.state_change``
-#      fresh. A *live* extraction's lock-holder is therefore never stale; a
-#      crashed one's keepalive dies with the loop, so ``state_change`` freezes.
-#   2. SELF-HEAL ON ACQUIRE — when ``pg_try_advisory_lock`` fails, we inspect
-#      the current holder; if it is idle AND its ``state_change`` is older than
-#      ``_LOCK_STALE_AFTER`` (≫ keepalive interval) it is a leaked orphan, so we
-#      ``pg_terminate_backend`` it (its session locks release on exit) and retry.
-# This is why a session lock + keepalive is preferred over ``pg_advisory_xact_lock``
-# (option ג): an xact lock would force a multi-minute open transaction
-# (idle-in-transaction bloat) and STILL wouldn't release a live-but-orphaned
-# connection promptly. ``_LOCK_STALE_AFTER`` is large enough that an in-flight
-# extraction is never mistaken for an orphan — the box-freeze the lock prevents
-# must never be re-introduced by killing a live holder.
-_LOCK_KEEPALIVE_INTERVAL = 30   # seconds between lock-conn keepalive touches
-_LOCK_STALE_AFTER = 150         # seconds idle ⇒ leaked orphan (5× keepalive)
-_LOCK_RECLAIM_RETRIES = 10      # poll attempts to re-acquire after terminate
-_LOCK_RECLAIM_DELAY = 0.2       # seconds between reclaim polls
-
 CHUNK_RETRY_ATTEMPTS = 1
 
 # If at least this fraction of chunks crash and the precedent yields zero
@@ -94,15 +62,6 @@ EXTRACTION_FAILURE_THRESHOLD = 0.5
 # never contain holdings, only positions, so we skip them.
 EXTRACTABLE_SECTIONS = ("legal_analysis", "ruling", "conclusion")
 
-# Sections confidently classified as NON-reasoning (parties' positions, the
-# factual background, the opening). The fallback path — taken when the chunker
-# labeled nothing as an extractable section (non-standard headings → 'other') —
-# excludes these so facts/arguments are NEVER fed into extraction, while
-# reasoning that merely landed under 'other' is still reached. Raises precision
-# on the dominant Facts↔Reasoning confusion class (#81.6; INV-LRN2
-# quality-at-source; LegalSeg / rhetorical-role labeling).
-NON_REASONING_SECTIONS = ("facts", "appellant_claims", "respondent_claims", "parties_claims", "intro")
-
 
 # Two prompts — choose by source's is_binding flag.
 #
@@ -117,12 +76,8 @@ NON_REASONING_SECTIONS = ("facts", "appellant_claims", "respondent_claims", "par
 # wants to be able to cite "another committee reached the same conclusion"
 # even though it is not binding.
 #
-# The prompt branches on is_binding only to choose the EXTRACTION STRATEGY
+# The schema's rule_type field accepts six values:
-# (what to pull, how to phrase) — NOT the rule_type. rule_type is the rule
+#   binding | interpretive | procedural | obiter | application | persuasive
-# ROLE and uses the SAME five values for both sources (INV-DM7):
-#   holding | interpretive | procedural | application | obiter
-# The authority axis (binding/persuasive) is derived from the source, never
-# a rule_type value — so the model never classifies it.
 
 HALACHA_EXTRACTION_PROMPT_BINDING = """אתה משפטן בכיר המתמחה בדיני תכנון ובניה (ועדות ערר, היטל השבחה, פיצויים לפי סעיף 197 לחוק התכנון והבניה). תפקידך: לחלץ הלכות מחייבות מתוך פסק דין/החלטה משפטית של ערכאה עליונה (עליון / מנהלי).
 
@@ -146,12 +101,10 @@ HALACHA_EXTRACTION_PROMPT_BINDING = """אתה משפטן בכיר המתמחה
 
 הלכה אחת יכולה לחול על כמה תחומים — practice_areas הוא array ולא string יחיד.
 
-## סוג הכלל (rule_type) — מהות הכלל בלבד, לא סמכות-המקור
+## סוגי הלכה (rule_type)
-**אל תסווג "מחייב/משכנע"** — דרגת-המחייבות נגזרת אוטומטית מזהות הערכאה. כאן בחר רק את **סוג הכלל**:
+- binding — הלכה מחייבת שהוחלה על התיק.
-- holding — עיקרון מהותי שהיה הכרחי להכרעה (ה-ratio; מבחן Wambaugh: שלילתו הייתה משנה את התוצאה).
+- interpretive — פרשנות סעיף חוק/תכנית שאומצה.
-- interpretive — פרשנות הוראת-חוק/מונח/תכנית שאומצה.
+- procedural — כלל פרוצדורלי (סמכות, מועדים, הליכי שמיעה).
-- procedural — כלל סדר-דין (סמכות, מועדים, זכות-עמידה, מיצוי הליכים, נטל).
-- application — החלת כלל על עובדות התיק (תלוי-עובדות; לרוב לא-הלכה בת-הכללה).
 - obiter — אמרת אגב חשובה (חלץ רק אם משמעותית; סמן confidence נמוך).
 
 ## פלט נדרש
@@ -159,7 +112,7 @@ HALACHA_EXTRACTION_PROMPT_BINDING = """אתה משפטן בכיר המתמחה
 [
   {
     "rule_statement": "ניסוח הכלל בלשון משפטית מדויקת בגוף שלישי, 1-3 משפטים.",
-    "rule_type": "holding",
+    "rule_type": "binding",
     "reasoning_summary": "תמצית ההיגיון: למה בית המשפט הגיע לכלל הזה (1-2 משפטים).",
     "supporting_quote": "ציטוט מילולי מדויק מהפסק התומך בכלל. חייב להופיע מילה במילה בטקסט הקלט.",
     "page_reference": "פס' 12 / עמ' 8 — ככל שניתן לזהות מהקלט.",
@@ -186,11 +139,11 @@ HALACHA_EXTRACTION_PROMPT_PERSUASIVE = """אתה משפטן בכיר המתמח
 
 המקור הזה **אינו** מקור להלכות מחייבות חדשות (binding rules). הלכות מחייבות מגיעות מהעליון/מנהלי. עם זאת, יש כאן ערך משמעותי שצריך לחלץ — איך הפנל הזה ניתח ויישם את הדין הקיים. כשנכתוב החלטה עתידית, נצטט מהמקור הזה כ"גם ועדת הערר ב-X הגיעה למסקנה דומה" — לא כסמכות מחייבת, אלא כתמיכה משכנעת.
 
-**יש לחלץ** (סווג לפי **סוג הכלל** בלבד — אל תסווג "מחייב/משכנע", דרגת-המחייבות נגזרת אוטומטית):
+**יש לחלץ:**
 - **יישום של הלכה ידועה** (rule_type=`application`) — הפנל החיל הלכה ידועה (של עליון/מנהלי) על עובדות הנידונות. תצטט את ניסוח הכלל **כפי שהוצג כאן** (לא בהכרח כפי שנקבע במקור) ואת התוצאה.
 - **עקרון פרשני שאומץ** (rule_type=`interpretive`) — איך הפנל פירש סעיף חוק / תכנית, באופן שניתן לאמץ.
 - **כלל פרוצדורלי** (rule_type=`procedural`) — קביעות בנושאי סמכות, מועדים, הליך.
-- **מסקנה מהותית מנומקת** (rule_type=`holding`) — מסקנה עקרונית שלמה של הפנל בסוגיה, עם ההיגיון התומך, בת-הכללה ובת-הסתמכות.
+- **מסקנה מנומקת ומשכנעת** (rule_type=`persuasive`) — מסקנה שלמה של הפנל בסוגיה, עם ההיגיון התומך, ניתנת לציטוט כאסמכתא משכנעת.
 
 **אין לחלץ:**
 - ממצאים עובדתיים ספציפיים לתיק או יישום על נסיבות התיק ("העורר לא הוכיח X", "במקרה דנן", שמות צדדים, סכומים קונקרטיים) — חלץ את העיקרון/היישום בניסוח בר-הכללה בלבד.
@@ -222,7 +175,7 @@ HALACHA_EXTRACTION_PROMPT_PERSUASIVE = """אתה משפטן בכיר המתמח
 ## כללי איכות
 1. **נאמנות מוחלטת לציטוט** — supporting_quote חייב להיות הדבקה מדויקת מהקלט. אם אין ציטוט מתאים — אל תוסיף את ההלכה.
 2. **מספר הלכות** — החלטה ארוכה של ועדת ערר יכולה להניב 2-8 פריטים (יישומים + מסקנות). אל תמתח את הרשימה. אם אין מה לחלץ — החזר [].
-3. **rule_type מדויק (סוג הכלל בלבד)** — application = יישום הלכה ידועה. interpretive = פרשנות. procedural = פרוצדורה. holding = מסקנה מהותית עקרונית. **לא** binding/persuasive (סמכות נגזרת אוטומטית).
+3. **rule_type מדויק** — application = יישום הלכה ידועה. interpretive = פרשנות. procedural = פרוצדורה. persuasive = מסקנה כללית בעלת ערך כאסמכתא.
 4. **לא לפצל יתר על המידה — קריטי** — כל פריט = שאלה משפטית מובחנת אחת. פנים שונים של אותה שאלה = פריט אחד (בחר את הניסוח הכללי ביותר). אל תחזיר את אותו עיקרון בכמה ניסוחים.
 5. **שפה** — עברית משפטית מקצועית, גוף שלישי.
 6. **subject_tags** — 2-5 תגיות בעברית, snake_case.
@@ -231,15 +184,10 @@ HALACHA_EXTRACTION_PROMPT_PERSUASIVE = """אתה משפטן בכיר המתמח
 
 
 _VALID_PRACTICE_AREAS = {"rishuy_uvniya", "betterment_levy", "compensation_197"}
-# rule_type holds the rule ROLE only — what KIND of statement it is (INV-DM7).
-# The authority axis (binding/persuasive) is DERIVED from the source, never a
-# rule_type value: see halacha_quality.derive_authority.
 _VALID_RULE_TYPES = {
-    "holding", "interpretive", "procedural", "application", "obiter",
+    "binding", "interpretive", "procedural", "obiter",
+    "application", "persuasive",
 }
-# Legacy authority-as-role values → fold to the nearest genuine role. Kept so
-# old LLM outputs (and pre-split rows re-fed) coerce safely.
-_LEGACY_RULE_TYPE_FOLD = {"binding": "holding", "persuasive": "interpretive"}
 
 
 def _normalize_for_comparison(text: str) -> str:
@@ -279,14 +227,13 @@ def _verify_quote(supporting_quote: str, full_text: str) -> bool:
     return False
 
 
-def _coerce_halacha(raw: dict) -> dict | None:
+def _coerce_halacha(raw: dict, is_binding: bool = True) -> dict | None:
     """Validate and normalize one LLM-returned halacha dict.
 
-    Returns ``None`` if the entry is missing required fields. ``rule_type`` is
+    Returns ``None`` if the entry is missing required fields. ``is_binding``
-    the rule ROLE only (INV-DM7) — it is NEVER defaulted from the source's
+    only affects the default rule_type when the LLM returned an unknown
-    bindingness (that was the source-conflation this split removed). Legacy
+    value — for binding sources we default to ``binding``, otherwise to
-    authority values fold to the nearest role; unknown defaults to
+    ``persuasive`` (never pretend an appeals committee created halacha).
-    ``interpretive`` (the most common role).
     """
     if not isinstance(raw, dict):
         return None
@@ -295,10 +242,13 @@ def _coerce_halacha(raw: dict) -> dict | None:
     if not rule_statement or not supporting_quote:
         return None
 
-    rule_type = (raw.get("rule_type") or "").strip().lower()
+    default_rule_type = "binding" if is_binding else "persuasive"
-    rule_type = _LEGACY_RULE_TYPE_FOLD.get(rule_type, rule_type)
+    rule_type = (raw.get("rule_type") or default_rule_type).strip().lower()
     if rule_type not in _VALID_RULE_TYPES:
-        rule_type = "interpretive"
+        rule_type = default_rule_type
+    # Guard: don't let a non-binding source produce 'binding' rule_type
+    if not is_binding and rule_type == "binding":
+        rule_type = "persuasive"
 
     practice_areas_raw = raw.get("practice_areas") or []
     if isinstance(practice_areas_raw, str):
@@ -348,7 +298,6 @@ async def _nli_check(items: list[dict]) -> list[str]:
             system=halacha_quality.NLI_SYSTEM,
             model=config.HALACHA_NLI_MODEL or None,
             effort=config.HALACHA_NLI_EFFORT or None,
-            tools="",  # pure text→JSON — no tool_use → no error_max_turns
         )
     except Exception as e:
         logger.warning("halacha NLI check failed (fail-open, no flags): %s", e)
@@ -392,7 +341,6 @@ async def _consolidate_precedent(case_law_id: UUID) -> int:
             system=halacha_quality.CONSOLIDATE_SYSTEM,
             model=config.HALACHA_CONSOLIDATE_MODEL or None,
             effort=config.HALACHA_CONSOLIDATE_EFFORT or None,
-            tools="",  # pure text→JSON — no tool_use → no error_max_turns
         )
         groups = halacha_quality.parse_fold_groups(raw)
         if not groups:
@@ -464,7 +412,6 @@ async def _extract_chunk(
                 system=base_prompt,
                 model=config.HALACHA_EXTRACT_MODEL or None,
                 effort=(effort or config.HALACHA_EXTRACT_EFFORT) or None,
-                tools="",  # pure text→JSON — no tool_use → no error_max_turns
             )
         except Exception as e:
             last_err = e
@@ -486,82 +433,6 @@ async def _extract_chunk(
     return [], False
 
 
-# Reconstruct the 64-bit advisory key from pg_locks' (classid, objid) pair so
-# the holder lookup is correct regardless of how Postgres splits the key.
-_LOCK_HOLDER_SQL = """
-SELECT a.pid,
-       a.state,
-       EXTRACT(EPOCH FROM (now() - a.state_change)) AS idle_seconds
-FROM pg_locks l
-JOIN pg_stat_activity a ON a.pid = l.pid
-WHERE l.locktype = 'advisory'
-  AND ((l.classid::bigint << 32) | (l.objid::bigint)) = $1
-  AND l.objsubid = 1
-  AND l.granted
-  AND a.pid <> pg_backend_pid()
-LIMIT 1
-"""
-
-
-async def _acquire_global_lock(pool) -> "asyncpg.Connection | None":
-    """Take the global advisory lock, self-healing a leaked (orphaned) holder.
-
-    Returns a connection that HOLDS the lock, or ``None`` if a *live* extraction
-    legitimately holds it. On failure we look up the holder: only an **idle**
-    backend whose ``state_change`` is older than ``_LOCK_STALE_AFTER`` (i.e. its
-    keepalive stopped — a crash) is treated as a leaked orphan and terminated;
-    a live extraction's holder is kept fresh by its keepalive and is never
-    killed, so the serialization guarantee (and the box-freeze it prevents) is
-    preserved.
-    """
-    conn = await pool.acquire()
-    try:
-        if await conn.fetchval("SELECT pg_try_advisory_lock($1)",
-                               _HALACHA_EXTRACT_LOCK_KEY):
-            return conn
-        holder = await conn.fetchrow(_LOCK_HOLDER_SQL, _HALACHA_EXTRACT_LOCK_KEY)
-        if (holder and holder["state"] == "idle"
-                and (holder["idle_seconds"] or 0) >= _LOCK_STALE_AFTER):
-            logger.warning(
-                "halacha extract: reclaiming LEAKED lock — holder pid=%s idle "
-                "%.0fs (≥%ds, keepalive stopped → crashed). pg_terminate_backend.",
-                holder["pid"], holder["idle_seconds"], _LOCK_STALE_AFTER,
-            )
-            await conn.execute("SELECT pg_terminate_backend($1)", holder["pid"])
-            for _ in range(_LOCK_RECLAIM_RETRIES):
-                if await conn.fetchval("SELECT pg_try_advisory_lock($1)",
-                                       _HALACHA_EXTRACT_LOCK_KEY):
-                    logger.info("halacha extract: leaked lock reclaimed.")
-                    return conn
-                await asyncio.sleep(_LOCK_RECLAIM_DELAY)
-        await pool.release(conn)
-        return None
-    except Exception:
-        await pool.release(conn)
-        raise
-
-
-async def _lock_keepalive(conn, stop: asyncio.Event) -> None:
-    """Touch ``conn`` every ``_LOCK_KEEPALIVE_INTERVAL`` s while extraction runs.
-
-    Keeps the lock-holder's ``pg_stat_activity.state_change`` fresh so a live
-    extraction is never mistaken for a leaked orphan by ``_acquire_global_lock``.
-    Exits on ``stop`` (clean finish) or on any DB error (so the final unlock,
-    which reuses ``conn``, never races a keepalive query on the same connection).
-    """
-    while not stop.is_set():
-        try:
-            await asyncio.wait_for(stop.wait(), timeout=_LOCK_KEEPALIVE_INTERVAL)
-            return  # stop signaled — clean exit
-        except asyncio.TimeoutError:
-            pass
-        try:
-            await conn.execute("SELECT 1")
-        except Exception as e:
-            logger.warning("halacha lock keepalive failed (stopping): %s", e)
-            return
-
-
 async def extract(case_law_id: UUID | str, force: bool = False,
                   effort: str | None = None) -> dict:
     """Extract halachot from an uploaded precedent — globally serialized.
@@ -589,30 +460,23 @@ async def extract(case_law_id: UUID | str, force: bool = False,
         case_law_id = UUID(case_law_id)
 
     pool = await db.get_pool()
-    lock_conn = await _acquire_global_lock(pool)
+    lock_conn = await pool.acquire()
-    if lock_conn is None:
+    try:
+        got = await lock_conn.fetchval(
+            "SELECT pg_try_advisory_lock($1)", _HALACHA_EXTRACT_LOCK_KEY,
+        )
+        if not got:
             logger.warning(
-            "halacha extract: global lock held by a live extraction — "
+                "halacha extract: global lock held by another extraction — "
                 "skipping %s (stays pending for next drain)", case_law_id,
             )
             return {
                 "status": "busy", "extracted": 0, "stored": 0,
                 "case_law_id": str(case_law_id),
             }
-
-    stop_keepalive = asyncio.Event()
-    keepalive_task = asyncio.create_task(_lock_keepalive(lock_conn, stop_keepalive))
         try:
             return await _extract_impl(case_law_id, force=force, effort=effort)
         finally:
-        # Stop the keepalive and await it BEFORE reusing lock_conn for unlock —
-        # two coroutines must never query the same asyncpg connection at once.
-        stop_keepalive.set()
-        try:
-            await keepalive_task
-        except Exception:  # pragma: no cover — keepalive swallows its own errors
-            logger.warning("halacha lock keepalive task ended abnormally")
-        try:
             await lock_conn.fetchval(
                 "SELECT pg_advisory_unlock($1)", _HALACHA_EXTRACT_LOCK_KEY,
             )
@@ -620,78 +484,6 @@ async def extract(case_law_id: UUID | str, force: bool = False,
         await pool.release(lock_conn)
 
 
-async def _select_extractable_chunks(
-    case_law_id: UUID,
-) -> tuple[list[dict], bool]:
-    """Pick the chunks that are candidates for halacha extraction (#81.6).
-
-    Rhetorical-role pre-filter (INV-LRN2 quality-at-source): only
-    reasoning/decision sections feed extraction.
-
-    Primary: chunks labeled as an extractable section
-    (``EXTRACTABLE_SECTIONS``). Fallback — taken only when the chunker labeled
-    *nothing* extractable (non-standard headings collapse everything to
-    'other') — is every chunk EXCEPT those confidently classified as
-    non-reasoning (``NON_REASONING_SECTIONS``: facts / parties' arguments /
-    intro). This preserves recall for reasoning that landed under 'other' while
-    never feeding the factual background or the parties' positions into
-    extraction. Previously the fallback took *all* chunks, re-admitting exactly
-    the sections the primary filter excludes.
-
-    Positive-anchor guard: when a document has a "דיון/הכרעה" section
-    (section_type='legal_analysis'), extraction starts from that section
-    onwards.  Any 'ruling' chunks that appear BEFORE the first legal_analysis
-    chunk by position are dropped — they most likely result from a party-claims
-    section whose header was not recognised by the chunker and was therefore
-    absorbed into the preceding section.
-
-    Returns ``(chunks, used_fallback)`` so the caller can log the fallback once.
-    """
-    chunks = await db.list_precedent_chunks(
-        case_law_id, section_types=EXTRACTABLE_SECTIONS,
-    )
-    if chunks:
-        chunks = _apply_discussion_anchor(chunks)
-        return chunks, False
-    all_chunks = await db.list_precedent_chunks(case_law_id)
-    filtered = [
-        c for c in all_chunks
-        if c.get("section_type") not in NON_REASONING_SECTIONS
-    ]
-    return filtered, True
-
-
-def _apply_discussion_anchor(chunks: list[dict]) -> list[dict]:
-    """Drop 'ruling' chunks that precede the first 'legal_analysis' chunk.
-
-    In Israeli planning-committee decisions the discussion section
-    (דיון / הכרעה / דיון והכרעה) always comes after the parties' claims.
-    A 'ruling'-labelled chunk that appears before the discussion is a strong
-    signal that a party-claims section was silently absorbed into it (chunker
-    regex didn't match the header).  Dropping those early 'ruling' chunks is
-    safe because all reasoning content falls at or after the 'דיון' anchor.
-    """
-    analysis_indices = [
-        c["chunk_index"] for c in chunks
-        if c.get("section_type") == "legal_analysis"
-    ]
-    if not analysis_indices:
-        return chunks
-    first_analysis = min(analysis_indices)
-    filtered = [
-        c for c in chunks
-        if not (c.get("section_type") == "ruling" and c["chunk_index"] < first_analysis)
-    ]
-    dropped = len(chunks) - len(filtered)
-    if dropped:
-        logger.info(
-            "halacha_extractor: positive-anchor guard dropped %d pre-discussion "
-            "'ruling' chunk(s) (first legal_analysis at chunk_index=%d)",
-            dropped, first_analysis,
-        )
-    return filtered
-
-
 async def _extract_impl(case_law_id: UUID, force: bool = False,
                         effort: str | None = None) -> dict:
     """Core extraction (caller holds the global advisory lock for the duration).
@@ -708,14 +500,20 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
 
     is_binding = bool(record.get("is_binding"))
 
-    # Rhetorical-role pre-filter (#81.6, INV-LRN2): only reasoning/decision
+    # Try the targeted sections first (legal_analysis / ruling / conclusion).
-    # sections are candidates. The fallback (no targeted section labeled)
+    # If the chunker labeled everything as 'other' (common when a ruling
-    # still excludes facts/arguments/intro — see _select_extractable_chunks.
+    # uses non-standard headings or the section markers aren't bracketed
-    chunks, used_fallback = await _select_extractable_chunks(case_law_id)
+    # cleanly), fall back to ALL chunks — better to over-include than to
-    if used_fallback and chunks:
+    # silently skip a ruling that has reasoning under an unexpected label.
+    chunks = await db.list_precedent_chunks(
+        case_law_id, section_types=EXTRACTABLE_SECTIONS,
+    )
+    if not chunks:
+        chunks = await db.list_precedent_chunks(case_law_id)
+        if chunks:
             logger.info(
                 "halacha_extractor: case_law=%s — no targeted sections, "
-            "falling back to %d non-argument chunks (facts/arguments excluded)",
+                "falling back to all %d chunks",
                 case_law_id, len(chunks),
             )
     if not chunks:
@@ -723,20 +521,8 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
         return {"status": "no_chunks", "extracted": 0, "stored": 0}
 
     # force = clean slate; otherwise resume (skip already-checkpointed chunks).
-    # "Clean slate" preserves chair-approved/published halachot (INV-G10) — only
-    # un-reviewed rows are dropped; the per-chunk dedup-on-insert skips fresh
-    # extractions that duplicate a preserved approval, so approvals survive a
-    # re-extract without duplicating. See db.reset_halacha_extraction / #108.
-    preserved_approved = 0
     if force:
-        reset = await db.reset_halacha_extraction(case_law_id)
+        await db.reset_halacha_extraction(case_law_id)
-        preserved_approved = reset.get("preserved", 0)
-        if preserved_approved:
-            logger.info(
-                "halacha_extractor: case_law=%s force re-extract — preserved %d "
-                "approved/published halachot (INV-G10), dropped %d un-reviewed.",
-                case_law_id, preserved_approved, reset.get("deleted", 0),
-            )
         for c in chunks:
             c["halacha_extracted_at"] = None
 
@@ -794,7 +580,7 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
             return
         cleaned: list[dict] = []
         for raw in items:
-            coerced = _coerce_halacha(raw)
+            coerced = _coerce_halacha(raw, is_binding=is_binding)
             if coerced is None:
                 continue
             coerced["quote_verified"] = _verify_quote(
@@ -806,16 +592,10 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
             flags = halacha_quality.compute_quality_flags(
                 coerced["rule_statement"], coerced["supporting_quote"],
                 coerced["reasoning_summary"], coerced["quote_verified"],
-                coerced["rule_type"],
             )
             coerced["quality_flags"] = flags
             if halacha_quality.FLAG_NON_DECISION in flags and coerced["rule_type"] != "obiter":
                 coerced["rule_type"] = "obiter"
-            # #81.4 — a holding-labeled rule that reads as a case-application is
-            # re-typed application (it carries FLAG_APPLICATION either way).
-            elif (halacha_quality.FLAG_APPLICATION in flags
-                  and coerced["rule_type"] == "holding"):
-                coerced["rule_type"] = "application"
             cleaned.append(coerced)
         # #81.3 NLI entailment — one batched judge call per chunk (fail-open).
         if config.HALACHA_NLI_ENABLED and cleaned:
@@ -843,10 +623,10 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
 
     await asyncio.gather(*[_process(c) for c in pending])
 
-    # Decide final status from what's LEFT (re-read checkpoints). Use the same
+    # Decide final status from what's LEFT (re-read checkpoints).
-    # candidate-selection policy as above so the pending count matches the set
+    after = await db.list_precedent_chunks(case_law_id, section_types=EXTRACTABLE_SECTIONS)
-    # we actually extracted from (G2 — single source of truth, no parallel path).
+    if not after:
-    after, _ = await _select_extractable_chunks(case_law_id)
+        after = await db.list_precedent_chunks(case_law_id)
     still_pending = sum(1 for c in after if c.get("halacha_extracted_at") is None)
     total = len(await db.list_halachot(case_law_id=case_law_id, limit=10_000))
 
@@ -891,6 +671,5 @@ async def _extract_impl(case_law_id: UUID, force: bool = False,
         "folded": folded,
         "stored": stored,
         "stored_this_run": stored_total,
-        "preserved_approved": preserved_approved,
         "total_chunks": len(chunks),
     }

mcp-server/src/legal_mcp/services/halacha_quality.py

@@ -18,37 +18,6 @@ from __future__ import annotations
 
 import re
 
-# ── Authority axis — DERIVED from the source, never LLM-classified (INV-DM7) ──
-#
-# A halacha's *authority* (binding vs persuasive) is a property of WHERE it came
-# from, not of the rule's content. It is therefore derived deterministically
-# from ``case_law.precedent_level`` and never stored on ``halachot`` or guessed
-# by the extractor — keeping it orthogonal to ``rule_type`` (the rule ROLE).
-# Higher courts (עליון/מנהלי) bind the appeals committee; another committee is
-# only persuasive. See docs/spec/02-data-model.md INV-DM7.
-
-AUTHORITY_BINDING = "binding"
-AUTHORITY_PERSUASIVE = "persuasive"
-
-_BINDING_LEVELS = {"עליון", "מנהלי"}
-_PERSUASIVE_LEVELS = {"ועדת_ערר_מחוזית"}
-
-
-def derive_authority(precedent_level: str | None) -> str | None:
-    """Map a source's precedent_level to its authority over the committee.
-
-    Returns ``"binding"`` for higher courts (עליון/מנהלי), ``"persuasive"`` for
-    another appeals committee (ועדת_ערר_מחוזית), or ``None`` when the level is
-    unknown/empty (never guesses). Pure — the single source of truth for the
-    authority axis (INV-DM7).
-    """
-    level = (precedent_level or "").strip()
-    if level in _BINDING_LEVELS:
-        return AUTHORITY_BINDING
-    if level in _PERSUASIVE_LEVELS:
-        return AUTHORITY_PERSUASIVE
-    return None
-
 # ── Hebrew text normalization (shared with the extractor's quote check) ──
 
 _HEB_QUOTE_VARIANTS = "\"'׳״‘’“”«»„′″"
@@ -159,120 +128,6 @@ def is_thin_restatement(rule_statement: str, supporting_quote: str) -> bool:
     return overlap >= _THIN_OVERLAP and len_ratio <= _THIN_LEN_RATIO
 
 
-# ── Fact-dependent application: not a generalizable holding (#81.4) ──
-#
-# The strict rubric's cut_application (docs/halacha-strict-rubric.md §3, §27):
-# a determination that rests on the case's specific facts/parties/amounts is an
-# illustration, not a holding — it must not enter the corpus as a binding rule.
-# The extractor already classifies ``rule_type='application'``; this is a
-# HIGH-PRECISION secondary catch for rules the model mislabeled as binding,
-# using only the unambiguous "applied to THIS case" deixis (bare party words
-# like "המערער" appear in genuine rules too, so they are deliberately excluded).
-
-_FACT_DEPENDENT_MARKERS = (
-    "במקרה דנן",
-    "במקרה שבפנינו",
-    "במקרה שלפנינו",
-    "במקרה שלפניי",
-    "בענייננו",
-    "בנדון דידן",
-    "בנדון דנן",
-    "במקרה שלנו",
-    "בנסיבות המקרה שלפנינו",
-    "בנסיבות תיק זה",
-    "בתיק שלפנינו",
-    "בערר שלפנינו",
-    "בערר דנן",
-)
-
-
-def is_fact_dependent(rule_statement: str) -> bool:
-    """True when the rule is phrased as an application to THIS case (not a holding)."""
-    norm = normalize_text(rule_statement)
-    return any(marker in norm for marker in _FACT_DEPENDENT_MARKERS)
-
-
-# ── Lexical near-duplicate signal (the 0.83–0.90 cosine tail) — #82.3 ──
-#
-# Embedding cosine alone misses paraphrases that float just below the dedup
-# threshold (0.93). A secondary lexical signal — Jaccard over word-shingles +
-# normalized Levenshtein on the rule_statement — catches "same rule, reworded"
-# in that band without lowering the global cosine threshold. Hybrid
-# lexical+semantic beats either alone (arXiv:1805.11611). Pure functions.
-
-def _shingles(text: str, k: int = 2) -> set[str]:
-    words = [w for w in re.split(r"[^א-ת0-9]+", normalize_text(text)) if w]
-    if len(words) < k:
-        return {" ".join(words)} if words else set()
-    return {" ".join(words[i : i + k]) for i in range(len(words) - k + 1)}
-
-
-def jaccard_shingles(a: str, b: str, k: int = 2) -> float:
-    sa, sb = _shingles(a, k), _shingles(b, k)
-    if not sa or not sb:
-        return 0.0
-    return len(sa & sb) / len(sa | sb)
-
-
-def normalized_levenshtein(a: str, b: str) -> float:
-    """1.0 == identical, 0.0 == fully different (edit distance / max len)."""
-    a, b = normalize_text(a), normalize_text(b)
-    if not a and not b:
-        return 1.0
-    if not a or not b:
-        return 0.0
-    # classic DP edit distance (rule_statements are short — a few hundred chars)
-    prev = list(range(len(b) + 1))
-    for i, ca in enumerate(a, 1):
-        cur = [i]
-        for j, cb in enumerate(b, 1):
-            cur.append(min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)))
-        prev = cur
-    return 1.0 - prev[-1] / max(len(a), len(b))
-
-
-_LEX_JACCARD_MIN = 0.55
-_LEX_LEVENSHTEIN_MIN = 0.70
-
-
-def lexical_near_duplicate(
-    a: str, b: str, jaccard_min: float = _LEX_JACCARD_MIN,
-    levenshtein_min: float = _LEX_LEVENSHTEIN_MIN,
-) -> bool:
-    """High lexical overlap → likely the same rule reworded (for the cosine tail)."""
-    return (jaccard_shingles(a, b) >= jaccard_min
-            or normalized_levenshtein(a, b) >= levenshtein_min)
-
-
-def dedup_action(
-    dist: float, rule_new: str, rule_neighbor: str,
-    dedup_distance: float, band_distance: float,
-) -> str:
-    """Decide a fresh halacha's fate vs its nearest same-precedent neighbor (#82.4).
-
-    PAIRWISE by construction — it compares the new rule to exactly ONE neighbor
-    (the nearest already-stored one), never to a cluster, so dedup-on-insert can
-    NEVER collapse a chain A~B~C into a single row even when A and C are
-    distinct: each insert is an independent pairwise decision and only the
-    *incoming* row is ever skipped (no existing row is merged or deleted). This
-    is the over-merge guard (#82.6) — connected-components closure, the central
-    over-merge risk in entity-resolution, is deliberately NOT performed here.
-
-    ``dist`` is cosine distance (1 − cosine sim) to the neighbor. Returns:
-      * 'skip' — semantic duplicate (dist ≤ dedup_distance): drop the incoming
-        row; the caller unions its provenance (cites) into the surviving
-        neighbor rather than blind-dropping it.
-      * 'flag' — lexical tail (dedup_distance < dist ≤ band_distance AND high
-        lexical overlap): keep the row but mark near_duplicate → chair review.
-      * 'keep' — distinct enough: store normally.
-    """
-    if dist <= dedup_distance:
-        return "skip"
-    if dist <= band_distance and lexical_near_duplicate(rule_new, rule_neighbor):
-        return "flag"
-    return "keep"
-
-
 # ── Aggregate ──
 
 FLAG_NON_DECISION = "non_decision"
@@ -280,49 +135,6 @@ FLAG_TRUNCATED_QUOTE = "truncated_quote"
 FLAG_THIN_RESTATEMENT = "thin_restatement"
 FLAG_QUOTE_UNVERIFIED = "quote_unverified"
 FLAG_NLI_UNSUPPORTED = "nli_unsupported"  # rule not entailed by its quote (#81.3)
-FLAG_APPLICATION = "application"            # fact-dependent, not a holding (#81.4)
-FLAG_NEAR_DUPLICATE = "near_duplicate"      # cosine-tail lexical dup (#82.3)
-FLAG_PARTY_CLAIM = "party_claim_language"   # quote reads as a party's position, not the court's
-
-
-# ── Party-claim language: quote is the court's words, not a party's ──
-#
-# Positive markers that a quote comes from a party's argument section rather
-# than the court's own reasoning.  The chunker now correctly classifies these
-# sections, but a belt-and-suspenders lexical gate catches any case where
-# the chunker still absorbs a party-claims section into a reasoning chunk
-# (e.g. an unrecognised header variant).  We scan the supporting_quote only —
-# the rule_statement is already abstracted and should not contain these phrases.
-
-_PARTY_CLAIM_MARKERS = (
-    # Named-party attribution forms — always party-claim language, never court reasoning
-    "לטענת העורר",
-    "לטענת העוררת",
-    "לטענת העוררים",
-    "לטענת המשיב",
-    "לטענת המשיבה",
-    "לטענת המשיבים",
-    "טוען העורר",
-    "טוענת העוררת",
-    "טוען המשיב",
-    "טוענת המשיבה",
-    # Excluded (too broad — courts also use these in their own reasoning):
-    # "נטען כי", "נטען על ידי", "נטען על-ידי", "לטענתו", "לטענתה", "לטענתם"
-)
-
-
-def detect_party_claim_language(supporting_quote: str) -> str | None:
-    """Return the first party-claim marker found in the quote (or None).
-
-    Only the supporting_quote is scanned — rule_statement is already abstracted.
-    A match means the LLM likely extracted from a party's argument section
-    rather than the court's reasoning.
-    """
-    norm = normalize_text(supporting_quote)
-    for marker in _PARTY_CLAIM_MARKERS:
-        if marker in norm:
-            return marker
-    return None
 
 
 # ── NLI entailment check (rule_statement ⊨ supporting_quote) — #81.3 ──
@@ -438,7 +250,6 @@ def compute_quality_flags(
     supporting_quote: str,
     reasoning_summary: str = "",
     quote_verified: bool = True,
-    rule_type: str = "interpretive",
 ) -> list[str]:
     """Return the list of quality flags for one halacha (empty == clean).
 
@@ -453,13 +264,4 @@ def compute_quality_flags(
         flags.append(FLAG_THIN_RESTATEMENT)
     if not quote_verified:
         flags.append(FLAG_QUOTE_UNVERIFIED)
-    # #81.4 — an application (fact-dependent) item is an illustration, not a
-    # generalizable holding: never auto-approve it. Trust the model's
-    # rule_type='application' and add a high-precision deixis catch.
-    if rule_type == "application" or is_fact_dependent(rule_statement):
-        flags.append(FLAG_APPLICATION)
-    # Belt-and-suspenders: if the quote contains party-claim language the
-    # chunker's section filter should have excluded, flag for manual review.
-    if detect_party_claim_language(supporting_quote):
-        flags.append(FLAG_PARTY_CLAIM)
     return flags

mcp-server/src/legal_mcp/services/ingest.py

@@ -14,8 +14,8 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import mimetypes
 import re
+import shutil
 from dataclasses import dataclass
 from datetime import date
 from pathlib import Path
@@ -23,7 +23,7 @@ from typing import Awaitable, Callable
 from uuid import UUID, uuid4
 
 from legal_mcp import config
-from legal_mcp.services import chunker, db, embeddings, extractor, storage
+from legal_mcp.services import chunker, db, embeddings, extractor
 
 logger = logging.getLogger(__name__)
 
@@ -66,22 +66,12 @@ def _safe_filename(name: str) -> str:
     return re.sub(r"[^\w.\-+א-ת ]", "_", base) or f"upload-{uuid4().hex[:8]}"
 
 
-async def _stage_file(src_path: Path, root: Path, subdir: str) -> str:
+def _stage_file(src_path: Path, root: Path, subdir: str) -> Path:
-    """Stage an intake file through the unified storage layer (INV-STG1).
+    dest_dir = root / (subdir or "other")
-
+    dest_dir.mkdir(parents=True, exist_ok=True)
-    Returns the storage KEY (DATA_DIR-relative path) the blob was written under.
+    dest = dest_dir / f"{uuid4().hex[:8]}_{_safe_filename(src_path.name)}"
-    The caller resolves a readable local path via ``storage.ensure_local`` — the
+    shutil.copy2(src_path, dest)
-    key is NOT guaranteed to map to an existing on-disk file (under the s3-only
+    return dest
-    backend the bytes live only in object storage). The Hebrew original filename
-    rides as object metadata, never as the key (INV-STG2)."""
-    dest = root / (subdir or "other") / f"{uuid4().hex[:8]}_{_safe_filename(src_path.name)}"
-    key = dest.relative_to(config.DATA_DIR).as_posix()
-    await storage.put_file(
-        src_path, key, bucket=storage.Bucket.DOCUMENTS,
-        content_type=mimetypes.guess_type(src_path.name)[0],
-        metadata={"filename": src_path.name},
-    )
-    return key
 
 
 def _validate_enums(spec: IntakeSpec, inputs: dict) -> None:
@@ -156,38 +146,21 @@ async def ingest_document(
     page_count = 0
     page_offsets = None
     staged: Path | None = None
-    staged_is_tmp = False
     if file_path:
         src = Path(file_path)
         if not src.is_file():
             raise FileNotFoundError(f"file not found: {src}")
         await progress("staging", 5, "מעתיק את הקובץ לאחסון")
-        staged_key = await _stage_file(src, spec.staging_root, spec.staging_subdir(inputs))
+        staged = _stage_file(src, spec.staging_root, spec.staging_subdir(inputs))
-        # Resolve a real local path to read from. Under filesystem/dual this is
-        # the on-disk copy; under s3-only the blob lives only in object storage,
-        # so ensure_local downloads it to a temp file we own and must clean up
-        # (INV-STG1 — the pipeline must read through the storage layer, never
-        # assume the key maps to an existing DATA_DIR file).
-        staged_is_tmp = storage.local_path(
-            staged_key, bucket=storage.Bucket.DOCUMENTS) is None
-        staged = await storage.ensure_local(
-            staged_key, bucket=storage.Bucket.DOCUMENTS)
-    try:
-        if staged is not None:
         await progress("extracting", 15, "מחלץ טקסט מהקובץ")
         try:
             raw_text, page_count, page_offsets = await extractor.extract_text(str(staged))
         except Exception as e:
             await progress("failed", 100, f"כשל בחילוץ טקסט: {e}")
             raise
-            raw_text = (raw_text or "")
+        raw_text = extractor.strip_nevo_preamble((raw_text or "")).strip()
     else:
-            raw_text = (text or "")
+        raw_text = (text or "").strip()
-        # Capture the Nevo מיני-רציו (editorial holdings summary) BEFORE stripping
-        # it out — it is a free professional gold-set for benchmarking halacha
-        # extraction (#86.3). Stored on the case_law row below once we have its id.
-        nevo_ratio = extractor.extract_nevo_ratio(raw_text)
-        raw_text = extractor.strip_nevo_preamble(raw_text).strip()
     if not raw_text:
         await progress("failed", 100, "לא נמצא טקסט בקובץ")
         raise ValueError("no extractable text in file")
@@ -207,13 +180,6 @@ async def ingest_document(
     )
     case_law_id = UUID(str(record["id"]))
 
-        # Persist the captured mini-ratio (best-effort; never block ingest on it).
-        if nevo_ratio:
-            try:
-                await db.update_case_law(case_law_id, nevo_ratio=nevo_ratio)
-            except Exception as e:  # noqa: BLE001 — additive metadata, non-fatal
-                logger.warning("could not store nevo_ratio for %s: %s", case_law_id, e)
-
     try:
         stored_chunks = await _chunk_embed_store(case_law_id, raw_text, page_offsets, page_count, progress)
         await db.mark_indexed(case_law_id)
@@ -250,14 +216,6 @@ async def ingest_document(
         await db.set_case_law_extraction_status(case_law_id, "failed")
         await progress("failed", 100, f"כשל בעיבוד: {e}")
         raise
-    finally:
-        # Drop the temp download (s3-only); on filesystem/dual ``staged`` is the
-        # canonical on-disk copy and must NOT be removed.
-        if staged_is_tmp and staged is not None:
-            try:
-                staged.unlink(missing_ok=True)
-            except OSError as e:  # noqa: BLE001 — temp cleanup, never fatal
-                logger.debug("could not remove temp staged file %s: %s", staged, e)
 
 
 async def _chunk_embed_store(case_law_id, text, page_offsets, page_count, progress) -> int:

mcp-server/src/legal_mcp/services/internal_decisions.py

@@ -58,7 +58,6 @@ def _internal_validate(inputs: dict) -> None:
 def _internal_derive(inputs: dict) -> dict:
     district = (inputs.get("district") or "").strip() or _district_from_court(inputs.get("court") or "")
     proc = (inputs.get("proceeding_type") or "").strip() or derive_proceeding_type(
-        case_number=inputs.get("case_number") or "",
         appeal_subtype=inputs.get("appeal_subtype") or "", subject=inputs.get("case_name") or "",
     )
     return {"district": district, "proceeding_type": proc}

mcp-server/src/legal_mcp/services/learning_loop.py

@@ -89,7 +89,7 @@ async def analyze_changes(draft_text: str, final_text: str) -> dict:
 --- גרסה סופית ---
 {final_sample}
 """
-    result = await claude_session.query_json(prompt, tools="")  # no tool_use → no error_max_turns
+    result = await claude_session.query_json(prompt)
     if result is None:
         logger.warning("Failed to parse lessons response")
         return {"changes": [], "new_expressions": [], "overall_assessment": ""}
@@ -149,21 +149,7 @@ async def process_final_version(
     # it (→ decision_lessons / appeal_type_rules, surfaced by T15) via the gate.
     # (Previously this auto-upserted every new_expression as a style_pattern —
     # that both bypassed the gate and contaminated style with substance. Removed.)
-    #
+    if pair_id is not None:
-    # create-or-update (INV-LRN4): normally mark-final already opened a
-    # 'final_received' pair, so we just advance it. For a case whose final
-    # pre-dates the mark-final snapshot mechanism (historical backfill) or a direct
-    # ingest_final_version call, no pair exists — open one now from the live blocks
-    # so the distillation is actually persisted instead of silently discarded.
-    # Caveat: the captured draft is the CURRENT blocks (possibly edited after
-    # sign-off), not a true mark-final snapshot.
-    if pair_id is None:
-        pair_id = await db.create_draft_final_pair(case_id, draft_text, "")
-        logger.info(
-            "process_final_version: no 'final_received' pair for case %s — opened one "
-            "from live blocks (backfill path; draft may post-date sign-off)",
-            case_id,
-        )
         await db.update_draft_final_pair(
             UUID(str(pair_id)),
             final_text=final_text,

mcp-server/src/legal_mcp/services/metrics.py

@@ -103,25 +103,12 @@ async def get_case_metrics(case_id: UUID) -> dict:
     return metrics
 
 
-def _median(values: list[float]) -> float | None:
-    """Median of a numeric list (None if empty). Pure — unit-tested."""
-    s = sorted(v for v in values if v is not None)
-    if not s:
-        return None
-    mid = len(s) // 2
-    return s[mid] if len(s) % 2 else (s[mid - 1] + s[mid]) / 2
-
-
 async def halacha_backlog(conn) -> dict:
     """תור אישור-ההלכות (GAP-14 / INV-QA1 / G10) — נראות ה-backlog האנושי.
 
     הלכות נכנסות כ-`pending_review` ובלתי-נראות לחיפוש עד אישור היו"ר; בלי ספירה
     גלויה, אישור-חסר נשאר סמוי (10/19 התגלה במקרה). מקבל connection פתוח כדי
     שאפשר יהיה לשלב בסנאפ-שוט קיים (get_dashboard, /api/system/diagnostics).
-
-    כולל גם מדדי-תור (#84.7): throughput (24ש'/7ימים), יחסי approve/reject/defer,
-    זמן-חציוני-לפריט (פער בין החלטות עוקבות בתוך session של 30 דק'), ופילוח
-    מי-החליט (panel/auto/chair) — כדי לראות גם מהירות וגם איכות, לא רק backlog.
     """
     rows = await conn.fetch(
         "SELECT review_status, COUNT(*) AS n FROM halachot GROUP BY review_status"
@@ -130,74 +117,13 @@ async def halacha_backlog(conn) -> dict:
     oldest = await conn.fetchval(
         "SELECT MIN(created_at) FROM halachot WHERE review_status = 'pending_review'"
     )
-    # #84.7 — split the pending bucket: how many are genuine candidates (clean)
-    # vs flagged 'needs extraction fix', and the breakdown by flag, so the chair
-    # sees how much of the backlog is real review vs extraction noise.
-    pending_clean = await conn.fetchval(
-        "SELECT COUNT(*) FROM halachot WHERE review_status = 'pending_review' "
-        "AND COALESCE(array_length(quality_flags, 1), 0) = 0"
-    )
-    flag_rows = await conn.fetch(
-        "SELECT flag, COUNT(*) AS n FROM ("
-        "  SELECT unnest(quality_flags) AS flag FROM halachot "
-        "  WHERE review_status = 'pending_review'"
-        ") t GROUP BY flag ORDER BY n DESC"
-    )
-    pending_total = counts.get("pending_review", 0)
-    reviewed = counts.get("approved", 0) + counts.get("rejected", 0) + counts.get("published", 0)
-
-    # ── #84.7 queue throughput + quality ──────────────────────────────────────
-    # throughput windows (decisions = anything with a reviewed_at stamp)
-    tp = await conn.fetchrow(
-        "SELECT COUNT(*) FILTER (WHERE reviewed_at >= now() - interval '24 hours') AS d24, "
-        "       COUNT(*) FILTER (WHERE reviewed_at >= now() - interval '7 days') AS d7 "
-        "FROM halachot WHERE reviewed_at IS NOT NULL"
-    )
-    # who decided — panel (tri-model), auto (confidence gate), chair (human), other
-    who_rows = await conn.fetch(
-        "SELECT CASE "
-        "  WHEN reviewer LIKE 'panel:%' THEN 'panel' "
-        "  WHEN reviewer LIKE 'auto-approved%' THEN 'auto' "
-        "  WHEN reviewer LIKE 'chair%' THEN 'chair' "
-        "  ELSE 'other' END AS who, COUNT(*) AS n "
-        "FROM halachot WHERE reviewed_at IS NOT NULL GROUP BY 1"
-    )
-    by_reviewer = {r["who"]: r["n"] for r in who_rows}
-    # time-per-item proxy: median seconds between consecutive HAND-PACED
-    # decisions — gaps in [1s, 30min]. Excludes 0-second gaps (batch operations
-    # like panel/auto stamp many rows with the same reviewed_at) and >30-min gaps
-    # (between sessions), so the number reflects interactive review pacing, not
-    # machine throughput. None when the queue is entirely batch-decided.
-    gap_rows = await conn.fetch(
-        "SELECT EXTRACT(EPOCH FROM (reviewed_at - prev)) AS gap FROM ("
-        "  SELECT reviewed_at, LAG(reviewed_at) OVER (ORDER BY reviewed_at) AS prev "
-        "  FROM halachot WHERE reviewed_at IS NOT NULL"
-        ") t WHERE prev IS NOT NULL "
-        "AND reviewed_at - prev BETWEEN interval '1 second' AND interval '30 minutes'"
-    )
-    median_secs = _median([float(r["gap"]) for r in gap_rows if r["gap"] is not None])
-
     return {
-        "pending_review": pending_total,
+        "pending_review": counts.get("pending_review", 0),
-        "pending_clean": pending_clean,           # real review candidates (#84.1)
-        "pending_flagged": pending_total - pending_clean,  # needs-fix bucket
         "approved": counts.get("approved", 0),
         "rejected": counts.get("rejected", 0),
-        "deferred": counts.get("deferred", 0),
         "published": counts.get("published", 0),
         "total": sum(counts.values()),
-        "reviewed_total": reviewed,
-        "approve_ratio": round(counts.get("approved", 0) / reviewed, 3) if reviewed else None,
-        "reject_ratio": round(counts.get("rejected", 0) / reviewed, 3) if reviewed else None,
-        "defer_ratio": (round(counts.get("deferred", 0) / (reviewed + counts.get("deferred", 0)), 3)
-                        if (reviewed + counts.get("deferred", 0)) else None),
-        "pending_by_flag": {r["flag"]: r["n"] for r in flag_rows},
         "oldest_pending_at": oldest.isoformat() if oldest else None,
-        # #84.7 throughput + quality
-        "throughput_24h": tp["d24"] if tp else 0,
-        "throughput_7d": tp["d7"] if tp else 0,
-        "median_seconds_per_decision": round(median_secs, 1) if median_secs is not None else None,
-        "by_reviewer": by_reviewer,
     }
 
 

mcp-server/src/legal_mcp/services/plans_extractor.py

@@ -1,279 +0,0 @@
-"""חילוץ מובנה של תכניות בניין-עיר ותוקפן לתוך מרשם-התכניות (טבלת plans).
-
-תכלית: לבנות SSOT קנוני לתכניות שחוזרות בין תיקים — מספר-תכנית מנורמל, תוקף
-(פרסום למתן תוקף ברשומות + מס' ילקוט-הפרסומים), ומשפט-ייעוד אחד — כדי שבלוק ט
-יצטט אותן בנוסח אחיד ודטרמיניסטי (format_plan_citation) במקום לגזור מחדש מהשומות
-בכל תיק (G2).
-
-חילוץ עובדתי בלבד. הרשומות נכנסות review_status='pending_review' וממתינות
-לאישור-יו"ר (INV-DM5/G10) לפני שישמשו בכתיבה. הקריאות ל-LLM מתבצעות דרך
-claude_session המקומי בלבד (כמו שאר המחלצים) — לא Anthropic SDK ישיר.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import re
-from uuid import UUID
-
-from legal_mcp.services import claude_session, db
-
-logger = logging.getLogger(__name__)
-
-# Descriptive provenance tag for INV-DM4 (we call the local claude CLI session,
-# not a pinned model id — the session model is whatever is configured).
-MODEL_TAG = "claude_local"
-
-# ── mavat auto-enrichment (Phase C trigger 2) ──────────────────────────────────
-# When an extracted candidate is missing its validity (gazette_date / yalkut), we
-# fill the gaps from the official source (mavat) via the host bridge. Conservative
-# by design: only modern numeric plan numbers resolve on mavat search, each fetch
-# drives a real browser (~30-60s, serial), so we gate by format + cap per call and
-# fail soft. Set PLAN_ENRICH_FROM_MAVAT=0 to disable.
-_ENRICH_ENABLED = os.environ.get("PLAN_ENRICH_FROM_MAVAT", "1").strip() not in ("0", "false", "")
-_ENRICH_MAX_PER_CALL = int(os.environ.get("PLAN_ENRICH_MAX_PER_CALL", "8"))
-# mavat search resolves the modern "NN-NNNNNNN" identifiers; legacy forms
-# (מי/820, 5166/ב, תמ"א 38) don't, so don't waste a browser launch on them.
-_MAVAT_NUM_RE = re.compile(r"^\d{2,4}-\d{6,8}$")
-
-
-EXTRACT_PLANS_PROMPT = """אתה מחלץ מידע עובדתי על תכניות בניין-עיר (תב"ע) עבור מרשם-תכניות של ועדת ערר.
-
-תפקידך: לחלץ כל תכנית שמצוין לגביה **תוקף** — מתי פורסמה למתן תוקף (ברשומות / בילקוט הפרסומים) — או ייעוד ברור.
-
-## כללים
-- עובדתי בלבד. אל תסיק, אל תפרש, ואל תמציא תאריך שאינו כתוב במפורש.
-- חלץ רק תכניות שמופיע לגביהן מידע-תוקף או ייעוד ברור. דלג על אזכור-אגב ללא פרטים.
-- gazette_date: תאריך הפרסום למתן תוקף, בפורמט ISO (YYYY-MM-DD). אם לא צוין תאריך — השאר "".
-- yalkut_number: מספר ילקוט הפרסומים / י"פ אם צוין (למשל "5965"). אחרת "".
-- display_name: שם-התכנית כפי שמקובל לכתוב בהחלטה, כולל המילה "תכנית" (למשל "תכנית מי/820").
-- plan_number: מזהה-התכנית בלבד, ללא המילה "תכנית" (למשל "מי/820", "5166/ב", "152-0132902", "תמ\\"א 38").
-- plan_type: אחד מ- ארצית / מחוזית / מקומית / מפורטת / כוללנית, אם ניתן לקבוע מהטקסט. אחרת "".
-- purpose: משפט-ייעוד אחד תמציתי (מה התכנית עושה/משנה/קובעת). אחרת "".
-- raw_quote: ציטוט מילולי של המשפט שממנו חולץ התוקף, עד 200 תווים.
-
-## פלט
-החזר JSON array בלבד — ללא markdown, ללא הסברים:
-[
-  {
-    "plan_number": "מי/820",
-    "display_name": "תכנית מי/820",
-    "plan_type": "מקומית",
-    "gazette_date": "2001-08-09",
-    "yalkut_number": "",
-    "purpose": "משנה את הוראות תכנית מי/200 ומרחיבה את השימושים המותרים באזור חקלאי",
-    "raw_quote": "תוכנית מי/820 ... פורסמה למתן תוקף ביום 9.8.2001"
-  }
-]
-
-אם אין תכניות עם מידע-תוקף/ייעוד — החזר [].
-"""
-
-
-def _chunk_text(text: str, max_chars: int = 25000) -> list[str]:
-    """Split a long document at paragraph boundaries (mirrors appraiser extractor)."""
-    if len(text) <= max_chars:
-        return [text]
-    chunks: list[str] = []
-    pos = 0
-    while pos < len(text):
-        end = min(pos + max_chars, len(text))
-        if end < len(text):
-            break_pos = text.rfind("\n\n", pos, end)
-            if break_pos > pos + max_chars // 2:
-                end = break_pos
-        chunks.append(text[pos:end])
-        pos = end
-    return chunks
-
-
-async def extract_plans_from_text(text: str) -> list[dict]:
-    """Extract plan candidates from arbitrary text via the local claude session.
-
-    Returns a list of normalized candidate dicts (not yet persisted). Factual only.
-    """
-    candidates: list[dict] = []
-    chunks = _chunk_text(text)
-    for i, chunk in enumerate(chunks):
-        chunk_label = f" (חלק {i+1}/{len(chunks)})" if len(chunks) > 1 else ""
-        prompt = (
-            f"{EXTRACT_PLANS_PROMPT}\n\n"
-            f"--- תחילת מסמך{chunk_label} ---\n{chunk}\n--- סוף מסמך ---"
-        )
-        result = await claude_session.query_json(prompt, tools="")  # no tool_use
-        if not isinstance(result, list):
-            logger.warning(
-                "extract_plans_from_text: chunk %d returned non-list (%s)",
-                i, type(result).__name__,
-            )
-            continue
-        for item in result:
-            if not isinstance(item, dict):
-                continue
-            num = (item.get("plan_number") or "").strip()
-            if not num:
-                continue
-            candidates.append({
-                "plan_number": num,
-                "display_name": (item.get("display_name") or "").strip(),
-                "plan_type": (item.get("plan_type") or "").strip(),
-                "gazette_date": (item.get("gazette_date") or "").strip(),
-                "yalkut_number": (item.get("yalkut_number") or "").strip(),
-                "purpose": (item.get("purpose") or "").strip(),
-                "raw_quote": (item.get("raw_quote") or "").strip(),
-            })
-    return candidates
-
-
-def _needs_enrichment(c: dict) -> bool:
-    """A candidate is worth enriching iff its validity is incomplete AND its
-    number is a mavat-resolvable modern identifier."""
-    if not (_ENRICH_ENABLED and _MAVAT_NUM_RE.match((c.get("plan_number") or "").strip())):
-        return False
-    return not (c.get("gazette_date") and c.get("yalkut_number"))
-
-
-async def _enrich_from_mavat(c: dict) -> tuple[dict, bool]:
-    """Fill a candidate's MISSING fields from mavat (never override case-grounded
-    values). Returns (candidate, enriched?). Fails soft — a bridge-down / not-found
-    / blocked fetch leaves the candidate untouched (logged, never swallowed)."""
-    from legal_mcp.services import plans_fetch
-
-    num = c["plan_number"].strip()
-    try:
-        fetched = await plans_fetch.fetch_plan(num)
-    except plans_fetch.PlanFetchUnavailable as e:
-        logger.info("plan-enrich: bridge unavailable for %s — %s", num, e)
-        return c, False
-    except plans_fetch.PlanFetchError as e:
-        logger.info("plan-enrich: mavat had no usable result for %s — %s", num, e)
-        return c, False
-    except Exception as e:  # noqa: BLE001 — never let enrichment break extraction
-        logger.warning("plan-enrich: unexpected error for %s — %s", num, e)
-        return c, False
-
-    enriched = dict(c)
-    filled: list[str] = []
-    for f in ("gazette_date", "yalkut_number", "display_name", "plan_type", "purpose"):
-        if not enriched.get(f) and fetched.get(f):
-            enriched[f] = fetched[f]
-            filled.append(f)
-    if filled:
-        logger.info("plan-enrich: %s filled %s from mavat (%s)",
-                    num, ",".join(filled), fetched.get("source_url", ""))
-        return enriched, True
-    return c, False
-
-
-async def upsert_candidates(
-    candidates: list[dict],
-    *,
-    source_case_number: str = "",
-    source_document_id: UUID | None = None,
-    model_used: str = MODEL_TAG,
-    enrich: bool = True,
-) -> list[dict]:
-    """Upsert extracted candidates into the registry as pending_review (G10).
-
-    When ``enrich`` (default) and a candidate's validity is incomplete, its
-    missing fields are pulled from mavat first (capped per call). The row still
-    enters pending_review — enrichment changes the candidate, not the chair gate.
-    """
-    out: list[dict] = []
-    enriched_count = 0
-    for c in candidates:
-        used = model_used
-        if enrich and enriched_count < _ENRICH_MAX_PER_CALL and _needs_enrichment(c):
-            c, did = await _enrich_from_mavat(c)
-            if did:
-                enriched_count += 1
-                used = f"{model_used}+mavat"
-        try:
-            plan = await db.upsert_plan(
-                plan_number=c["plan_number"],
-                display_name=c.get("display_name", ""),
-                plan_type=c.get("plan_type", ""),
-                gazette_date=c.get("gazette_date") or None,
-                yalkut_number=c.get("yalkut_number", ""),
-                purpose=c.get("purpose", ""),
-                review_status="pending_review",
-                source_case_number=source_case_number,
-                source_document_id=source_document_id,
-                model_used=used,
-            )
-            out.append(plan)
-        except ValueError as e:
-            # Don't swallow — surface the bad candidate so it isn't silently dropped.
-            logger.warning("upsert_candidates: skipped %r — %s", c.get("plan_number"), e)
-    if enrich and enriched_count >= _ENRICH_MAX_PER_CALL:
-        logger.warning(
-            "plan-enrich: hit the per-call cap (%d) — remaining candidates kept "
-            "as-extracted (no silent truncation; raise PLAN_ENRICH_MAX_PER_CALL).",
-            _ENRICH_MAX_PER_CALL,
-        )
-    return out
-
-
-async def extract_plans_for_case(case_id: UUID) -> dict:
-    """Extract plan candidates from every document with text in the case.
-
-    Upserts them into the registry as pending_review. Thorough by design (we do not
-    pre-filter by doc_type — a plan's validity can be cited anywhere). Returns a
-    summary for serialization back to the caller.
-    """
-    case = await db.get_case(case_id)
-    source_case_number = (case or {}).get("case_number", "") or ""
-    docs = await db.list_documents(case_id)
-
-    by_doc: list[dict] = []
-    seen_numbers: dict[str, dict] = {}
-    total_candidates = 0
-    for doc in docs:
-        text = await db.get_document_text(UUID(doc["id"]))
-        if not text:
-            continue
-        try:
-            cands = await extract_plans_from_text(text)
-        except Exception as e:  # noqa: BLE001 — record, don't swallow
-            logger.exception("extract_plans_for_case: failed on doc %s", doc["id"])
-            by_doc.append({
-                "document_id": doc["id"], "title": doc.get("title", ""),
-                "status": "error", "error": str(e), "candidates": 0,
-            })
-            continue
-        plans = await upsert_candidates(
-            cands,
-            source_case_number=source_case_number,
-            source_document_id=UUID(doc["id"]),
-        )
-        total_candidates += len(cands)
-        for p in plans:
-            seen_numbers[p["plan_number"]] = p
-        by_doc.append({
-            "document_id": doc["id"], "title": doc.get("title", ""),
-            "status": "completed", "candidates": len(cands),
-        })
-
-    # Surface near-duplicates for the chair to merge manually (G10) — never
-    # auto-merged. A variant of an existing plan written differently won't share
-    # the normalized key, so flag it here instead of silently creating a dup.
-    plans_out = list(seen_numbers.values())
-    dup_hits = 0
-    for p in plans_out:
-        sims = await db.find_similar_plans(
-            p["plan_number"], p.get("display_name", ""), exclude_id=UUID(p["id"]),
-        )
-        p["possible_duplicates"] = sims
-        dup_hits += len(sims)
-
-    return {
-        "status": "completed",
-        "case_number": source_case_number,
-        "documents_scanned": len(by_doc),
-        "total_candidates": total_candidates,
-        "distinct_plans": len(plans_out),
-        "possible_duplicate_hits": dup_hits,
-        "plans": plans_out,
-        "by_document": by_doc,
-    }

mcp-server/src/legal_mcp/services/plans_fetch.py

@@ -1,95 +0,0 @@
-"""Pull תב"ע identity + validity from mavat (מנהל התכנון) — container/MCP side.
-
-The thin container-side half of the mavat plan fetcher. The actual browser work
-happens on the **host** (`court_fetch_service` + `mavat_client`, Camoufox over
-Xvfb) because mavat sits behind an F5 BIG-IP ASM bot-wall that only a real
-JS-executing browser clears — a scripted httpx from the container gets a
-302→maintenance. This module just calls that host bridge over the docker0
-loopback (same bridge, secret and bind as X13 court-fetch — G2: no second
-service/port/secret) and normalises the result into registry fields.
-
-INV-AH: every pulled value carries `source_url` (the mavat plan page); a field
-the source doesn't expose (notably yalkut on some plans) comes back empty rather
-than guessed. The chair still gates the row (review_status) before block-ט cites
-it — this fetcher never writes the registry, it only returns a candidate dict.
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-
-import httpx
-
-logger = logging.getLogger(__name__)
-
-# Same host bridge as X13 (pm2 `legal-court-fetch-service`, docker0 gateway). The
-# container and the host MCP server both reach 10.0.1.1:8771; the secret is the
-# shared COURT_FETCH_SHARED_SECRET (Coolify env on the container).
-_SERVICE_URL = os.environ.get("COURT_FETCH_SERVICE_URL", "http://10.0.1.1:8771")
-_SHARED_SECRET = os.environ.get("COURT_FETCH_SHARED_SECRET", "").strip()
-# mavat is slow (F5 challenge + SPA hydration + SV4); give the browser room but
-# stay under the host driver's own hard cap.
-_TIMEOUT_S = float(os.environ.get("PLAN_FETCH_TIMEOUT_S", "180"))
-
-# The fields the bridge returns and we surface to the form / upsert.
-_PLAN_FIELDS = (
-    "plan_number", "display_name", "plan_type", "purpose",
-    "gazette_date", "yalkut_number", "yalkut_page", "source_url",
-)
-
-
-class PlanFetchUnavailable(RuntimeError):
-    """The host browser bridge isn't reachable / not configured."""
-
-
-class PlanFetchError(RuntimeError):
-    """mavat was reached but the plan couldn't be fetched/parsed."""
-
-
-async def fetch_plan(plan_number: str) -> dict:
-    """Fetch one plan's metadata from mavat via the host bridge.
-
-    Returns a dict with the keys in ``_PLAN_FIELDS`` (missing values empty, never
-    invented). Raises ``PlanFetchUnavailable`` if the bridge is down/unset, or
-    ``PlanFetchError`` if mavat was reached but the plan wasn't found/parsed.
-    """
-    plan_number = (plan_number or "").strip()
-    if not plan_number:
-        raise PlanFetchError("חסר מספר-תכנית")
-    if not _SHARED_SECRET:
-        raise PlanFetchUnavailable(
-            "COURT_FETCH_SHARED_SECRET אינו מוגדר — לא ניתן לפנות לשירות-המשיכה."
-        )
-
-    headers = {"Authorization": f"Bearer {_SHARED_SECRET}"}
-    try:
-        async with httpx.AsyncClient(timeout=_TIMEOUT_S) as client:
-            resp = await client.post(
-                f"{_SERVICE_URL}/plan-fetch",
-                json={"plan_number": plan_number},
-                headers=headers,
-            )
-    except httpx.ConnectError as e:
-        raise PlanFetchUnavailable(
-            f"שירות-המשיכה (legal-court-fetch-service) אינו זמין ב-{_SERVICE_URL}: {e}"
-        ) from e
-    except httpx.HTTPError as e:
-        raise PlanFetchUnavailable(f"שגיאת-תקשורת לשירות-המשיכה: {e}") from e
-
-    if resp.status_code == 401:
-        raise PlanFetchUnavailable("שירות-המשיכה דחה את הסוד (401) — בדוק drift של COURT_FETCH_SHARED_SECRET.")
-    if resp.status_code != 200:
-        raise PlanFetchError(f"שירות-המשיכה החזיר {resp.status_code}: {resp.text[:200]}")
-
-    body = resp.json()
-    if not body.get("ok"):
-        raise PlanFetchError(body.get("reason") or "התכנית לא נמצאה ב-מנהל-התכנון")
-
-    plan = body.get("plan") or {}
-    # Normalise to exactly our fields; keep source_url mandatory (INV-AH).
-    out = {k: (plan.get(k) or "") for k in _PLAN_FIELDS}
-    out["plan_number"] = out["plan_number"] or plan_number
-    if not out["source_url"]:
-        raise PlanFetchError("התקבלה תכנית ללא source_url — נדחה (INV-AH).")
-    return out

mcp-server/src/legal_mcp/services/practice_area.py

@@ -176,12 +176,8 @@ _APPEALS_COMMITTEE_DIGIT_TO_SUBTYPE = {
 
 # Match the case number (last numeric group) in formats like:
 #   ARAR-25-8126, ARAR-24-01-8007-33, 8126/25, 1170, ערר 1024-25
-# Serial is 4 OR 5 digits: 4 = ערר (appeal), 5 = בל"מ (extension-of-time) per
+_CASE_NUM = re.compile(r"(?:ARAR[-\s]*\d{2}[-\s]*(?:\d{2}[-\s]*)?)(\d{4})", re.IGNORECASE)
-# the post-reform numbering convention (Jerusalem adopted 5-digit בל"מ; Tel Aviv
+_PLAIN_NUM = re.compile(r"(\d{4})")
-# long predates it — e.g. 81002-01-21). The leading digit still encodes the
-# domain (1→רישוי, 8→היטל, 9→פיצויים) in BOTH widths — see is_blam_by_number().
-_CASE_NUM = re.compile(r"(?:ARAR[-\s]*\d{2}[-\s]*(?:\d{2}[-\s]*)?)(\d{4,5})", re.IGNORECASE)
-_PLAIN_NUM = re.compile(r"(\d{4,5})")
 
 
 _DOMAIN_TO_SUBTYPE: dict[str, str] = {
@@ -220,29 +216,6 @@ def derive_subtype(case_number: str, practice_area: str = DEFAULT_PRACTICE_AREA)
     return _APPEALS_COMMITTEE_DIGIT_TO_SUBTYPE.get(first_digit, "unknown")
 
 
-def case_serial_digits(case_number: str) -> int | None:
-    """Return the digit-count of the case serial, or None if unparseable.
-
-    The serial is the leading numeric group of the case number (the part
-    before month/year): ``8126-03-25`` → 4, ``81002-01-21`` → 5.
-    """
-    cn = case_number or ""
-    m = _CASE_NUM.search(cn) or _PLAIN_NUM.search(cn)
-    return len(m.group(1)) if m else None
-
-
-def is_blam_by_number(case_number: str) -> bool:
-    """True iff the case serial has 5 digits.
-
-    Post-reform numbering convention: a 4-digit serial is an ערר (appeal),
-    a 5-digit serial is a בל"מ (בקשה להארכת מועד). This is the authoritative
-    signal going forward; legacy 4-digit בל"מ cases are still detected from
-    the subject via ``is_blam_subject``. The rule is **one-directional** — a
-    5-digit serial implies בל"מ, but a 4-digit serial does NOT imply ערר.
-    """
-    return case_serial_digits(case_number) == 5
-
-
 def derive_subtype_with_blam(
     case_number: str,
     subject: str = "",
@@ -263,11 +236,9 @@ def derive_subtype_with_blam(
         'building_permit'
     """
     base = derive_subtype(case_number, practice_area)
-    # בל"מ is signalled either by the subject text (legacy 4-digit cases) or by
+    if not is_blam_subject(subject):
-    # a 5-digit serial (post-reform convention).
-    if not (is_blam_subject(subject) or is_blam_by_number(case_number)):
         return base
-    # it's a בל"מ — return the matching extension_request_* variant.
+    # subject says it's בל"מ — return the matching extension_request_* variant.
     # For domain practice_area (axis B), use the direct mapping.
     if practice_area in DOMAIN_PRACTICE_AREAS:
         return _DOMAIN_TO_BLAM_SUBTYPE.get(practice_area, base)
@@ -292,21 +263,15 @@ def is_blam_subtype(appeal_subtype: str) -> bool:
     return appeal_subtype in BLAM_SUBTYPES
 
 
-def derive_proceeding_type(
+def derive_proceeding_type(*, appeal_subtype: str = "", subject: str = "") -> str:
-    *, case_number: str = "", appeal_subtype: str = "", subject: str = "",
-) -> str:
     """Return 'בל"מ' / 'ערר' for appeals-committee decisions/cases.
 
-    Priority: explicit subtype prefix → subject regex → 5-digit serial →
+    Priority: explicit subtype prefix → subject regex → default 'ערר'.
-    default 'ערר'. The 5-digit signal is one-directional (a 4-digit serial
-    does not force 'ערר' — a legacy 4-digit בל"מ is caught by the subject).
     """
     if appeal_subtype and appeal_subtype.startswith("extension_request_"):
         return 'בל"מ'
     if subject and is_blam_subject(subject):
         return 'בל"מ'
-    if case_number and is_blam_by_number(case_number):
-        return 'בל"מ'
     return "ערר"
 
 

mcp-server/src/legal_mcp/services/precedent_library.py

@@ -15,7 +15,6 @@ from __future__ import annotations
 
 import asyncio
 import logging
-import os
 from pathlib import Path
 from typing import Awaitable, Callable
 from uuid import UUID
@@ -138,10 +137,6 @@ async def reextract_halachot(
 ) -> dict:
     """Re-run the halacha extractor on an existing precedent. Idempotent.
 
-    Chair-approved / published halachot are PRESERVED across the re-extract
-    (INV-G10) — only un-reviewed rows are replaced. See
-    ``db.reset_halacha_extraction`` / TaskMaster #108.
-
     **MCP-tool-only path.** This function calls into ``halacha_extractor``,
     which calls ``claude_session`` — the local CLI is required. Invoking
     this from the FastAPI container will raise ``Claude CLI not found``.
@@ -161,10 +156,9 @@ async def reextract_halachot(
     # bad data. See note in db.request_metadata_extraction.
 
     await progress("extracting_halachot", 50, "מחלץ הלכות מחדש")
-    # Explicit re-extraction = clean slate (force): drop un-reviewed halachot +
+    # Explicit re-extraction = clean slate (force): wipe prior halachot +
-    # clear per-chunk checkpoints and redo all, but PRESERVE chair-approved /
+    # per-chunk checkpoints and redo all. (Queue draining / resume uses the
-    # published rows (INV-G10; dedup-on-insert avoids duplicating them). (Queue
+    # default force=False so an interrupted run continues where it stopped.)
-    # draining / resume uses force=False so an interrupted run continues.)
     result = await halacha_extractor.extract(case_law_id, force=True)
     # Clear the queue timestamp on completion so the UI badge / worker queue
     # don't keep showing this row. The queue worker (process_pending_extractions)
@@ -185,9 +179,6 @@ async def reextract_halachot(
 # precedent into a 429 storm. Observed 2026-05-03: 1110/20 succeeded with 9
 # halachot, 317/10 immediately after returned silent no_halachot.
 INTER_PRECEDENT_COOLDOWN_SEC = 30
-# Metadata extraction is on Gemini (fast, high rate limits) — a brief spacer is
-# enough; the 30s above is for the Claude-backed halacha path.
-METADATA_COOLDOWN_SEC = float(os.environ.get("METADATA_COOLDOWN_SEC", "2"))
 
 # How many times to retry a precedent that came back as 'extraction_failed'
 # (i.e. >50% chunks crashed). Each retry uses a longer cooldown.
@@ -221,27 +212,6 @@ async def process_pending_extractions(kind: str = "metadata", limit: int = 20) -
     if kind not in {"metadata", "halacha"}:
         raise ValueError("kind must be 'metadata' or 'halacha'")
 
-    # Self-heal stale 'processing' rows (fully unattended): a drain that crashed
-    # mid-extraction can leave a row status='processing' with its requested_at
-    # cleared — orphaned, so it would never be re-picked. Re-stamp it so it
-    # re-drains (the halacha extractor uses force=False → resumes from chunk
-    # checkpoints, no duplicates). Safe under the global advisory lock (only one
-    # drain runs at a time). Mirrors the digests-drain self-heal.
-    healed = await db.requeue_stale_processing_extractions(kind=kind)
-    if healed:
-        logger.warning("self-healed %d stale '%s' processing row(s)", healed, kind)
-
-    # Re-enqueue eligible 'pending' rows that never got a queue stamp (orphaned
-    # from the queue — bulk/migration paths). requeue_stale only covers
-    # 'processing'; this covers 'pending' with requested_at IS NULL (#139). Runs
-    # before the list below so reclaimed rows drain in this same pass.
-    reconciled = await db.reconcile_orphaned_pending_extractions(kind=kind)
-    if reconciled:
-        logger.warning(
-            "reconciled %d orphaned 'pending' (no queue stamp) '%s' row(s)",
-            reconciled, kind,
-        )
-
     pending = await db.list_pending_extraction_requests(kind=kind, limit=limit)
     if not pending:
         return {"status": "no_pending", "kind": kind, "processed": 0, "results": []}
@@ -256,14 +226,11 @@ async def process_pending_extractions(kind: str = "metadata", limit: int = 20) -
             cid, effort=config.HALACHA_BULK_EXTRACT_EFFORT,
         )
 
-    # Metadata extraction runs on Gemini (high rate limits, fast) — the long
-    # cooldown is only needed for halacha (Claude/Anthropic rate limits).
-    cooldown = METADATA_COOLDOWN_SEC if kind == "metadata" else INTER_PRECEDENT_COOLDOWN_SEC
     results: list[dict] = []
     processed = 0
     for idx, row in enumerate(pending):
         if idx > 0:
-            await asyncio.sleep(cooldown)
+            await asyncio.sleep(INTER_PRECEDENT_COOLDOWN_SEC)
         cid = UUID(str(row["id"]))
         attempts = 0
         result: dict = {}
@@ -302,16 +269,10 @@ async def process_pending_extractions(kind: str = "metadata", limit: int = 20) -
                 if result.get("status") == "extraction_failed":
                     await db.set_case_law_halacha_status(cid, "failed")
                 await db.clear_extraction_request(cid, kind=kind)
-            elif result.get("status") == "extraction_failed":
-                # metadata transient failure (Gemini hiccup despite full text) —
-                # do NOT settle 'completed' or the row is silently stranded with
-                # empty metadata and the drain never revisits it (#138). Revert
-                # to 'pending' (the queue timestamp is preserved) so it re-drains.
-                await db.set_case_law_metadata_status(cid, "pending")
             else:
-                # metadata success / no_changes / no_metadata(no text) — set
+                # metadata — set terminal 'completed' status (also clears the
-                # terminal 'completed' (also clears the request timestamp) so the
+                # request timestamp) so the UI badge settles instead of
-                # UI badge settles instead of lingering on 'processing'.
+                # lingering on 'processing'.
                 await db.set_case_law_metadata_status(cid, "completed")
             processed += 1
             results.append({

mcp-server/src/legal_mcp/services/precedent_metadata_extractor.py

@@ -1,18 +1,12 @@
 """Auto-extract precedent metadata from a freshly-uploaded ruling.
 
-Runs after chunking. Reads the precedent's full_text and asks Gemini to
+Runs after chunking. Reads the precedent's full_text and asks Claude to
 fill in the metadata fields that an upload form usually leaves empty:
 short case_name, summary, headnote, key_quote, subject_tags,
 appeal_subtype, decision_date, precedent_level, court — plus
 chair_name + district for internal_committee rows (which the upload
 path stamps with PLACEHOLDER_PENDING_EXTRACTION when missing).
 
-The full citation (citation_formatted) is NOT formatted by the LLM — a Flash
-model reliably extracts the party line but drops the formatted string outright
-(#145). Instead the LLM extracts COMPONENTS (parties, citation_prefix) and
-``apply_to_record`` assembles the citation deterministically via
-``db.format_precedent_citation`` (X1 §3 / INV-ID2 — a derived display field).
-
 Caller policy: only empty user-supplied fields are filled. Anything the
 chair already typed in the upload form is preserved. This is enforced
 in ``apply_to_record``.
@@ -21,16 +15,11 @@ in ``apply_to_record``.
 from __future__ import annotations
 
 import logging
-import re
 from datetime import date as date_type
 from uuid import UUID
 
 from legal_mcp.config import parse_llm_json
-from legal_mcp.services import db, gemini_session
+from legal_mcp.services import claude_session, db
-from legal_mcp.services.practice_area import (
-    DOMAIN_PRACTICE_AREAS,
-    derive_domain_practice_area,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -62,7 +51,6 @@ METADATA_EXTRACTION_PROMPT = """אתה מסייע משפטי בכיר. קרא א
 {
   "case_name_short": "שם קצר ל-3-6 מילים (למשל 'אהרון ברק' או 'ב. קרן-נכסים'). אל תכלול מספר תיק. שם המבקש/העורר העיקרי. אם זו החלטה מאוחדת — שם הצד המוביל.",
   "appeal_subtype": "תת-סוג ספציפי בתוך תחום המשפט (למשל 'תכנית רחביה', 'מימוש במכר', 'תמ\\"א 38', 'שימוש חורג', 'סופיות ההחלטה'). מילה אחת או צירוף קצר.",
-  "practice_area": "תחום-העל המשפטי — אחד מ-3 בלבד: 'rishuy_uvniya' (רישוי ובנייה / היתרי בנייה / שימוש חורג / הקלות / תכנון), 'betterment_levy' (היטל השבחה — חיוב בעל מקרקעין בגין עליית-שווי מאישור תכנית), 'compensation_197' (פיצויים לפי סעיף 197 לחוק התכנון והבנייה — פגיעה במקרקעין ע\\\"י תכנית). קבע לפי מהות הסכסוך כפי שהוא עולה מהטקסט. אם לא ברור לאיזה מהשלושה — מחרוזת ריקה (אל תנחש).",
   "summary": "תקציר עניני 2-3 משפטים: מה הייתה השאלה, מה הוכרע. בלי שיפוט.",
   "headnote": "headnote בסגנון נבו: 1-2 משפטים שמסכמים את העיקרון שנקבע/יושם בפסק. למשל 'תכנית רחביה — היטל השבחה במימוש במכר — אין לחייב כשהזכויות צפות'.",
   "key_quote": "ציטוט מילולי בודד, 30-100 מילים, שמייצג את לב הפסק. חייב להופיע מילה במילה בטקסט. אם אין ציטוט מתאים — מחרוזת ריקה.",
@@ -73,10 +61,9 @@ METADATA_EXTRACTION_PROMPT = """אתה מסייע משפטי בכיר. קרא א
   "proceeding_type": "אחד מ-2 (רק להחלטות ועדת ערר): 'ערר' (הליך ערר עיקרי על החלטת ועדה מקומית) / 'בל\\\"מ' (בקשה להארכת מועד להגשת ערר). זהה דרך כותרת המסמך: 'ערר (ועדות ערר ...) NNNN/YY' → 'ערר'; 'בל\\\"מ NNNN/YY' או נושא 'בקשה להארכת מועד להגשת ערר' → 'בל\\\"מ'. בפסיקת בית משפט (לא ועדת ערר) — מחרוזת ריקה.",
   "court": "שם הערכאה כפי שהוא מופיע בכותרת (למשל 'בית המשפט העליון', 'בית המשפט המחוזי בירושלים בשבתו כבית משפט לעניינים מנהליים', 'ועדת הערר לתכנון ובניה פיצויים והיטלי השבחה — מחוז ירושלים'). מחרוזת ריקה אם לא ניתן לזהות.",
   "case_number_clean": "מספר הערר/תיק כפי שמופיע בכותרת — רק הספרות והאלכסון, למשל '1062/24' או '8031/21'. ללא המילה 'ערר', ללא שם הצדדים, ללא סוגריים. אם יש כמה עררים מאוחדים — הרשום הראשון. מחרוזת ריקה אם לא ניתן לזהות.",
-  "chair_name": "שם יו\\\"ר ההרכב של **ההחלטה הזו** — רלוונטי **רק להחלטות ועדת ערר**, לא לפסקי בית משפט. כמעט תמיד מופיע — בשני מקומות: (א) בכותרת/רובריקה בראש המסמך, ליד 'בפני:' / 'בהרכב:' / רשימת חברי הוועדה; (ב) בבלוק-החתימה בסוף ההחלטה, אחרי 'ההחלטה ניתנה' — שם מופיעים זה-לצד-זה מזכיר/ת הוועדה והיו\\\"ר (למשל בשתי עמודות: בצד אחד 'פלוני, עו\\\"ד / מזכיר ועדת הערר' ובצד השני 'אלמוני, עו\\\"ד / יו\\\"ר ועדת הערר'). **קח את השם שמעליו/לצדו כתוב 'יו\\\"ר' — לא את המזכיר/ה.** השאר שם פרטי+משפחה בלבד, בלי תוארים ('עו\\\"ד', 'אדריכל', 'עו\\\"ד דפנה תמיר'→'דפנה תמיר'). **אזהרה קריטית:** אל תיקח שם יו\\\"ר של פסק/החלטה אחרים ש**מצוטטים** בגוף ההחלטה (למשל 'כפי שנקבע ברשותה של יו\\\"ר פלונית בערר אחר...') — אלה תקדימים מצוטטים, לא היו\\\"ר של ההחלטה הנוכחית. אם זה פסק דין של בית משפט — מחרוזת ריקה.",
+  "chair_name": "שם יו\\\"ר ההרכב — רלוונטי **רק להחלטות ועדת ערר**, לא לפסקי בית משפט. חפש בכותרת/חתימה: 'עו\\\"ד דפנה תמיר, יו\\\"ר ועדת הערר', 'בפני: עו\\\"ד פלוני אלמוני (יו\\\"ר)'. השאר שם פרטי+משפחה בלי תוארים ('עו\\\"ד', 'אדריכל'). אם זה פסק דין של בית משפט — מחרוזת ריקה.",
   "district": "מחוז ועדת הערר — רלוונטי **רק להחלטות ועדת ערר**. ערכים מותרים: 'ירושלים', 'תל אביב', 'מרכז', 'חיפה', 'צפון', 'דרום', 'ארצית'. זהה מהכותרת ('ועדת הערר לתכנון ובניה — מחוז ירושלים' → 'ירושלים'; 'ועדות ערר - תכנון ובנייה תל אביב-יפו' → 'תל אביב'). אם זה פסק דין של בית משפט — מחרוזת ריקה.",
-  "parties": "שמות הצדדים בשורה אחת בצורה 'עורר נ\\' משיב' — בדיוק כפי שמופיעים בכותרת/רובריקה. בלי הדגשה, בלי מספר-תיק, בלי תוארים מיותרים. למשל 'ישיבת חברת אהבת שלום נ\\' תאיה' או 'ראם חיים נ\\' הוועדה המקומית לתכנון ובניה ירושלים'. אם הצדדים אינם מופיעים בטקסט (למשל החלטה שמתחילה בגוף בלי רובריקה) — מחרוזת ריקה. **אל תמציא שמות.**",
+  "citation_formatted": "המראה מקום המלא לפי **כללי הציטוט האחיד**, בפורמט Markdown — שמות הצדדים בלבד מוקפים בכפול-כוכבית (`**…**`), הכל השאר רגיל. ראה כללים מפורטים בסעיף 12 למטה."
-  "citation_prefix": "קידומת-ההליך של פסיקת בית-משפט בלבד, כפי שמופיעה בראש הכותרת: ע\\"א / רע\\"א / בג\\"ץ / עע\\"מ / עת\\"מ / ע\\"פ / דנ\\"א / ת\\"א וכד'. **רק לפסקי בית-משפט (עליון/מנהלי)** — להחלטות ועדת-ערר השאר ריק (הקוד גוזר 'ערר'/'בל\\"מ' מעצמו). אם לא ברור — מחרוזת ריקה."
 }
 
 ## כללי איכות
@@ -92,10 +79,22 @@ METADATA_EXTRACTION_PROMPT = """אתה מסייע משפטי בכיר. קרא א
 10. **court** — מהכותרת הראשית של הפסק. ניסוח מלא (לא קיצור). מחרוזת ריקה אם לא ניתן לזהות.
 11. **proceeding_type** — חובה לזהות עבור החלטות ועדת ערר; ריק עבור פסיקת בית משפט. הסימן הברור: בכותרת הראשונה של המסמך כתוב "ערר (ועדות ערר ...) NNNN/YY" → 'ערר'; "בל\"מ NNNN/YY" או הנושא "בקשה להארכת מועד להגשת ערר" → 'בל\"מ'. שני הסוגים יכולים לחלוק אותו מספר תיק — לכן חשוב להבחין מפורשות.
 12. **chair_name / district** — חובה למלא רק עבור החלטות ועדת ערר (source_type='appeals_committee'). chair_name נמצא בכותרת ("בפני: עו\"ד פלוני אלמוני, יו\"ר") או בחתימה. district = מחוז הוועדה, מתוך רשימה סגורה. עבור פסקי בית משפט — שני השדות ריקים.
-13. **parties / citation_prefix — רכיבי המראה-מקום (לא המראה-מקום עצמו)**. אינך מרכיב את הציטוט המעוצב — המערכת מרכיבה אותו דטרמיניסטית מהרכיבים. עליך רק **לחלץ** שני רכיבים נקיים:
+13. **citation_formatted — כללי הציטוט האחיד הישראלי**. הרכב את המראה מקום במחרוזת אחת בפורמט Markdown, **כשרק שמות הצדדים מודגשים** (מוקפים ב-`**…**`). כל השאר — קיצור הערכאה, סוגריים של הרכב/מחוז, מספר תיק, מאגר/תאריך — **רגיל ללא הדגשה**.
-   - **parties** — שורת הצדדים "[עורר/מבקש] נ' [משיב]" כפי שמופיעה בכותרת/רובריקה. בלי מספר-תיק, בלי קידומת-הליך, בלי הדגשה. הצדדים = מי שמופיע בין מספר-התיק לבין שם-הערכאה/התאריך. אם אין רובריקה עם צדדים (החלטה שפותחת ישר בגוף) — השאר ריק; **אל תמציא שמות**.
+
-   - **citation_prefix** — קידומת-ההליך **רק לפסקי בית-משפט** (ע"א / רע"א / בג"ץ / עע"מ / עת"מ / ע"פ / דנ"א / ת"א…), כפי שכתובה בראש הכותרת. להחלטות ועדת-ערר — ריק (המערכת גוזרת 'ערר'/'בל"מ' מ-proceeding_type).
+   תבניות לסוגי פסיקה:
-   - שניהם רשות; ריק עדיף על ניחוש (INV-AH — abstention על המצאה).
+   * **בית משפט עליון — לא פורסם:** `ע"א 1234/56 **פלוני נ' אלמוני** (נבו 1.2.3456)`
+   * **בית משפט עליון — פורסם:** `ע"א 1234/56 **פלוני נ' אלמוני**, פ"ד יב(3) 456 (1990)`
+   * **בית משפט מנהלי:** `עת"מ (י-ם) 1234/56 **פלוני נ' הוועדה** (נבו 1.2.3456)` — "(י-ם)" / "(ת"א)" / וכד' = קיצור המחוז
+   * **ועדת ערר תכנון ובנייה (מחוזית):** `ערר (ועדות ערר - תכנון ובנייה ת"א-יפו) 81002-01-21 **אברהם אגסי נ' הועדה המקומית לתכנון ובנייה תל אביב** (נבו 25.9.2025)`
+   * **בל"מ (בקשה להארכת מועד):** `בל"מ (ועדות ערר - ירושלים) 1028/20 **חלוואני ריאד נ' רשות הרישוי - הוועדה המקומית ירושלים** (נבו 7.1.2021)`
+   * **ועדת ערר ארצית:** `ערר ארצי 8047/23 **פלוני נ' אלמוני** (נבו 1.2.3456)`
+
+   כללים:
+   - **הצדדים מודגשים בלבד** — כל השאר רגיל. אל תדגיש את "ע"א" / "ערר" / מספר התיק / "(נבו ...)" / "פ"ד".
+   - הצדדים = מי שמופיע **בין מספר התיק לבין הסוגריים הסופיים** (תאריך/מאגר), כלומר "[עורר/מבקש] נ' [משיב]".
+   - תאריך בסוגריים סופיים בפורמט עברי "(נבו 25.9.2025)" — יום.חודש.שנה ללא אפסים מובילים.
+   - אם המאגר הוא נבו והפסיקה לא פורסמה ב-פ"ד — השתמש ב-"(נבו DATE)". אם פורסמה ב-פ"ד — הוסף את ההפניה הפורמלית אחרי הצדדים: `..., פ"ד יב(3) 456 (1990)`.
+   - אם לא ניתן לזהות איזשהו רכיב במדויק — השאר את **כל** השדה ריק. אל תניח / תמציא.
 """
 
 
@@ -151,10 +150,7 @@ async def extract_metadata(case_law_id: UUID | str) -> dict:
     )
 
     try:
-        # Bounded structured extraction → Gemini Flash (JSON mode). The agentic
+        result = await claude_session.query_json(
-        # claude CLI hit error_max_turns on this single-shot task; see
-        # gemini_session.py. Voice-sensitive/agentic work stays on claude_session.
-        result = await gemini_session.query_json(
             user_msg, system=METADATA_EXTRACTION_PROMPT,
         )
     except Exception as e:
@@ -174,16 +170,6 @@ async def extract_metadata(case_law_id: UUID | str) -> dict:
         out["case_name_short"] = result["case_name_short"].strip()
     if isinstance(result.get("appeal_subtype"), str):
         out["appeal_subtype"] = result["appeal_subtype"].strip()
-    if isinstance(result.get("practice_area"), str):
-        # Closed domain enum (axis B). Anything else (incl. the legacy
-        # multi-tenant 'appeals_committee' value or free text) is dropped so a
-        # slip can't write an unrenderable value into the radio facet — the
-        # deterministic case_number-prefix derivation in apply_to_record is the
-        # authoritative source anyway; this is the content fallback for court
-        # rulings whose docket prefix doesn't encode the domain.
-        pa = result["practice_area"].strip()
-        if pa in DOMAIN_PRACTICE_AREAS:
-            out["practice_area"] = pa
     if isinstance(result.get("summary"), str):
         out["summary"] = result["summary"].strip()
     if isinstance(result.get("headnote"), str):
@@ -220,42 +206,17 @@ async def extract_metadata(case_law_id: UUID | str) -> dict:
         # silently storing free-text in what callers treat as a filter facet.
         if d in {"ירושלים", "תל אביב", "מרכז", "חיפה", "צפון", "דרום", "ארצית"}:
             out["district"] = d
-    # parties / citation_prefix — COMPONENTS of the citation, not the formatted
+    if isinstance(result.get("citation_formatted"), str):
-    # string. citation_formatted itself is assembled deterministically by
+        cf = result["citation_formatted"].strip()
-    # db.format_precedent_citation in apply_to_record (#145): a Flash model reliably
+        # Sanity check: a valid citation should contain at least one bold
-    # extracts the party line but dropped the formatted citation outright.
+        # marker pair (the parties) AND a closing paren (the reporter/date).
-    if isinstance(result.get("parties"), str):
+        # If the LLM returned a half-formed string, drop it rather than
-        out["parties"] = result["parties"].strip()
+        # store junk that the UI then has to special-case.
-    if isinstance(result.get("citation_prefix"), str):
+        if cf.count("**") >= 2 and ")" in cf:
-        out["citation_prefix"] = result["citation_prefix"].strip()
+            out["citation_formatted"] = cf
     return out
 
 
-# Israeli court docket: digits with slash/dash separators, no spaces, no letters
-# (e.g. "1132-09-24", "4768/22", "35758-09-25"). Used to (a) detect a
-# citation-shaped case_number that must be normalized and (b) guard against ever
-# writing a non-docket string into the identity field.
-_DOCKET_RE = re.compile(r"\d{1,6}(?:[-/]\d{1,4}){1,2}")
-
-
-def _is_clean_docket(s: str) -> bool:
-    return bool(_DOCKET_RE.fullmatch((s or "").strip()))
-
-
-def _source_type_for_level(level: str) -> str:
-    """Derive source_type from precedent_level — the library section is driven by
-    source_type, so the two MUST agree (an LLM slip pairing
-    precedent_level='ועדת_ערר_מחוזית' with source_type='court_ruling' files a
-    committee decision under "court rulings"). Empty when the level is
-    indeterminate (don't force a guess)."""
-    level = (level or "").strip()
-    if level.startswith("ועדת_ערר"):
-        return "appeals_committee"
-    if level in ("עליון", "מנהלי"):
-        return "court_ruling"
-    return ""
-
-
 async def apply_to_record(
     case_law_id: UUID | str,
     suggested: dict,
@@ -363,88 +324,23 @@ async def apply_to_record(
         if pt and (record.get("source_kind") == "internal_committee"):
             fields_to_update["proceeding_type"] = pt
 
-    # case_number normalization. The precedent upload / missing-precedent flow
+    if overwrite_case_number:
-    # stores the FULL citation string into case_number (precedent_library:
+        cn = (suggested.get("case_number_clean") or "").strip()
-    # case_number=citation). Replace it with the clean docket when the LLM gives
+        if cn:
-    # one AND either (a) caller forces it (overwrite_case_number — migrations) or
+            fields_to_update["case_number"] = cn
-    # (b) the stored value is clearly citation-shaped (has a space / is long — a
-    # real docket never is). Guard: only write a value that IS a clean docket, so
-    # a bad LLM output can never corrupt the identity field.
-    cn_clean = (suggested.get("case_number_clean") or "").strip()
-    cur_cn = cur_case_number
-    citation_shaped = bool(cur_cn) and (" " in cur_cn or len(cur_cn) > 20)
-    if (
-        cn_clean
-        and _is_clean_docket(cn_clean)
-        and cn_clean != cur_cn
-        and (overwrite_case_number or citation_shaped)
-    ):
-        # Skip (don't crash) when the clean docket already belongs to ANOTHER
-        # non-internal row — a duplicate to dedupe later, not this run's concern.
-        # Writing it would hit uq_case_law_external_number and abort the whole merge
-        # (including the citation). No-silent-swallow: log the skip.
-        if (
-            record.get("source_kind") != "internal_committee"
-            and await db.case_number_collides(cn_clean, case_law_id)
-        ):
-            logger.warning(
-                "metadata_extractor: case_number normalization %r→%r skipped — docket "
-                "already owned by another non-internal row (likely duplicate)",
-                cur_cn, cn_clean,
-            )
-        else:
-            fields_to_update["case_number"] = cn_clean
 
-    # practice_area — the domain facet (axis B) that drives the /precedents radio
+    # citation_formatted — full citation per Israeli citation rules. Only
-    # and search filters. The LLM never set it historically (it was passed in as
+    # fill if empty; user edits in /precedents/[id] are preserved.
-    # read-only context), so committee/court uploads that left it blank stayed
+    if not (record.get("citation_formatted") or "").strip():
-    # blank forever. Fill when empty, preferring the DETERMINISTIC case_number
+        s = (suggested.get("citation_formatted") or "").strip()
-    # prefix (1xxx→rishuy, 8xxx→היטל, 9xxx→197 — authoritative for ועדת-ערר
+        if s:
-    # dockets, INV-AH rule-based) and falling back to the LLM's content
+            fields_to_update["citation_formatted"] = s
-    # classification for court rulings whose docket prefix doesn't encode a
-    # domain. Built off the EFFECTIVE case_number so a same-run normalization is
-    # seen. Abstains (no write) when neither yields a domain value.
-    if not (record.get("practice_area") or "").strip():
-        eff_cn = (
-            fields_to_update.get("case_number") or record.get("case_number") or ""
-        )
-        pa = derive_domain_practice_area(eff_cn) or (
-            suggested.get("practice_area") or ""
-        ).strip()
-        if pa in DOMAIN_PRACTICE_AREAS:
-            fields_to_update["practice_area"] = pa
 
-    # parties — store the extracted "עורר נ' משיב" line (the re-derivable basis for
+    # chair_name / district — only for internal_committee rows. The DB CHECK
-    # the deterministic citation). Only fill when empty; chair edits are preserved.
+    # forces these to be non-empty, so the upload endpoint stamps the row
-    if not (record.get("parties") or "").strip():
+    # with "(טרם חולץ)" as a placeholder. Treat that placeholder as empty
-        p = (suggested.get("parties") or "").strip()
+    # so the LLM-extracted value can overwrite it.
-        if p:
+    if record.get("source_kind") == "internal_committee":
-            fields_to_update["parties"] = p
-
-    # chair_name / district — for ANY ועדת-ערר decision, regardless of how it
-    # entered the corpus. Previously gated on source_kind=='internal_committee',
-    # which silently skipped committee decisions uploaded via the EXTERNAL
-    # precedent path (source_kind='external_upload', source_type='appeals_committee'
-    # — e.g. another district's decision pulled from נבו): the chair sat in the
-    # signature block but was never extracted. The CHECK only forces non-empty for
-    # internal_committee, so writing a chair onto an external_upload row is safe;
-    # for internal rows the upload endpoint stamps "(טרם חולץ)" which we treat as
-    # empty. The LLM prompt already abstains (empty) for court rulings, so this is
-    # additionally gated on the decision actually being a committee one — never a
-    # court ruling. Derive "is committee" from the effective source_type/level so a
-    # same-run fill is seen.
-    eff_st_chair = (
-        fields_to_update.get("source_type") or record.get("source_type") or ""
-    ).strip()
-    eff_lvl_chair = (
-        fields_to_update.get("precedent_level") or record.get("precedent_level") or ""
-    ).strip()
-    is_committee_decision = (
-        record.get("source_kind") == "internal_committee"
-        or eff_st_chair == "appeals_committee"
-        or eff_lvl_chair.startswith("ועדת_ערר")
-    )
-    if is_committee_decision:
         cur_chair = (record.get("chair_name") or "").strip()
         if cur_chair in ("", PLACEHOLDER_PENDING_EXTRACTION):
             s = (suggested.get("chair_name") or "").strip()
@@ -456,45 +352,6 @@ async def apply_to_record(
             if s:
                 fields_to_update["district"] = s
 
-    # Enforce source_type ↔ precedent_level consistency in CODE (the LLM prompt
-    # asks for it, but a slip would file a ועדת-ערר decision under "court
-    # rulings"). Derive from the EFFECTIVE level (this run's update or the stored
-    # value) and override an inconsistent source_type — even one already on the
-    # record, since the library section depends on it.
-    eff_level = (
-        fields_to_update.get("precedent_level")
-        or record.get("precedent_level")
-        or ""
-    ).strip()
-    derived_st = _source_type_for_level(eff_level)
-    if derived_st:
-        eff_st = (
-            fields_to_update.get("source_type")
-            or record.get("source_type")
-            or ""
-        ).strip()
-        if eff_st != derived_st:
-            fields_to_update["source_type"] = derived_st
-
-    # citation_formatted — DERIVED deterministically from the effective record
-    # (db.format_precedent_citation), NEVER formatted by the LLM (#145, INV-ID2).
-    # Built last, so it sees this run's component updates (case_number/date/level/
-    # source_type/district/proceeding_type/parties). Only fill when empty so chair
-    # edits in /precedents/[id] are preserved; abstains (no write) when a component
-    # is missing.
-    if not (record.get("citation_formatted") or "").strip():
-        eff = {**record, **fields_to_update}
-        eff_parties = (
-            fields_to_update.get("parties") or record.get("parties") or ""
-        ).strip()
-        cit = db.format_precedent_citation(
-            eff,
-            parties=eff_parties,
-            court_prefix=(suggested.get("citation_prefix") or "").strip(),
-        )
-        if cit:
-            fields_to_update["citation_formatted"] = cit
-
     if not fields_to_update:
         return {"updated": False, "fields": []}
 
@@ -509,20 +366,7 @@ async def extract_and_apply(
     """Convenience wrapper: extract → merge into row → return summary."""
     suggested = await extract_metadata(case_law_id)
     if not suggested:
-        # Empty result has two very different meanings (#138): the precedent has
+        return {"status": "no_metadata", "fields": []}
-        # NO text to extract from (permanent — nothing the queue can ever do), vs
-        # the Gemini call FAILED despite the row having full text (transient — a
-        # key/network/rate-limit hiccup that a retry can recover). Conflating
-        # them as 'no_metadata' let the drain settle the row to 'completed' on a
-        # transient failure, silently stranding it with empty metadata. Branch on
-        # whether text was actually present so the caller can retry the transient
-        # case and only settle the genuinely-empty one.
-        record = await db.get_case_law(case_law_id)
-        has_text = bool(((record or {}).get("full_text") or "").strip())
-        return {
-            "status": "extraction_failed" if has_text else "no_metadata",
-            "fields": [],
-        }
     result = await apply_to_record(case_law_id, suggested, overwrite_case_number=overwrite_case_number)
     if result["updated"]:
         await db.recompute_searchable(case_law_id)

mcp-server/src/legal_mcp/services/processor.py

@@ -8,9 +8,7 @@ from pathlib import Path
 from uuid import UUID
 
 from legal_mcp import config
-from legal_mcp.services import (
+from legal_mcp.services import chunker, db, embeddings, extractor, references_extractor
-    chunker, db, embeddings, extractor, references_extractor, storage,
-)
 
 logger = logging.getLogger(__name__)
 
@@ -42,17 +40,13 @@ async def process_document(document_id: UUID, case_id: UUID) -> dict:
             page_count=page_count,
         )
 
-        # Save extracted text (a DERIVED artifact — the DB column holds the
+        # Save extracted text to documents/extracted/ directory
-        # source of truth, INV-STG5) through the storage layer (INV-STG1).
-        # Non-fatal: the .txt is a convenience copy, the pipeline reads the DB.
         original_path = Path(doc["file_path"])
-        txt_path = original_path.parent.parent / "extracted" / (original_path.stem + ".txt")
+        extracted_dir = original_path.parent.parent / "extracted"
+        extracted_dir.mkdir(parents=True, exist_ok=True)
+        txt_path = extracted_dir / (original_path.stem + ".txt")
         try:
-            await storage.put_bytes(
+            txt_path.write_text(text, encoding="utf-8")
-                txt_path.relative_to(config.DATA_DIR).as_posix(),
-                text.encode("utf-8"), bucket=storage.Bucket.DERIVED,
-                content_type="text/plain; charset=utf-8",
-            )
             logger.info("Saved extracted text to %s", txt_path)
         except Exception as e:
             logger.warning("Failed to save text file (non-fatal): %s", e)

mcp-server/src/legal_mcp/services/proofreader.py

@@ -268,13 +268,12 @@ async def proofread(path: Path) -> tuple[str, dict]:
 
 # ── Metadata extraction ──────────────────────────────────────────
 
-# Serial is 3–5 digits: 4 = ערר, 5 = בל"מ (post-reform). 3 tolerates legacy short serials.
 FILENAME_NUMBER_PATTERNS = [
-    re.compile(r"^ARAR-(\d{2})-(\d{3,5})"),
+    re.compile(r"^ARAR-(\d{2})-(\d{3,4})"),
-    re.compile(r"^ערר\s+(\d{3,5})-(\d{2})"),
+    re.compile(r"^ערר\s+(\d{3,4})-(\d{2})"),
-    re.compile(r"^ערר\s+(\d{3,5})\s*-"),
+    re.compile(r"^ערר\s+(\d{3,4})\s*-"),
 ]
-LEGACY_MULTI_PATTERN = re.compile(r"(\d{3,5})\+(\d{3,5})")
+LEGACY_MULTI_PATTERN = re.compile(r"(\d{3,4})\+(\d{3,4})")
 
 
 def decision_number_from_filename(stem: str) -> str | None:

mcp-server/src/legal_mcp/services/qa_validator.py

@@ -104,7 +104,7 @@ CLAIMS_CHECK_PROMPT = """אתה בודק איכות החלטות משפטיות.
 """
 
 
-async def check_claims_coverage(blocks: list[dict], claims: list[dict], outcome: str = "") -> dict:
+async def check_claims_coverage(blocks: list[dict], claims: list[dict]) -> dict:
     """בדיקה סמנטית (Claude) שכל טענה נענתה בדיון."""
     yod = next((b for b in blocks if b["block_id"] == "block-yod"), None)
     if not yod or not yod.get("content"):
@@ -114,26 +114,16 @@ async def check_claims_coverage(blocks: list[dict], claims: list[dict], outcome:
     if not claims:
         return {"name": "claims_coverage", "passed": True, "errors": [], "severity": "critical"}
 
-    # #87/GAP-87 — only the appellant's claims from the APPEAL PLEADING itself
+    # Filter: only APPELLANT claims from original pleadings.
-    # must be addressed. claim_type: 'claim'=כתב ערר (mandatory), 'response'=כתב
+    # Committee/permit_applicant claims are defensive positions, not claims
-    # תשובה, 'reply'=תגובה/השלמת-טיעון/תכתובת (supplementary correspondence — NOT
+    # that need to be "addressed" in the discussion.
-    # a standalone duty to answer, especially on full acceptance). Counting reply/
-    # correspondence claims as "unanswered" produced false QA fails (1033-25).
     source_claims = [
         c for c in claims
         if c.get("source_document", "") != "block-zayin"
-        and c.get("claim_type") == "claim"
-        and c.get("party_role") == "appellant"
-    ]
-    if not source_claims:
-        # Fallback: appellant/respondent pleadings, excluding supplementary replies.
-        source_claims = [
-            c for c in claims
-            if c.get("source_document", "") != "block-zayin"
-            and c.get("claim_type") != "reply"
         and c.get("party_role") in ("appellant", "respondent")
     ]
     if not source_claims:
+        # Fallback: all non-block-zayin claims
         source_claims = [c for c in claims if c.get("source_document", "") != "block-zayin"]
     if not source_claims:
         source_claims = claims
@@ -154,7 +144,7 @@ async def check_claims_coverage(blocks: list[dict], claims: list[dict], outcome:
 ## בלוק הדיון:
 {discussion}"""
 
-    parsed = await claude_session.query_json(prompt, tools="")  # no tool_use → no error_max_turns
+    parsed = await claude_session.query_json(prompt)
     if parsed is None:
         logger.warning("Failed to parse claims check")
         # Fallback: assume all covered (don't block export on parse failure)
@@ -175,14 +165,9 @@ async def check_claims_coverage(blocks: list[dict], claims: list[dict], outcome:
     total = len(source_claims)
     covered = len(addressed) + len(partial)
 
-    # On full acceptance the appellant prevailed in full — not every sub-claim
-    # needs individual treatment (the chair noted this for correspondence claims,
-    # 1033-25). Relax the missing-tolerance accordingly.
-    allowed_missing_ratio = 0.4 if outcome == "full_acceptance" else 0.2
-
     return {
         "name": "claims_coverage",
-        "passed": len(missing) <= total * allowed_missing_ratio,
+        "passed": len(missing) <= total * 0.2,  # Allow up to 20% missing
         "errors": errors,
         "severity": "critical",
         "details": f"{covered}/{total} טענות נענו ({covered/total*100:.0f}%), {len(partial)} חלקית, {len(missing)} חסרות",
@@ -376,10 +361,8 @@ async def validate_decision(case_id: UUID) -> dict:
     # Get claims
     claims = await db.get_claims(case_id)
 
-    # Determine appeal type + outcome (outcome relaxes claims coverage on full acceptance — #87)
+    # Determine appeal type
     appeal_type = case.get("appeal_type", "licensing")
-    from legal_mcp.services.lessons import canonical_outcome
-    outcome = canonical_outcome(decision.get("outcome", "") or "")
 
     # Run all checks
     # Run sync checks
@@ -387,7 +370,7 @@ async def validate_decision(case_id: UUID) -> dict:
         check_neutral_background(blocks),
     ]
     # Async check: claims coverage with Claude
-    results.append(await check_claims_coverage(blocks, claims, outcome))
+    results.append(await check_claims_coverage(blocks, claims))
     # More sync checks
     results.extend([
         check_weight_compliance(blocks, appeal_type),

mcp-server/src/legal_mcp/services/research_md.py

@@ -346,7 +346,7 @@ def update_chair_position(
 
     # Atomic write
     tmp_path = file_path.with_suffix(file_path.suffix + ".tmp")
-    tmp_path.write_text(new_content, encoding="utf-8")  # noqa: STG1 — atomic .tmp; in-place edit, S3 re-sync in Phase-2 read-wiring
+    tmp_path.write_text(new_content, encoding="utf-8")
     os.replace(tmp_path, file_path)
 
     preview = new_text.strip()[:120]

mcp-server/src/legal_mcp/services/script_runner.py

@@ -1,50 +0,0 @@
-"""Allowlist of read-only scripts runnable from the /scripts page (#4).
-
-Single source of truth shared by BOTH:
-  - the host bridge (``court_fetch_service.server`` — the ENFORCER that actually
-    launches the process), and
-  - the container API (``web/app.py`` — display-only: tells the UI which rows get
-    a "הרץ" button).
-
-Each entry maps a script's basename to the EXACT, fixed argument list it runs
-with. **Read-only / audit scripts only**, with a safe fixed argv and **no
-user-supplied arguments** — never ``--apply``/``--force``. The system is
-single-user/internal, so this allowlist is a footgun-guard, not an auth boundary;
-enforcement lives on the trusted host side.
-
-Adding an entry is a security decision: verify the script is read-only (no DB
-writes, no destructive side effects) with the given argv before listing it.
-
-stdlib-only on purpose, so the lightweight host bridge can import it cheaply.
-"""
-
-from __future__ import annotations
-
-_REPO = "/home/chaim/legal-ai"
-_PYTHON = f"{_REPO}/mcp-server/.venv/bin/python"
-
-# basename → argv tail (script path relative to the repo root, then fixed flags).
-# Verified read-only 2026-06-17. `audit_corpus_integrity` runs with --no-notify
-# so it stays report-only (no notification side-effect) when run from the dashboard.
-SCRIPT_RUN_ALLOWLIST: dict[str, list[str]] = {
-    "leak_guard.py": ["scripts/leak_guard.py"],
-    "check_undefined_names.py": ["scripts/check_undefined_names.py"],
-    "storage_leak_tripwire.py": ["scripts/storage_leak_tripwire.py"],
-    "audit_training_corpus.py": ["scripts/audit_training_corpus.py"],
-    "audit_corpus_integrity.py": ["scripts/audit_corpus_integrity.py", "--no-notify"],
-}
-
-
-def runnable_names() -> list[str]:
-    """Sorted basenames the UI may show a "הרץ" button for (display-only)."""
-    return sorted(SCRIPT_RUN_ALLOWLIST)
-
-
-def build_argv(name: str) -> list[str] | None:
-    """Full argv (python + absolute script path + fixed flags) for an allowlisted
-    script, or ``None`` when *name* is not allowlisted. Arguments are taken ONLY
-    from the allowlist — anything the caller passes is ignored."""
-    tail = SCRIPT_RUN_ALLOWLIST.get(name)
-    if tail is None:
-        return None
-    return [_PYTHON, f"{_REPO}/{tail[0]}", *tail[1:]]

mcp-server/src/legal_mcp/services/storage.py

@@ -1,578 +0,0 @@
-"""Unified object-storage layer (X14, INV-STG1).
-
-THE single choke-point for all binary file I/O — originals, derived
-artifacts (thumbnails / extracted text), and exports. It replaces the
-scattered ``open()`` / ``shutil.copy`` / ``Path.write_bytes`` calls spread
-across ~8 services (G2: one storage path, no parallel routes). See
-docs/spec/X14-storage-minio.md.
-
-Keys
-----
-A *key* is a DATA_DIR-relative POSIX path, e.g.::
-
-    cases/8174-24/documents/originals/<uuid>.pdf
-    precedent-library/thumbnails/<case_law_id>/p001.jpg
-
-The filesystem backend maps ``key -> DATA_DIR / key``, preserving the exact
-current on-disk layout (zero behaviour change when ``STORAGE_BACKEND`` is the
-default ``filesystem``). The S3 backend maps a logical *bucket*
-(documents/immutable/derived) to a MinIO bucket and uses the key verbatim as
-the object key.
-
-INV-STG2: keys are atomic ASCII/UUID paths; a Hebrew original filename is
-carried as object metadata / a DB column, never as the key itself.
-INV-STG5: pgvector stays the source of truth for text + embeddings — this
-layer stores blobs only. INV-STG6: presigned URLs (minted against the public
-endpoint) serve bytes straight to the browser.
-
-Backends (config.STORAGE_BACKEND)
----------------------------------
-- ``filesystem`` (default) — disk only; current behaviour.
-- ``dual``                — write disk + S3; read S3, fall back to disk.
-                            The migration window; disk stays authoritative.
-- ``s3``                  — MinIO only.
-
-``aioboto3`` is imported lazily so this module loads even where the dependency
-is absent (the default filesystem backend needs nothing extra).
-"""
-from __future__ import annotations
-
-import asyncio
-import logging
-import shutil
-import tempfile
-from enum import Enum
-from pathlib import Path, PurePosixPath
-from typing import Iterable
-
-from legal_mcp import config
-
-logger = logging.getLogger(__name__)
-
-
-class Bucket(str, Enum):
-    """Logical governance buckets (INV-STG3). Resolved to MinIO bucket names
-    via config; ignored by the filesystem backend (which keeps one tree)."""
-
-    DOCUMENTS = "documents"
-    IMMUTABLE = "immutable"
-    DERIVED = "derived"
-
-
-def _bucket_name(bucket: Bucket) -> str:
-    return {
-        Bucket.DOCUMENTS: config.MINIO_BUCKET_DOCUMENTS,
-        Bucket.IMMUTABLE: config.MINIO_BUCKET_IMMUTABLE,
-        Bucket.DERIVED: config.MINIO_BUCKET_DERIVED,
-    }[bucket]
-
-
-def normalize_key(key: str | Path) -> str:
-    """Return a clean DATA_DIR-relative POSIX key.
-
-    Rejects absolute paths and ``..`` traversal (defence in depth — keys are
-    built internally, never from raw user input). An absolute path under
-    DATA_DIR is accepted and re-relativised so call-sites can pass either a
-    key or a full ``Path`` during the migration.
-    """
-    p = Path(key)
-    if p.is_absolute():
-        try:
-            p = p.relative_to(config.DATA_DIR)
-        except ValueError as exc:
-            raise ValueError(f"absolute path outside DATA_DIR: {key!r}") from exc
-    posix = PurePosixPath(p.as_posix())
-    parts = posix.parts
-    if not parts or any(part == ".." for part in parts):
-        raise ValueError(f"invalid storage key: {key!r}")
-    return posix.as_posix().lstrip("/")
-
-
-def _ascii_metadata(value) -> str:
-    """Coerce an S3 user-metadata value to ASCII.
-
-    S3/MinIO object metadata must be ASCII (botocore raises ParamValidationError
-    otherwise). The only non-ASCII value we attach is the original Hebrew
-    filename (``ingest._stage_file`` → ``metadata={"filename": ...}``), so a
-    Hebrew name like ``"יומון 5167 - 11.6.26.pdf"`` would 500 every s3-only
-    upload. Percent-encode non-ASCII losslessly (recover with
-    ``urllib.parse.unquote``) while leaving plain-ASCII values readable."""
-    s = str(value)
-    if s.isascii():
-        return s
-    from urllib.parse import quote
-    return quote(s)
-
-
-class StorageBackend:
-    """Abstract backend. All methods are async except the cheap path helpers."""
-
-    name = "abstract"
-
-    async def put_bytes(self, key, data, *, bucket=Bucket.DOCUMENTS,
-                        content_type=None, metadata=None) -> str:
-        raise NotImplementedError
-
-    async def put_file(self, src, key, *, bucket=Bucket.DOCUMENTS,
-                      content_type=None, metadata=None) -> str:
-        with open(src, "rb") as fh:
-            return await self.put_bytes(
-                key, fh.read(), bucket=bucket,
-                content_type=content_type, metadata=metadata,
-            )
-
-    async def get_bytes(self, key, *, bucket=Bucket.DOCUMENTS) -> bytes:
-        raise NotImplementedError
-
-    async def exists(self, key, *, bucket=Bucket.DOCUMENTS) -> bool:
-        raise NotImplementedError
-
-    async def delete(self, key, *, bucket=Bucket.DOCUMENTS) -> None:
-        raise NotImplementedError
-
-    async def list_keys(self, prefix, *, bucket=Bucket.DOCUMENTS) -> list[str]:
-        raise NotImplementedError
-
-    async def presign_get(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        download_name=None) -> str:
-        raise NotImplementedError
-
-    async def presign_put(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        content_type=None) -> str:
-        raise NotImplementedError
-
-    def local_path(self, key, *, bucket=Bucket.DOCUMENTS) -> Path | None:
-        """Return a real filesystem path if one exists *without* downloading,
-        else ``None``. Use :meth:`ensure_local` when a path is required."""
-        return None
-
-    async def ensure_local(self, key, *, bucket=Bucket.DOCUMENTS) -> Path:
-        """Return a local path to the object, downloading to a temp file if the
-        backend has no on-disk copy. Caller owns cleanup of temp files."""
-        path = self.local_path(key, bucket=bucket)
-        if path is not None:
-            return path
-        data = await self.get_bytes(key, bucket=bucket)
-        suffix = PurePosixPath(normalize_key(key)).suffix
-        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=suffix)
-        tmp.write(data)
-        tmp.close()
-        return Path(tmp.name)
-
-
-class FilesystemBackend(StorageBackend):
-    """Disk under DATA_DIR. ``bucket`` is ignored — the existing single tree is
-    preserved verbatim, so the default backend is byte-for-byte the legacy
-    behaviour."""
-
-    name = "filesystem"
-
-    def _abs(self, key, *, bucket=Bucket.DOCUMENTS) -> Path:
-        rel = normalize_key(key)
-        path = (Path(config.DATA_DIR) / rel).resolve()
-        root = Path(config.DATA_DIR).resolve()
-        if root not in path.parents and path != root:
-            raise ValueError(f"resolved path escapes DATA_DIR: {key!r}")
-        return path
-
-    async def put_bytes(self, key, data, *, bucket=Bucket.DOCUMENTS,
-                        content_type=None, metadata=None) -> str:
-        path = self._abs(key, bucket=bucket)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        path.write_bytes(data)
-        return f"file://{path}"
-
-    async def put_file(self, src, key, *, bucket=Bucket.DOCUMENTS,
-                      content_type=None, metadata=None) -> str:
-        path = self._abs(key, bucket=bucket)
-        path.parent.mkdir(parents=True, exist_ok=True)
-        shutil.copy2(src, path)  # preserve mtime, as the legacy code did
-        return f"file://{path}"
-
-    async def get_bytes(self, key, *, bucket=Bucket.DOCUMENTS) -> bytes:
-        return self._abs(key, bucket=bucket).read_bytes()
-
-    async def exists(self, key, *, bucket=Bucket.DOCUMENTS) -> bool:
-        return self._abs(key, bucket=bucket).exists()
-
-    async def delete(self, key, *, bucket=Bucket.DOCUMENTS) -> None:
-        self._abs(key, bucket=bucket).unlink(missing_ok=True)
-
-    async def list_keys(self, prefix, *, bucket=Bucket.DOCUMENTS) -> list[str]:
-        root = Path(config.DATA_DIR).resolve()
-        base = self._abs(prefix, bucket=bucket) if prefix else root
-        if not base.exists():
-            return []
-        out: list[str] = []
-        for p in sorted(base.rglob("*")):
-            if p.is_file():
-                out.append(p.resolve().relative_to(root).as_posix())
-        return out
-
-    def local_path(self, key, *, bucket=Bucket.DOCUMENTS) -> Path | None:
-        path = self._abs(key, bucket=bucket)
-        return path if path.exists() else None
-
-    async def presign_get(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        download_name=None) -> str:
-        raise NotImplementedError(
-            "presigned URLs require the S3 backend (set STORAGE_BACKEND=dual|s3)"
-        )
-
-    async def presign_put(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        content_type=None) -> str:
-        raise NotImplementedError(
-            "presigned URLs require the S3 backend (set STORAGE_BACKEND=dual|s3)"
-        )
-
-
-class S3Backend(StorageBackend):
-    """MinIO via aioboto3. Server-side ops use the internal endpoint; presigned
-    URLs are minted against the public endpoint so the browser can reach them
-    (INV-STG6)."""
-
-    name = "s3"
-
-    def __init__(self) -> None:
-        self._session = None  # lazy aioboto3 session
-
-    def _boto(self):
-        import aioboto3  # lazy — absent in the default filesystem path
-        from botocore.config import Config as BotoConfig
-        if self._session is None:
-            self._session = aioboto3.Session()
-        cfg = BotoConfig(signature_version="s3v4", s3={"addressing_style": "path"})
-        return aioboto3, BotoConfig, cfg
-
-    def _client(self, *, public: bool = False):
-        _aioboto3, _BotoConfig, cfg = self._boto()
-        endpoint = config.MINIO_PUBLIC_ENDPOINT if public else config.MINIO_ENDPOINT
-        return self._session.client(
-            "s3",
-            endpoint_url=endpoint,
-            aws_access_key_id=config.MINIO_ACCESS_KEY,
-            aws_secret_access_key=config.MINIO_SECRET_KEY,
-            region_name=config.MINIO_REGION,
-            config=cfg,
-        )
-
-    async def put_bytes(self, key, data, *, bucket=Bucket.DOCUMENTS,
-                        content_type=None, metadata=None) -> str:
-        k = normalize_key(key)
-        extra = {}
-        if content_type:
-            extra["ContentType"] = content_type
-        if metadata:
-            extra["Metadata"] = {kk: _ascii_metadata(vv) for kk, vv in metadata.items()}
-        async with self._client() as s3:
-            await s3.put_object(Bucket=_bucket_name(bucket), Key=k, Body=data, **extra)
-        return f"s3://{_bucket_name(bucket)}/{k}"
-
-    async def get_bytes(self, key, *, bucket=Bucket.DOCUMENTS) -> bytes:
-        k = normalize_key(key)
-        async with self._client() as s3:
-            resp = await s3.get_object(Bucket=_bucket_name(bucket), Key=k)
-            async with resp["Body"] as stream:
-                return await stream.read()
-
-    async def exists(self, key, *, bucket=Bucket.DOCUMENTS) -> bool:
-        from botocore.exceptions import ClientError
-        k = normalize_key(key)
-        async with self._client() as s3:
-            try:
-                await s3.head_object(Bucket=_bucket_name(bucket), Key=k)
-                return True
-            except ClientError as exc:
-                if exc.response["Error"]["Code"] in ("404", "NoSuchKey", "NotFound"):
-                    return False
-                raise
-
-    async def delete(self, key, *, bucket=Bucket.DOCUMENTS) -> None:
-        k = normalize_key(key)
-        async with self._client() as s3:
-            await s3.delete_object(Bucket=_bucket_name(bucket), Key=k)
-
-    async def list_keys(self, prefix, *, bucket=Bucket.DOCUMENTS) -> list[str]:
-        pfx = normalize_key(prefix) if prefix else ""
-        out: list[str] = []
-        async with self._client() as s3:
-            paginator = s3.get_paginator("list_objects_v2")
-            async for page in paginator.paginate(Bucket=_bucket_name(bucket), Prefix=pfx):
-                for obj in page.get("Contents", []):
-                    out.append(obj["Key"])
-        return out
-
-    async def presign_get(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        download_name=None) -> str:
-        k = normalize_key(key)
-        params = {"Bucket": _bucket_name(bucket), "Key": k}
-        if download_name:
-            # RFC 5987 — keep the Hebrew original filename on download (INV-STG2)
-            from urllib.parse import quote
-            params["ResponseContentDisposition"] = (
-                f"attachment; filename*=UTF-8''{quote(download_name)}"
-            )
-        async with self._client(public=True) as s3:
-            return await s3.generate_presigned_url(
-                "get_object", Params=params,
-                ExpiresIn=ttl or config.MINIO_PRESIGN_TTL,
-            )
-
-    async def presign_put(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        content_type=None) -> str:
-        k = normalize_key(key)
-        params = {"Bucket": _bucket_name(bucket), "Key": k}
-        if content_type:
-            params["ContentType"] = content_type
-        async with self._client(public=True) as s3:
-            return await s3.generate_presigned_url(
-                "put_object", Params=params,
-                ExpiresIn=ttl or config.MINIO_PRESIGN_TTL,
-            )
-
-
-class DualBackend(StorageBackend):
-    """Migration window: writes go to BOTH disk and S3 (disk authoritative);
-    reads prefer S3 and fall back to disk. An S3 write failure is logged (never
-    swallowed — engineering §6) but does not break the app while disk holds the
-    canonical copy."""
-
-    name = "dual"
-
-    def __init__(self) -> None:
-        self.fs = FilesystemBackend()
-        self.s3 = S3Backend()
-
-    async def put_bytes(self, key, data, *, bucket=Bucket.DOCUMENTS,
-                        content_type=None, metadata=None) -> str:
-        uri = await self.fs.put_bytes(key, data, bucket=bucket,
-                                      content_type=content_type, metadata=metadata)
-        try:
-            await self.s3.put_bytes(key, data, bucket=bucket,
-                                    content_type=content_type, metadata=metadata)
-        except Exception as exc:  # noqa: BLE001 — log, don't swallow
-            logger.warning("dual put_bytes: S3 mirror failed for %s: %s", key, exc)
-        return uri
-
-    async def put_file(self, src, key, *, bucket=Bucket.DOCUMENTS,
-                      content_type=None, metadata=None) -> str:
-        uri = await self.fs.put_file(src, key, bucket=bucket,
-                                     content_type=content_type, metadata=metadata)
-        try:
-            await self.s3.put_file(src, key, bucket=bucket,
-                                   content_type=content_type, metadata=metadata)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("dual put_file: S3 mirror failed for %s: %s", key, exc)
-        return uri
-
-    async def get_bytes(self, key, *, bucket=Bucket.DOCUMENTS) -> bytes:
-        try:
-            return await self.s3.get_bytes(key, bucket=bucket)
-        except Exception as exc:  # noqa: BLE001 — fall back to disk
-            logger.debug("dual get_bytes: S3 miss for %s (%s); using disk", key, exc)
-            return await self.fs.get_bytes(key, bucket=bucket)
-
-    async def exists(self, key, *, bucket=Bucket.DOCUMENTS) -> bool:
-        if await self.fs.exists(key, bucket=bucket):
-            return True
-        try:
-            return await self.s3.exists(key, bucket=bucket)
-        except Exception:  # noqa: BLE001
-            return False
-
-    async def delete(self, key, *, bucket=Bucket.DOCUMENTS) -> None:
-        await self.fs.delete(key, bucket=bucket)
-        try:
-            await self.s3.delete(key, bucket=bucket)
-        except Exception as exc:  # noqa: BLE001
-            logger.warning("dual delete: S3 delete failed for %s: %s", key, exc)
-
-    async def list_keys(self, prefix, *, bucket=Bucket.DOCUMENTS) -> list[str]:
-        return await self.fs.list_keys(prefix, bucket=bucket)
-
-    def local_path(self, key, *, bucket=Bucket.DOCUMENTS) -> Path | None:
-        return self.fs.local_path(key, bucket=bucket)
-
-    async def presign_get(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        download_name=None) -> str:
-        return await self.s3.presign_get(key, bucket=bucket, ttl=ttl,
-                                         download_name=download_name)
-
-    async def presign_put(self, key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                        content_type=None) -> str:
-        return await self.s3.presign_put(key, bucket=bucket, ttl=ttl,
-                                         content_type=content_type)
-
-
-_BACKENDS = {
-    "filesystem": FilesystemBackend,
-    "dual": DualBackend,
-    "s3": S3Backend,
-}
-
-_singleton: StorageBackend | None = None
-
-
-def get_storage() -> StorageBackend:
-    """Return the process-wide storage backend selected by config.STORAGE_BACKEND
-    (cached). Unknown values fall back to ``filesystem`` with a warning rather
-    than crashing the app."""
-    global _singleton
-    if _singleton is None:
-        cls = _BACKENDS.get(config.STORAGE_BACKEND)
-        if cls is None:
-            logger.warning(
-                "unknown STORAGE_BACKEND=%r — falling back to filesystem",
-                config.STORAGE_BACKEND,
-            )
-            cls = FilesystemBackend
-        _singleton = cls()
-        logger.info("storage backend = %s", _singleton.name)
-    return _singleton
-
-
-def reset_storage_cache() -> None:
-    """Drop the cached backend (tests / after an env change)."""
-    global _singleton
-    _singleton = None
-
-
-# ── module-level convenience wrappers ──────────────────────────────
-# Thin pass-throughs so call-sites can ``from legal_mcp.services import storage``
-# and use ``await storage.put_bytes(...)`` without fetching the singleton.
-
-async def put_bytes(key, data, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                    metadata=None) -> str:
-    return await get_storage().put_bytes(
-        key, data, bucket=bucket, content_type=content_type, metadata=metadata)
-
-
-async def put_file(src, key, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                   metadata=None) -> str:
-    return await get_storage().put_file(
-        src, key, bucket=bucket, content_type=content_type, metadata=metadata)
-
-
-async def get_bytes(key, *, bucket=Bucket.DOCUMENTS) -> bytes:
-    return await get_storage().get_bytes(key, bucket=bucket)
-
-
-async def exists(key, *, bucket=Bucket.DOCUMENTS) -> bool:
-    return await get_storage().exists(key, bucket=bucket)
-
-
-async def delete(key, *, bucket=Bucket.DOCUMENTS) -> None:
-    return await get_storage().delete(key, bucket=bucket)
-
-
-async def list_keys(prefix, *, bucket=Bucket.DOCUMENTS) -> list[str]:
-    return await get_storage().list_keys(prefix, bucket=bucket)
-
-
-async def presign_get(key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                      download_name=None) -> str:
-    return await get_storage().presign_get(
-        key, bucket=bucket, ttl=ttl, download_name=download_name)
-
-
-async def presign_put(key, *, bucket=Bucket.DOCUMENTS, ttl=None,
-                      content_type=None) -> str:
-    return await get_storage().presign_put(
-        key, bucket=bucket, ttl=ttl, content_type=content_type)
-
-
-def local_path(key, *, bucket=Bucket.DOCUMENTS) -> Path | None:
-    return get_storage().local_path(key, bucket=bucket)
-
-
-async def ensure_local(key, *, bucket=Bucket.DOCUMENTS) -> Path:
-    return await get_storage().ensure_local(key, bucket=bucket)
-
-
-# ── mirror: dual-write seal for the not-yet-read-wired pipeline (INV-STG1) ──────
-# A handful of upload/finalize paths still keep a copy on disk because the
-# ingest/extract pipeline reads files by their DATA_DIR path (not yet wired to
-# ensure_local). For those, ``mirror``/``mirror_file`` ALSO persist the blob to
-# object storage when the active backend is s3/dual — so no blob is ever missing
-# from MinIO (durability + presigned serving) even though a disk copy lingers
-# for the pipeline. No-op under the filesystem backend (the disk write is the
-# canonical copy). Best-effort: an S3 failure is logged, never breaks the
-# request (the disk copy holds). The full fix (read-wire the pipeline → drop the
-# disk copy) is tracked separately; until then this closes the data-loss leak.
-
-async def mirror(key, data, *, bucket=Bucket.DOCUMENTS,
-                 content_type=None, metadata=None) -> None:
-    backend = get_storage()
-    if backend.name == "filesystem":
-        return
-    s3 = getattr(backend, "s3", backend)
-    try:
-        await s3.put_bytes(key, data, bucket=bucket,
-                           content_type=content_type, metadata=metadata)
-    except Exception as exc:  # noqa: BLE001 — log, never break the request
-        logger.warning("storage.mirror: S3 persist failed for %s: %s", key, exc)
-
-
-async def mirror_file(src, key, *, bucket=Bucket.DOCUMENTS,
-                      content_type=None, metadata=None) -> None:
-    backend = get_storage()
-    if backend.name == "filesystem":
-        return
-    s3 = getattr(backend, "s3", backend)
-    try:
-        await s3.put_file(src, key, bucket=bucket,
-                          content_type=content_type, metadata=metadata)
-    except Exception as exc:  # noqa: BLE001
-        logger.warning("storage.mirror_file: S3 persist failed for %s: %s", key, exc)
-
-
-# ── synchronous facade ─────────────────────────────────────────────
-# A few legacy writers are plain sync functions (track-changes save, retrofit
-# backup, the multimodal thumbnail renderer which runs in a worker thread via
-# asyncio.to_thread). They go through the same layer via this blocking shim so
-# INV-STG1 holds everywhere.
-
-def _run_coro_blocking(coro):
-    """Run a storage coroutine to completion from synchronous code.
-
-    No running loop in this thread (the common case — sync helpers, or a
-    to_thread worker) → asyncio.run. If a loop *is* already running here, the
-    coroutine is offloaded to a fresh thread so we never deadlock the loop."""
-    try:
-        asyncio.get_running_loop()
-    except RuntimeError:
-        return asyncio.run(coro)
-    box: dict = {}
-
-    def _worker():
-        box["value"] = asyncio.run(coro)
-
-    import threading
-    t = threading.Thread(target=_worker)
-    t.start()
-    t.join()
-    return box["value"]
-
-
-def put_bytes_sync(key, data, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                   metadata=None) -> str:
-    return _run_coro_blocking(
-        put_bytes(key, data, bucket=bucket, content_type=content_type, metadata=metadata))
-
-
-def put_file_sync(src, key, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                  metadata=None) -> str:
-    return _run_coro_blocking(
-        put_file(src, key, bucket=bucket, content_type=content_type, metadata=metadata))
-
-
-def mirror_sync(key, data, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                metadata=None) -> None:
-    _run_coro_blocking(mirror(key, data, bucket=bucket,
-                              content_type=content_type, metadata=metadata))
-
-
-def mirror_file_sync(src, key, *, bucket=Bucket.DOCUMENTS, content_type=None,
-                     metadata=None) -> None:
-    _run_coro_blocking(mirror_file(src, key, bucket=bucket,
-                                   content_type=content_type, metadata=metadata))

mcp-server/src/legal_mcp/services/style_analyzer.py

@@ -166,7 +166,6 @@ async def _analyze_single_pass(rows, appeal_subtype: str = "") -> dict:
     raw = await claude_session.query(
         ANALYSIS_PROMPT.format(decisions=decisions_text),
         timeout=claude_session.LONG_TIMEOUT,
-        tools="",  # text→JSON style analysis — no tool_use → no error_max_turns
     )
 
     return await _parse_and_store_patterns(raw, len(rows), appeal_subtype)
@@ -184,7 +183,6 @@ async def _analyze_multi_pass(rows, appeal_subtype: str = "") -> dict:
         raw = await claude_session.query(
             SINGLE_DECISION_PROMPT.format(decision=decision_text),
             timeout=claude_session.LONG_TIMEOUT,
-            tools="",  # text→JSON style analysis — no tool_use → no error_max_turns
         )
 
         patterns = _extract_json(raw)
@@ -201,7 +199,6 @@ async def _analyze_multi_pass(rows, appeal_subtype: str = "") -> dict:
             patterns=json.dumps(all_patterns, ensure_ascii=False, indent=2),
         ),
         timeout=claude_session.LONG_TIMEOUT,
-        tools="",  # text→JSON style analysis — no tool_use → no error_max_turns
     )
 
     return await _parse_and_store_patterns(raw, len(rows), appeal_subtype)

mcp-server/src/legal_mcp/services/style_distance.py

@@ -27,62 +27,6 @@ _BLOCK_TO_SECTION = {
     "block-yod-alef": "summary",
 }
 
-# chunker section_type → golden-ratio section (for corpus measurement, T10)
-_CHUNK_SECTION_TO_GOLDEN = {
-    "facts": "background", "intro": "background",
-    "appellant_claims": "claims", "respondent_claims": "claims",
-    "legal_analysis": "discussion",
-    "conclusion": "summary", "ruling": "summary",
-}
-
-_CORPUS_RATIOS_CACHE: dict | None = None
-
-
-async def measure_corpus_ratios() -> dict:
-    """Measure ACTUAL section %-of-total from Dafna's style_corpus, averaged per
-    outcome — the empirical counterpart to lessons.GOLDEN_RATIOS (T10). Splits each
-    decision via chunker (accurate, not the filtered exemplars). Cached for the
-    process. Returns {outcome: {"n": int, "sections": {sec: pct}}}."""
-    global _CORPUS_RATIOS_CACHE
-    if _CORPUS_RATIOS_CACHE is not None:
-        return _CORPUS_RATIOS_CACHE
-
-    from legal_mcp.services.chunker import _split_into_sections
-    pool = await db.get_pool()
-    async with pool.acquire() as conn:
-        rows = await conn.fetch("SELECT full_text, outcome FROM style_corpus WHERE full_text <> ''")
-
-    # Per-outcome AND an "_all" aggregate. style_corpus.outcome is currently
-    # unpopulated for the imported corpus, so per-outcome may be empty — "_all"
-    # is the meaningful signal today, and per-outcome becomes live once outcomes
-    # are backfilled. No silent loss: callers see which buckets have data via n.
-    by_outcome: dict[str, list[dict]] = {}
-    for r in rows:
-        sect_words: dict[str, int] = {}
-        for stype, stext in _split_into_sections(r["full_text"]):
-            g = _CHUNK_SECTION_TO_GOLDEN.get(stype)
-            if g:
-                sect_words[g] = sect_words.get(g, 0) + len(stext.split())
-        total = sum(sect_words.values())
-        if total < 100:  # sections didn't parse — skip
-            continue
-        pct = {s: w / total * 100 for s, w in sect_words.items()}
-        by_outcome.setdefault("_all", []).append(pct)
-        outcome = canonical_outcome(r["outcome"] or "")
-        if outcome:
-            by_outcome.setdefault(outcome, []).append(pct)
-
-    result: dict = {}
-    for outcome, decs in by_outcome.items():
-        avg = {}
-        for sec in ("background", "claims", "discussion", "summary"):
-            vals = [d.get(sec, 0.0) for d in decs]
-            if vals:
-                avg[sec] = round(sum(vals) / len(vals), 1)
-        result[outcome] = {"n": len(decs), "sections": avg}
-    _CORPUS_RATIOS_CACHE = result
-    return result
-
 
 def count_anti_patterns(text: str) -> dict:
     """Count each anti-pattern occurrence in text. Lower = closer to Dafna."""

mcp-server/src/legal_mcp/services/style_metadata_extractor.py

@@ -119,7 +119,7 @@ async def extract_decision_metadata(corpus_id: UUID | str) -> dict:
     )
 
     try:
-        result = await claude_session.query_json(user_msg, system=METADATA_PROMPT, tools="")  # no tool_use → no error_max_turns
+        result = await claude_session.query_json(user_msg, system=METADATA_PROMPT)
     except Exception as e:
         logger.warning("style_metadata_extractor: query failed: %s", e)
         return {}

mcp-server/src/legal_mcp/services/usage_limits.py

@@ -1,103 +0,0 @@
-"""claude.ai subscription-usage ceilings — the single source of truth.
-
-ONE place that reads the (undocumented) OAuth usage endpoint and decides whether
-a usage window has crossed its soft stop-before-429 ceiling. Imported by BOTH the
-halacha drain (`scripts/drain_halacha_queue.py`) and its supervisor
-(`scripts/halacha_drain_supervisor.py`) so the two never drift (G1/G2).
-
-STRICTLY stdlib — no asyncpg / aiohttp / config imports. The supervisor runs as
-plain system ``python3`` and imports this module directly; pulling in heavy deps
-here would break that import. (``legal_mcp/__init__`` and ``services/__init__``
-are intentionally empty, which is what makes the system-python import work.)
-
-Soft ceilings (chair, 2026-06-15): stop the drain BEFORE a window exhausts so the
-in-flight case finishes on the remaining quota and the drain idles until reset,
-instead of hammering 429 (which burns retries and leaves cases half-extracted).
-5-hour ("hourly session") window stops at 75%, the weekly windows at 65%.
-Overridable via env for ops tuning without a redeploy.
-"""
-import json
-import os
-import urllib.request
-from datetime import datetime, timezone
-
-# claude.ai subscription usage. The token lives in the CLI's own credentials
-# file; the claude-code User-Agent is REQUIRED — without it the request lands in
-# an aggressively rate-limited bucket and 429s. Unofficial endpoint: may change,
-# so every caller must tolerate a None return and fall back.
-CLAUDE_CRED_PATH = "/home/chaim/.claude/.credentials.json"
-OAUTH_USAGE_URL = "https://api.anthropic.com/api/oauth/usage"
-USAGE_UA = "claude-code/2.1.177"
-
-
-def _env_int(name: str, default: int) -> int:
-    try:
-        return int(os.environ.get(name, default))
-    except (TypeError, ValueError):
-        return default
-
-
-# Reaching a ceiling is treated EXACTLY like 100% exhaustion (cooldown until that
-# window's resets_at). Both weekly keys share one threshold; the per-model cap
-# that's actually populated on this account is Sonnet (seven_day_opus is null) and
-# the all-models seven_day cap is the backstop for Opus usage either way.
-CEILING_FIVE_HOUR = _env_int("HALACHA_DRAIN_CEILING_5H", 75)
-CEILING_WEEKLY = _env_int("HALACHA_DRAIN_CEILING_WEEKLY", 65)
-USAGE_CEILINGS = {
-    "five_hour": CEILING_FIVE_HOUR,
-    "seven_day": CEILING_WEEKLY,
-    "seven_day_sonnet": CEILING_WEEKLY,
-}
-
-
-def subscription_usage() -> dict | None:
-    """Read the claude.ai subscription usage — the exact 5-hour / 7-day
-    utilization the Claude Code UI shows — from the OAuth usage endpoint.
-
-    Returns the parsed JSON (keys: five_hour, seven_day, seven_day_opus,
-    seven_day_sonnet, extra_usage; each window → {utilization 0-100, resets_at})
-    or None on ANY failure. Undocumented endpoint — every caller must tolerate
-    None and fall back."""
-    try:
-        with open(CLAUDE_CRED_PATH) as f:
-            token = json.load(f)["claudeAiOauth"]["accessToken"]
-    except Exception:
-        return None
-    req = urllib.request.Request(OAUTH_USAGE_URL, headers={
-        "Authorization": f"Bearer {token}",
-        "User-Agent": USAGE_UA,              # required — else aggressive 429
-        "anthropic-beta": "oauth-2025-04-20",
-    })
-    try:
-        with urllib.request.urlopen(req, timeout=15) as resp:
-            return json.loads(resp.read().decode("utf-8"))
-    except Exception:
-        return None
-
-
-def ceiling_status(usage: dict) -> tuple[bool, datetime | None, str]:
-    """Evaluate an already-fetched usage dict against USAGE_CEILINGS.
-
-    Returns (over, earliest_reset_utc, detail):
-      • over            — True iff ANY gated window is at/above its ceiling
-      • earliest_reset  — soonest resets_at among the windows that are over (UTC),
-                          or None
-      • detail          — short log string, e.g. "5h=78%/75 weekly=40%/65"
-
-    Takes the usage dict as a parameter (does NOT fetch) so the caller owns the
-    single network read. null utilization → treated as 0% (window inactive)."""
-    over, resets, parts = False, [], []
-    label = {"five_hour": "5h", "seven_day": "weekly", "seven_day_sonnet": "weekly-sonnet"}
-    for w, ceiling in USAGE_CEILINGS.items():
-        info = usage.get(w) or {}
-        util = info.get("utilization") or 0
-        parts.append(f"{label.get(w, w)}={util:.0f}%/{ceiling}")
-        if util >= ceiling:
-            over = True
-            r = info.get("resets_at")
-            if r:
-                try:
-                    resets.append(datetime.fromisoformat(r).astimezone(timezone.utc))
-                except Exception:
-                    pass
-    return over, (min(resets) if resets else None), " ".join(parts)

mcp-server/src/legal_mcp/tools/cases.py

@@ -132,7 +132,6 @@ async def case_create(
     practice_area: str = "",
     appeal_subtype: str = "",
     proceeding_type: str = "",
-    chair_name: str = "",
 ) -> str:
     """יצירת תיק ערר חדש.
 
@@ -154,9 +153,6 @@ async def case_create(
         appeal_subtype: סוג ערר (building_permit / betterment_levy / compensation_197).
                         ריק = יוסק אוטומטית ממספר התיק
         proceeding_type: 'ערר' / 'בל"מ'. ריק = יוסק מ-appeal_subtype/subject.
-        chair_name: שם יו"ר הוועדה. ריק = ברירת-המחדל של הוועדה לפי תחילית
-                    מספר-התיק (SoT: config.committee_chair_for_case) — נשמר
-                    תמיד לא-ריק כדי שהעתק-הסופי לקורפוס-הפסיקה לא ייכשל.
     """
     # INV-TOOL3 / GAP-52: idempotent on case_number (already UNIQUE in schema).
     # Re-creating an existing case returns it instead of raising a unique-violation.
@@ -187,10 +183,9 @@ async def case_create(
         appeal_subtype = derived_subtype
     pa.validate(practice_area, appeal_subtype)
 
-    # proceeding_type: explicit override > derived from subtype/subject/number > 'ערר'
+    # proceeding_type: explicit override > derived from subtype/subject > 'ערר'
-    # (a 5-digit serial signals בל"מ per the post-reform numbering convention).
     resolved_proc = proceeding_type.strip() or pa.derive_proceeding_type(
-        case_number=case_number, appeal_subtype=appeal_subtype, subject=subject,
+        appeal_subtype=appeal_subtype, subject=subject,
     )
 
     case = await db.create_case(
@@ -208,7 +203,6 @@ async def case_create(
         practice_area=practice_area,
         appeal_subtype=appeal_subtype,
         proceeding_type=resolved_proc,
-        chair_name=chair_name,
     )
 
     # If the user overrode the case-number convention (e.g. case 8500 marked
@@ -271,8 +265,10 @@ async def case_list(status: str = "", limit: int = 50) -> str:
     """רשימת תיקי ערר עם אפשרות סינון לפי סטטוס.
 
     Args:
-        status: סינון לפי סטטוס (new, processing, documents_ready, outcome_set,
+        status: סינון לפי סטטוס (new, processing, proofread, documents_ready, analyst_verified,
-        direction_approved, qa_review, drafted, exported, reviewed, final). ריק = הכל
+        research_complete, outcome_set, direction_pending, direction_approved,
+        analysis_enriched, ready_for_writing, drafted, qa_passed, qa_failed,
+        exported, done). ריק = הכל
         limit: מספר תוצאות מקסימלי
     """
     cases = await db.list_cases(status=status or None, limit=limit)
@@ -293,15 +289,6 @@ async def case_get(case_number: str) -> str:
 
     docs = await db.list_documents(UUID(case["id"]))
     case["documents"] = docs
-    # Derived post-final pipeline status (voice learning + halacha extraction) so the
-    # case shows whether each ran, succeeded, and how many halachot were extracted.
-    # Read-only derivation from existing tables (single source — same fn the
-    # /learning-status endpoint uses); best-effort, never fails the case fetch.
-    try:
-        case["learning_status"] = await db.case_learning_status(case)
-    except Exception as e:  # noqa: BLE001 — indicator is best-effort, must not 500 case_get
-        logger.warning("case_learning_status failed for %s: %s", case_number, e)
-        case["learning_status"] = None
     return ok(case)
 
 
@@ -314,7 +301,7 @@ async def case_update(
     hearing_date: str = "",
     decision_date: str = "",
     tags: list[str] | None = None,
-    expected_outcome: str | None = None,
+    expected_outcome: str = "",
     appellants: list[str] | None = None,
     respondents: list[str] | None = None,
     property_address: str = "",
@@ -325,7 +312,7 @@ async def case_update(
 
     Args:
         case_number: מספר תיק הערר
-        status: סטטוס חדש (new, processing, documents_ready, outcome_set, direction_approved, qa_review, drafted, exported, reviewed, final)
+        status: סטטוס חדש (new, in_progress, drafted, reviewed, final)
         title: כותרת חדשה
         subject: נושא חדש
         notes: הערות חדשות
@@ -341,13 +328,12 @@ async def case_update(
     """
     from datetime import date as date_type
 
-    # Ordered core lifecycle — regression protection (forward-only).
+    # Ordered workflow statuses — regression protection
-    # Single source of truth, mirrored by web-ui/src/lib/api/case-status.ts and
-    # models.CaseStatus. Trimmed from 17 → 10 (decorative statuses removed).
     STATUS_ORDER = [
-        "new", "processing", "documents_ready",
+        "new", "uploading", "processing", "documents_ready",
-        "outcome_set", "direction_approved",
+        "analyst_verified", "research_complete", "outcome_set",
-        "qa_review", "drafted",
+        "brainstorming", "direction_approved", "analysis_enriched", "ready_for_writing",
+        "drafting", "qa_review", "drafted",
         "exported", "reviewed", "final",
     ]
 
@@ -381,7 +367,7 @@ async def case_update(
             raise ValueError(f"Invalid decision_date format: {decision_date!r}") from exc
     if tags is not None:
         fields["tags"] = tags
-    if expected_outcome is not None:
+    if expected_outcome:
         fields["expected_outcome"] = expected_outcome
     if appellants is not None:
         fields["appellants"] = appellants

mcp-server/src/legal_mcp/tools/court_fetch.py

@@ -1,66 +0,0 @@
-"""MCP tools for the X13 court-verdict auto-fetch subsystem.
-
-- ``court_verdict_fetch`` — classify a citation, fetch the verdict from the
-  matching public source (Supreme portal / נט המשפט), and ingest it into the
-  precedent library via the canonical pipeline. The standalone entry point
-  (also driven automatically from digest auto-link, see X12/X13).
-- ``court_fetch_status`` — inspect the fetch-job queue (pending/failed/manual).
-
-Local-only: ``court_verdict_fetch`` runs the ingest pipeline, which drives
-halacha extraction via the local ``claude`` CLI — same constraint as
-``precedent_process_pending``. Invoking it from the container will fail.
-"""
-
-from __future__ import annotations
-
-from legal_mcp.services import court_fetch_orchestrator as orch
-from legal_mcp.services import db
-from legal_mcp.tools.envelope import err as _err, ok as _ok
-
-
-async def court_verdict_fetch(citation: str) -> str:
-    """אחזור אוטומטי של פסק-דין בית-משפט וקליטה לקורפוס.
-
-    מקבל ציטוט (למשל 'עת"מ 46111-12-22' או 'עע"מ 1234/22'), מסווג את הערכאה,
-    מוריד את הפסק מהמקור הציבורי המתאים, וקולט אותו דרך צינור-הקליטה הקנוני.
-    ערר/בל"מ (ועדת-ערר) אינם ניתנים לאחזור ציבורי ויסומנו כפער.
-    """
-    if not (citation or "").strip():
-        return _err("citation is required")
-    try:
-        result = await orch.fetch_and_ingest(citation.strip())
-    except Exception as e:  # noqa: BLE001 — surfaced, not swallowed (INV-CF2)
-        return _err(f"אחזור נכשל: {e}")
-
-    status = result.get("status")
-    if status in ("done", "already_done"):
-        return _ok(result, message="הפסק נקלט לקורפוס")
-    if status == "skipped":
-        return _ok(result, message="ועדת-ערר — לא ניתן לאחזור ציבורי (סומן כפער)")
-    if status in ("manual", "awaiting_manual"):
-        return _ok(result, message="האחזור האוטונומי נכשל — הוסלם להורדה ידנית")
-    if status == "unrecognized":
-        return _err("הציטוט לא זוהה כמספר-תיק תקין")
-    return _ok(result, message=f"סטטוס: {status}")
-
-
-async def court_fetch_status(case_number: str = "", status_filter: str = "") -> str:
-    """סטטוס תור-האחזור. case_number לפריט יחיד, או status_filter לסינון רשימה."""
-    if case_number.strip():
-        from legal_mcp.services.court_citation import normalize_case_number
-        job = await db.court_fetch_job_get(normalize_case_number(case_number))
-        if not job:
-            return _ok({"job": None}, message="אין job עבור תיק זה")
-        return _ok({"job": job})
-    jobs = await db.court_fetch_job_list(status=status_filter.strip() or None)
-    return _ok({"jobs": jobs, "count": len(jobs)})
-
-
-async def court_fetch_drain(limit: int = 10) -> str:
-    """ריקון תור-האחזור: מוריד וקולט את ה-jobs הממתינים (pending/failed) שהיומונים
-    מילאו, וקושר כל פסק שנקלט חזרה ליומון-המקור. סדרתי. כלי מקומי בלבד."""
-    try:
-        result = await orch.drain_pending(limit=max(1, min(int(limit or 10), 50)))
-    except Exception as e:  # noqa: BLE001
-        return _err(f"ריקון התור נכשל: {e}")
-    return _ok(result, message=f"עובדו {result.get('processed', 0)}, נקלטו {result.get('done', 0)}")