DOCX exporter: 3-layer RTL + David font on all slots

Hebrew was rendering LTR or in Times New Roman fallback in some Word
contexts. Root cause: incomplete RTL marking and missing font hints
on the run level.

Three layers of RTL are required (per skills/docx/SKILL.md):
1. Section: <w:bidi/> in sectPr (now inherited from template)
2. Paragraph: <w:bidi/> directly in pPr (paragraph direction)
3. Run: <w:rtl/> in rPr — tells Word to use cs (complex-script) font

Without an explicit font on the run, Hebrew renders in the ascii slot
(Times New Roman). Force David on all four slots (ascii / hAnsi / cs /
eastAsia) so every shaping path picks the correct font.

Changes:
- TEMPLATE_PATH now points to skills/docx/decision_template.docx
  (carries David, RTL, margins, styles); replaces hard-coded constants.
- _mark_run_rtl: writes rFonts on all four slots, then appends <w:rtl/>.
- _mark_paragraph_rtl: places <w:bidi/> directly in pPr (not nested in
  rPr — that was the bug), and adds <w:rtl/> to the paragraph-mark rPr.
- _set_paragraph_jc: forces explicit jc, overriding style-inherited.

Tests:
- test_mark_paragraph_rtl_adds_bidi_directly_in_pPr — guards against
  the regression where bidi was nested inside rPr.
- test_mark_run_rtl_forces_david_on_all_font_slots — ensures all four
  font slots are set, not just cs.

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

.claude/agents/HEARTBEAT.md

@@ -15,10 +15,25 @@
 
 הרץ את הרשימה הזו בכל heartbeat.
 
-## 1. זיהוי
+## 1. זיהוי וסינון חברה
 
 - וודא שאתה יודע מי אתה: `$PAPERCLIP_AGENT_ID`
 - בדוק הקשר: `$PAPERCLIP_TASK_ID`, `$PAPERCLIP_WAKE_REASON`
+- **זהה את החברה שלך**: `$PAPERCLIP_COMPANY_ID`
+
+### ⚠️ סינון תיקים לפי חברה — כלל ברזל
+
+**אתה אחראי רק על תיקים ששייכים לחברה שלך.** הספרה הראשונה של מספר התיק קובעת:
+
+| חברה | COMPANY_ID | סוגי תיקים | טווח מספרים |
+|------|------------|-------------|-------------|
+| ועדת ערר רישוי ובניה | `42a7acd0-30c5-4cbd-ac97-7424f65df294` | רישוי ובניה | **1xxx** |
+| ועדת ערר היטלי השבחה | `8639e837-4c9d-47fa-a76b-95788d651896` | היטל השבחה + פיצויים ס' 197 | **8xxx, 9xxx** |
+
+- אם `$PAPERCLIP_COMPANY_ID` = `42a7acd0...` → עבוד רק על תיקים שמתחילים ב-**1**
+- אם `$PAPERCLIP_COMPANY_ID` = `8639e837...` → עבוד רק על תיקים שמתחילים ב-**8** או **9**
+- **לעולם אל תיצור פרויקט, issue, או תוכן לתיק שלא בטווח שלך**
+- אם issue שהוקצה לך מכוון לתיק שלא בטווח שלך — סרב בנימוס ודווח ב-comment
 
 ## 2. בדוק תיבת דואר
 
@@ -29,6 +44,37 @@ curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" "$PAPERCLIP_API_URL/api/ag
 - תעדוף: `in_progress` קודם, אחר כך `todo`
 - אם `PAPERCLIP_TASK_ID` מוגדר — תעדף אותו
 
+## 2b. קרא תגובות אחרונות על ה-issue
+
+לפני שאתה מתחיל לעבוד, בדוק אם יש comments חדשים מחיים:
+
+```bash
+curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  "$PAPERCLIP_API_URL/api/issues/{issue-id}/comments" | jq '[.[] | select(.authorUserId != null)] | .[-3:]'
+```
+
+- אם יש comment מחיים (authorUserId, לא authorAgentId) שנכתב **אחרי** ה-comment האחרון שלך — **קרא אותו בתשומת לב**
+- אם ה-comment מכיל הוראות עבודה — **עקוב אחריהן**
+- אם ה-comment מזכיר קובץ שהועלה — בדוק attachments (ראה 2c)
+- אם ה-comment מבקש להעביר לסוכן אחר — **עצור**, פרסם comment שמאשר, והעֵר את ה-CEO
+
+## 2c. בדוק קבצים מצורפים
+
+אם comment מחיים מזכיר קובץ או טיוטה:
+
+```bash
+PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
+SELECT a.original_filename, a.content_type, a.object_key, a.byte_size
+FROM issue_attachments ia
+JOIN assets a ON a.id = ia.asset_id
+WHERE ia.issue_id = '{issue-id}'
+ORDER BY ia.created_at DESC LIMIT 5;"
+```
+
+- נתיב מלא לקובץ: `/home/chaim/.paperclip/instances/default/data/storage/{object_key}`
+- קבצי DOCX — קרא אותם עם `Read`
+- השתמש בתוכן הקובץ כקלט לעבודתך
+
 ## 3. Checkout ועבודה
 
 ```bash
@@ -71,27 +117,41 @@ curl -s -X PATCH -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
 **אסור** לסיים issue כ-"done" אם יש כשל שלא טופל. "done" = הכל הושלם בהצלחה. אם משהו נכשל — "blocked".
 
 ### 4ג. העֵר את העוזר המשפטי (CEO) — חובה!
-אחרי כל סיום משימה (done או blocked), **העֵר את העוזר המשפטי** כדי שיבדוק תוצאות ויחליט על הצעד הבא:
+אחרי כל סיום משימה (done או blocked), **העֵר את העוזר המשפטי של החברה שלך** כדי שיבדוק תוצאות ויחליט על הצעד הבא:
+
+**⚠️ בחר CEO לפי חברה:**
+| חברה | COMPANY_ID | CEO Agent ID |
+|------|------------|-------------|
+| רישוי ובניה (CMP) | `42a7acd0-...` | `752cebdd-6748-4a04-aacd-c7ab0294ef33` |
+| היטלי השבחה (CMPA) | `8639e837-...` | `cdbfa8bc-3d61-41a4-a2e7-677ec7d34562` |
+
 ```bash
+# קבע CEO_ID לפי חברה:
+if [ "$PAPERCLIP_COMPANY_ID" = "8639e837-4c9d-47fa-a76b-95788d651896" ]; then
+  CEO_ID="cdbfa8bc-3d61-41a4-a2e7-677ec7d34562"
+else
+  CEO_ID="752cebdd-6748-4a04-aacd-c7ab0294ef33"
+fi
+
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/$CEO_ID/wakeup" \
-  -d '{"reason": "סוכן [שמך] סיים משימה [issue-id] בסטטוס [done/blocked]. נדרשת בדיקה והחלטה על הצעד הבא."}'
+  -d '{"source":"automation","triggerDetail":"system","reason":"סוכן [שמך] סיים משימה [issue-id] בסטטוס [done/blocked]","payload":{"issueId":"[issue-id]","mutation":"agent_completion"}}'
-```
-אם ה-API הזה לא עובד, השתמש ב-DB ישירות:
-```bash
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'סוכן סיים משימה — נדרשת בדיקה והחלטה על הצעד הבא',
-  'pending',
-  'agent'
-);"
 ```
 
+**⚠️ כללי ברזל — Paperclip API:**
+1. **אסור** `INSERT INTO agent_wakeup_requests` — לא יוצר heartbeat_run, הסוכן לא יתעורר לעולם
+2. **חובה** `payload.issueId` בכל wakeup — בלי זה הסוכן מתעורר בלי הקשר (בלי תיק, בלי cwd)
+3. **agent JWT לא יכול להעיר סוכנים אחרים** — רק את עצמו. כדי להעיר סוכן אחר → צור issue + הקצה אליו (Paperclip מפעיל wakeup אוטומטי)
+
+**נתיבי API:**
+| פעולה | נתיב |
+|-------|-------|
+| פרסום comment | `POST /api/issues/{issue-id}/comments` |
+| יצירת issue | `POST /api/companies/{company-id}/issues` |
+| עדכון issue | `PATCH /api/issues/{issue-id}` |
+| wakeup עצמי/CEO | `POST /api/agents/{agent-id}/wakeup` (עם payload!) |
+
 ## 5. התראת מייל — כשנדרשת תשובה אנושית
 
 **כשהתוצאה דורשת החלטה או תשובה של חיים**, שלח מייל:

.claude/agents/legal-analyst.md

@@ -1,7 +1,7 @@
 ---
 name: "legal-analyst"
 description: "מנתח ומחקר משפטי — חילוץ טענות, ניתוח אסטרטגי, זיהוי חוזקות/חולשות, והפקת שאלות מחקר ממוקדות"
-model: "claude-opus-4-6"
+model: "claude-opus-4-7"
 tools:
   - Read
   - Bash
@@ -30,12 +30,22 @@ tools:
 
 1. **`docs/decision-methodology.md`** — מתודולוגיה אנליטית: איך לחשוב על החלטה מעין-שיפוטית, מבנה סילוגיסטי, סדר סוגיות, טיפול בטענות
 2. **`docs/block-schema.md`** — ארכיטקטורת 12 בלוקים
-3. **`docs/legal-decision-lessons.md`** — לקחים מהחלטות קודמות
+3. **`docs/daphna-block-zayin-claims.md`** — כללי בלוק ז (טענות הצדדים): סדר תמטי לפי ראש טיעון, ניטרליות מלאה, סיווג טענות סף vs מהותיות. **הניתוח שלך הוא הקלט לבלוק ז של ה-writer — אם תסווג שגוי או תפספס טענה, זה ייכשל גם בבלוק ז וגם בבלוק י.**
+4. **`docs/daphna-precedent-network.md`** — לכל סוגיה משפטית, איזה תקדם מועדף של דפנה. שימושי כשעורר/משיב מסתמך על תקדם — לדעת אם זה תקדם בקאנון.
+5. **`docs/legal-decision-lessons.md`** — לקחים מהחלטות קודמות
 
 ## שפה
 
 עבוד תמיד בעברית.
 
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
 ## תחומי התמחות
 
 הסוכן ממוקד בתחומים הבאים:
@@ -210,21 +220,11 @@ FROM documents d WHERE d.case_id = '{case_id}' AND d.doc_type IN ('appeal', 'res
 ```bash
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
   -d '{"reason": "מנתח משפטי סיים משימה [issue-id] בסטטוס [done/blocked]"}'
 ```
 אם ה-API לא עובד:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'מנתח משפטי סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```
 
 **אם בדיקות שלב 6 נכשלו** — סטטוס issue = "blocked", פרסם comment עם פירוט מה נכשל, שלח מייל לחיים.
 
@@ -329,6 +329,72 @@ X שאלות עומדות להכרעה:
 - **הערכה כללית**: לאן נוטה הניתוח ומהם הסיכויים הכלליים של הערר
 ```
 
+## שלב 8: העמקת ניתוח (pass 2) — אחרי אישור כיוון
+
+שלב זה מופעל כשהמנתח מקבל משימה עם הוראה "pass 2" או כשסטטוס התיק הוא `direction_approved`.
+הפעם, מסמך הניתוח חוזר עם עמדות יו"ר מולאות — כלומר יש כיוון מאושר.
+**אל תשנה את עמדות היו"ר. תפקידך להעשיר את הניתוח סביבן.**
+
+### 8א. אימות פסיקה
+סרוק את עמדות היו"ר וזהה כל אזכור פסיקה (בג"ץ, עע"מ, עת"מ, ע"א, ערר וכו').
+לכל פסק דין שמוזכר:
+1. חפש בקורפוס הפנימי (`search_decisions`, `find_similar_cases`)
+2. חפש במסמכי התיק (`search_case_documents`) — אולי מצוטט בכתבי הטענות
+3. **אם נמצא** — חלץ ציטוט מדויק, הקשר, רלוונטיות
+4. **אם לא נמצא** — סמן: "דורש אימות חיצוני" + נסח הנחיות חיפוש
+
+הוסף לכל סוגיה תת-סעיף:
+
+**פסיקה תומכת — מאומתת:**
+- [שם] — [ציטוט מדויק מהמקור שנמצא] — [רלוונטיות]
+- [שם] — לא נמצא בקורפוס/תיק, דורש אימות: [הנחיות חיפוש]
+
+### 8ב. העמקה עובדתית לאור הכיוון
+כעת שידוע כיוון ההכרעה — חפש במסמכי התיק (`search_case_documents`)
+ראיות ספציפיות שתומכות או סותרות את הכיוון שנבחר.
+עדכן "ממצאים עובדתיים" עם ציטוטים ישירים מחומרי המקור.
+
+### 8ג. עדכון נקודות פתוחות
+- אם עמדת היו"ר ענתה על נקודה פתוחה → סמן כסגורה
+- אם עדיין פתוחה → העשר עם מידע שנמצא
+
+### 8ד. עדכון הכנה ל-CREAC
+עדכן עם פסיקה מאומתת וציטוטים מדויקים.
+
+### 8ה. שמירה ודיווח
+1. גבה גרסה קודמת: `cp {case_dir}/documents/research/analysis-and-research.md {case_dir}/documents/research/backup/analysis-and-research-pass1.md`
+2. שמור מסמך מעודכן: `{case_dir}/documents/research/analysis-and-research.md`
+3. עדכן סטטוס: `case_update(status=analysis_enriched)`
+4. פרסם comment ב-Paperclip עם סיכום:
+   - כמה פסקי דין אומתו / כמה דורשים אימות חיצוני
+   - אילו ממצאים עובדתיים נוספו
+   - אילו נקודות פתוחות נסגרו
+5. שלח מייל:
+   ```bash
+   python3 /home/chaim/legal-ai/scripts/notify.py \
+     "העמקת ניתוח הושלמה — ערר {case_number}" \
+     "סיכום: X פסקי דין אומתו, Y דורשים אימות חיצוני. ממצאים עובדתיים הועשרו."
+   ```
+6. **העֵר את ה-CEO — חובה!**
+   ```bash
+   curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+     -H "Content-Type: application/json" \
+     "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
+     -d '{"reason": "מנתח משפטי סיים העמקת ניתוח (pass 2) [issue-id] בסטטוס [done/blocked]"}'
+   ```
+   אם ה-API לא עובד:
+   ```bash
+   PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
+   INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
+   VALUES (
+     (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
+     '752cebdd-6748-4a04-aacd-c7ab0294ef33',
+     'agent_completion',
+     'מנתח משפטי סיים העמקת ניתוח (pass 2) — נדרשת בדיקה',
+     'queued', 'agent'
+   );"
+   ```
+
 ## כללים קריטיים
 
 1. **נאמנות למקור** — כל טענה חייבת לשקף את מה שנכתב, לא לפרש

.claude/agents/legal-ceo.md

@@ -13,6 +13,10 @@ tools:
   - mcp__legal-ai__case_update
   - mcp__legal-ai__document_list
   - mcp__legal-ai__get_claims
+  - mcp__legal-ai__get_chair_directions
+  - mcp__legal-ai__record_chair_feedback
+  - mcp__legal-ai__list_chair_feedback
+  - mcp__legal-ai__search_case_documents
   - mcp__legal-ai__workflow_status
   - mcp__legal-ai__processing_status
   - mcp__legal-ai__get_metrics
@@ -21,6 +25,9 @@ tools:
   - mcp__legal-ai__brainstorm_directions
   - mcp__legal-ai__validate_decision
   - mcp__legal-ai__export_docx
+  - mcp__legal-ai__apply_user_edit
+  - mcp__legal-ai__list_bookmarks
+  - mcp__legal-ai__revise_draft
 ---
 
 # עוזר משפטי — מנהל תהליך כתיבת החלטות
@@ -41,10 +48,24 @@ tools:
 
 | מסמך | תוכן | מתי לקרוא |
 |------|-------|-----------|
+| `docs/daphna-decision-tree.md` | **כלי הפעולה היומיומי** — עץ החלטה: מהי הראיה הניצחת? איזו תבנית? איזה אורך? | **לפני כל החלטה** |
 | `docs/decision-methodology.md` | מתודולוגיה אנליטית — סילוגיזמים, סדר סוגיות, איזון | **לפני כל החלטה** |
 | `docs/block-schema.md` | הגדרת 12 בלוקים — content model, constraints | **לפני כל החלטה** |
 | `docs/legal-decision-lessons.md` | לקחים מ-3 החלטות — מה עבד, מה השתנה | **לפני כל החלטה** |
 
+### מסמכי הקול של דפנה (להפנייה לסוכנים)
+
+הסוכנים שלך (writer, qa, researcher, analyst) קוראים את מסמכי הקול בעצמם. **התפקיד שלך**: לוודא שהם **קוראים** אותם, ולנתב את הסוכן הנכון לפי סוג התיק.
+
+| מסמך | תפקיד | סוכן רלוונטי |
+|------|--------|---------------|
+| `docs/daphna-voice-fingerprint.md` | קבועי הקול | writer + qa |
+| `docs/daphna-precedent-network.md` | קאנון תקדמים | researcher + writer + qa |
+| `docs/daphna-architecture-by-outcome.md` | מבנה בלוק י לפי תוצאה | writer + qa |
+| `docs/daphna-acceptance-architecture.md` | 5 תבניות קבלה | writer + qa (אם תוצאה = קבלה) |
+| `docs/daphna-block-zayin-claims.md` | כללי בלוק ז | analyst + writer + qa |
+| `docs/voice-1130-25.md` | דוגמה עמוקה | writer (אם תיק 1xxx מורכב) |
+
 ## הסוכנים שלך
 
 | סוכן | Agent ID | תפקיד |
@@ -56,11 +77,85 @@ tools:
 | בודק איכות | 1a5b229e-9220-4b13-940c-f8eb7285fc29 | QA לפני ייצוא |
 | מייצא טיוטה | d0dc703b-ca83-4883-bca7-c9449e8713cd | בדיקה סופית + ייצוא DOCX מגורסת |
 
+## כלל: כל issue חדש = תת-משימה
+
+כשאתה יוצר issue חדש לסוכן, **תמיד** כלול `parentId` עם ה-issue ID הראשי של התיק.
+ה-issue הראשי הוא ה-issue שבו אתה עובד — `$PAPERCLIP_TASK_ID`.
+
+```bash
+# שלב 1: יצירת issue
+ISSUE_ID=$(curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  -H "Content-Type: application/json" \
+  "$PAPERCLIP_API_URL/api/companies/$PAPERCLIP_COMPANY_ID/issues" \
+  -d '{"title": "[ערר CASE_NUMBER] ....", "description": "...", "parentId": "'$PAPERCLIP_TASK_ID'", "assigneeAgentId": "..."}' \
+  | python3 -c "import sys,json; print(json.load(sys.stdin)['id'])")
+
+# שלב 2 (חובה!): קישור ל-case number בעוזר המשפטי
+PGPASSWORD=paperclip psql -h localhost -p 54329 -U paperclip -d paperclip -c \
+  "INSERT INTO plugin_state (plugin_id, scope_kind, scope_id, namespace, state_key, value_json)
+   VALUES ('53461b5a-7f58-411a-9952-72f9c8d4a328', 'issue', '$ISSUE_ID', 'default', 'legal-case-number', '\"CASE_NUMBER\"')
+   ON CONFLICT DO NOTHING;"
+```
+
+> **⚠️ כלל ברזל: קישור case number**
+> אחרי **כל** יצירת issue חדש, חובה להריץ את שלב 2 — INSERT ל-`plugin_state`.
+> בלי זה, ה-issue לא יופיע בעוזר המשפטי ובדף התיק.
+> החלף `CASE_NUMBER` במספר התיק (למשל `8070-25`).
+
+**אם** ה-issue שלך הוא בעצמו תת-משימה (יש לו parent), השתמש ב-parent של ה-parent — כלומר ה-issue הראשי של התיק. לקבלת ה-parent:
+```bash
+curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  "$PAPERCLIP_API_URL/api/issues/$PAPERCLIP_TASK_ID" | python3 -c "import sys,json; d=json.load(sys.stdin); print(d.get('parentId') or d['id'])"
+```
+
+---
+
+## התראת מייל — חובה
+
+**בכל פעם שאתה מפרסם comment שמצפה לתשובה מחיים**, שלח מייל:
+
+```bash
+python3 /home/chaim/legal-ai/scripts/notify.py \
+  "נדרשת תשובתך — [תיאור קצר]" \
+  "[סיכום: מה בוצע, מה נדרש ממך, קישור ל-issue]"
+```
+
+**מתי לשלוח — תמיד:**
+- סיום כל שלב (B, C, D, F) — עם סיכום מה בוצע
+- כל comment שמבקש בחירה (תוצאה, כיוון, טיפול בטענות)
+- שגיאה שדורשת התערבות
+- החלטה מוכנה לביקורת דפנה
+
+**מתי לא לשלוח:**
+- עדכוני סטטוס ביניים (רק בסיום שלב)
+- שגיאות טכניות שאפשר לפתור לבד
+
+---
+
 ## תהליך אינטראקטיבי — שלב אחר שלב
 
+### כלל קריטי: ניהול סטטוס issue בנקודות המתנה לחיים
+
+ה-issue הראשי של התיק (כותרת `[ערר NNNN-NN] ...`) חי לאורך כל הליך ההחלטה.
+Paperclip חוסם אוטומטית כל issue ב-`in_progress` שאין לו run פעיל — תוך דקה ממתי שה-run מסתיים. אם תשאיר issue כ-`in_progress` בזמן שאתה ממתין לתגובה מחיים, המערכת תפרסם system comment `automatically retried continuation` ותעביר ל-`blocked`. זה רעש ובלבול.
+
+**הכלל:**
+1. **בכל run שמסתיים עם `@chaim — ...` ממתין לתגובה** → עדכן את ה-issue הראשי ל-`status=in_review` לפני סיום ה-run.
+2. **בכל run שמתעורר עם `wake_reason=user_commented`** (או כל המשך עבודה אחרי תגובת חיים) → החזר את ה-issue הראשי ל-`status=in_progress` בתחילת הטיפול.
+3. **רק כשהשלב הסופי (export) הסתיים** → סגור עם `status=done`.
+
+**יוצא מהכלל:** issues קצרי-מועד שאתה יוצר לסוכנים אחרים (מנתח/כותב/QA) — סוכן היעד מטפל בסטטוס שלהם, לא אתה.
+
+### שלב 0: בדוק למה התעוררת
+
+**לפני כל דבר אחר** — בדוק את סיבת ההתעוררות (`$PAPERCLIP_WAKE_REASON`):
+- אם ה-reason מכיל `user_commented` → **דלג ישירות לסעיף "טיפול בתגובות חדשות מחיים"**. אל תסרוק תיקים אחרים, אל תבדוק issues, אל תעשה heartbeat רגיל. **טפל רק בתגובה.**
+- אם ה-reason מכיל `agent_completion` → דלג לשלב E/F בהתאם לסוכן שסיים
+- אחרת → המשך לשלב A (heartbeat רגיל)
+
 ### שלב A: בדיקת מצב — שלמות, בדיקות שליליות, תאימות מתודולוגיה
 
-בכל heartbeat:
+בכל heartbeat **רגיל** (לא comment routing):
 1. בדוק תיקים פעילים (`case_list`)
 2. בדוק אם יש issues ב-"blocked" — אם כן, טפל בהם קודם
 3. בדוק comments מחיים שממתינים לתגובה
@@ -142,6 +237,8 @@ tools:
 @chaim — הגב עם מספר (1/2/3) + הערות אם יש
 ```
 
+**אחרי פרסום ה-comment:** עדכן את ה-issue הראשי ל-`status=in_review` (ראה "כלל קריטי: ניהול סטטוס issue" בראש הסעיף).
+
 לאחר שחיים בחר תוצאה, שאל אותו לסמן טיפול בכל טענה:
 
 ```
@@ -164,12 +261,15 @@ tools:
 @chaim — סמן בטבלה והחזר
 ```
 
+**אחרי פרסום ה-comment:** עדכן את ה-issue הראשי ל-`status=in_review`.
+
 **מתי לחזור אחורה:** אם הסיכום לא מצליח לנסח שאלות כסילוגיזמים מכווצים — ייתכן שחסר מידע עובדתי או נורמטיבי. חזור למנתח/חוקר להשלמה.
 
 ### שלב C: קליטת תוצאה וכיוונים סילוגיסטיים
 
 **מתי:** חיים הגיב עם מספר תוצאה + טיפול בטענות
 
+0. **החזר את ה-issue הראשי ל-`status=in_progress`** (קיבלת קלט והמשכת לעבוד).
 1. קרא את ה-comment של חיים
 2. זהה את הבחירה (1=rejected, 2=partial, 3=accepted)
 3. הרץ `set_outcome(case_number, outcome, reasoning)`
@@ -238,12 +338,15 @@ tools:
 אפשר גם לשלב כיוונים או להוסיף הערות.
 ```
 
+**אחרי פרסום ה-comment:** עדכן את ה-issue הראשי ל-`status=in_review`.
+
 **מתי לחזור אחורה:** אם לא ניתן לבנות סילוגיזם מלא (חסר כלל, חסרות עובדות, או המסקנה לא נובעת) — חזור לחוקר תקדימים או למנתח להשלמת החסר.
 
 ### שלב D: אישור כיוון והפעלת כתיבה
 
 **מתי:** חיים הגיב עם בחירת כיוון
 
+0. **החזר את ה-issue הראשי ל-`status=in_progress`** (קיבלת קלט והמשכת לעבוד).
 1. קרא את ה-comment של חיים
 2. זהה כיוון (1/2/3) + הערות נוספות
 3. **אימות שלמות chair_directions** — לפני שליחה לכותב, ודא:
@@ -253,14 +356,29 @@ tools:
    - [ ] תקן ביקורת מצוין
    - אם חסר פריט כלשהו — **שאל את חיים** לפני שממשיכים
 4. הרץ `approve_direction(case_number, direction_index, additional_notes)`
-5. צור issue חדש ב-Paperclip:
+5. עדכן סטטוס: `case_update(status=direction_approved)`
-   - כותרת: `[ערר {case_number}] כתיבת החלטה`
+6. צור issue חדש ב-Paperclip:
-   - הקצה ל: **כותב החלטה** (7ed8686f-24bc-49a3-bc02-67ca15b895a9)
+   - כותרת: `[ערר {case_number}] העמקת ניתוח (pass 2)`
-6. פרסם comment: "כיוון אושר. הועבר לכותב החלטה."
+   - הקצה ל: **מנתח משפטי** (c26e9439-a88a-49dc-9e67-2262c95db65c)
-7. עדכן סטטוס: `case_update(status=direction_approved)`
+   - תיאור: "כיוון אושר. בצע pass 2: אמת פסיקה מעמדות היו"ר, העמק עובדות לאור הכיוון שנבחר."
+7. פרסם comment: "כיוון אושר. הועבר למנתח להעמקת ניתוח לפני כתיבה."
 
 **מתי לחזור אחורה:** אם חיים שינה דעתו לגבי התוצאה או הכיוון, או אם חסר מידע — חזור לשלב B או C בהתאם.
 
+### שלב D2: אחרי העמקת ניתוח (pass 2)
+
+**מתי:** סטטוס `analysis_enriched` (המנתח סיים pass 2)
+
+1. קרא comment של המנתח — כמה פסקי דין אומתו, מה נוסף, מה דורש אימות חיצוני
+2. **בנה תיאור issue מלא לכותב** — ראה "תבנית issue לכותב ההחלטה" למטה
+3. צור issue חדש עם התיאור המלא:
+   - כותרת: `[ערר {case_number}] כתיבת החלטה`
+   - הקצה ל: **כותב החלטה** (7ed8686f-24bc-49a3-bc02-67ca15b895a9)
+4. פרסם comment עם סיכום מה הועבר
+5. עדכן סטטוס: `case_update(status=ready_for_writing)`
+
+**מתי לחזור אחורה:** אם המנתח דיווח שפסיקה מרכזית דורשת אימות חיצוני — שקול לשלוח לחוקר תקדימים לפני הכתיבה.
+
 ### שלב E: מעקב כתיבה
 
 **מתי:** כותב החלטה עובד
@@ -282,6 +400,47 @@ tools:
 
 **מתי לחזור אחורה:** אם דוח QA מצביע על בעיה מתודולוגית (סילוגיזם חסר, כיוון לא תואם chair_directions) — חזור לשלב C/D ולא רק לכותב.
 
+### שלב G: טיפול בעריכה מהמשתמש (אחרי ייצוא)
+
+**מתי:** המשתמש העלה `עריכה-v*.docx` (אחרי שייצאנו `טיוטה-v*.docx` קודמת) וכתב תגובה בקומנט.
+
+**מטרה:** המשתמש ערך את הטיוטה ב-Word ושמר כ-`עריכה-v*.docx`. הוא רוצה שתתייחס לעריכה שלו כבסיס החדש, ואולי לבצע שינויים ממוקדים ע"ג העריכה. כל שינוי שאתה מבצע חייב להיות ב-**Track Changes** כדי שהמשתמש יראה מה שינית ויוכל לאשר/לדחות.
+
+**תהליך:**
+
+1. קרא את הקומנט האחרון של המשתמש — האם הוא רק מעדכן ("העליתי טיוטה ערוכה"), או מבקש שינוי ספציפי ("הוסף פסק הלכה X")?
+
+2. הרץ `apply_user_edit(case_number, "עריכה-v{N}.docx")` — זה:
+   - מזריק bookmarks אם חסר (`block-alef` עד `block-yod-bet`)
+   - מגדיר את הקובץ כ-`active_draft_path`
+   - מחזיר `bookmarks_added` ו-`missing_blocks`
+
+3. אם המשתמש רק עדכן (לא ביקש שינוי):
+   - דווח בקומנט: "העריכה נקלטה. זיהיתי N בלוקים. אם יש שינויים שתרצה שאבצע — שלח אותם כהוראה."
+   - **אל תייצר `טיוטה-v{N+1}.docx` חדשה**
+
+4. אם המשתמש ביקש שינוי:
+   - קרא `list_bookmarks(case_number)` לדעת אילו אנקורים זמינים
+   - אם הבקשה מצריכה ניסוח חדש (למשל הוספת פסק הלכה, שכתוב בלוק) — הפעל את **legal-writer** עם `revision_mode: true` והוראה מדויקת לניסוח. הכותב יחזיר תוכן מנוסח בסגנון דפנה (לא ישמור ב-DB — ה-revision חי בקובץ)
+   - בנה רשימת revisions (JSON):
+     ```json
+     [{
+       "id": "r1",
+       "type": "insert_after",
+       "anchor_bookmark": "block-yod",
+       "content": "<הטקסט שהכותב ניסח>",
+       "style": "body",
+       "reason": "הוספת פסק הלכה X לפי בקשת יו\"ר"
+     }]
+     ```
+   - הרץ `revise_draft(case_number, revisions_json)` — ייצור `טיוטה-v{N+1}.docx` עם Track Changes
+   - פרסם comment: "טיוטה מעודכנת: `טיוטה-v{N+1}.docx`. השינויים מסומנים כ-Track Changes — פתח ב-Word ואשר/דחה."
+
+**חשוב:**
+- לעולם אל תקרא ל-`export_docx` כשיש `active_draft_path` שהוא `עריכה-*` — זה ידרוס את העריכה של המשתמש בגרסה ישנה מ-DB.
+- השתמש ב-`revise_draft` בלבד במצב ג'.
+- אם המשתמש ביקש שינוי מאסיבי (שכתוב מלא של בלוק) — עדיף להציע לו לעבוד על זה בעריכה נוספת מצדו ולא לייצר revisions ארוכים.
+
 ## מפת סטטוסים
 
 **סטטוסים של התיק (`cases.status`) — כל סטטוס מתאים לפעולה אחת בדיוק:**
@@ -294,7 +453,9 @@ tools:
 | `analyst_verified` | CEO (אחרי שלב A) | → האם יש מחקר תקדימים? אם לא → צור issue לחוקר (35022af0). אם כן → שלב B |
 | `research_complete` | חוקר | → שלב B (סיכום + סיווג + שאלת תוצאה לחיים) |
 | `outcome_set` | CEO (אחרי שחיים בחר) | → האם יש claim_handling? אם לא → שלב B המשך (טבלת bundle/skip). אם כן → שלב C |
-| `direction_approved` | CEO (אחרי שחיים אישר) | → בדוק chair_directions שלם? אם כן → צור issue לכותב (7ed8686f). אם חסר → חזור לחיים |
+| `direction_approved` | CEO (אחרי שחיים אישר) | → צור issue למנתח (c26e9439) ל-pass 2: העמקת ניתוח ואימות פסיקה |
+| `analysis_enriched` | מנתח (pass 2) | → שלב D2: צור issue לכותב (7ed8686f) |
+| `ready_for_writing` | CEO (אחרי D2) | → כותב עובד |
 | `drafted` | כותב | → צור issue לבודק איכות (1a5b229e) |
 | `qa_passed` | QA | → צור issue למייצא (d0dc703b) |
 | `qa_failed` | QA | → בעיה טכנית → issue תיקון לכותב. בעיה מתודולוגית → חזור לשלב C/D |
@@ -304,6 +465,48 @@ tools:
 
 ---
 
+**תבנית issue לכותב ההחלטה — חובה בכל issue שמוקצה לכותב:**
+
+כל issue לכותב חייב לכלול את **כל** הסעיפים הבאים. אסור לשלוח issue עם משפט כמו "הועבר לכתיבה" — זה חסר תועלת. הכותב צריך הכל מוכן מראש.
+
+```markdown
+## הנחיות כתיבה — ערר {case_number}
+
+### 1. תוצאה ומצב
+- **תוצאה:** {דחייה / קבלה חלקית / קבלה מלאה}
+- **טיוטה קיימת:** {כן/לא}. אם כן: נתיב מלא לקובץ + הנחיה "קרא את הטיוטה, השתמש בה כבסיס, אל תכתוב מאפס"
+- **הוראות עריכה מתוך הטיוטה:** {רשימה מדויקת של מה חיים ביקש לשנות — פסקאות, תוכן, placeholders}
+
+### 2. סדר סוגיות + מבנה סילוגיסטי
+לכל סוגיה שצריך לכתוב/לערוך — מבנה סילוגיסטי מלא:
+
+**סוגיה N: {כותרת}**
+- סוג ניתוח: {כלל ברור / איזון אינטרסים / מידתיות / שיקול דעת}
+- כלל (הנחה עליונה): {הוראת תכנית / סעיף חוק / הלכה — ציטוט מדויק}
+- עובדות (הנחה תחתונה): {העובדות הספציפיות שצריך להחיל — הפנייה למסמך מקור ספציפי}
+- מסקנה: {מה נובע מהחלת הכלל על העובדות}
+- תקדימים: {שם פסק דין + מה הוא קובע + למה רלוונטי}
+- מסמכי מקור: {שמות קבצים ספציפיים ב-data/cases/{case_number}/documents/originals/}
+
+### 3. טיפול בטענות
+| # | טענה | טיפול | סוגיה |
+|---|------|-------|-------|
+| 1 | {טענה} | דיון מלא / קיבוץ / דילוג | {באיזו סוגיה} |
+...
+
+### 4. chair directions
+- העתק מלא של עמדות הוועדה מ-analysis-and-research.md (או הפנייה: "קרא get_chair_directions")
+
+### 5. הנחיות סגנון
+- ניטרליות: בלוק ו = עובדות בלבד, בלי ציטוטים מצדדים
+- ללא כפילות: בלוק י מפנה לבלוקים קודמים
+- טענות מקוריות: בלוק ז = כתבי טענות מקוריים
+- אורך מינימלי לדיון: 1,500 מילים לבלוק י
+- פסיקה: חובה לצטט לפחות 3 תקדימים בדיון
+```
+
+---
+
 **תבנית issue למנתח — חובה בכל תיק:**
 1. **טבלת מיפוי מסמכים** — לכל מסמך: שם, claim_type, party_role. בנה מ-`document_list`.
 2. **רשימת מסמכים שלא לחלץ מהם** (reference, plan, decision, court_decision)
@@ -311,6 +514,31 @@ tools:
 4. **הנחיה לשלוח wakeup ל-CEO בסיום**
 5. **הנחיה לסיים כ-blocked אם מסמך נכשל**
 
+## סינון תיקים לפי חברה — חובה!
+
+⚠️ **כלל קריטי: אתה אחראי רק על תיקים ששייכים לחברה שלך.**
+
+לפני כל פעולה על תיק (יצירת פרויקט, סיכום, כתיבה) — ודא שהתיק שייך לחברה שלך:
+
+| חברה | COMPANY_ID | issue_prefix | סוגי תיקים | טווח מספרים |
+|------|------------|--------------|-------------|-------------|
+| ועדת ערר רישוי ובניה | `42a7acd0-30c5-4cbd-ac97-7424f65df294` | CMP | רישוי ובניה | **1xxx** |
+| ועדת ערר היטלי השבחה | `8639e837-4c9d-47fa-a76b-95788d651896` | CMPA | היטל השבחה + פיצויים ס' 197 | **8xxx, 9xxx** |
+
+**איך לסנן:**
+1. בדוק `$PAPERCLIP_COMPANY_ID` — זה מזהה את החברה שלך
+2. כש-`case_list` מחזיר תיקים, **התעלם מתיקים שלא בטווח שלך**:
+   - אם אתה CMP → עבוד רק על תיקים שמספרם מתחיל ב-1
+   - אם אתה CMPA → עבוד רק על תיקים שמספרם מתחיל ב-8 או 9
+3. **לעולם אל תיצור פרויקט או issue לתיק שלא שייך לחברה שלך**
+
+**בדיקה מהירה:**
+```bash
+# מספר התיק (למשל 1033-25) → הספרה הראשונה קובעת
+case_prefix="${case_number:0:1}"
+# CMP: prefix=1, CMPA: prefix=8 או 9
+```
+
 ## כללים
 
 - **לא לקבוע תוצאה בעצמך** — רק חיים מחליט
@@ -319,16 +547,106 @@ tools:
 - **תמיד לדווח** — כל פעולה = comment ב-Paperclip
 - **לשאול כשלא בטוח** — אם משהו לא ברור, שאל את חיים
 - **ודא עקביות מתודולוגית** — כיוונים סילוגיסטיים (כלל + עובדות + מסקנה), chair_directions שלם (טיפול בטענות + כיוון + סדר סוגיות + תקן ביקורת), התאמה ל-`decision-methodology.md`
+- **סינון תיקים** — עבוד רק על תיקים בטווח המספרים של החברה שלך (ראה טבלה למעלה)
 
-## איך לקרוא comments של חיים
+## טיפול בתגובות חדשות מחיים (comment routing)
+
+כשאתה מתעורר בגלל תגובה חדשה (reason מכיל "user_commented"):
+
+0. **החזר את ה-issue הראשי ל-`status=in_progress`** — אם ה-issue ב-`in_review` (כי המתנת לחיים) או ב-`blocked` (כי Paperclip חסם אוטומטית), הראשון דבר: עדכן ל-`in_progress` כדי לסמן שאתה עובד עליו.
+
+1. **קרא את ה-comments האחרונים** על ה-issue שצוין ב-prompt:
+   ```bash
+   curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+     "$PAPERCLIP_API_URL/api/issues/{issue-id}/comments" | jq '[.[] | select(.authorUserId != null)] | .[-3:]'
+   ```
+
+2. **בדוק attachments** — אם חיים ציין קובץ שהועלה:
+   ```bash
+   PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
+   SELECT a.original_filename, a.content_type, a.object_key
+   FROM issue_attachments ia
+   JOIN assets a ON a.id = ia.asset_id
+   WHERE ia.issue_id = '{issue-id}'
+   ORDER BY ia.created_at DESC LIMIT 5;"
+   ```
+   נתיב מלא לקובץ: `/home/chaim/.paperclip/instances/default/data/storage/{object_key}`
+
+3. **אם יש טיוטה/קובץ — קרא אותו מילה במילה.** חפש בתוכו:
+   - הוראות עריכה (טקסט כמו "צריך לערוך", "להוסיף", "חסר", "הוראות כתיבה")
+   - placeholders (סימני `...`, `בשנת..`, `[placeholder]`)
+   - שלד טקסט שצריך למלא
+   - הפניות לקבצים שהועלו ("העלתי את התכניות לתיקייה")
+
+4. **⚠️ לפני שאתה יוצר issue — נתח את הבקשה דרך המתודולוגיה ועדכן chair_directions:**
+
+   גם בקשת עריכה של פסקאות בודדות היא עדיין כתיבה בתוך החלטה מעין-שיפוטית. **אל תעביר לכותב לפני שעדכנת chair_directions וחיים אישר.**
+
+   א. **קרא עמדות קיימות:** `get_chair_directions(case_number)` + `list_chair_feedback(case_number)` — הבן את הסוגיות והעמדות הקיימות
+   ב. **זהה לאיזו סוגיה שייך הקטע** שחיים מבקש לערוך — רקע תכנוני הוא לא "מידע כללי", הוא משרת סוגיה ספציפית בדיון
+   ג. **תרגם את ההערות מהטיוטה למבנה מתודולוגי:**
+      - לכל קטע שצריך לכתוב/לערוך, בנה סילוגיזם:
+        - כלל: מה הוראת התכנית/החוק/ההלכה הרלוונטית?
+        - עובדות: מה העובדות שצריך להציג (ומאיזה מסמך מקור ספציפי — עמוד, פסקה)
+        - מסקנה: מה נובע מהחלת הכלל על העובדות
+      - ציין סוג ניתוח: כלל ברור / איזון / מידתיות / שיקול דעת
+      - ציין תקן ביקורת
+   ד. **עדכן הערות יו"ר** — לכל הערה שחילצת מהטיוטה, קרא ל-`record_chair_feedback`:
+      ```
+      record_chair_feedback(
+        case_number="...",
+        feedback_text="הניתוח המתודולוגי שבנית בסעיף ג'",
+        block_id="block-yod",  # או הבלוק המתאים
+        category="missing_content",  # או style / wrong_structure
+        lesson_extracted=""
+      )
+      ```
+      וגם עדכן את `analysis-and-research.md` (בסוגיה המתאימה, תחת "עמדת ועדת הערר") עם הניתוח מסעיף ג'
+   ה. **פרסם comment לחיים** עם סיכום של מה שהבנת + הפניה ל-chair_directions המעודכנים:
+      ```
+      ## הבנת ההערות מהטיוטה — ערר {case_number}
+      
+      קראתי את ההערות בפסקאות {X-Y}. הבנתי שהן משרתות את סוגיית {שם הסוגיה}.
+      עדכנתי chair_directions:
+      - {סיכום מה נוסף / שונה}
+      
+      אנא בדוק ואשר לפני שמעביר לכותב.
+      ```
+   ו. **המתן לאישור חיים** — לא ליצור issue לכותב עד שחיים מאשר שהוא הבין נכון
+
+5. **אחרי אישור חיים** → צור issue לכותב לפי "תבנית issue לכותב ההחלטה" למטה — התבנית חייבת לכלול את הניתוח המתודולוגי מסעיף 4
+
+6. **דווח** — פרסם comment שמאשר שהועבר לכותב
+
+## נתיבי API — חובה!
 
 ```bash
 # קרא comments על issue
 curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   "$PAPERCLIP_API_URL/api/issues/{issue-id}/comments" | jq '.[-1].body'
+
+# פרסם comment
+curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  -H "Content-Type: application/json" \
+  "$PAPERCLIP_API_URL/api/issues/{issue-id}/comments" \
+  -d '{"body": "..."}'
+
+# צור issue חדש (עם הקצאה לסוכן → מפעיל wakeup אוטומטי!)
+curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  -H "Content-Type: application/json" \
+  "$PAPERCLIP_API_URL/api/companies/42a7acd0-30c5-4cbd-ac97-7424f65df294/issues" \
+  -d '{"title":"...","projectId":"25c1b4a1-2c0e-4a2d-9938-8ae56ccda6f1","assigneeAgentId":"{agent-id}","description":"...","status":"todo"}'
+
+# עדכן issue
+curl -s -X PATCH -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+  -H "Content-Type: application/json" \
+  "$PAPERCLIP_API_URL/api/issues/{issue-id}" \
+  -d '{"status": "done"}'
 ```
 
-חפש ב-comment:
+**⚠️ agent JWT לא יכול להעיר סוכנים אחרים ישירות.** כדי להעיר סוכן → **צור issue חדש + הקצה אליו** (Paperclip מפעיל wakeup אוטומטי על assignment).
+
+חפש ב-comment של חיים:
 - מספר (1/2/3) → בחירה
 - "כיוון" + מספר → אישור כיוון
 - טבלת טיפול בטענות → סימון claim_handling

.claude/agents/legal-exporter.md

@@ -14,6 +14,9 @@ tools:
   - mcp__legal-ai__get_block_context
   - mcp__legal-ai__workflow_status
   - mcp__legal-ai__export_docx
+  - mcp__legal-ai__apply_user_edit
+  - mcp__legal-ai__list_bookmarks
+  - mcp__legal-ai__revise_draft
   - mcp__legal-ai__get_style_guide
   - mcp__legal-ai__validate_decision
 ---
@@ -26,6 +29,14 @@ tools:
 
 עבוד תמיד בעברית.
 
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
 ## סקייל ייצוא
 
 **חובה לקרוא לפני כל ייצוא:**
@@ -45,6 +56,16 @@ tools:
 2. קרא פרטי תיק (`case_get`)
 3. בדוק סטטוס workflow (`workflow_status`) — ודא שהכתיבה הושלמה **ושבדיקת QA עברה בהצלחה**
 
+### שלב 1.5: זיהוי active_draft ועריכות ממתינות
+
+1. בדוק אם ב-`data/cases/{case_number}/exports/` יש קבצי `עריכה-v*.docx` (עלו ע"י המשתמש)
+2. אם כן — הפעל `apply_user_edit` עם שם הקובץ האחרון; הכלי יזריק bookmarks ויגדיר את הקובץ כמקור האמת
+3. אם במצב הזה המשתמש לא ביקש revisions מפורשים — **אל תייצא מחדש** (הקובץ שהועלה *הוא* הטיוטה העדכנית). דווח למשתמש ששמרת את העריכה כמקור האמת, והצע revisions אם נדרש
+4. אם המשתמש ביקש שינויים (למשל "הוסף פסק הלכה X" / "תקן את הבלוק"):
+   - הרץ `list_bookmarks` כדי לראות אילו אנקורים זמינים
+   - בנה רשימת revisions (ראה פורמט למטה)
+   - הרץ `revise_draft` — זה ייצור `טיוטה-v{N+1}.docx` חדשה עם Track Changes
+
 ### שלב 2: בדיקה סופית מהירה
 1. הרץ `validate_decision` — בדוק שאין כשלים קריטיים
 2. בדוק שכל 12 הבלוקים (א-יב) קיימים ומלאים
@@ -54,9 +75,30 @@ tools:
 6. בדוק שסטטוס ה-QA הוא "passed" — אם ה-QA לא רץ או נכשל, **אל תייצא**
 
 ### שלב 3: ייצוא DOCX
+
+**מצב א' — ייצוא ראשוני (אין active_draft):**
 1. קרא את סקייל legal-docx (SKILL.md) כדי להבין את דרישות העיצוב
-2. השתמש ב-`export_docx` לייצוא ראשוני לקובץ זמני
+2. השתמש ב-`export_docx` לייצוא ראשוני
-3. אם הסקריפט `create-legal-doc.js` מתאים יותר (למשל לעיצוב מותאם) — השתמש בו
+3. ה-tool יוסיף bookmarks ב-12 הבלוקים ויסמן את הקובץ כ-active_draft_path
+
+**מצב ב' — יש active_draft + המשתמש ביקש שינויים:**
+
+1. בנה רשימת revisions ב-JSON. פורמט כל revision:
+   ```json
+   {
+     "id": "r1",
+     "type": "insert_after",  // או insert_before, replace, delete
+     "anchor_bookmark": "block-yod",  // מ-list_bookmarks
+     "content": "וכך נפסק בעניין פלוני. בבג\"ץ 1234/21 קבע השופט...",
+     "style": "body",  // או heading, quote
+     "reason": "הוספת פסק הלכה שחסר לפי בקשת יו\"ר"
+   }
+   ```
+2. הפעל `revise_draft` — ייצור `טיוטה-v{N+1}.docx` עם `<w:ins>` / `<w:del>` — המשתמש יקבל/ידחה ב-Word
+3. דווח למשתמש על הגרסה החדשה ו-applied/failed count
+
+**מצב ג' — יש active_draft אך המשתמש לא ביקש שינוי ספציפי:**
+הטיוטה כבר עדכנית (המשתמש ערך ב-Word). אל תייצא מחדש. דווח: "הקובץ העדכני הוא `<active_draft>`. רוצה שאבצע שינויים ממוקדים?"
 
 ### שלב 4: שמירה מגורסת
 1. צור תיקייה `~/legal-ai/data/cases/{מספר-ערר}/exports/` (אם לא קיימת)
@@ -78,21 +120,11 @@ tools:
 ```bash
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
   -d '{"reason": "מייצא טיוטה סיים משימה [issue-id] בסטטוס [done/blocked]"}'
 ```
 אם ה-API לא עובד:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'מייצא טיוטה סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```
 
 ## כללים קריטיים
 

.claude/agents/legal-proofreader.md

@@ -1,7 +1,7 @@
 ---
 name: "legal-proofreader"
 description: "מגיה מסמכים — תיקון שגיאות OCR בטקסט משפטי עברי לפני ניתוח"
-model: "claude-opus-4-6"
+model: "claude-opus-4-7"
 tools:
   - Read
   - Write
@@ -22,6 +22,14 @@ tools:
 
 עבוד תמיד בעברית.
 
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
 ## רקע
 
 מסמכים משפטיים (כתבי ערר, תגובות, פרוטוקולים) מגיעים כסריקות PDF. מנוע OCR מחלץ מהם טקסט ושומר אותו כקבצי MD. אבל ה-OCR לא מושלם — במיוחד בעברית משפטית:
@@ -62,60 +70,4 @@ tools:
 1. **גיבוי**: העתק את הקובץ המקורי מ-`extracted/` לתיקיית `documents/backup/` עם סיומת `.pre-proofread.txt`
 2. **כתוב** את הגרסה המתוקנת לתיקיית `documents/proofread/` (עם אותו שם קובץ כמו ב-`extracted/`)
 3. עדכן את מסד הנתונים — שנה `extraction_status` ל-`proofread`:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="${PGPASSWORD:-$(grep DB_PASSWORD /home/chaim/.env | cut -d= -f2)}" \
-psql -h localhost -p 5432 -U "${DB_USER:-legal_ai}" -d "${DB_NAME:-legal_ai}" \
--c "UPDATE documents SET extraction_status = 'proofread', extracted_text = pg_read_file('/path/to/file.txt') WHERE id = '{doc_id}';"
-```
-אם עדכון DB לא אפשרי, עדכן רק את הקובץ ודווח.
-
-### שלב 5: עדכון סטטוס ודיווח
-
-1. **עדכן סטטוס**: `case_update(case_number, status='proofread')`
-
-2. פרסם comment ב-Paperclip עם:
-```
-## דוח הגהת מסמכים — תיק {case_number}
-
-### סיכום
-- **מסמכים שנבדקו:** {count}
-- **מסמכים שתוקנו:** {fixed_count}
-- **סה"כ תיקונים:** {total_fixes}
-
-### פירוט לכל מסמך
-| מסמך | ראשי תיבות | שגיאות OCR | הערות |
-|------|------------|-----------|-------|
-| {title} | {abbr_count} | {ocr_count} | {notes} |
-
-### מקומות לא ברורים
-- {document}: סעיף {n} — [?] "{problematic_text}"
-```
-
-## כללים קריטיים
-
-1. **אל תשנה תוכן משפטי** — רק תיקוני OCR. אם מילה נראית מוזרה אבל היא מונח משפטי — אל תגע
-2. **אל תדרוס בלי גיבוי** — תמיד העתק ל-`backup/` לפני שינוי
-3. **ראשי תיבות ארוכים קודם** — `נתבייע` (5 תווים) לפני `עייד` (3 תווים)
-4. **דווח מקומות מסופקים** — סמן `[?]` ותן לאדם להחליט
-5. **אל תמציא טקסט** — אם חסר משהו, סמן `[...]` ואל תנחש
-6. **קרא את כל המסמך** — לפעמים הקשר ממסמך שלם עוזר להבין מילה שבורה
-
-### העֵר את העוזר המשפטי (CEO) — חובה!
-```bash
-curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
-  -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
-  -d '{"reason": "מגיה מסמכים סיים משימה [issue-id] בסטטוס [done/blocked]"}'
-```
-אם ה-API לא עובד:
-```bash
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'מגיה מסמכים סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```

.claude/agents/legal-qa.md

@@ -24,7 +24,26 @@ tools:
 
 עבוד תמיד בעברית.
 
-## 6 בדיקות
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
+## לפני שאתה מתחיל — קרא את מסמכי הקול
+
+בלי קריאת מסמכי הקול, אינך יכול לבדוק שה-writer עקב אחר הסגנון של דפנה.
+
+1. **`docs/daphna-decision-tree.md`** — תקציר תפעולי. ממנו תגיע למסמכים הספציפיים לפי שאלה.
+2. **`docs/daphna-voice-fingerprint.md`** — קבועי הקול (פעלי "אנחנו", אנטי-דפוסים, ביטויי קישור)
+3. **`docs/daphna-architecture-by-outcome.md`** — מבנה בלוק י לפי תוצאה
+4. **`docs/daphna-acceptance-architecture.md`** — חמש תבניות קבלה. **חובה אם התיק קבלה (לא חלקית)**
+5. **`docs/daphna-block-zayin-claims.md`** — כללי בלוק ז (טענות הצדדים)
+6. **`docs/daphna-precedent-network.md`** — לכל סוגיה משפטית, איזה תקדם דפנה מצטטת
+
+## 7 בדיקות
 
 ### 1. שלמות מבנית (structural_integrity)
 - כל בלוקי חובה קיימים (ה עד יא)
@@ -66,6 +85,44 @@ tools:
 - אין "נוסחאות ריקות" (משפטים שמחיקתם לא משנה כלום)?
 - ציטוטים עטופים בסנדוויץ' (הקדמה → ציטוט → ניתוח)?
 
+### 8. עמידה בקול דפנה (voice_compliance)
+מבוסס על 6 מסמכי הקול. בדוק:
+
+#### בלוק ז (מ-`daphna-block-zayin-claims.md`)
+- כותרת **"תמצית טענות הצדדים"** (לא "טענות הצדדים")?
+- כל צד מקבל כותרת משנה (טענות העוררים / תגובת הוועדה / תגובת מבקשי ההיתר)?
+- אין רשימה ממוספרת `(1)... (2)...` בתוך פסקה?
+- אין מילות הערכה ("בצדק", "בטעות", "משכנעת")?
+- אין גילוי מסקנה עתידית ("טענה זו תידחה בהמשך")?
+- אין ציטוטי פסיקה ארוכים — רק שם + הפניה?
+- קול פעיל ("העורר טוען") ולא פסיביזציה ("טענות העורר היו")?
+
+#### בלוק י (מ-`daphna-voice-fingerprint.md` + `daphna-architecture-by-outcome.md`)
+- כותרת בלוק י = **"דיון והכרעה"** (קבוע)?
+- קול "אנחנו" פעיל — אין "הוועדה מוצאת" אלא "מצאנו"?
+- כל פועל "אנחנו" נושא תפקיד — אין "נחדד" כפתיחת פסקה אקראית?
+- דפוס "אכן... אולם" לטענות שנדחות (לא דחייה במשפט אחד)?
+- אין רשימה ממוספרת באנליזה?
+- אין מספור פסקאות סדרתי (1., 2., 3.) — מגמה ישנה שנטושה ב-2025+?
+- כותרות משנה רק אם 3+ סוגיות מובחנות (לא בתיק עם סוגיה אחת)?
+- ציטוטי פסיקה במלואם (4-15 שורות), לא תמציות?
+- אם תיק 1xxx מורכב — מסגור פילוסופי בפתיחה?
+- אם תיק 8xxx עם הכרעה שמאית — ציטוט בר"מ 3644/13 קיים?
+- "למעלה מן הצורך" לטיעונים מרכזיים?
+- אין רטוריקה דרמטית של הצדדים בקול ההכרעה?
+- אין תוצאה הכל-או-לא-כלום בתיק עם טענות מהותיות משני הצדדים?
+
+#### תקדמים (מ-`daphna-precedent-network.md`)
+- לכל סוגיה משפטית — האם נבחר התקדים המועדף של דפנה?
+- האם יש תקדים אישי שלה רלוונטי? אם כן — האם הופנה אליו (חיסכון / דחייה / הבחנה)?
+
+#### תבנית קבלה (מ-`daphna-acceptance-architecture.md` — אם תוצאה = קבלה)
+- האם הסיבה לקבלה ברורה: פגם פנימי / החזרה / תיקונים / 8xxx מהותית / שומה?
+- האם התבנית הנבחרת (A/B/C/D/E) מתאימה לסיבה?
+- האם פורמט הסיום נכון לתבנית? (תבנית A: "מתבטלת"; B: "תיקבע לדיון" + הוראת הבהרה; C: "בכפוף לתיקונים"; D: "דרישת התשלום בטלה"; E: "השומה תושב לתיקון")
+- בתבנית A: יש "הודאת צד נגדי" ו"השמטה רחבה"?
+- בתבנית C: יש פסקת הכרה בוועדה ("פעלה נכון בקיום הדיון")?
+
 ## חומרה
 
 | בדיקה | חומרה | משמעות |
@@ -77,6 +134,7 @@ tools:
 | כפילות | warning | מדווח, לא חוסם |
 | מספור | warning | מדווח, לא חוסם |
 | מתודולוגיה | critical | חוסם ייצוא |
+| **קול דפנה** | **critical** | **חוסם ייצוא** |
 
 ## תהליך עבודה
 
@@ -109,18 +167,8 @@ tools:
 ```bash
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
   -d '{"reason": "בודק איכות סיים משימה [issue-id] בסטטוס [done/blocked]"}'
 ```
 אם ה-API לא עובד:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'בודק איכות סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```

.claude/agents/legal-researcher.md

@@ -27,10 +27,20 @@ tools:
 
 עבוד תמיד בעברית.
 
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
 ## לפני שאתה מתחיל — קרא!
 
-1. **מתודולוגיה אנליטית**: `docs/decision-methodology.md` — במיוחד סעיפים ד.2 (התחל מלשון הטקסט), ד.3 (שלושה מקורות להנחה עליונה), ז (ציטוטים ואזכורי פסיקה)
+1. **רשת תקדמים של דפנה**: `docs/daphna-precedent-network.md` — **קריאת חובה**. לכל סוגיה משפטית, יש לדפנה תקדם **מועדף** שהיא מצטטת באופן עקבי (אייזן/רוזן/שפר/הרמלין/חוף השרון/בר"מ 3644/13 גלר וכו'). אל תחפש תקדמים אקראיים — בדוק את הקאנון שלה תחילה.
-2. לקחים מהחלטות קודמות: `docs/legal-decision-lessons.md`
+2. **מתודולוגיה אנליטית**: `docs/decision-methodology.md` — במיוחד סעיפים ד.2 (התחל מלשון הטקסט), ד.3 (שלושה מקורות להנחה עליונה), ז (ציטוטים ואזכורי פסיקה)
+3. **תקדמים אישיים של דפנה**: השתמש ב-`search_decisions` לפני שמציעים תקדם חיצוני. אם דפנה כבר הכריעה בסוגיה זהה — התקדם שלה הוא חלק מהקאנון.
+4. לקחים מהחלטות קודמות: `docs/legal-decision-lessons.md`
 
 ## סוגי מסמכים שאתה מטפל בהם
 
@@ -61,8 +71,19 @@ tools:
    - **רמת התקדים**: עליון / מנהלי / ועדת ערר ארצית / ועדת ערר מחוזית
    - **הלכה מחייבת או אמרת אגב**
    - **כיצד ישרת את מבנה ההנמקה**: כ"כלל" (הנחה עליונה), כ"הרחבה" (Explanation ב-CREAC), או כאנלוגיה
+   - **האם זה תקדם מהקאנון של דפנה?** (בדוק `docs/daphna-precedent-network.md` — אם כן, ציין שזה התקדם המועדף שלה לסוגיה)
 4. הפק הפניות (`extract_references`)
 
+### שלב 2ב: בדיקה מצטלבת מול הקאנון של דפנה
+אחרי שאספת את הפסיקה הרלוונטית בתיק:
+1. **לכל סוגיה משפטית** בתיק — בדוק ב-`daphna-precedent-network.md`:
+   - האם יש תקדם מועדף של דפנה לסוגיה?
+   - האם הוא הוצג בכתבי הטענות? אם לא — סמן כתקדם שיש להוסיף
+2. **תקדמים אישיים**: `search_decisions` בקטגוריה זהה לתיק. אם דפנה כבר הכריעה בסוגיה דומה:
+   - אם תוצאה דומה: תקדם לחיסכון דוקטרינרי ("כפי שקבענו ב-X")
+   - אם תוצאה הפוכה: ציין כי **חובה** הבחנה (distinguishing)
+3. **דווח** איזה תקדמים מהקאנון רלוונטיים, ואיזה תקדמים אישיים נמצאו
+
 ### שלב 3: מיפוי תכנית
 1. קרא הוראות התכנית **במלואן** — לא רק את הסעיף הנטען
 2. זהה סעיפים רלוונטיים למחלוקת
@@ -98,21 +119,11 @@ python3 /home/chaim/legal-ai/scripts/notify.py \
 ```bash
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
   -d '{"reason": "חוקר תקדימים סיים משימה [issue-id] בסטטוס [done/blocked]"}'
 ```
 אם ה-API לא עובד:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'חוקר תקדימים סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```
 
 ## כללים
 - **דיוק** — ציין מספרי סעיפים, תאריכים, שמות שופטים

.claude/agents/legal-writer.md

@@ -1,7 +1,7 @@
 ---
 name: "legal-writer"
 description: "כותב החלטה — כתיבת בלוקים ה-יא של ההחלטה בסגנון דפנה תמיר"
-model: "claude-sonnet-4-6"
+model: "claude-opus-4-7"
 tools:
   - Read
   - Bash
@@ -32,12 +32,34 @@ tools:
 
 עבוד תמיד בעברית.
 
+## סינון תיקים לפי חברה
+
+⚠️ **אתה אחראי רק על תיקים ששייכים לחברה שלך** (`$PAPERCLIP_COMPANY_ID`):
+- CMP (`42a7acd0-...`) → רק תיקים **1xxx** (רישוי ובניה)
+- CMPA (`8639e837-...`) → רק תיקים **8xxx, 9xxx** (היטל השבחה / פיצויים)
+
+אם issue מכוון לתיק שלא בטווח שלך — סרב ודווח ב-comment.
+
 ## לפני שאתה מתחיל — קרא!
 
-1. **מתודולוגיה אנליטית: `docs/decision-methodology.md`** — איך לחשוב על החלטה
+### חובה לפני כל כתיבה — נקודת ההתחלה:
-2. מדריך סגנון: `skills/decision/SKILL.md` — איך דפנה כותבת
+0. **עץ ההחלטה: `docs/daphna-decision-tree.md`** — **כלי הפעולה היומיומי**. מאחד את כל המסמכים לתהליך אנליטי קצר: מהי הראיה הניצחת? איזה ארכיטקטורה? איזה מוד פתיחה? איזה אורך? **תמיד להתחיל כאן** — המסמך מצביע איזה מסמך אחר לקרוא לפי השאלה.
-3. ארכיטקטורת 12 בלוקים: `docs/block-schema.md`
+
-4. לקחים מהחלטות קודמות: `docs/legal-decision-lessons.md`
+### חובה לפני בלוק י (חמישיית הקול):
+1. **טביעת אצבע של הקול: `docs/daphna-voice-fingerprint.md`** — הקבועים החוצים, מודי פתיחה, פעלי "אנחנו", אנטי-דפוסים
+2. **רשת תקדמים: `docs/daphna-precedent-network.md`** — לכל סוגיה משפטית, איזה תקדם דפנה מצטטת. מסמך זה מחליף שיטוט אקראי בפסיקה — דפנה עקבית והסוכן חייב להיות עקבי כמוה
+3. **ארכיטקטורה לפי תוצאה: `docs/daphna-architecture-by-outcome.md`** — איך משתנה מבנה בלוק י לפי סוג התוצאה. כולל **עץ החלטה לסוכן** ופרופורציות פנימיות
+4. **ארכיטקטורת קבלה: `docs/daphna-acceptance-architecture.md`** — חמש תבניות שונות לקבלת ערר. **חובה אם התוצאה הצפויה היא קבלה (לא חלקית).** כולל "הודאת הצד הנגדי", "אכיפה תנאית", פורמטי סיום מובחנים.
+5. **קריאה עמוקה לדוגמה: `docs/voice-1130-25.md`** — איך הקול עובד בתיק קונקרטי
+
+### חובה לפני בלוק ז (טענות הצדדים):
+- **בלוק ז: `docs/daphna-block-zayin-claims.md`** — מבנה, סדר הצדדים, ביטויי קישור, ניטרליות מלאה, אנטי-דפוסים. בלוק ז הוא **דוח עובדתי** של הטענות — לא הערכה.
+
+### תשתית כללית:
+5. **מתודולוגיה אנליטית: `docs/decision-methodology.md`** — איך לחשוב על החלטה
+6. מדריך סגנון: `skills/decision/SKILL.md` — איך דפנה כותבת
+7. ארכיטקטורת 12 בלוקים: `docs/block-schema.md`
+8. לקחים מהחלטות קודמות: `docs/legal-decision-lessons.md`
 
 ## ארכיטקטורת 12 בלוקים
 
@@ -70,6 +92,41 @@ tools:
 
 ## תהליך עבודה
 
+### מצב revision — תוספת נקודתית לטיוטה קיימת
+
+כש-CEO מבקש **תוספת נקודתית** (לא כתיבה מאפס) — למשל "הוסף פסק הלכה X בבלוק י" — המצב הוא:
+
+- המשתמש העלה `עריכה-v*.docx` והוא ה-`active_draft_path`
+- נדרש ניסוח של פסקה/פסקאות בסגנון דפנה להכנסה ב-Track Changes
+- **אסור להשתמש ב-`save_block_content`** — ה-revision חי בקובץ, לא ב-DB
+
+**זרימה:**
+
+1. קרא `get_block_context(case_number, block_id)` להקשר
+2. קרא `get_style_guide()` לוודא סגנון דפנה
+3. נסח את התוספת — טקסט עברי נקי, בלי placeholders (`X`, `...`, `[לציטוט]`), מוכן להכנסה ישירה ל-DOCX
+4. החזר את הטקסט ל-CEO (בקומנט או כ-return value) — **לא** שומר ב-DB
+5. CEO יקרא ל-`revise_draft` עם הטקסט שלך
+
+**דוגמה לפלט מצופה:**
+
+> בבג"ץ 1234/21 [פלוני נ' הוועדה המחוזית] קבע בית המשפט העליון כי הוועדה המקומית מחויבת לשקול שיקולי Y גם בהיעדר התנגדות מפורשת. הלכה זו חלה ישירות על ענייננו: הוועדה המקומית לא בחנה את Y, ודי בכך כדי להחזיר את הדיון לוועדה.
+
+---
+
+### שלב 0: בדיקת הוראות וטיוטות
+
+לפני שתתחיל לכתוב, בדוק אם יש הנחיות ספציפיות:
+
+1. **קרא comments אחרונים על ה-issue** — חפש הוראות מה-CEO או מחיים:
+   ```bash
+   curl -s -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
+     "$PAPERCLIP_API_URL/api/issues/{issue-id}/comments" | jq '[.[] | select(.authorUserId != null)] | .[-3:]'
+   ```
+2. **בדוק attachments** (ראה HEARTBEAT שלב 2c) — אם יש קובץ DOCX מצורף, קרא אותו
+3. **אם יש טיוטת DOCX** — קרא אותה, השתמש בה כבסיס. **אל תכתוב מאפס אם יש טיוטה.**
+4. **אם ה-CEO או חיים כתבו הנחיות ב-comment** (למשל "ערוך בהתאם ל...") — **עקוב אחריהן**
+
 ### שלב 1: הכנה
 1. **קרא את המתודולוגיה**: `Read docs/decision-methodology.md` — חובה לפני כל כתיבה
 2. קרא פרטי התיק (`case_get`)
@@ -147,41 +204,88 @@ case_update(case_number, status="drafted")
 ```bash
 curl -s -X POST -H "Authorization: Bearer $PAPERCLIP_API_KEY" \
   -H "Content-Type: application/json" \
-  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wake" \
+  "$PAPERCLIP_API_URL/api/agents/752cebdd-6748-4a04-aacd-c7ab0294ef33/wakeup" \
   -d '{"reason": "כותב החלטה סיים משימה [issue-id] בסטטוס [done/blocked]"}'
 ```
 אם ה-API לא עובד:
-```bash
+**⚠️ אסור להשתמש ב-INSERT INTO agent_wakeup_requests ישירות!** הכנסה ישירה ל-DB יוצרת רק את הבקשה בלי heartbeat_run — והסוכן לא יתעורר לעולם. **תמיד להשתמש ב-API בלבד.**
-PGPASSWORD="paperclip" psql -h 127.0.0.1 -p 54329 -U paperclip -d paperclip -c "
-INSERT INTO agent_wakeup_requests (company_id, agent_id, source, reason, status, requested_by_actor_type)
-VALUES (
-  (SELECT company_id FROM agents WHERE id = '\$PAPERCLIP_AGENT_ID'),
-  '752cebdd-6748-4a04-aacd-c7ab0294ef33',
-  'agent_completion',
-  'כותב החלטה סיים משימה — נדרשת בדיקה',
-  'pending', 'agent'
-);"
-```
 
 **אם לא תעדכן סטטוס ל-drafted — בודק האיכות לא יוכל לרוץ!**
 
 ## בלוק י — דיון (הבלוק החשוב ביותר)
 
+**קריאת חובה לפני כתיבה (5 מסמכים)**:
+1. `docs/daphna-voice-fingerprint.md` — קבועים, פעלי "אנחנו", אנטי-דפוסים
+2. `docs/daphna-precedent-network.md` — לכל סוגיה משפטית, איזה תקדם
+3. `docs/daphna-architecture-by-outcome.md` — מבנה לפי תוצאה + עץ החלטה
+4. `docs/daphna-acceptance-architecture.md` — **חובה אם תוצאה צפויה: קבלה (לא חלקית).** חמש תבניות מובחנות
+5. `docs/voice-1130-25.md` — דוגמה עמוקה
+
+**עץ החלטה לבחירת ארכיטקטורה**:
+1. מה התוצאה?
+   - דחייה פשוטה / מורכבת / סף+מהות / חלקית → architecture-by-outcome.md
+   - **קבלה (מלאה / החזרה לוועדה / תיקונים / 8xxx מהותית / שומה)** → acceptance-architecture.md
+2. כמה סוגיות מובחנות? (1-2 / 3+ מובחנות / 3+ באותו עניין)
+3. תיק מאוחד? (כן/לא)
+4. רמאנד מתיק קודם? (כן/לא)
+
+**אם התוצאה היא קבלה** — שאלה ראשונה: **מה הסיבה לקבלה?**
+- הוועדה קבעה תנאי, לא וידאה שהוא מתקיים → תבנית A (קצר, "הודאת צד נגדי")
+- הוועדה דחתה ללא דיון תכנוני → תבנית B (החזרה + הוראת הבהרה)
+- הוועדה דנה אבל הליקויים ניתנים לתיקון → תבנית C (בכפוף לתיקונים)
+- סוגיה משפטית מהותית בחוק (8xxx) → תבנית D (אקדמי-משפטי)
+- פגם בעבודת השמאי → תבנית E (השבת שומה)
+
+לכל שילוב — ארכיטקטורה ספציפית במסמך הרלוונטי.
+
 **עקוב אחר `docs/decision-methodology.md` — שלבי הניתוח:**
 
-### שלב א: פסקת מפה
+### שלב א: בחירת מוד פתיחה (לא רשימה ממוספרת!)
-פתח בפסקה שמודיעה מה ייבחן: "שלוש שאלות עומדות להכרעה: (1)...; (2)...; (3)..."
+
+⛔ **אסור** לפתוח ב-"שלוש שאלות עומדות להכרעה: (1)...; (2)...; (3)...". דפנה מעולם לא משתמשת ברשימה ממוספרת בדיון. ב-0/10 החלטות סופיות נמצאה רשימה ממוספרת באנליזה.
+
+✅ **בחר מוד פתיחה** מבין 5, לפי **תוצאת ההכרעה ומורכבות התיק**:
+
+| מוד | מתי | תבנית פתיחה |
+|------|------|---------------|
+| **A. בוטם-ליין** | דחייה ברורה, פשוטה | "לאחר ש<חומרים שעיינו בהם>, הגענו לכלל מסקנה כי דין הערר להידחות." |
+| **B. תיעוד תהליכי** | תהליך מקיף, תוצאה מורכבת | "נקדים ונציין כי <דיון/סיור/השלמות>, ועל כן <מסקנה כללית>. ונפרט;" |
+| **C. ניסוח סוגיה** | שאלה משפטית מובחנת (פטור, מימוש, סטאטוס) | "הסוגייה שנדונה בערר שלפנינו מעמידה במבחן את נקודת המפגש בין <X> לבין <Y>. השאלה המרכזית מתמקדת בסוגיה האם <שאלה ספציפית>." |
+| **D. ישיר-עובדתי** | תיק עם הרבה עובדות, התוצאה מהן | "הצדדים הרבו בטענות... התבהרה תמונה עובדתית ומשפטית כלהלן: <תמצית עובדתית>" |
+| **E. תרכובת** | קבלה חלקית | "בכל הנוגע לטענה המרכזית... נקדים ונציין כי אנו מקבלים את עמדת <צד> כי <תמצית>." |
+
+**אם תיק 1xxx (תכנון/רישוי) עם תוצאה מורכבת**: הוסף לפני המוד מסגור פילוסופי על המתחים המובנים בדיני התכנון (ראה 1130-25 פס' 93). לדוגמה: `כידוע דיני התכנון נדרשים מעצם טיבם ליישב מתחים מובנים בין X לבין Y.`
+
+**אם תיק 8xxx (היטל השבחה) עם הכרעה שמאית**: הוסף פסקת פתיח דוקטרינלית עם ציטוט בר"מ 3644/13 (גלר/משרד התחבורה) — "התערבות תיעשה במשורה". ראה תבנית 4.4 ב-fingerprint.md.
 
 ### שלב ב: סוגיות סף (אם רלוונטיות)
-אם עולה שאלת סף — היא נדונה ראשונה. אם נדחית — פסקה אחת ועבור לגוף.
+אם עולה שאלת סף — היא נדונה ראשונה. אסור לדחות במשפט אחד; כל טענה משמעותית — לפחות פסקה עם **"אכן [נקודה תקפה של הצד]... אולם [למה לא מכריע]"**.
 
-### שלב ג: לכל סוגיה — מבנה סילוגיסטי (CREAC)
+### שלב ג: לכל סוגיה — מבנה סילוגיסטי (CREAC) בקול דפנה
-1. **מסקנה** — פתח בתשובה
+1. **מסקנה** — פתח בתשובה (בקול "אנחנו" — ראה טבלה למטה)
-2. **כלל** — ציטוט הוראת תכנית/חוק (התחל מלשון הטקסט, לא מפסיקה)
+2. **כלל** — ציטוט סעיף החוק במלואו (לא תמצית). אם רלוונטי — סעיפי משנה כולם.
-3. **הרחבה** — תקדים רלוונטי אחד (טכניקת סנדוויץ': הקדמה→ציטוט→ניתוח)
+3. **הרחבה** — תקדים רלוונטי אחד **בציטוט מלא** (לא תמצית). דפנה תמיד מצטטת בני 4-15 שורות עם הפניה `(פורסם בנבו)`.
 4. **יישום** — החל את הכלל על העובדות. הפרד ממצא עובדתי ממסקנה משפטית. השתמש בנתונים (מספרים, מידות, אחוזים).
-5. **Steel-Man** — הצג את הטענה הטובה ביותר של הצד המפסיד: "אמנם צודק העורר כי..., אולם..."
+5. **אישור-לפני-דחייה (חובה)** — הצג את הטענה הטובה ביותר של הצד המפסיד: **"אכן [נקודה תקפה]... אולם [למה לא מכריע]"**. השימוש ב-"אכן" (לא "אמנם") הוא הסטנדרט.
-6. **מסקנה חוזרת** — סגור
+6. **למעלה מן הצורך** (חובה לטענות מרכזיות) — "גם אם היינו מקבלים את פרשנות העורר... התוצאה הייתה זהה". סוגר חלון לערעור.
+7. **מסקנה חוזרת** — סגור
+
+### קול "אנחנו" פעיל — לא קישור סתמי
+
+| פועל | תפקיד — לפי הצורך |
+|-------|---------------------|
+| **אנו סבורים** | שיפוט ערכי |
+| **מצאנו / לא מצאנו** | קביעת ממצא |
+| **נציין** | תצפית צדדית |
+| **נפנה** | מעבר לסוגיה/פסיקה |
+| **נחדד** | הבהרת נקודה שמסתכנת בטשטוש (לא פתיחה כללית) |
+| **נשוב על כך / נחזור על כך** | חזרה ביודעין לרעיון מרכזי |
+| **נבהיר** | הבהרת מה **לא** הוכרע |
+| **ודוק** | פתיחת reductio ad absurdum |
+| **קראנו / שמענו / ערכנו / ביקשנו / המתנו** | תיעוד תהליכי |
+| **התרשמנו** | רושם תהליכי |
+
+⛔ אם אתה משתמש ב"נחדד" כפתיחת פסקה אקראית — אתה מאבד את העיקר. כל פועל "אנחנו" נושא תפקיד.
 
 ### שלב ד: איזון (כשנדרש)
 אם אין כלל ברור — בנה איזון: זהה אינטרסים קונקרטיים → בחן השלכות לכל כיוון → שקול השלכות מערכתיות → הכרע.
@@ -196,6 +300,30 @@ VALUES (
 - אל תחזור על עובדות מבלוק ו — הפנה: "כאמור בסעיף X לעיל"
 - כל מילה עובדת — אין "לאחר ששקלנו את כלל השיקולים"
 - כנות לגבי קושי — "הדבר אינו נקי מספקות, אולם..."
+- **מעבר עם נקודה-פסיק**: לפני הצללת דיון פנימי השתמש ב-`;` במקום `:` או `.`. דוגמאות: `ונפרט;` / `להלן נבחן את הדברים;` / `ברוח הדברים לעיל נבחן את טענות הצדדים;`
+- **דחייה למומחים** — לסוגיות תכנוניות-טכניות (כמויות, חישובים, חניה, בטיחות תנועתית), דחה למהנדס/יועץ תנועה/וועדה המקומית. הוועדה אינה מתכננת.
+
+### חיפוש תקדימים אישיים של דפנה (חובה)
+
+לפני כתיבה — `search_decisions` בקטגוריה זהה לתיק הנוכחי. אם יש תקדים של דפנה עצמה — חובה להפנות אליו ב-3 מודים:
+
+1. **חיסכון דוקטרינרי**: "סוגיה זו נדונה בהרחבה בהחלטתנו ב<תיק>" — חוסך פסקאות דוקטרינה.
+2. **דחייה לדיון מפורט**: "נפנה להנמקה המפורטת בהחלטתנו ב<תיק>" — אם הניתוח ארוך.
+3. **הבחנה (distinguishing)**: "בניגוד לתכנית שנדונה ב<תיק>, שם <X>, הרי שבמקרה הנדון <Y>" — אם התוצאה שונה.
+
+זה לא קישוט. דפנה בונה ג'וריספרודנציה אישית מתמשכת. ראה דוגמה ב-1194-25 פס' 61, 64, 97, 98, 99 — חמש הפניות ל-1130-25.
+
+### אנטי-דפוסים — בדיקה אחרי כתיבה (חובה)
+
+- [ ] **אין רשימות ממוספרות בתוך פסקה** (`(1)... (2)... (3)...`) — דפנה מעולם לא משתמשת
+- [ ] **אין מספור פסקאות סדרתי** (1., 2., 3.) — מגמה ישנה שנטושה ב-2025+; הסגנון החדש הוא נרטיב רציף
+- [ ] **כותרות משנה רק אם 3+ סוגיות מובחנות** — בתיק עם פסילה + עמידה + מהות, מותר. בתיק עם סוגיה אחת — לא.
+- [ ] **אין סיכומים בנקודות** של החלטות אחרות — תמיד ציטוט מלא
+- [ ] **אין דחיית טענה במשפט אחד** — כל טענה משמעותית = פסקה
+- [ ] **אין רטוריקה דרמטית של הצדדים** ("חטא קדמון") בקול ההכרעה — לתעד, לא לאמץ
+- [ ] **אין תוצאה הכל-או-לא-כלום** בתיק עם טענות מהותיות משני הצדדים — דפנה מעדיפה איזון
+- [ ] **אין משפטים קטועים** בסוף פסקה — בדוק שכל פסקה מסתיימת במשפט שלם ובסימן פיסוק
+- [ ] **אין פסיביזציה** — "העורר טוען" ולא "טענות העורר היו"
 
 ### חובה: שימוש בעמדות יו"ר מ-`get_chair_directions`
 
@@ -216,8 +344,32 @@ VALUES (
    שחולצו ב-analysis-and-research.md כמבנה לניתוח (שאלה עקרונית
    תחילה, ואז יישום קונקרטי).
 
-## בלוק יא — סיכום
+## בלוק יא — סיכום (סוף דבר)
 
-- חזור על המסקנות של דפנה מה-`chair_ruling` של כל סוגיה בקצרה
+תבנית הסיום של דפנה (קבועה ב-10/10 החלטות):
-- ציין את התוצאה הסופית (ערר מתקבל/נדחה/מתקבל בחלקו) בהתאם לעמדות
+
-- הוסף את פסקת "ניתנה פה אחד" עם תאריך עברי ולועזי
+### פסקה ראשונה — תיעוד תהליכי (כש-revision מקיף)
+לתיקים שעברו תהליך ארוך — דיון, סיור, השלמות טיעון, המתנה לתיקים מקבילים — פתח ב:
+> "טרם סיום נבקש לציין כי ערר זה נדון לפנינו ביסודיות רבה ב<דיון/בסיור/בהשלמות טיעון/בהמתנה לשמיעת העררים המקבילים>. עשינו כן מתוך <נימוק>."
+
+### פסקה שנייה — תוצאה אופרטיבית
+
+**ניסוח התוצאה תלוי בתבנית** (ראה `daphna-acceptance-architecture.md` סעיף 7.3):
+
+- **דחייה**: "לאור כל האמור לעיל, הערר נדחה."
+- **קבלה חלקית**: "לאור כל האמור לעיל, הערר מתקבל באופן חלקי, וזאת כדלקמן:" + פירוט סעיפים
+- **קבלה תבנית A** (פגם פנימי, 1033): "החלטת הוועדה המקומית מיום X לאשר את הבקשה במתכונתה הנוכחית מתבטלת"
+- **קבלה תבנית B** (החזרה, 1043+1054): "העררים מתקבלים במובן זה שהבקשות יקבעו לדיון בוועדה המקומית" + הוראת הבהרה: "ככל שיאושרו הבקשות... תתווסף הבהרה לפיה מדובר בהחלטה תכנונית, שאין בה כדי לגרוע מיתר הוראות הדין, לרבות חוק המקרקעין"
+- **קבלה תבנית C** (תיקונים, 1113): "הערר מתקבל בכפוף לתיקונים שפורטו לעיל"
+- **קבלה תבנית D** (8xxx מהותית, נאמנות): "הערר מתקבל, מאחר ודרישת התשלום בטלה" + "ככל שהעורר שילם את היטל ההשבחה יושב לו הסכום ששולם בצירוף הפרשי הצמדה וריבית"
+- **קבלה תבנית E** (השבת שומה, ורדיה): "אנו משיבים את השומה המכרעת לתיקון ובחינה מחודשת" + רשימת הוראות לשמאי + "על החלטתה המתוקנת... עומדת זכות ערר כדין"
+
+### פסקה שלישית — הוצאות
+- **אם דחייה מוחלטת**: "העורר/ת ישא בהוצאות ההליך בסך של X ₪ שישולם למשיבה בתוך 14 יום."
+- **אם קבלה חלקית או סוגיה מורכבת**: "בנסיבות העניין, ומאחר ו<נימוק>, איננו מוצאים מקום לחייב את מי מהצדדים בהוצאות וכל צד ישא בהוצאותיו."
+- **אם קבלה — נסיבות אישיות**: "נוכח הנסיבות האישיות שפורטו בפנינו מצאנו שלא לחייב בהוצאות."
+- **אם קבלה — סוגיה משפטית מורכבת**: "מאחר והסוגייה שעמדה במוקד הערר הינה סוגיה משפטית מורכבת... איננו מוצאים מקום לחייב."
+- **אם קבלה — הוועדה התבצרה / סירבה לציית**: "הוועדה המקומית תישא בהוצאות ההליך בסך של X ₪." (נאמנות, 1071-25)
+
+### פסקה אחרונה — מתן ההחלטה
+> "ניתנה פה אחד, <תאריך עברי>, <תאריך לועזי>."

.dockerignore

@@ -9,6 +9,8 @@ web/static/
 web/__pycache__/
 scripts/
 skills/
+!skills/docx/
+!skills/docx/decision_template.docx
 docs/
 legacy/
 node_modules/

.gitea/workflows/deploy.yaml

@@ -54,5 +54,5 @@ jobs:
       - name: Trigger Coolify redeploy
         run: |
           curl -sf \
-            "http://coolify:8080/api/v1/deploy?uuid=my85gabx37ele9aouub8t8ju&force=true" \
+            "http://coolify:8080/api/v1/deploy?uuid=gyjo0mtw2c42ej3xxvbz8zio&force=true" \
             -H "Authorization: Bearer ${{ secrets.COOLIFY_TOKEN }}"

.gitignore

@@ -2,6 +2,8 @@ data/uploads/
 data/cases/
 data/training/
 data/exports/
+data/backups/
+data/.auto-sync.log
 mcp-server/.venv/
 __pycache__/
 *.pyc

CLAUDE.md

@@ -30,7 +30,7 @@
 - לקחים מהשוואת טיוטות לגרסאות סופיות
 - סקריפט ייצוא DOCX
 
-כל החומר הועבר לתיקיית `legacy/` כקריאה בלבד. **הפרויקט הנוכחי** מעביר את הידע הזה למערכת מובנית עם PostgreSQL + pgvector + n8n.
+הידע שהופק מה-vault הוטמע במערכת הנוכחית — מסמכי ייחוס (`docs/`), קורפוס אימון (`data/training/`), ומבנה 12 בלוקים. ה-vault המקורי נמחק; הפרויקט הנוכחי עובד עם PostgreSQL + pgvector.
 
 ---
 
@@ -43,7 +43,14 @@
 | [`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/garner-methodology-extraction.md` | חומר מקור: מיצוי מספרי Garner על כתיבה משפטית | רק לבדיקת מקור |
+| `docs/fjc-principles-extraction.md` | חומר מקור: מיצוי מ-Judicial Writing Manual (FJC) | רק לבדיקת מקור |
 | [`docs/corpus-analysis.md`](docs/corpus-analysis.md) | ניתוח שיטתי של 24 החלטות — מפת תוכן, דפוסי דיון תכנוני, פערים | **לפני כל כתיבת החלטה** |
+| [`docs/product-specification.md`](docs/product-specification.md) | איפיון מוצר מלא — personas, תהליכים עסקיים, דרישות | להתמצאות עסקית/מוצרית |
+| [`docs/new-company-setup-guide.md`](docs/new-company-setup-guide.md) | מדריך הקמת חברה חדשה (CMPA) — skills, corpus, style analysis | לפני הוספת חברה/סוג ערר חדש |
+| [`docs/audit-report.md`](docs/audit-report.md) | דוח audit של המערכת | רקע כללי |
+| [`docs/case-migration-tracker.md`](docs/case-migration-tracker.md) | מעקב מיגרציה של תיקים קיימים | לצורך מעקב |
+| [`docs/decision-block-mapping.md`](docs/decision-block-mapping.md) | מיפוי בלוקים להחלטות — איך 12 הבלוקים משתקפים ב-DOCX | להתמצאות במבנה |
 | [`docs/memory.md`](docs/memory.md) | הקשר כללי — skills, פרויקטים שהושלמו, מבנה vault | להתמצאות כללית |
 | [`skills/decision/SKILL.md`](skills/decision/SKILL.md) | מדריך סגנון מלא של דפנה — טון, מבנה, ביטויים, מתודולוגיה | **לפני כל כתיבת החלטה** |
 
@@ -58,9 +65,27 @@
 | Redis | תור משימות | `legal-ai-redis` |
 | n8n | אוטומציית workflows | להגדרה |
 | Gitea | מאגר קוד | `gitea.nautilus.marcusgroup.org/ezer-mishpati` |
-| ezer-mishpati-web | ממשק העלאת מסמכים | `legal-ai.nautilus.marcusgroup.org` |
+| 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` |
 
+### ⚠️ ארכיטקטורת Deploy — חובה לקרוא
+
+**עוזר משפטי (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**
+
 ---
 
 ## מבנה תיקיות
@@ -81,15 +106,28 @@
 │   └── docx/                             עיצוב DOCX
 ├── data/
 │   ├── training/                      ← 4 החלטות לאימון (DOCX)
-│   ├── exports/                       ← ייצוא legacy (תיקים ישנים)
+│   ├── exports/                       ← טיוטות DOCX מיוצאות
 │   └── cases/{case-number}/           ← תיקי עררים (מבנה שטוח, סטטוס ב-DB)
-├── web/                               ← UI + API + integration clients
+├── web/                               ← FastAPI backend (Python): 75 API endpoints
+│   ├── app.py                            ← API ראשי
+│   ├── paperclip_client.py               ← אינטגרציית Paperclip
+│   └── gitea_client.py                   ← אינטגרציית Gitea
+├── web-ui/                            ← Next.js frontend (TypeScript/React): ממשק המשתמש
+│   └── next.config.ts                    ← proxy: /api/* → FastAPI :8000
 ├── mcp-server/                        ← MCP server + services + tools
-└── scripts/                           ← סקריפטים וכלי עזר
+└── scripts/                           ← סקריפטים וכלי עזר (ראה scripts/SCRIPTS.md)
+    └── .archive/                      ← סקריפטים שהושלמו (לא להריץ)
 ```
 
 ---
 
+## כלל: עדכון `scripts/SCRIPTS.md`
+
+בכל פעם שנוצר, נמחק, או משתנה סקריפט בתיקיית `scripts/` — **חובה לעדכן את `scripts/SCRIPTS.md`** בהתאם.
+הקובץ מתעד את התפקיד, הסטטוס, וההחלפה (אם יש) של כל סקריפט.
+
+---
+
 ## ניהול משימות — TaskMaster AI
 
 הפרויקט משתמש ב-**TaskMaster AI** (MCP server) לניהול משימות מובנה:
@@ -102,6 +140,26 @@
 
 ---
 
+## 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)
+
+---
+
 ## עקרונות כתיבה קריטיים
 
 1. **"מבחן השופט"** — כל החלטה חייבת להיות קריאה לשופט שלא מכיר את התיק

Dockerfile

@@ -34,10 +34,9 @@ WORKDIR /app
 
 # Install Node.js 20.x
 RUN apt-get update && apt-get install -y --no-install-recommends \
-      curl ca-certificates \
+      curl ca-certificates git \
  && curl -fsSL https://deb.nodesource.com/setup_20.x | bash - \
  && apt-get install -y --no-install-recommends nodejs \
- && apt-get purge -y curl \
  && rm -rf /var/lib/apt/lists/*
 
 ENV NODE_ENV=production
@@ -58,6 +57,10 @@ COPY --from=builder /app/.next/static ./.next/static
 COPY web/ ./web/
 COPY mcp-server/src/ ./mcp-server/src/
 
+# DOCX template used by analysis_docx_exporter — loaded at runtime by path
+# (Path(__file__).resolve().parents[4] / "skills/docx/decision_template.docx")
+COPY skills/docx/decision_template.docx ./skills/docx/decision_template.docx
+
 # Make mcp-server source available to web/app.py (it does sys.path.insert for legal_mcp)
 ENV PYTHONPATH=/app/mcp-server/src
 

docs/architecture.md

@@ -1,82 +1,305 @@
 # System Architecture — Legal Decision Assistant
 
-## Components
+> עודכן: 2026-04-16 — הוספת ארכיטקטורת Track Changes לעריכת טיוטות
+
+## רכיבי המערכת
 
 ```
-┌─────────────────────────────────────────────────────┐
+┌───────────────────────────────────────────────────────────────┐
 │                      Nautilus Server                          │
 │                      158.178.131.193                          │
 │                                                               │
-│  ┌──────────┐  ┌──────────┐  ┌──────────────────┐   │
+│  ┌──────────────────────────────────────────────────────┐    │
-│  │ Coolify   │  │ Traefik  │  │ ezer-mishpati-web│   │
+│  │ legal-ai container (Coolify UUID: gyjo0mtw2c42ej3...) │    │
-│  │ (manage)  │  │ (proxy)  │  │ (upload UI)      │   │
+│  │   ┌────────────┐    ┌──────────────────────────┐     │    │
-│  └──────────┘  └──────────┘  └──────────────────┘   │
+│  │   │ Next.js UI │    │ FastAPI backend           │    │    │
+│  │   │  :3000     │◄──►│  :8000 (internal)         │    │    │
+│  │   └────────────┘    │  + MCP server             │    │    │
+│  │                     └──────────────────────────┘     │    │
+│  └──────────────────────────────────────────────────────┘    │
 │                                                               │
 │  ┌──────────────────┐  ┌──────────────────────────┐           │
-│  │ PostgreSQL        │  │ Redis                     │  │
+│  │ PostgreSQL +     │  │ Redis                     │           │
-│  │ + pgvector        │  │ (task queue)              │  │
+│  │ pgvector (1024D) │  │ (task queue)              │           │
-│  │ (legal-ai-postgres│  │ (legal-ai-redis)          │  │
+│  │ legal-ai-postgres│  │ legal-ai-redis            │           │
 │  └──────────────────┘  └──────────────────────────┘           │
 │                                                               │
-│  ┌──────────┐  ┌──────────┐                          │
+│  ┌──────────────┐  ┌──────────────────────────┐               │
-│  │ Gitea    │  │ n8n      │                          │
+│  │ Gitea         │  │ Traefik (SSL + routing)  │               │
-│  │ (code)   │  │ (automate│                          │
+│  │ (code + cases)│  │ (*.nautilus.marcusgroup) │               │
-│  └──────────┘  └──────────┘                          │
+│  └──────────────┘  └──────────────────────────┘               │
-│                                                       │
+└───────────────────────────────────────────────────────────────┘
-│  ┌──────────────────────────────────────────────┐    │
+
-│  │ Claude Code (via SSH or API)                  │    │
+Local (developer machine, pm2):
-│  │ — Skills: legal-decision, legal-docx          │    │
+┌──────────────────────────────────────────────────────────────┐
-│  │ — MCP: postgres, n8n, cloudflare, chrome      │    │
+│  Paperclip — agent orchestrator                              │
-│  └──────────────────────────────────────────────┘    │
+│  localhost:3100, DB localhost:54329                          │
-└─────────────────────────────────────────────────────┘
+│  Runs Claude Code agents: legal-ceo, legal-writer,           │
+│  legal-exporter, legal-researcher, legal-qa, legal-proofreader│
+└──────────────────────────────────────────────────────────────┘
 
 External:
-  ← Claude API (embeddings, analysis)
+  ← Claude API (Opus 4.7 for agents)
-  ← Cloudflare DNS (*.nautilus.marcusgroup.org)
+  ← Voyage AI (voyage-3-large, 1024-dim embeddings)
-  ← User (Putty SSH / Browser)
+  ← Infisical (secret management)
+  ← Gmail SMTP (agent notifications)
 ```
 
-## Data Flow
+---
 
-```
+## הזרימה המלאה — מהעלאת מסמכים ועד טיוטה סופית
-1. Document Upload
-   User → ezer-mishpati-web → file storage → n8n trigger
-   → classify document → store metadata in PostgreSQL
-   → generate embeddings → store in pgvector
 
-2. Decision Writing
+### שלב 1 — יצירת תיק + העלאת מסמכי מקור
-   Claude Code → read source materials from DB
-   → generate structure DOCX (12 blocks)
-   → write each block with appropriate model/parameters
-   → validate against block-schema
-   → export final DOCX
 
-3. Precedent Search (RAG)
+**מה קורה:**
-   Query → generate embedding → pgvector similarity search
+1. חיים יוצר תיק דרך UI (`/cases/new`) — מקבל `case_number` (1xxx = CMP, 8xxx/9xxx = CMPA)
-   → return relevant paragraphs/decisions
+2. מעלה PDFs/DOCX: כתב ערר, תשובה, פרוטוקול, תכניות, היתר, פסיקה
-   → Claude analyzes relevance → present to user
+3. ה-backend:
-```
+   - שומר קובץ ב-`data/cases/{case_number}/documents/originals/`
+   - מפעיל OCR (Google Vision) אם PDF ללא טקסט
+   - מריץ proofreader להסרת artifacts מ-Nevo
+   - מחלץ טקסט ל-`documents.extracted_text`
+   - מפצל ל-chunks של ~500 מילים, מחשב embeddings (voyage-3-large, 1024D), שומר ב-`document_chunks`
+4. סטטוס תיק: `new` → `proofread`
 
-## Database Schema — 4 Layers
+### שלב 2 — ניתוח משפטי (legal-researcher + analyst)
+
+**מי רץ:** סוכני Paperclip (מתוזמרים ע"י legal-ceo).
+
+1. **legal-proofreader** — מנקה את המסמכים אחרי OCR
+2. **legal-researcher** — מפה תכניות, תקדימים, חקיקה רלוונטית. שומר `research_md`
+3. **analyst (legal-researcher pass 1)** — מחלץ טענות (`extract_claims`), ממפה סוגיות, בודק שלמות
+
+סטטוס: `proofread` → `documents_ready` → `analyst_verified`
+
+### שלב 3 — החלטת תוצאה + כיוונים (CEO + חיים)
+
+1. **legal-ceo** מציג סיכום לחיים: סיווג, טענות, פסיקה רלוונטית, שאלות מפתח
+2. חיים בוחר תוצאה (דחייה/קבלה חלקית/קבלה מלאה)
+3. CEO מציג 2-3 **כיוונים סילוגיסטיים** לנימוק
+4. חיים מאשר כיוון
+
+סטטוס: `analyst_verified` → `outcome_set` → `direction_approved`
+
+### שלב 4 — ניתוח מעמיק (analyst pass 2)
+
+legal-researcher (תפקיד analyst) מעמיק בפסיקה ובחקיקה על בסיס הכיוון שאושר, מאמת ציטוטים מדויקים.
+
+סטטוס: `direction_approved` → `analysis_enriched`
+
+### שלב 5 — כתיבת טיוטה (legal-writer)
+
+1. CEO יוצר issue לכותב עם **כל ההקשר**: תוצאה, סוגיות, מבנה סילוגיסטי, מסמכי מקור, תקדימים
+2. legal-writer כותב בלוק-אחרי-בלוק (12 בלוקים: א-יב) בסגנון דפנה
+3. כל בלוק נשמר ב-DB (`decision_blocks.content`)
+
+סטטוס: `ready_for_writing` → `drafted`
+
+### שלב 6 — QA
+
+legal-qa מריץ 6 בדיקות איכות:
+- שלמות (כל 12 הבלוקים מלאים)
+- ניטרליות (בלוק ו אין ציטוטים מצדדים)
+- אין כפילות (בלוק י מפנה, לא חוזר)
+- מספור רציף
+- פסיקה מצוטטת במדויק
+- תואם `chair_directions` של דפנה
+
+אם עובר → `qa_passed`. אם נכשל → `qa_failed` + issue תיקון לכותב.
+
+### שלב 7 — ייצוא טיוטה ראשונית (legal-exporter)
+
+**מה עשה עד עכשיו:** בונה DOCX מאפס מבלוקים ב-DB.
+
+**מה חדש (2026-04):** הייצוא מזריק **bookmarks** בתחילת וסיום כל בלוק — אנקורים לעריכות עתידיות:
+- `<w:bookmarkStart w:name="block-alef">` ... `<w:bookmarkEnd>`
+- כך עד `block-yod-bet`
+
+הקובץ: `data/cases/{case_number}/exports/טיוטה-v1.docx` (גופן David, RTL, גודל ~43KB)
+
+**חשוב:** הטיוטה הזו נרשמת ב-`cases.active_draft_path` = **המקור הרשמי של התיק**.
+
+סטטוס: `qa_passed` → `exported`
+
+---
+
+## שלב 8 — לולאת עריכה מול דפנה (החלק החדש)
+
+> זה הלב של ארכיטקטורת Track Changes שנוספה ב-2026-04.
+
+### 8א. חיים מוריד + עורך + מעלה
+
+1. חיים מוריד `טיוטה-v1.docx` מה-UI
+2. פותח ב-Word (שולחן עבודה או Word Online)
+3. עורך ידנית: תיקוני ניסוח, עיצוב, תוספות של תוכן שהמערכת לא ידעה עליו
+4. שומר מחדש בשם שמתחיל ב-`עריכה-`
+5. מעלה חזרה דרך ה-UI (`/cases/{case}` → "העלה גרסה מתוקנת")
+
+### 8ב. Backend קולט — אוטומטית
+
+ה-endpoint `POST /api/cases/{case}/exports/upload` ([web/app.py:1991](web/app.py#L1991)) עושה שלושה דברים:
+
+1. **שומר את הקובץ** כ-`עריכה-v{N}.docx` (כאשר N = הגרסה הבאה)
+2. **מריץ retrofit** דרך `apply_user_edit` ב-MCP:
+   - פותח את ה-DOCX, מזהה גבולות בלוקים לפי heuristic דו-שכבתי:
+     - א) מרקרים עבריים בתחילת פסקה: `א.`, `ב.`, ..., `יב.`
+     - ב) כותרות סגנון דפנה: "רקע", "תמצית טענות", "דיון והכרעה", "סוף דבר", וכו'
+   - מזריק `<w:bookmarkStart>` / `<w:bookmarkEnd>` חסרים
+3. **מעדכן את DB**: `cases.active_draft_path = '/data/cases/{case}/exports/עריכה-v{N}.docx'`
+
+התגובה ל-UI כוללת `bookmarks_added`, `missing_blocks`, `apply_status` — ה-UI מציג toast:
+- ✓ "הועלה: עריכה-v2.docx — זוהו N בלוקים"
+- ⚠ "M בלוקים לא זוהו — ייתכנו בעיות בתיקונים עתידיים"
+
+### 8ג. חיים מבקש תיקון ספציפי מ-CEO
+
+חיים כותב ב-Paperclip comment ל-CEO של החברה:
+
+> "העליתי טיוטה ערוכה. בבקשה הוסף פסק הלכה של בג"ץ 1234/21 בבלוק י' (דיון), ותקן את הניסוח של סוף דבר."
+
+### 8ד. CEO מתזמר — שלב G
+
+[.claude/agents/legal-ceo.md — שלב G](.claude/agents/legal-ceo.md) מפעיל:
+
+1. `list_bookmarks(case_number)` — מקבל את רשימת האנקורים הזמינים
+2. אם הבקשה דורשת ניסוח חדש → מפעיל legal-writer במצב **revision**
+   - writer מקבל `block_id` + `bookmark_anchor` + הוראת ניסוח
+   - מחזיר טקסט נקי בסגנון דפנה
+   - **לא שומר ב-DB** (ה-revision חי בקובץ)
+3. בונה JSON array של revisions:
+   ```json
+   [{
+     "id": "r1",
+     "type": "insert_after",
+     "anchor_bookmark": "block-yod",
+     "content": "<הטקסט שהכותב ניסח>",
+     "style": "body",
+     "reason": "הוספת פסק הלכה לפי בקשת חיים"
+   }]
+   ```
+4. קורא ל-`revise_draft(case_number, revisions)`
+
+### 8ה. docx_reviser מבצע XML surgery
+
+[mcp-server/src/legal_mcp/services/docx_reviser.py](mcp-server/src/legal_mcp/services/docx_reviser.py):
+
+1. פותח את `עריכה-v{N}.docx` כ-ZIP + טוען `word/document.xml` עם lxml
+2. מוסיף `<w:trackRevisions/>` ב-`word/settings.xml` (אם חסר)
+3. לכל revision:
+   - מאתר את ה-bookmark בעץ
+   - בונה פסקה חדשה עם RTL + David + המילה "מערכת AI" כמחבר
+   - עוטף את ה-runs החדשים ב-`<w:ins w:id w:author w:date>`
+   - שומר IDs ייחודיים (סורק max קיים)
+4. שומר כ-`טיוטה-v{N+1}.docx` — **הקובץ החדש שומר על כל העיצוב המקורי של המשתמש** (הטמפלט, הפונטים, הטבלאות, הכל)
+5. מעדכן `cases.active_draft_path` לקובץ החדש
+
+### 8ו. חיים מקבל + מאשר/דוחה
+
+1. UI מציג: "טיוטה v{N+1} (מתוקנת) מוכנה לעיון"
+2. חיים מוריד, פותח ב-Word
+3. ה-Track Changes מופעל — השינויים מסומנים בצבע, סרגל Review פעיל
+4. חיים לוחץ Accept על כל שינוי שהוא מסכים איתו, Reject על מה שלא
+5. אם יש עוד שינויים שהוא רוצה לבקש — חוזר לשלב 8א (שומר, מעלה `עריכה-v{N+2}.docx`, מבקש עוד שינוי)
+
+### 8ז. סיום — `final`
+
+כשחיים מרוצה, הוא מסמן בייוויי "סמן כסופי" ב-UI → הקובץ מועתק ל-`סופי-{case}.docx` + ל-`data/training/` ללמידה עתידית של דפוסי סגנון.
+
+סטטוס: `exported` → `final`
+
+---
+
+## סכמת DB — 4 שכבות
 
 ### Layer 1: Core
-appeals, parties, panels, documents
+`cases`, `documents`, `document_chunks`
+
+**חדש (2026-04):** `cases.active_draft_path TEXT` — הנתיב המלא ל-DOCX שהוא מקור האמת הנוכחי של התיק. null עד לייצוא הראשון.
 
 ### Layer 2: Decision
-decisions, decision_blocks, decision_paragraphs, claims
+`decisions`, `decision_blocks`, `decision_paragraphs`, `claims`
 
 ### Layer 3: Legal Knowledge
-case_law, case_law_citations, statutory_provisions, transition_phrases, lessons_learned
+`case_law`, `statutory_provisions`, `transition_phrases`, `lessons_learned`, `style_corpus`, `style_patterns`
 
 ### Layer 4: Semantic Search (RAG)
-document_embeddings, paragraph_embeddings, case_law_embeddings
+`document_embeddings`, `paragraph_embeddings`, `case_law_embeddings` (pgvector 1024-dim, voyage-3-large)
-(all using pgvector vector(1536) columns)
+
+### Layer 5 — Multi-tenancy
+`companies`, `tag_company_mappings` (appeal_subtype → company_id)
+
+---
+
+## רב-חברתיות (CMP + CMPA)
+
+**חברות:**
+- CMP (`42a7acd0-30c5-4cbd-ac97-7424f65df294`) — תיקי 1xxx (רישוי ובניה)
+- CMPA (`8639e837-4c9d-47fa-a76b-95788d651896`) — תיקי 8xxx/9xxx (היטלי השבחה, פיצויים ס' 197)
+
+**מה משותף לשתי החברות:**
+- DB יחיד, backend יחיד, frontend יחיד
+- כל הקוד + agents — פועלים לפי `$PAPERCLIP_COMPANY_ID` בזמן ריצה
+- ארכיטקטורת Track Changes (docx_reviser, docx_retrofit, apply_user_edit, revise_draft)
+
+**מה כפול לכל חברה:**
+- Paperclip skills (`/home/chaim/.paperclip/instances/default/skills/{company_uuid}/`)
+- ניתוח סגנון נפרד (`style_patterns` filtered by appeal_subtype)
+- CEO agent משלה (CMP: `752cebdd...`, CMPA: `cdbfa8bc...`)
+
+**סקריפט סנכרון:** [scripts/deploy-track-changes.sh](scripts/deploy-track-changes.sh) — מעתיק skills מ-CMP ל-CMPA.
+
+---
+
+## MCP Tools (חלקי — הרלוונטיים לטיוטות)
+
+| Tool | מה עושה |
+|------|----------|
+| `export_docx(case)` | ייצוא טיוטה ראשונית מה-DB, עם bookmarks. מעדכן `active_draft_path`. |
+| `apply_user_edit(case, filename)` | רישום `עריכה-*.docx` כ-active_draft + הזרקת bookmarks. |
+| `list_bookmarks(case)` | רשימת אנקורים זמינים ב-active_draft. |
+| `revise_draft(case, revisions_json)` | החלת Track Changes על active_draft → יוצר `טיוטה-v{N+1}.docx`. |
+| `write_block`, `save_block_content` | כתיבה/שמירה של בלוקים ב-DB (לשלב הכתיבה הראשוני). |
+| `validate_decision` | 6 בדיקות QA. |
+
+---
+
+## API Endpoints (הרלוונטיים לטיוטות)
+
+| Endpoint | שימוש |
+|----------|--------|
+| `POST /api/cases/{case}/export-docx` | ייצוא טיוטה מה-DB |
+| `GET /api/cases/{case}/exports` | רשימת טיוטות + עריכות קיימות |
+| `GET /api/cases/{case}/exports/{filename}/download` | הורדת קובץ |
+| `POST /api/cases/{case}/exports/upload` | **העלאת עריכה → auto-retrofit + register כ-active_draft** |
+| `DELETE /api/cases/{case}/exports/{filename}` | מחיקה |
+| `POST /api/cases/{case}/exports/{filename}/mark-final` | סימון כסופי |
+| `POST /api/cases/{case}/exports/revise` | החלת revisions (Track Changes) |
+| `GET /api/cases/{case}/exports/bookmarks` | רשימת bookmarks ב-active_draft |
+| `POST /api/cases/{case}/exports/{filename}/retrofit` | ריצת retrofit ידנית (לקבצים ישנים) |
+| `GET /api/cases/{case}/active-draft` | סטטוס active_draft (path + exists) |
+
+---
+
+## טכנולוגיות עיקריות
 
-## Technology Choices
 - **Database**: PostgreSQL 15 + pgvector 0.8.1
-- **Embedding model**: TBD (Claude/OpenAI ada-002/local)
+- **Embeddings**: Voyage AI (`voyage-3-large`, 1024-dim)
-- **Automation**: n8n (workflow engine)
+- **Agents**: Claude Opus 4.7 (via Paperclip pm2)
-- **Code repository**: Gitea (self-hosted)
+- **DOCX manipulation**: `python-docx` 1.2+ ו-`lxml` 5.2+ (XML surgery)
-- **Deployment**: Coolify (Docker management)
+- **Frontend**: Next.js + TanStack Query + Tailwind
-- **Proxy**: Traefik v3.6 (auto-SSL)
+- **Backend**: FastAPI + asyncpg
-- **Frontend**: ezer-mishpati-web (static HTML + API)
+- **Deployment**: Coolify + Docker + Traefik (SSL ב-Let's Encrypt)
+- **Code repo**: Gitea (`gitea.nautilus.marcusgroup.org/ezer-mishpati/legal-ai`)
+- **Secret management**: Infisical
+
+---
+
+## מסמכים קשורים
+
+- [`block-schema.md`](block-schema.md) — מבנה 12 הבלוקים, content model, constraints
+- [`decision-methodology.md`](decision-methodology.md) — מתודולוגיה אנליטית
+- [`legal-decision-lessons.md`](legal-decision-lessons.md) — לקחים מ-3 החלטות
+- [`new-company-setup-guide.md`](new-company-setup-guide.md) — הקמת חברה חדשה (CMPA)
+- [`product-specification.md`](product-specification.md) — איפיון מוצר מלא (persona, תהליכים עסקיים)
+- [`../CLAUDE.md`](../CLAUDE.md) — הנחיות לסוכני AI שעובדים על הקוד
+- [`../scripts/SCRIPTS.md`](../scripts/SCRIPTS.md) — כל הסקריפטים והשימוש בהם

docs/block-schema.md

@@ -573,3 +573,55 @@ Conclusion → Rule → Explanation → Application → Conclusion.
 יא (סיכום)    → תלוי ב: י (מסקנות). מפנה ל: י בלבד.
 יב (חתימות)   → עצמאי
 ```
+
+---
+
+## 7. טיוטת ביניים (Pre-Ruling Draft)
+
+ועדת הערר לעיתים מבקשת לראות טיוטה חלקית **לפני** שהוועדה מכריעה — כאשר התיק
+לא מגובש או יש מחלוקת בין חברי הוועדה. הטיוטה משמשת בסיס לדיון פנימי לקראת
+פרק הדיון וההכרעה.
+
+### מבנה טיוטת הביניים
+
+המסמך משתמש **באותו טמפלט, אותו skill ואותם prompts** של החלטה רגילה (David
+12pt, RTL, bookmarks). השוני היחיד הוא בחירת הבלוקים וסידורם:
+
+| מקום | בלוק | תפקיד |
+|------|------|-------|
+| 1 (אופציונלי) | א-ד | העמוד הראשון. נכלל אם יש תוכן, ולא נדרש שיהיה. |
+| 2 | **ו (רקע עובדתי)** | פתח דבר — מקרקעין, סביבה, היסטוריה, החלטה, ערר |
+| 3 | **ט (תכניות + היתרים)** | פירוט התכניות החלות **+ תת-פרק היתרים מהשומות**, עם סימון סתירות בין שמאים |
+| 4 | **ז (טענות הצדדים)** | תמצית טענות העוררים, הוועדה ומבקשי ההיתר |
+| 5 | **ח (הליכים)** | דיון בפני הוועדה, נקודות חדשות שעלו, **השלמות טיעון ומשא-ומתן לפשרה** |
+
+הבלוקים שמדולגים: ה (פתיחה), י (דיון והכרעה), יא (סיכום), יב (חתימות).
+
+### עובדות שמאיות וזיהוי סתירות
+
+בטיוטת ביניים, בלוק ט מורחב לכלול תת-פרק היתרים. המקור הוא טבלת
+`appraiser_facts` ב-DB, שמתמלאת ע"י `extract_appraiser_facts` — הפועל על
+מסמכים מסוג `appraisal` ומחלץ לכל שמאי בנפרד את התכניות וההיתרים שציין.
+
+זיהוי סתירות נעשה ב-DB: כל זיהוי שצוין ע"י **שני שמאים שונים או יותר** נחשב
+סתירה, ומועבר אל ה-prompt של בלוק ט בנוסח structured. ה-prompt מורה לסמן את
+הסתירה במפורש, בנוסח ניטרלי (לדוגמה: "יצוין כי השמאי X ציין... בעוד השמאי Y
+סבר כי..."), בלי להכריע בה — ההכרעה תתבצע (אם בכלל) בבלוק י של הטיוטה
+הסופית.
+
+### מסמכי פוסט-דיון
+
+בלוק ח מקבל בקונטקסט גם רשימת מסמכים שתויגו כ-`metadata.is_post_hearing=true`
+(השלמות טיעון, הצעות פשרה). תיוג זה נעשה בעת ההעלאה (UI/API).
+
+### Pipeline
+
+```
+1. extract_appraiser_facts(case_number)        # ממלא appraiser_facts + מזהה סתירות
+2. write_interim_draft(case_number)             # כותב blocks ו, ט, ז, ח (ב-DB)
+3. export_interim_draft(case_number)            # מייצר טיוטת-ביניים-v{N}.docx
+```
+
+`write_interim_draft` מריץ אוטומטית את `extract_appraiser_facts` אם הטבלה
+ריקה. הקובץ הסופי נרשם כ-`active_draft_path` בדיוק כמו טיוטה רגילה, ולכן
+`apply_user_edit` ו-`revise_draft` עובדים עליו ללא שינוי.

docs/daphna-acceptance-architecture.md

@@ -0,0 +1,640 @@
+# ארכיטקטורת קבלת ערר — חמש תבניות שונות
+
+מסמך זה ממפה את הקטגוריה החסרה במסמכי הקול הקודמים: **כיצד דפנה כותבת תיקי קבלת ערר**. מבוסס על קריאה עמוקה של 5 תיקים מייצגים — 1033-25, 1043+1054, 1071+1077, 1113-25, נאמנות, טור סיני, גמר בניה, ורדיה — ומאמת בסקירת התוצאות של 33 תיקי הקורפוס.
+
+**העיקרון המרכזי**: "קבלת ערר" איננה קטגוריה אחת. היא **חמש תבניות שונות** שנבחרות לפי **טיב הפגם** שבעטיו מתקבל הערר. הסוכן חייב לזהות את התבנית **לפני** שהוא מתחיל לכתוב — כי הסטרוקטורה, האורך, הפסיקה, ופורמט הסיום שונים מהותית בין התבניות.
+
+---
+
+## 0. מה תבנית "קבלה" אינה — תיקון לטעות נפוצה
+
+המסמך הקודם `daphna-architecture-by-outcome.md` סעיף 5 כתב:
+> "קבלה מלאה → ארכיטקטורת §5 (אך ניסוח חיובי)"
+
+**זה שגוי.** קבלה אינה קבלה חלקית עם "ניסוח חיובי". היא קטגוריה מובנית אחרת:
+
+| היבט | קבלה חלקית | קבלה (מלאה) |
+|-------|------------|-------------|
+| הלוגיקה | **איזון** בין ערכים מתחרים | **תיקון** של פגם בהחלטת הוועדה |
+| המסר ליו"ר ביהמ"ש המנהלי בעתיד | "שקלנו את שני הצדדים" | "התערבנו בגלל פגם ספציפי" |
+| מסגור פילוסופי | כן (1130: "מתחים מובנים") | בדרך כלל לא — שאלה ממוקדת |
+| אורך | 4,000-5,500 מילים | **1,700-9,500** (תלוי בתבנית) |
+| ציטוטי פסיקה | רחבים | **תלוי בתבנית** (A: כמעט אין; B/C/D: רחבים) |
+| הסבר חיובי בסיום | "אינה דחייה אלא הכרה" | אין צורך — הביטול מדבר בעד עצמו |
+
+**העקרון**: קבלה אינה איזון. היא **קביעה** שהוועדה המקומית טעתה — בדרך אחת מתוך חמש.
+
+---
+
+## 1. חמש תבניות קבלה — מטריצה
+
+| תבנית | סיבה לקבלה | אורך בלוק י | דוגמאות | פסיקה |
+|-------|--------------|---------------|----------|---------|
+| **A. קבלה+ביטול בגלל פגם פנימי** | הוועדה המקומית קבעה תנאי, ולא וידאה שהוא מתקיים | 1,500-2,000 | 1033-25 (הר בשן) | מעט מאוד |
+| **B. קבלה+החזרה לוועדה לדיון מחדש** | הוועדה דחתה ללא דיון תכנוני (היעדר תימוכין קנייניים) | 3,000-9,500 | 1043+1054, 1071+1077, 1071-25 | רחבה (אייזן, רוזן, טליאט) |
+| **C. קבלה+דרישת תיקונים בבקשה** | הוועדה דחתה אבל הליקויים ניתנים לתיקון | 4,000-4,500 | 1113-25 (אייל מבורך לוי) | רחבה |
+| **D. קבלה+ביטול דרישת תשלום (8xxx)** | מחלוקת משפטית מהותית בפרשנות החוק (פטור, מימוש) | 5,000-7,500 | נאמנות, גמר בניה, טור סיני | אקדמית-משפטית עמוקה |
+| **E. קבלה+השבת שומה לשמאי (8xxx)** | פגם ספציפי בעבודת השמאי המכריע | 1,500-2,500 | ורדיה | מינימלית |
+
+**שלוש שאלות לבחירת התבנית**:
+
+1. **האם הליקוי בהחלטת הוועדה המקומית עצמה** (התעלמות מתנאי שלה, היעדר דיון תכנוני, פגם נמשך)? → **A/B**
+2. **האם הליקוי בבקשת המבקש** (אך עם פוטנציאל תיקון)? → **C**
+3. **האם זה תיק 8xxx של מהות משפטית או שמאית**? → **D/E**
+
+---
+
+## 2. תבנית A — קבלה+ביטול בגלל פגם פנימי
+
+**המקרה הקלאסי**: הוועדה המקומית עצמה קבעה תנאי אופרטיבי ("בקשה כוללת או תכנית צל"), אישרה את הבקשה — אבל בפועל התנאי לא התקיים. דפנה לא מתערבת בשיקול דעת תכנוני; היא **אוכפת על הוועדה את התנאים שהיא עצמה קבעה**.
+
+**דוגמה מובהקת**: 1033-25 (הר בשן). הוועדה המקומית דרשה "תכנית לבינוי אחיד או בנייה שאינה משנה את אופי הסביבה". המבקשת הציגה "תכנית צל" — והדיון בפני ועדת הערר חשף שתכנית הצל **תיאורטית בלבד**, ועל כך הודתה נציגת הרישוי של הוועדה עצמה.
+
+### 2.1 ארכיטקטורה
+
+```
+1. פתיחה — מוד A (בוטם-ליין):
+   "לאחר שבחנו את טענות הצדדים... מצאנו כי דין הערר להתקבל. ונפרט;"
+   
+2. דחיית טענות סף של מבקש ההיתר (אם הועלו):
+   - לכל טענת סף: פסקה אחת קצרה
+   - דחייה ללא ציטוטי פסיקה רחבים
+   - ביטויים: "אין בטענה זו ממש", "אף טענה זו דינה דחייה"
+   
+3. ציטוט מילולי של ההחלטה הקודמת/התנאי שקבעה הוועדה:
+   "כאמור, התכנית קובעת... הוועדה המקומית עצמה, בהחלטה מיום X, דרשה כתנאי..."
+   
+4. ניסוח השאלה הממוקדת:
+   "השאלה שעמדה בפנינו היא האם הבקשה המעודכנת... עומדת בתנאים אלה."
+   
+5. מסקנה מיידית:
+   "מסקנתנו היא שהבקשה אינה עומדת בתנאים שקבעה הוועדה המקומית עצמה, 
+    ולפיכך אישור הבקשה אינו יכול לעמוד."
+   
+6. פירוט הפגם — בנייה מצטברת של ראיות:
+   א. הצגת הפגם הראשי (תכנית הצל תיאורטית)
+   ב. **הודאת הצד הנגדי בדיון** (נשק עיקרי)
+   ג. ראיה ויזואלית/קונקרטית (בתים 5, 7, 11)
+   ד. תמיכה ממהנדס/מומחה הוועדה (התנגד מלכתחילה)
+   
+7. חיזוק תיאורטי קצר:
+   "ודוק, בחינת הקלה מהוראה בנספח בינוי מחייב דורשת בחינה מעמיקה..."
+   "ברי כי הכוונה לתכנית הממחישה ומבטיחה כי..."
+   
+8. מסקנת ביניים:
+   "מסקנת ביניים הינה כי הבקשה לא עמדה בתנאים שהוועדה המקומית עצמה קבעה."
+   
+9. השמטה רחבה של טענות נוספות:
+   "נוכח מסקנתנו, הרי שאין מקום לדון לגופן בטענות הנוספות שהועלו, 
+    אך למען הסדר הטוב נציין אותם בקצרה."
+   - לטענה אחת או שתיים: פסקה קצרה, "מקדים את זמנו"
+   - ליתר: "לא מצאנו מקום להידרש אליהן"
+
+10. סוף דבר:
+    "לאור כל האמור לעיל, הערר מתקבל, החלטת הוועדה המקומית מיום X 
+     לאשר את הבקשה במתכונתה הנוכחית מתבטלת."
+    [אופציונלי: 1-2 פסקאות שמסכמות את הפגם המכריע]
+    "ניתנה פה אחד היום, X."
+```
+
+### 2.2 מאפיינים ייחודיים
+
+#### **א. נשק "הודאת הצד הנגדי" (admission against interest)**
+דפנה מעניקה משקל מכריע להודאה של נציג הוועדה המקומית עצמה (הצד שתומך באישור) שתכנית הצל אינה ישימה. זה איננו טיעון משפטי-פורמלי — זה **שכנוע אנליטי**: הצד שמתנגד לערר חושף בעצמו את הפגם בהחלטה.
+
+ביטויים מאפיינים:
+- "ונוסיף, **נציגת הרישוי**, גב' רחל ברזילאי, שנכחה בדיון בפנינו, **אישרה ממצא זה ואמרה**: ..."
+- "הנה כי כן, **גם הגורם המקצועי של הוועדה המקומית עצמה הכיר בכך** ש..."
+- "**הדברים מתחדדים שעה שנזכיר** כי גם מהנדס הוועדה... **התנגד לבקשה עוד בשלב הראשון**."
+
+#### **ב. ביטול במקום החזרה**
+פורמט הסיום מצומצם וחד: *"החלטת הוועדה המקומית... מתבטלת"*. בלי דרישות, בלי תנאים, בלי "תיבחן בשנית". זה ייחודי לתבנית A — **לא** ניתן ליישום.
+
+#### **ג. השמטה רחבה**
+דפנה מקדישה דיון רק לפגם המכריע. **לכל יתר הטענות**: *"לא מצאנו מקום להידרש אליהן"*. זה עומד בניגוד מובהק לקבלה חלקית או דחייה מורכבת, שם **כל טענה משמעותית מקבלת פסקה**.
+
+זה לא מקרי. ההיגיון: בתבנית A, הראיה הניצחת לבדה מספיקה. הוספת דיונים נוספים תחליש את הטיעון ("אם הסוגיה כל כך פשוטה, למה הם דנים בעוד 5 דברים?").
+
+#### **ד. פסיקה כמעט נטולת ציטוטים**
+ב-1033 כמעט אין ציטוטי פסיקה. הסוגיה איננה דורשת — היא **אכיפה תנאית**, לא פרשנות תקדימים.
+
+### 2.3 ביטויים מאפיינים — תבנית A
+
+| ביטוי | תפקיד | דוגמה מ-1033 |
+|--------|--------|----------------|
+| **ונפרט;** | מעבר מהפתיחה לדיון | "מצאנו כי דין הערר להתקבל. ונפרט;" |
+| **אין בטענה זו ממש** | דחיית טענת סף קצרה | (טענת ייפוי כוח) |
+| **אף טענה זו דינה דחייה** | דחיית טענת סף שנייה | (השתק ומעשה בית דין) |
+| **כאמור** | ציטוט חוזר של עובדה | "כאמור, התכנית קובעת..." |
+| **מסקנתנו היא** | קביעה ראשית | "מסקנתנו היא שהבקשה אינה עומדת..." |
+| **ונוסיף** | חיזוק עם ראיה נוספת | "ונוסיף, נציגת הרישוי..." |
+| **הנה כי כן** | מעבר לחיזוק | "הנה כי כן, גם הגורם המקצועי..." |
+| **הדברים מתחדדים שעה שנזכיר** | חיזוק נוסף | "הדברים מתחדדים שעה שנזכיר כי גם מהנדס הוועדה..." |
+| **נחדד כי** | חידוד של עיקרון | "נחדד כי בהתאם להוראות התכנית..." |
+| **ברי כי** | קביעה משכנעת | "ברי כי הכוונה לתכנית הממחישה..." |
+| **ודוק** | רידוקציו אד אבסורדום | "ודוק, בחינת הקלה מהוראה בנספח בינוי מחייב דורשת..." |
+| **די בכך בכדי לקבל את הערר** | מסקנה | "די בכך בכדי לקבל את הערר ולבטל את החלטת המשיבה" |
+| **למען הסדר הטוב נציין אותם בקצרה** | פתיחת השמטה רחבה | (לפני ההתייחסות הקצרה ליתר הטענות) |
+| **לא מצאנו מקום להידרש אליהן** | השמטה סופית | (לטענות עומס תשתיתי, ירידת ערך וכו') |
+
+---
+
+## 3. תבנית B — קבלה+החזרה לוועדה לדיון מחדש
+
+**המקרה הקלאסי**: הוועדה המקומית **דחתה** בקשה להיתר על הסף בשל "היעדר תימוכין קנייניים" — מבלי לדון בה תכנונית. דפנה אומרת: "תרשה ההלכה — קיימת היתכנות קניינית, ועל הוועדה לדון תכנונית."
+
+**דוגמאות מובהקות**: 1043+1054, 1071+1077 (תיקי הראל). כולם 1xxx, כולם נסבו על אותה סוגיה משפטית — **תימוכין קנייניים**.
+
+### 3.1 ארכיטקטורה
+
+```
+1. פתיחה — מוד C (ניסוח סוגיה):
+   "טענות הצדדים בעררים נסובו סביב השאלה האם מבקשי ההיתר הציגו 
+    תימוכין קניינים מספקים על מנת שהוועדה המקומית תידרש לדון בבקשות."
+   או:
+   "השאלה שעמדה בפנינו היא האם בנסיבות הערר אכן ערכה הוועדה המקומית 
+    איזון ראוי..."
+
+2. הצגת ההלכה (פסיקה רחבה):
+   - בג"ץ 1578/90 אייזן (תקדים יסוד)
+   - עע"מ 4185/23 רוזן (עדכני)
+   - עת"מ 70277-05-18 טליאט ("עניין טליאט")
+   - דנ"מ 668/11 בני אליעזר
+   - עע"מ 4440/21 יהלומית פרץ
+   - ערר 143/12 רענן סיון (הגדרת "תימוכין קניינים")
+   - עע"מ 3975/22 ב. קרן-נכסים (2025, חדש)
+   - ערר 1009-01-24 עדי שיף (ועדה אחרת — בכבוד)
+   - ערר 1180-12-18 לאמיה מסארווה
+   
+3. ציטוטים מלאים — לפעמים פסקאות שלמות:
+   "כפי שטענו רשויות התכנון, וכפי שקבע בית משפט קמא, הלכה פסוקה היא 
+    כי רשויות התכנון רשאיות 'להחליט לפי שיקול דעתן... שלא יתקיים דיון 
+    בבקשה כל עוד לא ניתן פסק דין מטעם בית משפט מוסמך הקובע שלמבקש 
+    זכות קניינית.'"
+   
+4. סינתזה של ההלכה:
+   "ההלכה שגובשה היא, כי מוסדות התכנון רשאים לבדוק 'היתכנות קניינית' 
+    ליישום הבניה לפי ההיתר... אך מצד שני אל להם להתעלם מהמציאות..."
+   
+5. מעבר ליישום: "ומכאן לעניין שלפנינו, נקדים ונציין כי קיבלנו את 
+    עמדת העוררים, ולפיה על הוועדה המקומית לדון בבקשות להיתר."
+   
+6. הצגת מסמכי המבקש בהרחבה:
+   - נסחי טאבו, תקנונים, תשריטי בית משותף
+   - היתרים קודמים בבניין (אינדיקציה לדפוס)
+   - חישוב שיעור החתימות (75%, 11/12, וכו')
+   
+7. ניתוח מסודר של ההיתכנות:
+   - ראשית, [טענה 1]
+   - שנית, [טענה 2]  
+   - שלישית, [טענה 3]
+   או כפרגרפים נושאיים בלי מספור
+   
+8. דחיית טענות הצד הנגדי (מתנגדים):
+   - "לא מצאנו לקבל את עמדת המשיבה 3..."
+   - "אכן... אולם" כשרלוונטי
+   - הזכרת חוסר תום לב/עבירות בנייה אם יש (תקדים: ערר 1173/23 רחמים כהן)
+   
+9. מסקנה:
+   "בנסיבות אלה, אנו סבורים כי קיימת 'היתכנות קניינית' מספקת 
+    לאשר את הבקשה להיתר... החלטת הוועדה המקומית לדחות את הבקשות 
+    על הסף... אינה עולה בקנה אחד עם ההלכה הפסוקה."
+
+10. סוף דבר:
+    "לאור כל האמור לעיל העררים מתקבלים במובן זה שהבקשות להיתרים 
+     יקבעו לדיון בוועדה המקומית אשר תבחן את כלל ההיבטים הנדרשים 
+     לבחינה תכנונית."
+    "ככל שיאושרו הבקשות להיתרים נשוא העררים תתווסף הבהרה בהחלטות 
+     ובהיתרי הבנייה לפיה מדובר בהחלטה תכנונית, שאין בה כדי לגרוע 
+     מיתר הוראות הדין, לרבות חוק המקרקעין."
+    [הוצאות: לרוב "כל צד יישא בהוצאותיו" או חיוב הוועדה]
+```
+
+### 3.2 מאפיינים ייחודיים
+
+#### **א. כותרת משנה אופציונלית**
+ב-1043+1054 הופיעה כותרת משנה: *"שאלת התימוכין הקנייניים כתנאי לדיון בבקשות"* — כי זה היה שמו של הסוגיה היחידה. כותרת משנה כזו מותרת **כאשר** הסוגיה ממוקדת ומובחנת.
+
+#### **ב. ציטוט עצמי בין תיקים מאוחדים**
+ב-1071+1077, דפנה ציטטה במפורש את 1043+1054 שהיא עצמה כתבה — **"כפי שקבענו בהחלטתנו בערר 1043/24"**. רואה בהן **מערכת מתמשכת**.
+
+#### **ג. סוף דבר אחיד עם הוראת הבהרה**
+**שלושת התיקים** (1043+1054, 1071+1077, 1071-25) מסיימים בנוסחה כמעט זהה:
+> "ככל שיאושרו הבקשות... תתווסף הבהרה בהחלטות ובהיתרי הבנייה לפיה מדובר בהחלטה תכנונית, שאין בה כדי לגרוע מיתר הוראות הדין, לרבות חוק המקרקעין."
+
+זו **הוראה אופרטיבית מובנית** — מגנה את ההחלטה התכנונית מטענה עתידית של הכרעה קניינית.
+
+#### **ד. הוצאות מותאמות לנסיבות**
+- **1043+1054**: "נוכח הנסיבות האישיות שפורטו בפנינו מצאנו שלא לחייב בהוצאות"
+- **1071-25** (בעקבות סירוב הוועדה לציית להחלטה הקודמת): חיוב הוועדה המקומית בהוצאות העוררים
+- כשהמתנגד הוא בעצמו עברייני בנייה: ציטוט תקדים רחמים כהן ושקילה לחיובו
+
+### 3.3 ביטויים מאפיינים — תבנית B
+
+| ביטוי | תפקיד |
+|--------|--------|
+| **טענות הצדדים נסובו סביב השאלה** | מסגור הסוגיה |
+| **ההלכה קובעת כי** | פתיחת ניתוח דוקטרינלי |
+| **הפסיקה הנוגעת ל-X היא ענפה, והקושי בניתוחה עולה שוב ושוב** | הכרה במורכבות |
+| **כפי שטענו רשויות התכנון, וכפי שקבע בית משפט קמא** | ציטוט נרחב מתקדים |
+| **ומכאן לעניין שלפנינו, נקדים ונציין כי קיבלנו את עמדת העוררים** | מעבר ליישום |
+| **בנסיבות אלה, אנו סבורים כי קיימת 'היתכנות קניינית' מספקת** | מסקנה |
+| **נחזור ונדגיש** | חזרה מודעת לעיקרון |
+| **כפי שקבענו בהחלטתנו ב<תיק>** | ציטוט עצמי |
+| **תתווסף הבהרה בהחלטות ובהיתרי הבנייה** | הוראה אופרטיבית |
+
+---
+
+## 4. תבנית C — קבלה+דרישת תיקונים בבקשה
+
+**המקרה הקלאסי**: הוועדה המקומית דחתה את הבקשה לאחר דיון תכנוני, על שלושה אדנים: סטייה ניכרת בגובה, היעדר פתרון חניה, היעדר תימוכין קנייניים. דפנה דנה בכל אחד **לחוד**, מבטלת את כולם — חלקם על-ידי תיקון של המבקש (הסרת עליית גג), חלקם על-ידי קבלת עמדת המבקש (חניה), חלקם על-ידי הלכה (תימוכין קנייניים).
+
+**דוגמה מובהקת**: 1113-25 (אייל מבורך לוי).
+
+### 4.1 ארכיטקטורה
+
+```
+1. פתיחה — מוד A מותנה (בוטם-ליין עם תיקונים):
+   "לאחר שמיעת טענות הצדדים ועיון במסמכים שהוגשו, הגענו לכלל מסקנה 
+    כי דין הערר להתקבל **בכפוף למספר תיקונים בבקשה להיתר** כפי 
+    שיורחב להלן (הסרת עליית הגג מהבקשה להיתר וכפועל יוצא תיקון 
+    השטחים וכן הטמעת תכנית צל בבקשה להיתר)."
+
+2. **פסקה ייחודית של "הוועדה פעלה נכון בקיום הדיון"**:
+   "בפתח הדברים ראוי לציין, כי במקרה שלפנינו הוועדה המקומית לא 
+    משכה ידה מן הבקשה על הסף ובמילים אחרות הוועדה המקומית דנה 
+    בבקשה להיתר... אנו סבורים כי הוועדה המקומית פעלה נכונה כשבחרה 
+    לקיים את הדיון, וטוב עשתה שלא חסמה את דרכם של העוררים."
+   
+3. הצגת ההלכה — תימוכין קנייניים (כמו תבנית B):
+   ציטוטים רחבים מאייזן, רוזן, טליאט, יהלומית פרץ
+   
+4. הפניה לתקדים אישי כדוקטרינה מבוססת:
+   "נפנה להחלטה בה פירטנו את הפסיקה הרלוונטית ואת עמדתנו, ונשוב 
+    על עיקריה, ראו ערר 1043/24 אביב טל-לי מטילד..."
+   
+5. ניתוח כל אדן של הוועדה — בנפרד:
+   
+   5א. תימוכין קנייניים (שלא הוצגו מספקים):
+       - הצגת המסמכים שהוצגו
+       - ניתוח לפי תקנון הבית המשותף
+       - "אנו סבורים כי קיימת 'היתכנות קניינית' מספקת"
+   
+   5ב. גובה (סטייה ניכרת):
+       - הצגת עמדת הוועדה
+       - **"דא עקא, במהלך הדיון בפנינו הצהירו העוררים כי הם מוכנים 
+          לוותר על עליית הגג..."** (תיקון מצד המבקש)
+       - "מתייתר הצורך בחישוב שטח הגג"
+   
+   5ג. חניה (פתרון לא מספק):
+       - הצגת עמדת הוועדה
+       - "לא נוכל לקבל את עמדת הוועדה המקומית בעניין זה"
+       - **"ראשית, לא ניתן להתעלם מאישור מהנדסת המועצה..."**
+       - **"שנית, כאמור, החניה הינה בהתאם לנספחי התכנית..."**
+       - **"שלישית, באשר למקומות החניה בתחום המגרש..."**
+   
+   5ד. (אם רלוונטי) טענות מתנגדים:
+       - חששות יציבות מבנה — נדחה (יבחן בהליך הרישוי)
+       - מטרדים, ירידת ערך — נדחה (לא נתמך בחוות דעת)
+   
+6. סיכום ביניים מודרג:
+   "סיכומם של דברים, החלטת הוועדה המקומית לדחות את הבקשה להיתר 
+    נשענה על שלושה אדנים מרכזיים: [רשימה]. 
+    באשר לסוגיית X — ... 
+    במישור התכנוני, הוסרו המכשולים העיקריים..."
+   
+7. סוף דבר:
+   "לאור כל האמור לעיל הערר מתקבל **בכפוף לתיקונים שפורטו לעיל 
+    בבקשה להיתר**."
+   [הוראת הבהרה כמו בתבנית B]
+   [הוצאות]
+```
+
+### 4.2 מאפיינים ייחודיים
+
+#### **א. הכרה דו-צדדית בוועדה המקומית**
+דפנה מקדישה פסקה לבטוי שהוועדה **פעלה נכון** כשבחרה לקיים דיון תכנוני (ולא דחתה על הסף). זה איזון פסיכולוגי: לפני שהיא הופכת את ההחלטה, היא מכבדת את התהליך. **רק אז** היא עוברת לפגמים בהחלטה הסופית.
+
+זה ייחודי לתבנית C — **אינו** קיים בתבנית A (1033) או תבנית B (1043+1054).
+
+#### **ב. תיקונים מצד המבקש כחלק מההיגיון**
+דפנה לא רק מבטלת את הוועדה. היא **מקבלת תיקונים מהמבקש בדיון** ("דא עקא, הצהירו העוררים כי הם מוכנים לוותר על עליית הגג") ועושה אותם חלק מההכרעה. הקבלה היא **התאמה משולשת**: המבקש מתקן, הוועדה טעתה, הערר מתקבל.
+
+#### **ג. ארגון מנומק "ראשית/שנית/שלישית"**
+זה אחד המקרים היחידים בקורפוס שבהם דפנה משתמשת במילות מנייה תוך כדי דיון רציף (ללא רשימה ממוספרת בולטת). זה **מותר** רק כאשר הוועדה הציגה רשימת ראשי טיעון ממוספרת והדיון מסודר לפיהם.
+
+#### **ד. סיכום מנומק בסיום**
+לפני "סוף דבר", פסקת **"סיכומם של דברים"** מסכמת מנומקת — ביחיד, לא מנייני.
+
+### 4.3 ביטויים מאפיינים — תבנית C
+
+| ביטוי | תפקיד |
+|--------|--------|
+| **בכפוף למספר תיקונים בבקשה להיתר** | פתיחה מותנית |
+| **בפתח הדברים ראוי לציין, כי במקרה שלפנינו** | פסקת הכרה בוועדה |
+| **אנו סבורים כי הוועדה המקומית פעלה נכונה** | הכבוד לתהליך |
+| **על כן, משעה ש... נדון גם אנחנו** | מעבר לדיון |
+| **דא עקא, במהלך הדיון בפנינו הצהירו העוררים** | תיקון של המבקש |
+| **מתייתר הצורך** | תוצאה של תיקון |
+| **לא נוכל לקבל את עמדת הוועדה המקומית בעניין זה** | היפוך |
+| **ראשית/שנית/שלישית** | ארגון נימוקים בתוך פסקה |
+| **סיכומם של דברים** | מסקנה ביניים מסודרת |
+| **בכפוף לתיקונים שפורטו לעיל** | סיום מותנה |
+
+---
+
+## 5. תבנית D — קבלה+ביטול דרישת תשלום (8xxx מהותית)
+
+**המקרה הקלאסי**: תיק היטל השבחה / פטור / מימוש שמעלה **שאלה משפטית מהותית** הדורשת ניתוח דוקטרינלי. דפנה מבטלת את דרישת התשלום על-ידי קביעה משפטית עקרונית.
+
+**דוגמאות מובהקות**:
+- **נאמנות** — האם העברה לחברת נאמנות עצמית = "מימוש זכויות"?
+- **גמר בניה** — מהו "גמר בניה" לצורך פטור סעיף 19(ג)?
+- **טור סיני** — האם חל סעיף 21 (הקצאה מחדש)?
+
+### 5.1 ארכיטקטורה
+
+```
+1. פתיחה — מוד C (ניסוח סוגיה משפטית מהותית):
+   "הסוגייה שנדונה בערר שלפנינו מעמידה במבחן את נקודת המפגש בין 
+    דיני X לבין דיני Y הנוגעים למקרה מושא הערר. השאלה המרכזית 
+    מתמקדת בסוגיה האם <שאלה ספציפית>."
+   או:
+   "השאלה שעומדת במרכז הערר האם בנסיבות המקרה עמדו העוררים 
+    בהתחייבותם במסגרת סעיף הפטור..."
+   
+2. ציטוט מלא של הוראת החוק הרלוונטית:
+   "להלן לשון סעיף 19(ג)(1) ו(2) לתוספת השלישית לחוק..."
+   - ציטוט מלא של סעיף ותתי-סעיפים
+   - ציטוט מדברי ההסבר לתיקון (אם רלוונטי)
+   
+3. הצגת מסגרת תיאורטית (לפעמים תחת כותרת משנה):
+   ב-נאמנות: **כותרת "מהותו של מוסד הנאמנות"**
+   - ציטוטים מספרות אקדמית (כרם, ספר חוק הנאמנות)
+   - ציטוטי פסיקה (ע"א 5717/95 וייסנר; דנ"א 1740/91 בנק)
+   - הגדרות יסוד מהחוק
+   
+4. ניתוח דוקטרינלי עמוק:
+   - אופי הזכות
+   - תכלית החוק
+   - פסיקה משלימה
+   
+5. יישום הדוקטרינה על המקרה:
+   - הצגת המסמכים והעובדות הספציפיות
+   - יישום מילולי של ההלכה
+   
+6. דחיית פרשנות הוועדה:
+   "לא מצאנו לקבל את עמדת הוועדה המקומית..."
+   "פרשנות זו אינה מתיישבת עם תכלית החוק..."
+   
+7. כותרת "סיכום":
+   "לאור כל האמור לעיל, במקום בו הוצגו בפנינו מסמכים המלמדים על X..."
+   "אין אנו מקבלים את טענת הוועדה המקומית כי..."
+   
+8. סוף דבר:
+   "על כן, הערר מתקבל, מאחר ודרישת התשלום בטלה..."
+   "ככל שהעורר שילם את היטל ההשבחה יושב לו הסכום ששולם בצירוף 
+    הפרשי הצמדה וריבית..."
+   [הוצאות: בתיקי 8xxx של מהות משפטית — לעיתים על הוועדה המקומית]
+```
+
+### 5.2 מאפיינים ייחודיים
+
+#### **א. כותרות משנה — מותרות וחיוניות**
+תיקי 8xxx מהותיים הם **המקרה הברור** לכותרות משנה (גם לפי `daphna-architecture-by-outcome.md` סעיף 4). דוגמאות:
+- נאמנות: "מהותו של מוסד הנאמנות" + "סיכום"
+- גמר בניה: ארגון לפי שלבי הניתוח (סעיף הפטור → תכלית → "גמר בניה" → יישום)
+
+#### **ב. ספרות אקדמית**
+זו **הקטגוריה היחידה** בקורפוס של דפנה שבה היא מצטטת **ספרות אקדמית** (פרופ' שלמה כרם, נמדר ב-עלות עודפת בחניה). זה מובחן מתבניות אחרות שבהן רק פסיקה.
+
+#### **ג. ציטוט הוראת חוק במלואה**
+תיקי 8xxx מהותיים מתחילים תמיד בציטוט מילולי של הוראת החוק הנדונה — לפעמים גם דברי ההסבר. זה **חובה** בתבנית זו (כי כל הדיון הוא פרשנות החוק).
+
+#### **ד. סיכום ב"כותרת" — לא בפסקה**
+כותרת **"סיכום"** מובחנת — לא רק פסקת סיום אלא **כותרת מובחנת** המסמנת את החלק האופרטיבי.
+
+#### **ה. הוצאות לעיתים על הוועדה**
+ב-נאמנות: *"הוועדה המקומית תישא בהוצאות ההליך בסך של 7,000 ₪..."*. זה רגיל בתבנית D כשהוועדה התבצרה בעמדה משפטית שגויה לאחר ניסיונות לפתרון.
+
+### 5.3 ביטויים מאפיינים — תבנית D
+
+| ביטוי | תפקיד |
+|--------|--------|
+| **הסוגייה שנדונה בערר שלפנינו מעמידה במבחן את נקודת המפגש בין X לבין Y** | פתיחה משפטית-תיאורטית |
+| **השאלה המרכזית מתמקדת בסוגיה האם** | ניסוח השאלה |
+| **בטרם נבחן... עלינו לעמוד תחילה על מהותו של** | מעבר למסגרת תיאורטית |
+| **המלומד <שם> בספרו על <נושא> מתאר את** | ציטוט אקדמי |
+| **כדבריו: '...'** | ציטוט מילולי מספרות |
+| **פרשנות תכליתית המביאה בחשבון את המהות הכלכלית** | מתודולוגיה פרשנית |
+| **לאור כל האמור לעיל, במקום בו** | מסקנה מסכמת |
+| **לא השתכנענו כי** | קביעת ממצא משפטי |
+| **דרישת התשלום בטלה** | פעולה אופרטיבית |
+
+---
+
+## 6. תבנית E — קבלה+השבת שומה לשמאי
+
+**המקרה הקלאסי**: ערר על שומה מכרעת. דפנה לא דוחה את הערר ולא מקבלת אותו במלואו — היא **מחזירה לשמאי המכריע** עם הוראות תיקון ספציפיות.
+
+**דוגמה מובהקת**: ורדיה (8xxx, 1,950 מילים).
+
+### 6.1 ארכיטקטורה
+
+```
+1. פתיחה — מוד B מותאם:
+   "נקדים ונציין כי לאחר שעיינו במסמכים שהונחו בפנינו ולאחר 
+    ששמענו את טענות הצדדים..."
+
+2. פסקת "התערבות במשורה" — הציטוט הקלאסי:
+   "בטרם נתייחס לטענות הצדדים נזכיר כי כידוע הלכה היא כי 
+    התערבות ועדת הערר בשיקול דעתו המקצועי של השמאי המכריע 
+    תיעשה במשורה..."
+   [ציטוט בר"מ 3644/13 גלר במלואו]
+   
+3. ניתוח כל טענה של העורר:
+   - הצגת הטענה
+   - השוואה לפסיקת השמאי
+   - הכרעה (מקבל / דוחה / מחזיר לבחינה)
+   
+4. סוף דבר — רשימת הוראות מדויקות:
+   "לאור כל האמור לעיל אנו משיבים את השומה המכרעת לתיקון 
+    ובחינה מחודשת של השמאית המכריעה כלהלן:
+    - לאור הסכמת הצדדים יש לתקן שווי מ"ר מבונה ל-X ₪
+    - ייבחן השווי לדיור מוגן באופן מחודש בהתחשב ב-Y
+    - בבחינת השווי, תיבדק גם טענת העוררת ל-Z
+    - השמאית המכריעה תקיים דיון נוסף לשמיעת הצדדים..."
+   "על החלטתה המתוקנת של השמאית המכריעה עומדת זכות ערר כדין."
+```
+
+### 6.2 מאפיינים ייחודיים
+
+#### **א. הוראות מילוליות לשמאי**
+בתבנית E, פורמט הסיום הוא **רשימה ממוספרת של הוראות לשמאי** — שונה מכל תבנית אחרת. הסיום לא מבטל ולא מחזיר לוועדה — הוא **מנחה את השמאי המכריע**.
+
+#### **ב. אורך מצומצם**
+תיקי השבת שומה הם **מהקצרים בקורפוס** (ורדיה: 1,950 מילים). הסיבה: אין צורך לבסס דוקטרינה — רק להצביע על הליקויים.
+
+#### **ג. ציטוט בר"מ 3644/13 חובה**
+כל תיק 8xxx של שומה כולל את ציטוט בר"מ 3644/13 (משרד התחבורה נ' גלר). זו **חובה דוקטרינלית**.
+
+#### **ד. שמירת זכות ערר**
+תמיד: *"על החלטתה המתוקנת של השמאית המכריעה עומדת זכות ערר כדין"*. זה הגנה מפני סגירת מעגל.
+
+---
+
+## 7. השוואה דיפרנציאלית — קבועים בכל תבניות הקבלה
+
+מעבר להבדלים בין התבניות, יש **מספר קבועים** שמופיעים בכל תיקי הקבלה של דפנה:
+
+### 7.1 הימנעות ממסגור פילוסופי
+בכל 5 התבניות (1033, 1043+1054, 1071+1077, 1071-25, 1113, נאמנות, גמר בניה, טור סיני, ורדיה), **אין** משפט פילוסופי דמוי 1130 על "מתחים מובנים". הסיבה: בקבלה, יש **קביעה ברורה** שהוועדה טעתה — אין צורך לסבך עם פילוסופיה.
+
+### 7.2 פתיחה ממוקדת בשאלה
+תיקי קבלה תמיד פותחים באחד משלושה אופנים:
+- **בוטם-ליין** ("דין הערר להתקבל") — תבניות A, C
+- **ניסוח שאלה** ("הסוגייה... מעמידה במבחן את נקודת המפגש בין") — תבניות B, D
+- **מתודולוגית** ("הצדדים הרבו בטענות... התבהרה תמונה") — וריאציה
+
+**אף פעם** במוד פילוסופי-ערכי כמו 1130. זה דפוס חזק.
+
+### 7.3 ניסוח התוצאה
+תבניות שונות, וניסוח שונה של "מתקבל":
+
+| תבנית | ניסוח הסיום |
+|-------|--------------|
+| A | "החלטת הוועדה המקומית מתבטלת" |
+| B | "העררים מתקבלים במובן זה שהבקשות יקבעו לדיון בוועדה המקומית" |
+| C | "הערר מתקבל בכפוף לתיקונים שפורטו לעיל" |
+| D | "הערר מתקבל, דרישת התשלום בטלה" |
+| E | "אנו משיבים את השומה המכרעת לתיקון ובחינה מחודשת" |
+
+### 7.4 הוצאות — מטריצה לקבלה
+
+| נסיבות | הוצאות | ניסוח |
+|---------|--------|--------|
+| קבלה רגילה — נסיבות אישיות | אין | "נוכח הנסיבות האישיות שפורטו... מצאנו שלא לחייב בהוצאות" |
+| קבלה — סוגיה משפטית מורכבת | אין | "הסוגייה שעמדה במוקד הערר הינה סוגיה משפטית מורכבת... איננו מוצאים מקום לחייב" |
+| קבלה — הוועדה התבצרה אחרי ניסיונות פתרון | על הוועדה | "הוועדה המקומית תישא בהוצאות ההליך בסך של X ₪" |
+| קבלה — סירוב הוועדה לציית להחלטה קודמת | על הוועדה | "אנו מחייבים את הוועדה המקומית בהוצאות העוררים בסך X ₪ לכל עורר" |
+
+**אין** תיק קבלה בקורפוס שבו העוררים מחויבים בהוצאות (סביר — הם זכו).
+
+### 7.5 השמטה רחבה כשהיא אפשרית (תבנית A בלבד)
+תבניות B, C, D, E **לא** מבצעות השמטה רחבה. הן דנות בכל שיקול. **רק תבנית A** מאפשרת *"לא מצאנו מקום להידרש"*. הסיבה: בתבנית A, הפגם **פנימי וברור** — אין צורך לדון בעוד.
+
+---
+
+## 8. עץ ההחלטה לסוכן
+
+לפני כתיבת בלוק י של תיק שצפוי להתקבל:
+
+```
+1. מהי סיבת הקבלה?
+   ├─ הוועדה קבעה תנאי, לא וידאה שהוא מתקיים → תבנית A
+   ├─ הוועדה דחתה ללא דיון תכנוני (תימוכין קנייניים) → תבנית B
+   ├─ הוועדה דנה אבל הליקויים ניתנים לתיקון → תבנית C
+   ├─ סוגיה משפטית מהותית בחוק (פטור, מימוש, פטור מסיווג) → תבנית D
+   └─ פגם בעבודת השמאי המכריע → תבנית E
+
+2. כמה עומק נדרש?
+   ├─ פגם פנימי ברור + ראיה ניצחת (הודאה, תיעוד) → קצר (1,500-2,000)
+   ├─ פסיקה מבוססת + יישום על נסיבות → בינוני (3,000-4,500)
+   ├─ סוגיה משפטית טהורה הדורשת פיתוח → ארוך (5,000+)
+   └─ פגם נקודתי בשומה → קצר (1,500-2,500)
+
+3. מהו פורמט הסיום?
+   ├─ A: "החלטת הוועדה מתבטלת"
+   ├─ B: "הבקשה תיקבע לדיון בוועדה" + הוראת הבהרה
+   ├─ C: "מתקבל בכפוף לתיקונים"
+   ├─ D: "דרישת התשלום בטלה" + השבת תשלום
+   └─ E: "השומה תושב לתיקון" + רשימת הוראות
+
+4. הוצאות?
+   ├─ נסיבות אישיות / סוגיה מורכבת → "כל צד יישא בהוצאותיו"
+   ├─ הוועדה התבצרה / סירבה לציית → על הוועדה
+   └─ בכל מקרה אחר → "כל צד יישא בהוצאותיו"
+```
+
+---
+
+## 9. שתי טכניקות עיקריות שראויות להזרקה
+
+### 9.1 "הודאת הצד הנגדי" (תבנית A)
+
+עיקרון: **הראיה החזקה ביותר היא הודאה של הצד שתומך בעמדה הפוכה**. כשנציג הוועדה המקומית, מהנדס ועדה, או עד-מקצועי של הצד הנגדי **מודה בדיון** בעובדה שמערערת את העמדה — זה **הנשק העיקרי**.
+
+ביישום: לפני כתיבת תבנית A, הסוכן צריך לחפש בפרוטוקול הדיון **התבטאויות** של נציגי הוועדה / מהנדס / יועץ-תנועה / שמאי הוועדה שתומכות בעמדת העוררים. אם מצא — להפעיל את הביטוי "הנה כי כן, גם הגורם המקצועי של הוועדה המקומית עצמה הכיר בכך ש...".
+
+### 9.2 "אכיפת התנאים שהוועדה עצמה קבעה" (תבנית A)
+
+עיקרון: דפנה לא מתערבת בשיקול דעת תכנוני (זה כללי דחייה למומחים). אבל היא **כן מתערבת באכיפה של תנאים שהוועדה עצמה הציבה**. זה לא "מה התכנון הראוי" אלא "האם הוועדה עצמה עמדה בדבריה".
+
+ביישום: הסוכן צריך לזהות בכל תיק האם הוועדה המקומית הציבה **תנאי מפורש** בדיון או החלטה קודמת ("יוגש תכנית X", "תוצג תכנית Y"). אם כן — האם התנאי **באמת התקיים**? אם לא — זה הציר של הטיעון.
+
+---
+
+## 10. הוראות אופרטיביות לסוכן
+
+### 10.1 שאלה ראשונה לפני כתיבה
+**"מה הסיבה לקבלה?"** — לא "מה התוצאה?". התוצאה זהה (קבלה), אבל ה**סיבה** קובעת את התבנית.
+
+### 10.2 לאחר זיהוי התבנית
+1. קרא את הסעיף הרלוונטי במסמך זה (2/3/4/5/6)
+2. אסוף את הביטויים מהטבלה
+3. בדוק את פורמט הסיום
+4. וודא שהאורך תואם לטבלה בסעיף 1
+
+### 10.3 לעולם לא לבלבל בין התבניות
+הסוכן **לא** יכול לכתוב תיק בסגנון תבנית A (קצר, השמטה רחבה) כשהסיבה היא תבנית B (תימוכין קנייניים). זה ייצור החלטה שטחית. ההיפך: הוא לא יכול לכתוב תיק בסגנון תבנית D (אקדמי-משפטי) כשהסיבה היא תבנית E (שומה).
+
+### 10.4 פסיקה
+- תבנית A: כמעט אין פסיקה
+- תבנית B: פסיקת תימוכין קנייניים (אייזן, רוזן, טליאט, יהלומית, עניין סיון, בני אליעזר, ב.קרן-נכסים)
+- תבנית C: פסיקת תימוכין + תקדים אישי (1043/24)
+- תבנית D: פסיקה דוקטרינלית + ספרות אקדמית
+- תבנית E: בר"מ 3644/13 גלר חובה
+
+### 10.5 תקדמים אישיים של דפנה לקבלה
+מ-`daphna-precedent-network.md` ובהרחבה:
+- **1043/24** — תקדים תימוכין קנייניים (תבנית B/C)
+- **1071/25** — תקדים תימוכין קנייניים + סירוב הוועדה לציית (תבנית B)
+- **1130/25** — לא תקדים קבלה אלא קבלה חלקית, אבל הציטוטים שלה משמשים בתבניות אחרות
+
+### 10.6 בדיקה אחרי כתיבה
+- [ ] התבנית הנבחרת מתאימה לסיבת הקבלה
+- [ ] האורך תואם לטווח של התבנית
+- [ ] פורמט הסיום נכון
+- [ ] אין מסגור פילוסופי (אלא אם זה קבלה חלקית — אז זה לא תבנית קבלה)
+- [ ] הפסיקה מתאימה לתבנית
+- [ ] אם תבנית A: יש "הודאת צד נגדי" ו"השמטה רחבה"
+- [ ] אם תבנית B: יש הוראת הבהרה ("שאין בה כדי לגרוע מיתר הוראות הדין")
+- [ ] אם תבנית C: יש פסקת הכרה בוועדה ("פעלה נכון בקיום הדיון")
+- [ ] אם תבנית D: יש ציטוט הוראת החוק במלואה
+- [ ] אם תבנית E: ציטוט בר"מ 3644/13 + רשימת הוראות לשמאי
+
+---
+
+## 11. פערים שנשארו לעתיד
+
+### 11.1 קורפוס מצומצם
+- **תבנית A**: תיק אחד בלבד (1033-25). דרושה אימות בתיקים נוספים שייכנסו לקורפוס.
+- **תבנית C**: תיק אחד (1113-25). אותה הערה.
+- **תבנית E**: תיק אחד (ורדיה).
+
+### 11.2 תיקים מורכבים
+- **1015-24 כוכבה תורן** (8,245 מילים, **דעת רוב**) — קבלה חלקית עם תנאים נוספים. לא נכלל כתבנית עצמאית כי הוא **דעת רוב** ולא פה אחד. דורש בחינה נפרדת.
+
+### 11.3 התפתחות הקאנון
+כשייכנסו תיקי קבלה נוספים, ייתכן שיתגלו תבניות נוספות (F, G, ...). יש לעדכן את המסמך הזה אחרי כל תיק קבלה משמעותי.
+
+---
+
+## 12. הערה לדפנה
+
+המסמך הזה הוא **ההצעה שלי** המבוססת על קריאת תיקי הקבלה הקיימים בקורפוס. דפנה מוזמנת:
+1. לסמן תבניות שלדעתה לא קיימות בפועל ("זו לא קטגוריה אצלי")
+2. להוסיף תבנית שחסרה
+3. לתקן ביטויים אופייניים שהובאו לא נכון
+
+**העיקרון**: זה לא ניסוח קבוע — זה תיעוד של מה שזיהיתי בכתיבה הקיימת.

docs/daphna-architecture-by-outcome.md

@@ -0,0 +1,381 @@
+# ארכיטקטורת בלוק י לפי סוג תוצאה
+
+מסמך זה ממפה **איך משתנה המבנה של בלוק י** לפי סוג ההכרעה. מבוסס על קריאה של 23 החלטות 1xxx + 10 החלטות 8xxx/9xxx.
+
+**העיקרון**: דפנה לא משתמשת באותה ארכיטקטורה לכל תיק. סוג התוצאה (דחייה / קבלה חלקית / קבלה / מאוחד) מכתיב את המבנה. הסוכן חייב לבחור בארכיטקטורה הנכונה **לפני** שהוא מתחיל לכתוב.
+
+---
+
+## 1. דחייה מוחלטת — תיקים פשוטים (קצר, 555-2,000 מילים)
+
+**דוגמה מובהקת**: עלות עודפת בחניה (8xxx, 555 מילים), 1188-23 (1xxx, 1,939)
+
+### ארכיטקטורה
+
+```
+1. פתיחה — מוד A (בוטם-ליין):
+   "לאחר ש<חומרים>, הגענו לכלל מסקנה כי דין הערר להידחות."
+   
+2. הצגת מסגרת דוקטרינלית קצרה:
+   "סוגיה זו היא סוגיה <שמאית/תכנונית> מובהקת, ובהתאם להלכה הפסוקה..."
+   ציטוט תקדם מנחה (בר"מ 3644/13 בתיקי שמאי).
+
+3. ניתוח קצר של המחלוקת:
+   - הצגת טענת הצד הדוחה
+   - הצגת הסבר הצד הזוכה
+   - השוואה עובדתית/מספרית
+   
+4. מסקנה:
+   "אנו סבורים כי קביעת <X> סבירה ומבוססת ולא נפלה בה טעות המצדיקה את התערבותנו"
+   
+5. סיום:
+   "לאור כל האמור הערר נדחה. <הצד המפסיד> ישא בהוצאות בסך X ₪"
+```
+
+### חוסרים בתיקי דחייה פשוטים
+- אין דפוס "אכן... אולם" אם אין טענה ראויה לאישור
+- אין טענות סף בנפרד
+- אין כותרות משנה
+- אין "למעלה מן הצורך"
+- אין מספור פסקאות
+
+---
+
+## 2. דחייה לאחר ניתוח מורכב — תיקים בינוניים (2,500-4,500 מילים)
+
+**דוגמה מובהקת**: 1024-25 (1,949), 1024-24 (4,469), 1062-24 (2,500), 1126-1141 (3,654), 1126-25 (3,660), 1128-25 (4,413), 1109-25 (3,598), 1067-25 (3,291), 1167-25 (2,779)
+
+### ארכיטקטורה
+
+```
+1. פתיחה — מוד B/C (תיעוד תהליכי / ניסוח סוגיה):
+   "נקדים ונציין כי לאחר שעיינו במסמכים שהונחו בפנינו ולאחר ששמענו את 
+   טענות הצדדים <לא מצאנו מקום להתערב / לא מצאנו לנכון לקבל>"
+   או:
+   "הסוגייה שנדונה בערר שלפנינו <מנסחת את השאלה>"
+
+2. הצגת מסגרת דוקטרינלית — ציטוט תקדם מנחה במלואו
+
+3. ניתוח כל סוגיה לפי תבנית:
+   - הצגת טענת המתנגד
+   - ציטוט סעיף החוק / הוראת תכנית
+   - ציטוט פסיקה מנחה
+   - יישום על העובדות
+   - "אכן [נקודה תקפה]... אולם [למה לא מכריע]" (אם יש משקל)
+   - מסקנה
+   
+4. סוגיה משנית — אופציונלי "התייחסות לטענות נוספות שעלו בכתב הערר"
+   (כותרת בלבד אם יש 4+ סוגיות לא קשורות)
+
+5. סיום:
+   - "בנסיבות אלה, לא מצאנו כי <X>"
+   - "בהיבט של <Y>... ההחלטה סבירה ומאוזנת"
+   - "החשוב מכל נראה כי יישום ההחלטה יביא ל<Z>"
+   - "לאור כל האמור הערר נדחה"
+   - הוצאות (לפי תוצאה — ראה סעיף 6)
+```
+
+### מאפיינים אופייניים
+- 1-3 פסקאות לכל סוגיה
+- ציטוטי פסיקה מלאים (4-10 שורות)
+- "אכן... אולם" לטענות שראויות לדיון
+- "נחדד" / "נציין" / "נשוב על כך" — שימוש פונקציונלי
+- חזרה לעיקרון מארגן בסיום
+
+---
+
+## 3. דחיית סף + דיון מהותי "ועל מנת לא לצאת בחסר"
+
+**דוגמה מובהקת**: 1180-1181 (2,787), 1067-25 (3,291), 1079-24 (8,440)
+
+### ארכיטקטורה
+
+```
+1. פתיחה — מוד F (סף + מהות):
+   "לאחר שבחנו את טענות הצדדים ונערך דיון בפנינו... החלטנו בשלב ראשון 
+   כי העוררים נעדרים זכות להגשת הערר ומכאן כי נכון לדחות את הערר על הסף.
+   אך יחד עם זאת ועל מנת לא לצאת בחסר ומאחר ונשמעו הצדדים בפנינו 
+   מצאנו להוסיף מספר הערות..."
+
+2. ניתוח טענת הסף — בהרחבה (פסקה לכל ראש טיעון):
+   - ציטוט הוראת החוק (סעיף 100, סעיף 152, וכו')
+   - ציטוט פסיקה מנחה (במלואה)
+   - יישום על העובדות
+   - מסקנה
+   
+3. כותרת משנה למעבר: "מהות הבקשה" / "להלן נדון..."
+
+4. ניתוח מהותי קצר יותר — "למעלה מן הצורך"
+   טון מתון יותר, אבל עדיין רציני.
+   
+5. סיום:
+   "מכל האמור לעיל, <תוצאת הסף> לא קמה זכות הערר ובכל מקרה 
+   <תוצאת המהות>"
+   הוצאות
+```
+
+### מתי להשתמש
+- כשיש דחיית סף מובהקת אבל גם:
+  - מקרקעי ציבור
+  - אתר רגיש
+  - סוגיה כבדת משקל
+  - "למניעת שגגה"
+- כשהמתנגד טוען ארוכות לגוף
+
+### מתי **לא** להשתמש
+- דחיית סף ברורה ופשוטה (אין צורך לעמוס)
+- אין סוגיה ציבורית מהותית
+
+---
+
+## 4. תיק עם 3+ סוגיות מובחנות — כותרות משנה
+
+**דוגמה מובהקת**: 1079-24 (8,440 — 4 כותרות), 1041-24 (5,287 — 4 כותרות), 1067-25 (3,291 — 4 כותרות)
+
+### ארכיטקטורה
+
+```
+1. פתיחה — מוד תלוי-תוצאה (A/B/C/F)
+
+2. כותרות משנה — לכל סוגיה מובחנת:
+   ## הבקשות לפסילה (אם רלוונטי — תמיד ראשון)
+   ## מעמד המבקשת וזכות עמידה
+   ## עותרים ציבוריים (אם בנפרד)
+   ## להלן נדון באישור הבקשה להיתר (מהות)
+   
+   או:
+   ## הטענה לחריגה מקו בניין
+   ## טענות לעניין תכנית הפיתוח
+   ## טענות הנוגעות לשימור העצים
+   ## סיכומו של דבר
+
+3. תחת כל כותרת — ניתוח מלא (פסקאות 5-15):
+   ציטוטי חוק + ציטוטי פסיקה + יישום + מסקנה
+   
+4. סיום:
+   "סיכומו של דבר" (כותרת אופציונלית)
+   ניסוח התוצאה
+   הוצאות
+```
+
+### עיקרון להחלטה אם להשתמש
+- ✅ **כן** כשהסוגיות **מובחנות** (פסילה ≠ עמידה ≠ מהות)
+- ✅ **כן** כשיש 3+ נושאים מהותיים נפרדים (כמו: קו בניין / פיתוח / עצים)
+- ❌ **לא** כשיש סוגיה אחת עם תת-שיקולים (1126-1141 לא משתמשת)
+
+### שמות הכותרות
+- **ללא מספור**
+- **תמטיים** (שם הסוגיה בלבד)
+- **קצרים** (3-7 מילים)
+- **לא במשפט שלם** (בלי ":", בלי ".")
+
+---
+
+## 5. קבלה חלקית — תיקים מורכבים (3,500-5,500 מילים)
+
+**הבחנה קריטית**: קבלה חלקית **אינה זהה** לקבלה מלאה. קבלה חלקית = איזון בין ערכים מתחרים. קבלה מלאה = תיקון של פגם בהחלטת הוועדה. **לקבלה מלאה יש 5 תבניות שונות לחלוטין** — ראה [`daphna-acceptance-architecture.md`](daphna-acceptance-architecture.md). אל תשתמש בארכיטקטורה זו לתיק קבלה מלאה.
+
+**דוגמה מובהקת**: 1130-25 (4,409), 1167-25 (2,779), 1041-24 (5,287)
+
+### ארכיטקטורה
+
+```
+1. פתיחה — מוד B/E (תיעוד תהליכי / תרכובת):
+   "נקדים ונציין כי <תהליך מקיף>"
+   או:
+   "בכל הנוגע לטענה המרכזית... נקדים ונציין כי אנו מקבלים את עמדת <צד>"
+   
+   ב-1xxx מורכב: גם משפט פילוסופי על מתחים מובנים
+   "כידוע, דיני התכנון והבניה נדרשים מעצם טיבם ליישב מתחים מובנים..."
+
+2. ארכיטקטורת משפך 9 תנועות (ראה voice-1130-25.md):
+   [1] מסגור התחים
+   [2] תיעוד תהליך ההכרעה
+   [3] טענות סף
+   [4] סמכות וטכניקה
+   [5] רקע היסטורי
+   [6] דוקטרינה
+   [7] השאלה האמיתית
+   [8] ההכרעה (איזון)
+   [9] עניינים נוספים
+
+3. ניסוח האיזון בפסקה ייחודית:
+   "אנו סבורים כי האיזון הראוי הינו <X>"
+   "ההחלטה <Y> אינה דחיית זכויות <Z> אלא דווקא הכרה בהן"
+   
+4. דחייה למומחים:
+   "ההיקף המדויק יקבע על ידי מהנדס הוועדה המקומית"
+   "נקודת העוגן למסקנתנו זו היא המלצת <X>"
+
+5. סיום:
+   "לאור כל האמור הערר מתקבל באופן חלקי, וזאת כדלקמן:
+   <פירוט עם אותיות א, ב, ג, ד>"
+   "בנסיבות העניין, ומאחר ו<X>, איננו מוצאים מקום לחייב את מי 
+   מהצדדים בהוצאות וכל צד ישא בהוצאותיו"
+```
+
+### עקרונות לקבלה חלקית
+- האיזון הוא הלב — לא הכרעה חדה
+- הסבר חיובי של הצמצום ("אינה דחייה אלא הכרה")
+- דחייה למומחים לפרטים טכניים
+- "כל צד יישא בהוצאותיו" כסטנדרט
+
+---
+
+## 6. תיקים מאוחדים (1126/1141, 1043/1054, 1071/1077, 1180/1181)
+
+**דוגמה מובהקת**: 1126-1141 (3,654), 1043-1054 (3,070), 1071-1077 (6,093), 1180-1181 (2,787)
+
+### ארכיטקטורה
+
+```
+1. פתיחה משותפת:
+   "לפנינו <X> עררים שהדיון בהם אוחד..."
+   או נכלל בפסקה הפותחת.
+
+2. דיון משותף — כי עוסקים בדרך כלל באותו פרויקט / מגרש / תכנית
+   
+3. במקרים של תיקים דומים אבל לא זהים — ציון הבחנה:
+   "בתיק <X> שעניינו <Y>" 
+   "בתיק <Z> שעניינו <W>"
+
+4. סיום משותף:
+   ניסוח התוצאה לכל הערר/ים
+   הוצאות
+```
+
+### תכונה ייחודית — הקלדה משותפת
+- **1071-25 ו-1071-1077** חולקים בלוק י כמעט זהה
+- **1126-25 ו-1126-1141** דומים מאוד
+- **1043-24 ו-1043-1054** סגנון משותף
+
+**עיקרון לסוכן**: כשתיק נמצא בקבוצה של תיקים דומים → להשתמש בארכיטקטורה הזהה. לא להמציא מחדש.
+
+---
+
+## 7. תיק חוזר אחרי רמאנד
+
+**דוגמה מובהקת**: 1024-25, 1071-25/1071-1077
+
+### ארכיטקטורה
+
+```
+1. פתיחה — תיעוד הרמאנד:
+   "נקדים ונציין כי לאחר שעיינו במסמכים... <האם הוועדה ביצעה את ההנחיה>"
+   "כאמור, בהחלטת ועדת הערר השבנו את הדיון לוועדה המקומית..."
+
+2. ציטוט מההחלטה הקודמת — מילולי:
+   "נשוב על סעיפים <X>, <Y> להחלטה: ..."
+   "מכאן ההנחיה הייתה ש<Z>"
+
+3. בחינה — האם הוועדה המקומית ביצעה
+   - אם כן: "אנו מקבלים את שיקולי הוועדה המקומית"
+   - אם לא: "מצאנו התחשבות ב<X> ובהימנעות מלמלא אחר החלטת ועדת הערר"
+
+4. שיתוף בקושי (אם הוועדה לא ביצעה):
+   "בהחלטה לעיל שבנו וחזרנו על חלק ניכר מקביעותינו... וזאת על מנת 
+   להבהיר שוב את מסקנתנו הגם שהיה מצופה כי תובן בשלב הראשוני"
+
+5. סיום:
+   - אם הוועדה ציותה: דחיית הערר, אין הוצאות
+   - אם הוועדה התעלמה: חיוב הוועדה המקומית בהוצאות העוררים
+```
+
+### ביטויים מאפיינים
+- "אנו נחזור על כך כי..."
+- "בהחלטה לעיל שבנו וחזרנו..."
+- "הגם שהיה מצופה כי תובן בשלב הראשוני"
+
+---
+
+## 8. סדר ההוצאות
+
+| תוצאה | הוצאות | ניסוח |
+|--------|---------|--------|
+| דחייה מוחלטת + צד נורמלי | תשלום מתנגד למשיבה | "העורר/ת ישא בהוצאות בסך X ₪ שישולם תוך 14 יום" |
+| דחייה מוחלטת + סוגיה מורכבת | אין | "לא מצאנו לנכון לפסוק הוצאות" |
+| דחיית סף + צד בעייתי | חצי-וחצי | "כל צד יישא בהוצאותיו" |
+| קבלה חלקית | אין | "בנסיבות העניין, איננו מוצאים מקום לחייב את מי מהצדדים בהוצאות וכל צד ישא בהוצאותיו" |
+| קבלה מלאה | תשלום משיבה לעורר | "המשיבה תישא בהוצאות העורר/ת בסך X ₪" |
+| ועדה מקומית עיכבה / לא צייתה לרמאנד | **חיוב הוועדה המקומית** | "אנו מחייבים את הוועדה המקומית בהוצאות העוררים בסך X ₪ לכל עורר" |
+
+---
+
+## 9. תוספות אופציונליות
+
+### תקופת המתנה לפניה לערכאות
+כשיש שאלה קניינית סמויה:
+> "החלטה זו תיכנס לתוקפה לאחר 30 ימים ממועד קבלתה וזאת על מנת ליתן 
+> פרק זמן לפניה לערכאות על ידי המעוניין"
+
+### הוראה אופרטיבית לוועדה המקומית
+> "אנו נחזור על כך כי על הוועדה המקומית לציין בהיתרי הבניה לאחר 
+> הוצאתם הערה ולפיה - אין באישור ההיתרים בכדי לגרוע מיתר הוראות הדין"
+
+### הצעה לעתיד
+> "בשלב זה נוכל להציע כי נכון יהיה לשקול קידום תכנית מפורטת מתאימה 
+> לצורך כך"
+
+### הסתייגות מאמירות שהושמעו
+> "בשולי הדברים נבקש גם להסתייג מדברים שהושמעו בדיון..."
+
+### עתירה על החלטה קודמת
+> "ערר 1071/25... (שעתירה על החלטה זו נדחתה לאחר חזרת העותרת ממנה)"
+> — שקיפות לגבי מצב התקדמים
+
+---
+
+## 10. עץ ההחלטה לסוכן
+
+```
+לפני כתיבת בלוק י — שאל:
+
+1. מה התוצאה הצפויה?
+   ├─ דחייה מוחלטת פשוטה → ארכיטקטורת §1 (קצר, מוד A)
+   ├─ דחייה מוחלטת מורכבת → ארכיטקטורת §2 (מוד B/C)
+   ├─ דחיית סף + מהות → ארכיטקטורת §3 (מוד F)
+   ├─ קבלה חלקית → ארכיטקטורת §5 (מוד B/E + פילוסופי ב-1xxx)
+   └─ קבלה מלאה → ראה `daphna-acceptance-architecture.md` — 5 תבניות שונות
+                    (A: ביטול בגלל פגם פנימי / B: החזרה לוועדה / 
+                     C: תיקונים בבקשה / D: ביטול דרישת תשלום 8xxx / 
+                     E: השבת שומה לשמאי)
+
+2. כמה סוגיות מובחנות?
+   ├─ 1-2 → זרימה רציפה ללא כותרות משנה
+   ├─ 3+ סוגיות מובחנות לחלוטין → ארכיטקטורת §4 (כותרות משנה)
+   └─ 3+ סוגיות באותו עניין → זרימה רציפה (כמו 1126-1141)
+
+3. תיק מאוחד?
+   ├─ כן → ארכיטקטורת §6 (פתיחה משותפת + דיון משותף)
+   └─ לא → המשך לפי הבחירה לעיל
+
+4. רמאנד מתיק קודם?
+   ├─ כן → ארכיטקטורת §7 (תיעוד הרמאנד + בדיקת ציות)
+   └─ לא → המשך לפי הבחירה לעיל
+```
+
+---
+
+## 11. פרופורציות פנימיות (לפי קורפוס)
+
+| חלק של בלוק י | אחוז ממוצע מהבלוק | הערה |
+|----------------|-------------------|--------|
+| פתיחה (מוד) | 5-10% | בקבלה חלקית: 10-15% (פילוסופי) |
+| מסגרת דוקטרינלית | 15-25% | בתיקי שמאי: 20-25% (בר"מ 3644/13 חובה) |
+| ניתוח טענות סף | 0-30% | רק אם יש סוגיות סף |
+| ניתוח מהותי | 30-50% | הלב של הבלוק |
+| איזון/מסקנה | 10-20% | בקבלה חלקית: 15-25% |
+| סיום אופרטיבי | 5-10% | תוצאה + הוצאות + תאריך |
+
+---
+
+## 12. הערה לסוכן
+
+המסמך הזה הוא **מסגרת**, לא נוסחה. הסוכן צריך:
+1. **לזהות את הסוג** של התיק לפי 4 השאלות בעץ ההחלטה
+2. **לבחור ארכיטקטורה** מהמסמך
+3. **למלא את הארכיטקטורה** עם תוכן ספציפי לתיק
+4. **לעקוב אחר הפרופורציות** הפנימיות
+5. **להתאים את הסיום וההוצאות** לתוצאה
+
+לעולם לא לסטות מהארכיטקטורה. דפנה עקבית — הסוכן חייב להיות עקבי כמוה.

docs/daphna-block-zayin-claims.md

@@ -0,0 +1,385 @@
+# בלוק ז — תמצית טענות הצדדים
+
+מסמך זה ממפה את כללי הכתיבה של בלוק ז (טענות הצדדים) — בלוק שיש לו **כללים נפרדים** מבלוק י (דיון), ושכשלים בו פוגעים באמינות ההחלטה כולה. מבוסס על קריאה מדוקדקת של בלוק ז ב-7 תיקים מייצגים: 1130-25, 1194-25, 1113-25, 1043+1054, 1033-25, נאמנות, קרקעות ירושלים, 1109-25.
+
+**העיקרון המרכזי**: בלוק ז הוא **דוח עובדתי** של מה שכל צד טען — לא הערכה. דפנה מציגה את כל הטענות, כולל אלה שתידחה בבלוק י, **באובייקטיביות מלאה**. אם הסוכן מערב הערכה, ביקורת, או ניטרל לטובת או לרעת צד — ההחלטה כולה מאבדת אמינות.
+
+---
+
+## 1. הכותרת — קבועה
+
+| היבט | הקביעה |
+|-------|---------|
+| כותרת הבלוק | **תמיד "תמצית טענות הצדדים"** — לא "טענות הצדדים", לא "טיעוני הצדדים" |
+| מספור | אין |
+| גודל | כותרת רמה ראשונה — שווה לשאר כותרות הבלוקים |
+
+⚠️ **אסור**: לחבר עם בלוק אחר. "תמצית טענות הצדדים" מקבל כותרת עצמאית, גם אם בלוק ו (רקע) קצר.
+
+---
+
+## 2. הסדר הכללי — לפי תפקיד פרוצדורלי
+
+הסדר הוא **אחיד** וצמוד לתפקיד הפרוצדורלי, לא לאלפבית או לזמן הגשה:
+
+### בערר על **אישור** בקשה (העוררים = שכנים):
+1. טענות העוררים (תחילה)
+2. תגובת/עמדת הוועדה המקומית
+3. תגובת/טענות מבקש/י ההיתר (משיב 2 ומעלה)
+
+### בערר על **דחייה** (העוררים = מבקשי ההיתר):
+1. טענות העוררים (מבקשי ההיתר)
+2. תגובת/עמדת הוועדה המקומית
+3. תגובת/עמדת המתנגדים (משיב 2 ומעלה — אם הם משיבים)
+
+### בערר 8xxx (היטל השבחה):
+1. טענות העורר
+2. תגובת המשיבה (הוועדה המקומית)
+3. (אופציונלי) "הדיון בוועדת הערר" / "מסמכים נוספים"
+
+### בערר מאוחד (1043+1054, 1071+1077):
+1. **תמצית טענות הצדדים בערר 1 - X/Y**: עורר 1 → משיבים בערר 1
+2. **תמצית טענות הצדדים בערר 2 - X/Y**: עורר 2 → משיבים בערר 2
+3. (אופציונלי) "דיון נוסף" — אם היו אירועים שחורצים בין שני העררים
+
+---
+
+## 3. כותרות המשנה — לכל צד
+
+### 3.1 לעוררים
+| נסיבה | כותרת מועדפת |
+|--------|---------------|
+| עורר יחיד | **"טענות העורר"** |
+| עוררת יחידה | **"טענות העוררת"** |
+| מספר עוררים בעלי טיעון משותף | **"טענות העוררים"** |
+| מספר עוררים עם טיעונים נפרדים מובחנים | **"טענות העורר [שם]"** + **"טענות [המתנגד הנוסף]"** (כפי שב-1130: "טענות העורר מר קובר" + "טענות משיב 3 (מר יצחק מטמון)") |
+
+### 3.2 לוועדה המקומית
+מותר באחת מהוואריאציות:
+- **"תגובת הוועדה המקומית"**
+- **"עמדת הוועדה המקומית"**
+- **"תשובת הוועדה המקומית"**
+
+דפנה משתמשת באלה לסירוגין — אין הבחנה דוקטרינלית. אבל בתיקים שבהם הוועדה דחתה את הבקשה — נטייה ל**"עמדת הוועדה המקומית"**. בתיקים שבהם היא משיבה לערר נגד אישור — **"תגובת הוועדה המקומית"**.
+
+### 3.3 למבקשי ההיתר / משיבים נוספים
+- **"תגובת מגישי התכנית"** / **"עמדת מגישי התכנית"** (תיקי 1xxx)
+- **"תגובת המשיבה 2"** / **"תגובת המשיבים 2"** / **"תגובת משיבים 3-5"**
+- **"טענות מבקשת ההיתר"** (כש-מבקש ההיתר הוא העוררת — בערר על דחייה)
+
+### 3.4 כותרות נוספות אופציונליות
+- **"הדיון בוועדת הערר"** — מופיע ב-1113, נאמנות, קרקעות ירושלים, 1043+1054. רק כשהיו טיעונים מהותיים שעלו לראשונה בדיון
+- **"מסמכים נוספים"** — בנאמנות, אחרי "הדיון בוועדת הערר", להצגת מסמכים שהוגשו אחרי הדיון
+- **"דיון נוסף"** — בתיקי 1043+1054: כשבמסגרת ההליך התקיים אירוע אחרי הדיון הראשי (דו"ח פיקוח, מינוי מומחה)
+
+⚠️ **אבחנה קריטית**: "הדיון בוועדת הערר" בבלוק ז שונה מבלוק ח ("הליכים בפני ועדת הערר"). בבלוק ז — **רק טיעונים** שעלו בדיון. בבלוק ח — **פעולות הוועדה** (סיור, החלטות ביניים, השלמות, רמאנד).
+
+---
+
+## 4. הקול והפעלים — קול פעיל של הצד
+
+דפנה מציגה כל טענה דרך **גוף שלישי פעיל** של הצד עצמו. **אסור** לפסיביזציה.
+
+### 4.1 פעלי הצגה — לפי תפקיד
+
+| פועל | תפקיד | דוגמה |
+|-------|--------|--------|
+| **טוען / טוענת / טוענים** | טענה ראשית | "העורר טוען כי לוועדה המקומית אין סמכות..." |
+| **מוסיף / מוסיפה** | טיעון נוסף | "העורר מוסיף כי..." |
+| **מציין / מציינת** | תצפית | "העוררת מציינת כי..." |
+| **מצביע / מצביעה** | הפניה לראיה | "העורר מצביע על שורה ארוכה של פגמים..." |
+| **מסתמך / מסתמכת** | הסתמכות על תקדים/חוק | "העורר מסתמך על פסיקת בית המשפט העליון בבג"ץ..." |
+| **מפנה** | הפניה למסמך/סעיף | "העורר מפנה לסעיף 198(ב) לחוק..." |
+| **מבקש / מבקשת** | תוצאה מבוקשת | "העורר מבקש לבטל את החלטת..." |
+| **מדגיש / מדגישה** | הדגשה | "המשיבה מדגישה כי..." |
+| **דוחה / דוחים** | דחייה של עמדה (נדיר בבלוק ז) | "העוררת דוחה את הטענה..." |
+| **מציע / מציעה** | הצעה חלופית | "העורר מציע פתרון חליפי..." |
+| **חולק על / חולקת** | מחלוקת מובחנת | "העורר חולק גם על גובה הדרישה..." |
+
+### 4.2 ביטויים אסורים (אנטי-דפוסים)
+
+❌ **"טענות העורר היו"** — פסיביזציה. השתמש בקול פעיל: "העורר טוען".  
+❌ **"לדעת העורר X"** — הופך את הטענה לדעה של דפנה. השתמש: "העורר טוען כי X".  
+❌ **"העורר טוען בצדק/בטעות"** — הוספת הערכה. הערכה שייכת לבלוק י.  
+❌ **"העורר מנסה לטעון"** — מילת רמיזה שמכרסמת באובייקטיביות. דפנה לא משתמשת.
+
+### 4.3 כשמבטאים פסיקה / החלטה — בקול הצד
+דוגמה מ-1130: *"העוררת מסתמכת על פסיקת ועדת הערר בערר 67/00 זיו... שם נקבע כי תכנית חייבת להיות 'מדויקת' כדי שניתן יהיה לתבוע מכוחה פיצויים."*
+
+המבנה: **הצד** + **מסתמך על** + **שם פסק הדין** + **'שם נקבע כי' + ציטוט/תמצית**.
+
+**אסור**: להציג את התקדים בלי שיוך לצד שמסתמך עליו. ("בערר 67/00 נקבע כי..." — בלי "העוררת מסתמכת על" — נשמע כאילו דפנה מציגה את התקדים כסמכותי. זה שייך לבלוק י.)
+
+---
+
+## 5. ארגון הטיעונים — נרטיב רציף תמטי
+
+### 5.1 ⛔ אסור: רשימה ממוספרת
+
+ב-0 מ-7 התיקים שנבדקו יש רשימה ממוספרת `(1)... (2)... (3)...` בתוך פסקת בלוק ז. גם כש**הצד עצמו** ארגן את טיעוניו ברשימה ממוספרת בכתב הערר — דפנה **שוטחת** אותם לנרטיב רציף. דוגמה מ-1109:
+
+> *"העורר מצביע על שורה ארוכה של פגמים פרוצדורליים חמורים שנפלו לטענתו בהליך קבלת ההחלטה, ובראשם העובדה כי הנושא כלל לא היה על סדר היום של ועדת המשנה..."*
+
+(במקום: "(1) הנושא לא היה על סדר היום; (2) הוכנס תחת 'שונות'; (3) ...")
+
+### 5.2 ✅ ארגון תמטי — לפי ראש טיעון
+
+לכל **ראש טיעון** של הצד — פסקה משלה. הסדר הוא **לפי חשיבות לטיעון** (לא לפי הסדר בכתב הערר), ולעיתים לפי **המבנה הפרוצדורלי** (סף → סמכות → מהות).
+
+דוגמה מ-1130 (טענות העורר מר קובר), הסדר התמטי:
+1. סמכות הוועדה (62א(א)(4א))
+2. הגדרת "מימוש" של יחידת הדיור השישית
+3. חישוב אחוזי התוספת (50% / 67%)
+4. השתלבות בסביבה (סטייה ניכרת)
+5. החלטת הוועדה המחוזית 2017
+6. פגמי פרסום
+7. פתרון חניה
+8. זכות עמידה
+9. חלופת מימוש בקומה הקיימת
+10. פגם בפרוטוקול
+
+מ-1043+1054, סדר העוררת 1:
+1. ההסכמות שיש לה (גג צמוד, תקנון, תקדימים)
+2. תקדימים פנימיים בוועדה (51%, היעדר חתימות)
+3. פסיקה מנחה (בג"צ ובית המשפט העליון)
+4. טיעון חלופי
+
+### 5.3 ביטויי קישור בתוך הצגת הצד
+
+#### לסדר נושאי
+- **"לעניין X..."** — מעבר לנושא הבא ("לעניין חישוב אחוזי התוספת טוען העורר...")
+- **"באשר ל-X..."** — וריאציה ("באשר להשתלבות בסביבה...")
+- **"בנוגע ל-X..."** — וריאציה ("בנוגע לפתרון חניה...")
+- **"בהקשר זה..."** — להוספה תמטית
+- **"בהיבט X..."** — להבדלה בין צד דיוני למהותי
+
+#### להוספה
+- **"עוד טוען..."** / **"עוד נטען כי..."**
+- **"בנוסף, טוען..."**
+- **"מוסיף ה[צד] כי..."**
+- **"כמו כן..."**
+- **"יתרה מכך..."**
+- **"מעבר לכך..."**
+
+#### לטיעון חלופי
+- **"לחלופין, טוען..."**
+- **"לחילופין נטען..."**
+- **"לחלופין... גם אם תידחה הטענה הראשונה..."**
+
+#### למיקום בתוך רשימת ראשי טיעון
+- **"ראשית... שנית... שלישית..."** — נדיר. רק כשהצד עצמו ארגן כך
+- **"ובראשם..."** — לטיעון הראשון בחשיבותו ("ובראשם העובדה כי...")
+
+#### לסיכום הטיעון
+- **"לבסוף נטען..."**
+- **"לסיכום נטען..."**
+- **"לאור כל האמור, מבוקש..."**
+
+### 5.4 קישור פנימי בתוך פסקה אחת
+
+**מקובל**: "ראשית... שנית... שלישית..." בתוך **פסקה אחת** (לא מנייה ממוספרת בנקודה). דוגמה מ-1043+1054:
+> *"העוררת מבססת את זכויותיה הקנייניות על מספר יסודות. ראשית, הגג הוצמד לדירתה בטאבו באופן בלעדי. שנית, בהתאם לתקנון הבית המשותף, כל בעל דירה רשאי להוסיף תוספת בנייה לדירתו... בנוסף, התקנון קובע..."*
+
+זה לא רשימה ממוספרת — זה משפט אחד עם נימוקים מנויים. **מותר**.
+
+---
+
+## 6. מה מותר ומה אסור בתוכן
+
+### 6.1 ✅ מותר וחיוני
+
+#### **א. ציטוטי סעיפי חוק שהצד מסתמך עליהם**
+> *"העוררת מפנה לסעיף 198(ב) לחוק וטוענת כי: 'הועדה המקומית תדון בתביעה ותחליט, בתוך תשעים ימים מיום הגשת התביעה...'"*
+
+#### **ב. שמות תקדימים שהצד מסתמך עליהם — אבל בקצרה**
+> *"לעניין זה מפנה הוועדה לערר 1136/23 יוסף צבי דוידוביץ נ' הוועדה המקומית ירושלים."*
+
+⚠️ ציטוט מלא של פסיקה (4-15 שורות) שייך ל**בלוק י**, לא לבלוק ז. בבלוק ז: שם, מספר, אולי משפט מפתח — לא יותר.
+
+#### **ג. נתונים מספריים, מידות, אחוזים, חתימות**
+> *"חישוב מגיש התכנית שגוי וכי 72 מ"ר שטחי מחסנים (6×12 מ"ר) שלא נבנו... בחישוב נכון הבסיס הוא 591 מ"ר בלבד, ואחוז התוספת עולה לכ-67% מעבר לסמכות הוועדה."*
+
+#### **ד. ציטוטים קצרים מכתבי הטענות / פרוטוקולים**
+> *"כדבריו: 'במשך השנים, האמנתי כי יש ברשותי את האישורים המתאימים. רק כאשר פניתי לאדריכל לבדוק את הסטטוס החוקי, גיליתי להפתעתי כי אין לי היתר על התוספת, דבר שהותיר אותי המומה.'"*
+
+ציטוטים קצרים (1-3 משפטים) — מותרים. הם מחזקים את האותנטיות. ציטוטים ארוכים — לא בבלוק ז.
+
+#### **ה. הסכמים, נסחי טאבו, תקנונים — כראיות שהצד הציג**
+> *"העוררת הציגה היתר משנת 2012, בו אושרה בקשה דומה של שכן..."*
+
+הצגת ראיות מותרת. **הערכת** הראיות — לא.
+
+#### **ו. הסעד שמבקש הצד**
+> *"לאור כל האמור, מבוקש לבטל את החלטת הוועדה המקומית; להורות על החזרת הסמכות..."*
+
+נסגר את כל ראש הטיעון.
+
+### 6.2 ⛔ אסור
+
+#### **א. הערכת איכות הטענה**
+❌ "העורר טוען בצדק כי..."  
+❌ "טענה זו אינה משכנעת..."  
+❌ "טענה חזקה במיוחד..."
+
+#### **ב. גילוי מסקנת הבלוק י**
+❌ "אנו דוחים טענה זו..."  
+❌ "טענה זו תידון בהמשך..."
+
+#### **ג. ציטוטי פסיקה במלואם**
+ציטוט בן 5+ שורות מפסק דין שייך לבלוק י. בבלוק ז — שם, מספר, רעיון בקצרה.
+
+#### **ד. דיוני סף עצמאיים**
+טענות סף שהצד הנגדי מעלה (למשל "הערר הוגש באיחור") — מובאות תחת "טענות [המשיב]". **לא** בכותרת עצמאית "טענות סף" בבלוק ז. הדיון בטענות הסף הוא בבלוק י.
+
+#### **ה. רטוריקה דרמטית של הצד — בלי סימון**
+אם הצד אומר "מדובר בחטא קדמון תכנוני" או "התנהלות שערורייתית" — מותר להביא, **אבל בייחוס לצד**: *"העורר תיאר את ההליך כ'חטא קדמון תכנוני'..."*. **לא** "ההליך היה חטא קדמון..." (זה אימוץ הדרמטיות).
+
+#### **ו. שיפוט מוסרי או רגשי**
+❌ "התנהלות הוועדה הייתה מקוממת לעורר..."  
+✅ "העורר רואה בהתנהלות הוועדה משום הטעיה מכוונת..." (מסומן כדעת הצד)
+
+---
+
+## 7. תיקים מאוחדים — מבנה ייחודי
+
+ב-1043+1054, 1071+1077, 1180+1181 — **לכל ערר מבנה משלו** בבלוק ז:
+
+```
+תמצית טענות הצדדים בערר 1 - 1043/0524
+   טענות העוררת 1
+   תשובת המשיבה 2
+   תשובת הוועדה המקומית
+
+תמצית טענות הצדדים בערר 2 - 1054/0624
+   טענות העורר 2
+   תשובת המשיבה 3
+   תשובת הוועדה המקומית
+
+[אופציונלי: דיון נוסף — אירועים משותפים לשני העררים]
+```
+
+**עיקרון**: גם אם הסוגיות זהות, **לא לאחד את הצגת הטענות**. כל ערר מקבל הצגה נפרדת — כי לכל ערר עוררים שונים, מסמכים שונים, ולעיתים נסיבות שונות.
+
+⚠️ **אבחנה**: זה שונה מהדיון (בלוק י), שם דפנה **כן** מאחדת לפעמים את הניתוח של תיקים דומים. בבלוק ז — אף פעם לא.
+
+---
+
+## 8. אורך — לפי מורכבות, לא לפי תוצאה
+
+| תיק | תוצאה | אורך בלוק ז | מאפיין |
+|------|--------|---------------|---------|
+| 1194-25 | דחייה | ~1,000 מילים | סוגיות מועטות, צדדים פשוטים |
+| 1033-25 | קבלה | ~1,200 | סוגיה אחת מכריעה, טענות סף של מבקש ההיתר |
+| 1113-25 | קבלה+תיקונים | ~1,400 | 3 צדדים, ציטוטי פרוטוקול |
+| 1043+1054 | קבלה — מאוחד | ~1,800 | שני עררים נפרדים |
+| נאמנות | קבלה (8xxx) | ~1,650 | סוגיה משפטית מורכבת + דיון |
+| קרקעות ירושלים | דחייה (9xxx) | ~1,900 | תיק פיצויים מורכב |
+| 1130-25 | קבלה חלקית | ~3,000 | רב-טענות, רב-צדדים |
+| 1109-25 | דחייה | ~3,600 | תיק רב-הליכים, עורר בעייתי |
+
+**העיקרון**: האורך תלוי ב**מספר ראשי הטיעון** ו**מספר הצדדים** — לא בתוצאה. תיק קבלה פשוט (1033) קצר; תיק דחייה מורכב (1109) ארוך. זה הפוך מבלוק י, שם תיקי קבלה לפעמים ארוכים יותר (תבנית D — נאמנות).
+
+---
+
+## 9. דוגמאות מעוגנות
+
+### 9.1 פתיחת "טענות העורר" — מסגרת אחת
+מבנה אופייני (פסקה ראשונה):
+> *"לטענת העוררים, [הצגת הטענה המרכזית במשפט אחד]. [נימוק קצר]. לעניין זה מפנים העוררים לכך ש[הוכחה תומכת]."*
+
+### 9.2 פתיחת "טענות הוועדה המקומית" — לעיתים פתיחה ב"דין הערר דחייה"
+> *"עמדתה העקרונית של המשיבה היא כי דין הערר דחייה על הסף בשל התיישנות התביעה, ולחילופין דחייה לגופו של ערר."*
+
+מותר רק כשהוועדה עצמה ניסחה זאת בכתב התשובה. דפנה מצטטת — לא ממציאה.
+
+### 9.3 הצגת טענת סף של מבקש ההיתר
+> *"מבקשת ההיתר טוענת כי הערר הוגש על ידי הגב' גלנסקי בשם מתנגדים נוספים מבלי שהוסמכה כדין לייצגם, וכי שמות העוררים הנוספים הוקלדו על ידה בלבד. לפיכך, יש למחוק את יתר העוררים מהערר."*
+
+הטענה מובאת **במלואה** ובאובייקטיביות. **גם אם** דפנה תדחה אותה בבלוק י.
+
+### 9.4 הצגת טיעון חלופי
+> *"לחלופין, גם אם ניתן לאשר מימוש יח"ד שישית, לא היה מקום לאשר הוספת קומה, שכן ניתן לממש את היחידה בקומה השלישית הקיימת על ידי סגירת מרפסות."*
+
+ביטוי המעבר: **"לחלופין..."** — סימן ברור שזה טיעון משני.
+
+### 9.5 ציטוט מילולי מהדיון
+> *"במהלך הדיון בוועדת הערר ביקשה העוררת למסור את גרסתה בנוגע לסוגיה הקניינית העומדת במוקד המחלוקת. העוררת הציגה השתלשלות עניינים היסטורית... וכדבריה: 'כאשר רכשנו את הדירה, נעשתה החלפה של זכויות עם הדיירים שמתחתינו ומעלינו...'"*
+
+מבנה: תיאור הקשר → "וכדבריה:" → ציטוט במרכאות.
+
+### 9.6 הצגת תקדים שהצד מסתמך עליו
+> *"העוררת מסתמכת על פסיקת ועדת הערר בערר 67/00 זיו נ' הוועדה המקומית לתכנון ולבנייה עפולה, שם נקבע כי תכנית חייבת להיות 'מדויקת' כדי שניתן יהיה לתבוע מכוחה פיצויים."*
+
+**מבנה**: שם הצד + "מסתמך/ת על" + שם פסק הדין מלא + "שם נקבע כי" + תמצית/ציטוט קצר.
+
+---
+
+## 10. אנטי-דפוסים — בדיקה אחרי כתיבה
+
+- [ ] אין רשימה ממוספרת `(1)... (2)...` בתוך פסקה
+- [ ] אין מילות הערכה ("בצדק", "בטעות", "משכנעת", "חזקה")
+- [ ] אין גילוי מסקנה עתידית ("טענה זו תידחה בהמשך")
+- [ ] אין ציטוטי פסיקה ארוכים — רק שם והפניה
+- [ ] אין אימוץ רטוריקה דרמטית של הצדדים — רק ייחוס
+- [ ] אין פסיביזציה ("טענות העורר היו ש...")
+- [ ] אין דיון בטענות סף בכותרת עצמאית — תחת "טענות [המשיב]"
+- [ ] כל צד מקבל כותרת משנה אחידה (טענות / תגובת / עמדת)
+- [ ] בתיקים מאוחדים — לכל ערר תת-בלוק עצמאי
+- [ ] סדר הצדדים: עוררים → ועדה מקומית → משיבים אחרים
+- [ ] הסדר התמטי בתוך כל צד — לא כרונולוגי
+- [ ] ציטוטים קצרים בלבד (1-3 משפטים) מכתבי הטענות
+
+---
+
+## 11. עיקרון מטא — בלוק ז כסוס טרויאני של אובייקטיביות
+
+יו"ר בית משפט מנהלי שיקרא את ההחלטה בעתיד יבחן **את בלוק ז קודם כל** כדי להעריך:
+1. **האם הוועדה הבינה את הטענות לעומק?** — ייחוסים מדויקים, ציטוטים נכונים, לא הקלת ראש
+2. **האם הוועדה הציגה את הטענות בהוגנות?** — אם הניצוח של דפנה בבלוק י "מנצח" טענה שלא הוצגה במלואה בבלוק ז, ההכרעה חשודה
+3. **האם הצדדים יכלו לזהות את עצמם בבלוק ז?** — אם עורר קורא את הבלוק ואומר "זה לא מה שטענתי", זה כשל באמינות
+
+לכן: **בלוק ז הוא ההגנה האסטרטגית של ההחלטה**. כשהוא מצוין — הוא נותן לדפנה חופש מלא בבלוק י לדחות טענות בבטחון. כשהוא קלוקל — בלוק י מתחיל מעמדה חלשה.
+
+לסוכן: לפני שהוא עובר לבלוק ח/ט/י, הוא צריך לוודא שבלוק ז **מציג כל טענה שתידחה בבלוק י בנקודה הכי גבוהה שלה**. זה התנאי הקודם לדפוס "אכן... אולם" של דפנה — ואין דרך לנסח "אכן [טענה תקפה]" בבלוק י אם לא הצגתה בבלוק ז.
+
+---
+
+## 12. הוראות אופרטיביות לסוכן
+
+### 12.1 לפני כתיבת בלוק ז
+1. **קרא את כל כתבי הטענות** — לא תחליטך מה רלוונטי על סמך התקציר
+2. **מפה את ראשי הטיעון של כל צד** — לפני שאתה כותב, רשום רשימה
+3. **בדוק את סדר התיק** — ערר על אישור / דחייה / 8xxx / מאוחד?
+4. **זהה ציטוטים מילוליים** שכדאי לכלול (1-3 משפטים מכל צד)
+
+### 12.2 במהלך הכתיבה
+1. **התחל מהעוררים** — תמיד
+2. **כותרת משנה לכל צד** — אפילו אם הוועדה המקומית קצרה
+3. **פסקה לכל ראש טיעון** — לא לדחוף שני נושאים מרכזיים לפסקה אחת
+4. **גוף שלישי פעיל** — "טוען / מוסיף / מסתמך"
+5. **ביטויי קישור תמטיים** — "באשר ל-", "לעניין", "בנוגע ל-"
+6. **טענות חלופיות** — בסוף, עם "לחלופין"
+
+### 12.3 אחרי הכתיבה
+1. **בדיקת אובייקטיביות**: עבור על כל פסקה ושאל "האם זה מה שהצד טוען, או מה שאני חושב על זה?"
+2. **בדיקת שלמות**: לכל טענה שתידון בבלוק י — האם היא הוצגה בבלוק ז?
+3. **בדיקת ייחוס**: לכל ציטוט ומספר — האם ברור מאיזה צד הוא בא?
+4. **בדיקת אנטי-דפוסים** מסעיף 10
+
+---
+
+## 13. פערים והערות
+
+### 13.1 קורפוס מצומצם
+- **תיק 9xxx** (פיצויים): רק קרקעות ירושלים נקרא בעיון. ייתכן שיש דפוסים נוספים
+- **תיק רמאנד**: לא נקרא בעיון בלוק ז — האם הוא שונה כשמדובר ברמאנד?
+- **בלוק ז כשהעוררים הם עותרים ציבוריים** (1079-24 ירושלים שקופה): יש לבחון בנפרד
+
+### 13.2 התפתחות בקאנון
+התיקים החדשים (2025-2026) **ללא מספור פסקאות**. תיקים ישנים (1079-24, 1170-23) **עם** מספור. בלוק ז של תיק חדש **לא** ימוספר.
+
+### 13.3 הערה לדפנה
+המסמך הזה הוא **ההצעה שלי** המבוססת על קריאה של 7 תיקים. דפנה מוזמנת:
+1. לסמן ביטויים שאין בהם שימוש בפועל
+2. להוסיף ביטויים מועדפים שחסרים
+3. לתקן סדרי-עדיפויות (לדוגמה — האם יש מקרים שבהם היא **כן** מתחילה במשיב לפני העוררים?)

docs/daphna-decision-tree.md

@@ -0,0 +1,521 @@
+# עץ ההחלטה לסוכן — מסגרת תפעולית
+
+מסמך זה הוא **כלי הפעולה היומיומי** של הסוכן. הוא מאחד את 5 מסמכי הקול לתהליך אנליטי קצר שיכול להתבצע **לפני** קריאה עמוקה של החומר. המטרה: לקבל בתוך פסקאות ספורות תשובה לשאלות "איזה סוג תיק זה? איזה קוד אני כותב?".
+
+⚠️ **המסמך הזה אינו תחליף לקריאת המסמכים האחרים**. הוא **תחליף לחיפוש בהם** — מצביע איזה סעיף ואיזה מסמך רלוונטי לתיק הזה.
+
+---
+
+## 0. השאלה הראשונה — לא "מה אני כותב" אלא "מה הראיה הניצחת"
+
+לפני כל החלטת מבנה, סגנון, אורך — דפנה (ולכן הסוכן) שואלת:
+
+> **מהי הראיה הניצחת בתיק הזה?**
+
+זוהי השאלה שמכריעה הכל. **הצורה משרתת את הראיה הניצחת**, לא ההפך.
+
+| הראיה הניצחת | תבנית | אורך מצופה | פסיקה |
+|----------------|--------|---------------|---------|
+| פסיקה רחבה (תקדים מנחה של עליון/בג"ץ) | תיק 1130 / תבנית B / תבנית D | ארוך (4,000-7,000) | רחבה |
+| הודאת הצד הנגדי בדיון | תבנית A (1033) | קצר (1,500-2,000) | מינימלית |
+| סיור פיזי + התרשמות שטח | 1130 חלקית | בינוני | בינונית |
+| דוקטרינה תקדים-יסוד (אייזן, חוף השרון) | תיק 1194 / תבנית B | בינוני-ארוך | רחבה |
+| נתון מספרי / חישוב כמותי | 8xxx שמאי | קצר-בינוני | בר"מ 3644/13 |
+| תנאי שהוועדה עצמה קבעה | תבנית A | קצר | מינימלית |
+| פגם פרוצדורלי שהוועדה לא תיקנה | תבנית C / רמאנד | בינוני | תיקי רמאנד |
+| חוק / פרשנות תכליתית | תבנית D (8xxx מהותית) | ארוך | אקדמית |
+
+**עיקרון**: זיהוי הראיה הניצחת מתרחש **אחרי קריאת כתבי הטענות והדיון**, **לפני** כתיבת בלוק י. הסוכן צריך להקדיש 5-10 דקות לשאלה הזו לפני שהוא מתחיל לבנות.
+
+---
+
+## 1. עץ החלטה ראשי — בחירת סוג ארכיטקטורה
+
+```
+שלב 1: מהי התוצאה הצפויה? (מ-chair_directions / expected_outcome)
+│
+├─ דחייה
+│  ├─ פשוטה וברורה (טענה אחת מכריעה)
+│  │   → architecture-by-outcome.md §1 (קצר, מוד A)
+│  │   → אורך: 555-2,000 מילים
+│  │
+│  ├─ מורכבת (3+ סוגיות, טענות מהותיות משני הצדדים)
+│  │   → architecture-by-outcome.md §2 (מוד B/C)
+│  │   → אורך: 2,500-4,500 מילים
+│  │
+│  └─ דחיית סף + מהות "למען הסדר הטוב"
+│      → architecture-by-outcome.md §3 (מוד F)
+│      → אורך: 2,800-8,500 מילים
+│
+├─ קבלה חלקית
+│   → architecture-by-outcome.md §5 (מוד B/E + פילוסופי ב-1xxx)
+│   → אורך: 3,500-5,500 מילים
+│   → סימן ייחודי: ניסוח האיזון, "אינה דחייה אלא הכרה"
+│
+├─ קבלה מלאה — שאל: מה הסיבה לקבלה? (acceptance-architecture.md §1)
+│  ├─ הוועדה קבעה תנאי, לא וידאה שהוא מתקיים
+│  │   → תבנית A: קצר (1,500-2,000), בוטם-ליין, "הודאת צד נגדי", השמטה רחבה
+│  │   → ביטול: "החלטת הוועדה מתבטלת"
+│  │
+│  ├─ הוועדה דחתה ללא דיון תכנוני (תימוכין קנייניים)
+│  │   → תבנית B: בינוני-ארוך (3,000-9,500), פסיקה רחבה (אייזן, רוזן, טליאט)
+│  │   → סיום: "הבקשה תיקבע לדיון בוועדה" + הוראת הבהרה
+│  │
+│  ├─ הוועדה דנה אבל הליקויים ניתנים לתיקון
+│  │   → תבנית C: בינוני (4,000-4,500), פסיקה רחבה
+│  │   → סיום: "מתקבל בכפוף לתיקונים"
+│  │   → ייחודי: פסקת "הוועדה פעלה נכון בקיום הדיון"
+│  │
+│  ├─ סוגיה משפטית מהותית (פטור, מימוש, סטאטוס) — 8xxx
+│  │   → תבנית D: ארוך (5,000-7,500), אקדמי-משפטי
+│  │   → ספרות אקדמית מותרת (כרם, נמדר)
+│  │   → סיום: "דרישת התשלום בטלה" + השבת תשלום
+│  │
+│  └─ פגם בעבודת השמאי — 8xxx
+│      → תבנית E: קצר (1,500-2,500), בר"מ 3644/13 חובה
+│      → סיום: "השומה תושב לתיקון" + רשימת הוראות לשמאי
+│
+└─ תיק חוזר (רמאנד / החזרה מבית משפט)
+    → architecture-by-outcome.md §7
+    → ייחודי: תיעוד הרמאנד + בדיקת ציות
+    → אם הוועדה צייתה: דחייה רגילה
+    → אם הוועדה לא צייתה: חיוב הוועדה בהוצאות
+```
+
+---
+
+## 2. עץ החלטה משני — שאלות מבנה לאחר בחירת ארכיטקטורה
+
+### 2.1 כמה סוגיות בתיק?
+```
+├─ 1-2 סוגיות → זרימה רציפה, ללא כותרות משנה
+├─ 3+ סוגיות מובחנות לחלוטין (פסילה / עמידה / מהות)
+│   → architecture-by-outcome.md §4 (כותרות משנה תמטיות)
+│   → דוגמאות: 1079-24, 1041-24
+│
+└─ 3+ סוגיות באותו עניין (שיקולים בתוך נושא אחד)
+    → זרימה רציפה (כמו 1126-1141)
+```
+
+### 2.2 תיק מאוחד?
+```
+├─ כן (1043+1054, 1071+1077)
+│   → בלוק ז: כל ערר נפרד עם תת-כותרת "תמצית טענות הצדדים בערר X"
+│   → בלוק י: לפעמים דיון משותף (אם אותם נסיבות), לפעמים נפרד
+│   → ראה architecture-by-outcome.md §6
+│
+└─ לא → המשך לפי הבחירה לעיל
+```
+
+### 2.3 תיק חוזר אחרי רמאנד?
+```
+├─ כן
+│   → architecture-by-outcome.md §7
+│   → ביטויים: "אנו נחזור על כך כי...", "בהחלטה לעיל שבנו וחזרנו..."
+│   → אם הוועדה לא צייתה: חיוב הוועדה בהוצאות העוררים
+│
+└─ לא → המשך לפי הבחירה לעיל
+```
+
+### 2.4 סוג הערר — האם זה משנה?
+```
+├─ 1xxx (רישוי ובניה — תכנון)
+│   → אם תוצאה מורכבת: מסגור פילוסופי בפתיחה ("מתחים מובנים")
+│   → פסיקה: עע"מ שפר, עע"מ הרמלין, חוף השרון, אייזן
+│
+├─ 8xxx (היטל השבחה)
+│   → אם הכרעה שמאית: ציטוט בר"מ 3644/13 חובה (פסקת "התערבות במשורה")
+│   → אם סוגיה מהותית: ספרות אקדמית מותרת
+│   → ביטוי: "הסוגייה... מעמידה במבחן את נקודת המפגש בין X לבין Y"
+│
+└─ 9xxx (פיצויים סעיף 197)
+    → סעיף 197 חובה לציטוט במלואו
+    → תקדים יסוד: עניין רוטשטיין / טוטחיינר / 18/06 צפריר בנימין
+    → קור ויובש — אין מסגור פילוסופי
+```
+
+---
+
+## 3. עץ החלטה לפי בלוק
+
+### 3.1 בלוק ה — פתיחה
+- **תמיד**: 1-2 פסקאות. תיאור התיק במשפט אחד + תוצאה צפויה במשפט אחד.
+- ראה skills/decision/SKILL.md
+
+### 3.2 בלוק ו — רקע עובדתי
+- **קריטי**: ניטרלי, ללא ציטוטים מצדדים, ללא מילות שיפוט
+- ראה block-schema.md
+
+### 3.3 בלוק ז — טענות הצדדים
+- **חובה**: קרא `daphna-block-zayin-claims.md`
+- **שאלות לפני כתיבה**:
+  - סוג הערר (אישור / דחייה / 8xxx / מאוחד)?
+  - כמה צדדים?
+  - האם יש טענות סף של הצד הנגדי (משיב)?
+- **שלד**:
+  - "תמצית טענות הצדדים" (כותרת)
+  - "טענות העוררים" / "טענות העורר"
+  - "תגובת/עמדת הוועדה המקומית"
+  - "תגובת מגישי התכנית" / "תגובת המשיבה X"
+  - אופציונלי: "הדיון בוועדת הערר" / "מסמכים נוספים"
+- **אנטי-דפוסים**: רשימה ממוספרת, מילות הערכה, גילוי מסקנה
+
+### 3.4 בלוק ח — הליכים בפני ועדת הערר
+- **קריטי**: רק פעולות הוועדה (דיון, סיור, השלמות, החלטות ביניים)
+- **לא**: טיעונים שעלו בדיון (אלה בבלוק ז)
+
+### 3.5 בלוק ט — תכניות חלות (אופציונלי)
+- רק אם רלוונטי — תכנית עיקרית + תכניות נלוות
+- בכל הקורפוס שנבדק, בלוק ט קצר (1-3 פסקאות) או נעדר
+
+### 3.6 בלוק י — דיון והכרעה
+- **חובה**: קרא 5 מסמכי הקול (ראה למעלה)
+- **קריטי**: הראיה הניצחת + תבנית מתאימה + פעלי "אנחנו" נכונים
+
+### 3.7 בלוק יא — סוף דבר
+**ניסוח התוצאה לפי תבנית** (ראה acceptance-architecture.md §7.3):
+
+| תוצאה | ניסוח |
+|---------|--------|
+| דחייה | "לאור כל האמור לעיל, הערר נדחה" |
+| קבלה חלקית | "הערר מתקבל באופן חלקי, וזאת כדלקמן:" + פירוט |
+| קבלה תבנית A | "החלטת הוועדה המקומית... מתבטלת" |
+| קבלה תבנית B | "העררים מתקבלים במובן זה שהבקשות יקבעו לדיון בוועדה" + הוראת הבהרה |
+| קבלה תבנית C | "מתקבל בכפוף לתיקונים שפורטו לעיל" |
+| קבלה תבנית D | "דרישת התשלום בטלה" + השבת תשלום |
+| קבלה תבנית E | "השומה תושב לתיקון" + רשימת הוראות לשמאי |
+
+**הוצאות**:
+
+| נסיבות | ניסוח |
+|---------|--------|
+| דחייה רגילה | "העורר/ת ישא בהוצאות בסך X ₪ שישולם תוך 14 יום" |
+| דחייה / סוגיה מורכבת | "כל צד יישא בהוצאותיו" |
+| קבלה חלקית | "כל צד יישא בהוצאותיו" |
+| קבלה — נסיבות אישיות | "נוכח הנסיבות האישיות שפורטו, מצאנו שלא לחייב בהוצאות" |
+| קבלה — סוגיה משפטית מורכבת | "הסוגייה... הינה סוגיה משפטית מורכבת... איננו מוצאים מקום לחייב" |
+| קבלה — הוועדה התבצרה | "הוועדה המקומית תישא בהוצאות בסך X ₪" |
+| ועדה לא צייתה לרמאנד | "אנו מחייבים את הוועדה המקומית בהוצאות העוררים בסך X ₪ לכל עורר" |
+
+**חתימה**: "ניתנה פה אחד היום, [תאריך עברי], [תאריך לועזי]."
+
+---
+
+## 4. עץ החלטה לבחירת מוד פתיחה (בלוק י)
+
+```
+מהו טיב התיק?
+│
+├─ דחייה ברורה ופשוטה
+│   → מוד A — בוטם-ליין
+│   → "לאחר ש<חומרים>, הגענו לכלל מסקנה כי דין הערר להידחות"
+│
+├─ דחייה מורכבת + תהליך מקיף
+│   → מוד B — תיעוד תהליכי
+│   → "נקדים ונציין כי <דיון/סיור/השלמות>... ונפרט;"
+│
+├─ שאלה משפטית מהותית מובחנת (פטור, מימוש, סטאטוס)
+│   → מוד C — ניסוח סוגיה
+│   → "הסוגייה... מעמידה במבחן את נקודת המפגש בין X לבין Y"
+│
+├─ תיק עם הרבה עובדות מבולבלות
+│   → מוד D — ישיר-עובדתי
+│   → "הצדדים הרבו בטענות... התבהרה תמונה עובדתית ומשפטית כלהלן"
+│
+├─ קבלה חלקית
+│   → מוד E — תרכובת
+│   → "בכל הנוגע לטענה המרכזית... אנו מקבלים את עמדת..."
+│   → אם 1xxx מורכב: + מסגור פילוסופי לפני
+│
+├─ דחיית סף + דיון מהותי "למען הסדר הטוב"
+│   → מוד F — סף + מהות
+│   → "החלטנו בשלב ראשון כי... אך יחד עם זאת... מצאנו להוסיף"
+│
+├─ תיק חוזר אחרי רמאנד
+│   → מוד G — סקירה אחרי רמאנד
+│   → "כאמור, בהחלטת ועדת הערר השבנו את הדיון..."
+│
+└─ קבלה מלאה תבנית A (פגם פנימי, 1033)
+    → מוד A מותאם — בוטם-ליין + "ונפרט;"
+    → "מצאנו כי דין הערר להתקבל. ונפרט;"
+```
+
+---
+
+## 5. עץ החלטה לציטוטי פסיקה — לפי סוגיה
+
+מבוסס על `daphna-precedent-network.md`. לכל סוגיה — תקדם המנחה של דפנה.
+
+### סוגיות סף
+| סוגיה | תקדים מועדף |
+|---------|---------------|
+| זכות עמידה — עותר ציבורי | בג"ץ 910/86 רסלר + עע"ם 8723/03 הרצליה |
+| זכות עמידה — שוכר ארוך-טווח | עת"מ 34056-02-21 עירון + עע"מ 8193/02 פז |
+| סמכות ועדת ערר על היתר תואם | עע"מ 317/10 שפר |
+| תימוכין קנייניים | בג"ץ 1578/90 אייזן + עע"מ 4185/23 רוזן + טליאט |
+| פגם פרסום נרפא | ערר 1136/23 דוידוביץ |
+| פסילת חבר ועדה | ערר 1112/22 ירושלים שקופה |
+| עבירות בנייה כשיקול | בג"ץ 609/75 ישראלי + ערר 152/07 עמירה |
+
+### סוגיות מהותיות
+| סוגיה | תקדים מועדף |
+|---------|---------------|
+| תכנון נקודתי vs כולל | עע"מ 8909/13 הרמלין |
+| תוקף תכנית כדין | ע"א 3213/97 נקר |
+| סטייה ניכרת — תקנה 2(19) | ע"א 6291/95 בן יקר גת |
+| שילוב סעיפי 62א | בג"ץ 5145/00 חוף השרון |
+| חניה — נטל על מתנגד | ערר 1015-06-19 אבו נימר |
+| תמ"א 38 — שיקול דעת | ערר 1181/22 אדלר |
+| תכניות ישנות לפני 1996 | ערר 1110/20 תלמוד תורה בעלז |
+| שימוש חורג — "כבדהו וחשדהו" | עע"מ 109/12 גבעת האירוסים |
+| שיקולים תכנוניים רחבים | עע"מ 9387/17 המרכז למשפטים |
+
+### סוגיות 8xxx
+| סוגיה | תקדים מועדף |
+|---------|---------------|
+| התערבות בשמאי מכריע | בר"מ 3644/13 גלר (חובה!) |
+| נאמנות — מימוש זכויות | ע"א 7610/19 גליס |
+| פטור גמר בניה | ניתוח מילולי של סעיף 19(ג)(2) — תיק "גמר בניה" |
+| הקצאה מחדש (סעיף 21) | תיק "טור סיני" |
+
+### סוגיות 9xxx
+| סוגיה | תקדים מועדף |
+|---------|---------------|
+| התיישנות סעיף 197 | סעיף 119 לחוק + ערר 18/06 צפריר בנימין |
+| תיקון טעות סופר — האם פותח חישוב | ערר 67/00 זיו (לעוררים) / ערר 92002/22 שולמית (למשיבה) |
+
+---
+
+## 6. עץ החלטה לתקדמים אישיים של דפנה
+
+לפני כתיבה, תמיד `search_decisions` בקטגוריה זהה. אם נמצא תקדים אישי של דפנה — חובה להחליט באיזה מוד להפנות:
+
+```
+האם התיק זהה / דומה במהותו לתקדים שלי?
+│
+├─ זהה לחלוטין (אותה שכונה / אותו פרויקט)
+│   → ציטוט עצמי כתקדים: "כפי שקבענו בהחלטתנו ב<תיק>"
+│   → אורך מצומצם — להפנות, לא לחזור
+│
+├─ סוגיה משפטית זהה, נסיבות שונות
+│   → דחייה לדיון מפורט: "נפנה להנמקה המפורטת בהחלטתנו ב<תיק>"
+│   → לחסוך פסקאות דוקטרינה
+│
+├─ סוגיה זהה אבל תוצאה הפוכה
+│   → הבחנה (distinguishing): "בניגוד לתכנית שנדונה ב<תיק>, שם <X>, הרי שכאן <Y>"
+│   → קריטי לעקביות — שופט בית משפט מנהלי יבדוק את העקביות
+│
+└─ אין תקדים אישי
+    → להסתמך רק על תקדמים חיצוניים (סעיף 5)
+```
+
+ראה דוגמה ב-1194-25 פס' 61, 64, 97, 98, 99 — חמש הפניות שונות ל-1130-25 שלה עצמה.
+
+---
+
+## 7. עץ החלטה לאורך — לפי משקל בהכרעה
+
+```
+לכל סוגיה — איזה משקל יש לה בהכרעה?
+│
+├─ סוגיה מכריעה לבדה (1033: תכנית הצל)
+│   → 60-80% מבלוק י על סוגיה זו
+│   → לכל יתר הסוגיות: "לא מצאנו מקום להידרש אליהן"
+│
+├─ סוגיה משמעותית מבין כמה
+│   → 20-30% מבלוק י
+│   → דיון מלא, "אכן... אולם" אם נדחית
+│
+├─ סוגיה משנית — נדונה אבל לא מכריעה
+│   → 5-10% מבלוק י
+│   → פסקה אחת או שתיים
+│
+├─ סוגיה שמתייתרת
+│   → 1-3% — משפט אחד
+│   → "מכל מקום, סוגיית X מתייתרת לאור הקביעה לעיל"
+│
+└─ סוגיה שמבססת תקדים (גם אם לא מכרעת בתיק)
+    → 15-25% — דיון מלא
+    → "כתיבה לתיק הבא" — דפנה מבססת דוקטרינה לעתיד
+```
+
+**עיקרון קריטי**: אורך = משקל בהכרעה, **לא** מורכבות הסוגיה. סוגיה מורכבת אבל לא מכרעת — פסקה. סוגיה פשוטה אבל מכרעת — עמוד. ראה `voice-1130-25.md` סעיף 6.
+
+---
+
+## 8. ביטויי הקול — מטריצה מהירה
+
+מאוחד מ-`daphna-voice-fingerprint.md` סעיפים 1.2 ו-6.4. **אסור** להשתמש כקישור סתמי — כל פועל נושא תפקיד אינטלקטואלי.
+
+| פועל | תפקיד | מתי |
+|-------|--------|------|
+| **אנו סבורים** | שיפוט ערכי | בהכרעה אופרטיבית |
+| **מצאנו / לא מצאנו** | קביעת ממצא | אחרי בחינה |
+| **נציין** | תצפית צדדית | להוספת רקע |
+| **נפנה** | מעבר | לסוגיה / לפסיקה |
+| **נחדד** | חידוד נקודה שעלולה להיטשטש | לא כפתיחה כללית! |
+| **נדגיש** | חיזוק נקודה מרכזית | אחרי הצגתה |
+| **נוסיף** | חיזוק אגב | בסוף פסקה |
+| **נשוב על כך / נחזור על כך** | חזרה ביודעין | לרעיון מרכזי |
+| **נחזור ונדגיש** | וריאציה — חזרה + חיזוק | לעיקרון מארגן |
+| **נבהיר** | הבהרת מה **לא** הוכרע | לפעמים בסוף בלוק י |
+| **ודוק** | reductio ad absurdum | לפני "אם נקבל את פרשנות העורר... התוצאה תהיה..." |
+| **ברי כי** | קביעה משכנעת | לעובדה בסיסית |
+| **ללמדך כי** | מסקנה מציטוט | אחרי ציטוט פסיקה |
+| **קראנו / שמענו / ערכנו / ביקשנו / המתנו** | תיעוד תהליכי | בפתיחה / סיכום |
+| **התרשמנו** | רושם תהליכי | אחרי סיור / דיון |
+| **לא נוכל לקבל** | דחייה מנומסת | לעמדת צד |
+| **לא נעלם מעניינו** | הכרה בקושי | לקושי שלא נדון ישירות |
+| **לא נוכל להתעלם מ-** | קביעה קשה | לפגם בולט |
+| **בשולי הדברים** | הסתייגות עדינה | לתוספת אגב |
+| **מצאנו להוסיף כי** | תוספת חופשית | סוף פסקה |
+| **דא עקא** | תפנית בטיעון | לפני "אבל" משמעותי |
+| **שוב על מנת שלא לצאת בחסר** | תוספת ערך | לדיון מהותי בדחיית סף |
+| **כאמור / כפי שצוין לעיל** | חזרה לעובדה שכבר נכתבה | לקיצור |
+| **הדברים מתחדדים** | חיזוק | לראיה נוספת |
+| **הנה כי כן** | מעבר לחיזוק | אחרי ראיה |
+| **לסיכום נשוב על כך כי** | סגירה מסכמת | סוף בלוק י |
+
+---
+
+## 9. ביטויים מסורתיים — מטריצה לפי שימוש
+
+| ביטוי | משמעות | שימוש מועדף |
+|--------|----------|---------------|
+| **כבדהו וחשדהו** | ספקנות תוך כיבוד | שימוש חורג |
+| **דבר מה נוסף** | סף נוסף | זכות עמידה של עותר ציבורי |
+| **רע הכרחי** | כלי שיש להימנע ממנו | שימוש חורג |
+| **כביש עוקף תכנית** | סטייה משימוש מקובל | שימוש חורג מסולף |
+| **טעם לפגם** | פגם מוסרי | מתנגד עם עבירות בנייה |
+| **בלשון המעטה** | הסתייגות מנומסת | לפגם בולט שלא דנו בו במלואו |
+| **בנדון דנא** | בעניין שלפנינו | פתיחת פסקה (נדיר) |
+| **דא עקא** | תפנית | לפני "אולם" משמעותי |
+| **ודוק** | הבהרה | לפני reductio ad absurdum |
+| **ברי כי** | קביעה משכנעת | לקביעה ברורה |
+| **ללמדך כי** | מסקנה מציטוט | אחרי ציטוט פסיקה |
+| **משכך** | כתוצאה מכך | אחרי רצף נימוקים |
+| **משעה ש-** | מאז | למעבר לוגי |
+| **לאור כל האמור** | סיכום | לסיום פסקה / בלוק |
+
+---
+
+## 10. ביטויי קישור בנקודה-פסיק — דקדוק רטורי ייחודי
+
+לפני הצללת דיון פנימי, השתמש ב-`;` במקום `:` או `.`:
+
+| ביטוי | מתי |
+|--------|------|
+| **ונפרט;** | אחרי הצהרת תוצאה כללית, לפני פירוט |
+| **להלן נבחן את הדברים;** | לפני בחינת סוגיות |
+| **ברוח הדברים לעיל נבחן את טענות הצדדים;** | אחרי הצגת מסגרת דוקטרינלית |
+| **להלן נדון בטענות;** | לפני דיון פרטני |
+| **להלן נפרטה;** | לפני סקירה כרונולוגית/היסטורית |
+
+⛔ **אסור**: נקודה (`.`) או נקודתיים (`:`) במקומות אלה. נקודה-פסיק = "פסקה אחת מסיימת אבל הרעיון נמשך".
+
+---
+
+## 11. אנטי-דפוסים מאוחדים — צ'קליסט סופי
+
+לפני הגשת ההחלטה, עבור על הרשימה:
+
+### בלוק ז
+- [ ] אין רשימה ממוספרת `(1)... (2)...` בתוך פסקה
+- [ ] אין מילות הערכה ("בצדק", "בטעות", "משכנעת")
+- [ ] כל צד מקבל כותרת משנה אחידה
+- [ ] סדר הצדדים: עוררים → ועדה מקומית → משיבים אחרים
+
+### בלוק י
+- [ ] אין רשימה ממוספרת באנליזה
+- [ ] אין מספור פסקאות סדרתי (1., 2., 3.) — מגמה ישנה שננטשה
+- [ ] כותרות משנה רק אם 3+ סוגיות מובחנות
+- [ ] אין סיכומים בנקודות של החלטות אחרות — תמיד ציטוט מלא
+- [ ] אין דחיית טענה במשפט אחד — כל טענה משמעותית = פסקה
+- [ ] אין רטוריקה דרמטית של הצדדים בקול ההכרעה
+- [ ] אין תוצאה הכל-או-לא-כלום בתיק עם טענות מהותיות משני הצדדים
+- [ ] אין משפטים קטועים בסוף פסקה
+- [ ] אין פסיביזציה ("טענות העורר היו")
+- [ ] לא מסגור פילוסופי בתיקים פשוטים — רק 1xxx מורכב
+- [ ] בתיק 8xxx עם הכרעה שמאית: ציטוט בר"מ 3644/13 קיים
+- [ ] בתיק עם תקדים אישי: הפניה אליו (חיסכון / דחייה / הבחנה)
+- [ ] קבלה מלאה — תבנית מתאימה (A/B/C/D/E)?
+- [ ] השמטה רחבה ("לא מצאנו מקום להידרש") רק בתבנית A
+
+### כללי
+- [ ] עברית תקנית, ללא ערבוב לועזית
+- [ ] הקול "אנחנו" — כל פועל נושא תפקיד
+- [ ] ביטויי קישור בנקודה-פסיק במקומות הנכונים
+- [ ] הוצאות מותאמות לנסיבות (טבלה ב-§3.7)
+- [ ] חתימה "פה אחד" + תאריך עברי + לועזי
+
+---
+
+## 12. נוהל עבודה — סדר הפעולות לסוכן
+
+```
+1. קרא את כתבי הטענות + הדיון (מסמכי המקור)
+   └─ זמן: 15-30 דקות
+
+2. שלוף הקשר טכני
+   ├─ chair_directions (עמדות יו"ר)
+   ├─ get_claims (טענות מחולצות)
+   └─ search_decisions (תקדמים אישיים)
+   └─ זמן: 5-10 דקות
+
+3. עץ ההחלטה (מסמך זה)
+   ├─ §0: מה הראיה הניצחת?
+   ├─ §1: איזה ארכיטקטורה?
+   ├─ §2: כמה סוגיות / מאוחד / רמאנד?
+   ├─ §4: איזה מוד פתיחה?
+   └─ §7: מה האורך הצפוי לפי משקל?
+   └─ זמן: 5-10 דקות
+
+4. קרא את המסמכים הרלוונטיים בעומק
+   ├─ daphna-voice-fingerprint.md (תמיד)
+   ├─ daphna-precedent-network.md (לסוגיות הספציפיות)
+   ├─ daphna-architecture-by-outcome.md / daphna-acceptance-architecture.md
+   ├─ daphna-block-zayin-claims.md (לפני בלוק ז)
+   └─ voice-1130-25.md (אם תיק 1xxx מורכב)
+   └─ זמן: 15-20 דקות
+
+5. כתיבה — בלוק אחר בלוק
+   ├─ ה: 1-2 פסקאות
+   ├─ ו: רקע ניטרלי
+   ├─ ז: לפי daphna-block-zayin-claims.md
+   ├─ ח: הליכים בפני הוועדה
+   ├─ ט: תכניות חלות (אופציונלי)
+   ├─ י: לפי תבנית + מסמכי הקול
+   ├─ יא: לפי acceptance-architecture.md §7.3 + הוצאות
+   └─ זמן: לפי אורך התיק
+
+6. בדיקה אחרי כתיבה (§11)
+   └─ זמן: 5-10 דקות
+```
+
+---
+
+## 13. הערה לסוכן — מתי לסטות
+
+המסמך הזה הוא **כלי**, לא תורה. דפנה מתאימה את הכתיבה לתיק — לא ההפך. כשהסוכן רואה שהמסגרת לא מתאימה לתיק הספציפי:
+
+1. **תעדף את הראיה הניצחת** — הצורה משרתת אותה
+2. **תעדף את הקול הפעיל "אנחנו"** — הקבוע החשוב ביותר
+3. **תעדף את האנטי-דפוסים** — אלה אזהרות חזקות שלא לסטות
+
+אבל אורך, מוד פתיחה, סוגי תבניות — **גמישים**. דפנה לפעמים יוצרת מודי פתיחה חדשים לתיקים ייחודיים. מה שלא משתנה: הקול האנטליגנטי, האובייקטיביות בבלוק ז, "אכן... אולם" בבלוק י, וההפרדה בין שיקול דעת תכנוני (שלא בסמכות הוועדה) לבין אכיפת תנאים (שכן בסמכותה).
+
+---
+
+## 14. עדכון המסמך
+
+המסמך הזה הוא **תמצית** של 5 מסמכי הקול. כשמתעדכן מסמך מקור — יש לעדכן גם כאן:
+
+| מסמך מקור | מה לעדכן כאן |
+|------------|------------------|
+| `daphna-voice-fingerprint.md` | §8 (ביטויי קול), §9 (ביטויים מסורתיים), §10 (נקודה-פסיק), §11 (אנטי-דפוסים) |
+| `daphna-precedent-network.md` | §5 (תקדמים) |
+| `daphna-architecture-by-outcome.md` | §1 (עץ ראשי), §2 (משני), §4 (מודי פתיחה) |
+| `daphna-acceptance-architecture.md` | §1 (עץ ראשי — קבלה), §3.7 (פורמטי סיום) |
+| `daphna-block-zayin-claims.md` | §3.3 (בלוק ז) |
+
+ראה את הקבצים המקוריים לדוגמאות ולפירוט מלא. **המסמך הזה אינו תחליף** — הוא **מצביע** איזה סעיף ואיזה מסמך לקרוא לפי השאלה.

docs/daphna-precedent-network.md

@@ -0,0 +1,379 @@
+# רשת התקדמים של דפנה — הקאנון שלה
+
+מסמך זה ממפה את **גוף הידע המשפטי הקבוע** שדפנה משתמשת בו לכל סוגיה משפטית בתחומי 1xxx (תכנון ורישוי). הוא מבוסס על קריאה של 23 החלטות 1xxx + 10 החלטות 8xxx/9xxx.
+
+**העיקרון היסודי**: דפנה לא בוחרת תקדמים מקרי לכל מקרה. לכל סוגיה משפטית מרכזית **יש לה תקדים מועדף** שהיא מצטטת **באופן עקבי**. זה הקאנון שלה. הסוכן חייב לעקוב אחריו.
+
+---
+
+## 1. סוגיות סף
+
+### זכות עמידה של "עותר ציבורי"
+
+**העיקרון**: עותר ציבורי הוא חריג, נדרש "דבר מה נוסף" — פגיעה משמעותית בשלטון החוק.
+
+**תקדמים מנחים** (לפי סדר ציטוט אופייני):
+1. **בג"ץ 910/86 רסלר נ' שר הביטחון, פ"ד מב(2) 441** — מקור הליברליזציה
+2. **בג"ץ 1759/94 סרוזברג נ' משרד הביטחון, פ"ד נה(1) 625** — חריג: "רב את ריבו של אחר"
+3. **בג"ץ 6972/07 לקסר נ' שר האוצר** — טעמי הסייג (תפיסה כי "אם לא עתר → אין צורך בהתערבות שיפוטית")
+4. **עע"ם 8723/03 עיריית הרצליה נ' חוף השרון** — "דבר מה נוסף"
+5. **עע"מ 4881/08 אלמוג אילת** — פגיעה משמעותית בשלטון החוק
+6. **עת"מ (ת"א) 43259-06-11 הראל** — "ליברליזציה" אבל לא לעותר שמתעבר על ריב לא לו
+7. **עת"מ (חי') 2234-01-22 בורנשטיין** — "תיקון פגמים מהותיים"
+8. **בג"ץ 962/07 לירן** — חריג של "חשיבות חוקתית מן המעלה הראשונה"
+
+**תקדמים אישיים של דפנה**:
+- **ערר 1112/22 ירושלים שקופה** (מובא ב-1079-24, 1009-25)
+- **ערר 1015/21 ירושלים שקופה** (אותה מבקשת — שימוש לרעה במעמד)
+- **ערר 1015-01-22 ירושלים שקופה (בית שמש)** + עת"מ (י-ם) 44348-12-21 שאישר אותה
+
+**ביטוי המסגרת שדפנה משתמשת בו**:
+> "הפסיקה אכן הכירה באפשרות של 'עותר ציבורי'... אך זאת רק במקרים חריגים, אם הצביע אותו אדם... על פגיעה משמעותית בשלטון החוק, בצורך באכיפת עקרונות חוקתיים, או על פגמים מהותיים בפעולת המינהל הציבורי"
+
+**מילות מפתח לחיפוש**: "עותר ציבורי", "דבר מה נוסף", "מתעבר על ריב לא לו"
+
+---
+
+### זכות עמידה של מי שאינו בעל קניין
+
+**העיקרון**: שוכר ארוך-טווח עם זיקה ישירה למקרקעין — כן זכות עמידה.
+
+**תקדמים מנחים**:
+1. **עת"מ 34056-02-21 עירון** — "מעגל הזכאים יכול שיכלול גם את מי שאין לו זכות במקרקעין"
+2. **עע"מ 8193/02 פז** — "מגמה כללית של הקלה בתנאי העמידה"
+3. **סעיף 100 לחוק התכנון והבניה** — מי רשאי להגיש התנגדות
+
+**ביטוי המסגרת**:
+> "כפי שנטען בפנינו העורר מחזיק כשוכר... זה למעלה מ-X שנים. טענותיו... הן טענות לטעמנו של מי ש'רואה עצמו נפגע' כמשמעות המונח בחוק"
+
+**הסתייגות אופיינית**:
+> "אכן, יש לזכור כי ההתנגדות הינה של שוכר ועל כן טענותיו אמורות להיות בגדר פגיעה בהנאה של שוכר ולא של בעל קניין שלעיתים הינן טענות שונות במהותן ובעצימותן"
+
+---
+
+### "הלכת שפר" — סמכות ועדת ערר על היתר תואם תכנית
+
+**עע"מ 317/10 שפר נ' מורן סקאל יניב** — תקדים יסוד לכל תיק 1xxx.
+
+**הציטוט הקלאסי**:
+> "מקום בו המתנגד למתן ההיתר לא מעלה טענה של סטיה מתכנית, אזי רואים את היתר הבניה כהיתר שניתן ב'מסלול הירוק' ותרופתו של המתנגד אינה בוועדת הערר... היה ותמצא ועדת הערר כי ההיתר תואם את התכנית החלה על האזור, הרי שבכך יסתיים הדיון."
+
+**מתי דפנה מצטטת**:
+- כשהמתנגד טוען לסטייה מתכנית בהיתר תואם
+- כשיש שאלה האם בכלל יש לה סמכות לדון
+
+**תקדם תומך**: עת"מ (ב"ש) 65175-09-17 נחמה אזולאי — מבהיר שאם ההיתר תואם → אין סמכות.
+
+---
+
+### זכות ערר על דחיית התנגדות (סעיף 152)
+
+**העיקרון**: זכות ערר תחומה לדחיית התנגדות מסעיף 149(א) — להקלה / שימוש חורג / תשריט בסטייה. **לא** לכל החלטה של רשות רישוי.
+
+**תקדמים**:
+1. **ערר ת"א 1006-08-22 יניב עזרא נ' החברה לפיתוח הרצליה** — "סעיף 149 ככזה המתיר התנגדות בעניין ההקלה ובעניינה בלבד"
+2. **עע"מ 1461/20 אנטרים אינווסטמנטס** — "השלב של בקשה להיתר... אין לציבור בכללותו זכות להגשת התנגדות"
+3. **ערר חי' 1017-02-23 חנין בר יוסף** (מיכל הלברשטם דגני)
+4. **ערר ת"א 1039-07-23 דוד נחמיאס**
+5. **ערר ת"א 1026-02-23 ג'ולי רבי**
+6. **ערר מרכז 1011-03-25 נגאח עבד אל קאדר** — "ניתוח מקיף"
+
+---
+
+### טענות קנייניות — אינן בסמכות מוסדות התכנון
+
+**העיקרון**: ועדת הערר אינה מכריעה במחלוקות קנייניות.
+
+**תקדמים מרכזיים**:
+1. **בג"ץ 1578/90 אייזן** — "בשום מקרה לא תכרענה הועדות בשאלות הקנייניות לגופו של הענין"
+2. **בג"ץ 419/14 סלואד** — הבחנה בין דיני תכנון לדיני קניין
+3. **עע"מ 317/10 שפר** — "מחלוקות בשאלות קנייניות... הנדונות בערכאות האזרחיות הרגילות"
+4. **עע"מ 4440/21 יהלומית פרץ** — מתי לא לעכב דיון
+5. **עע"מ 4185/23 רוזן** — שיקול דעת לעכב/לא לעכב
+6. **עע"מ 3975/22 ב. קרן-נכסים** — תיק עדכני (2025) — "מתחם הסבירות"
+
+**תקדמים אישיים**:
+- **ערר 1524-05-24 עמאש** — היתכנות קניינית מול זכות קניינית
+- **ערר 1132-19 שטרנפלד** — חזרה מהסכמה
+- **ערר 1093-19 כביר** — חזרה מהסכמה
+- **ערר 1065/22 עובדיה מכלוף** — מתנגדים שחזרו מחתימה
+
+**ביטוי הסיום הקלאסי** (חוזר ב-3+ תיקים):
+> "החלטתנו זו וכך גם אישור הבקשה להיתר אין בהם בכדי להוות כל הכרעה בשאלות הקנייניות שבין הצדדים, והדלת פתוחה בפני כל צד לפנות לערכאות המוסמכות בעניינים אלו"
+
+---
+
+### פגמי פרסום — נרפא ב-ריפוי בפועל
+
+**העיקרון**: פגם פורמלי בפרסום נרפא אם המתנגד **קיבל את מלוא יומו** בפועל.
+
+**תקדמים**:
+1. **ערר 1136/23 דוידוביץ נ' הוועדה המקומית ירושלים (שנלר)** — "במידה שהיה פגם בפרסום, הרי שהוא נרפא בעת הגשת הערר והדיון המעמיק בו"
+
+**ביטוי המסגרת**:
+> "גם אם נפל פגם מסוים בפרסום הרי שהוא נרפא על ידי שמיעת המתנגדים והעוררים. אין חולק כי העוררים ידעו על התכנית בפועל, הגישו התנגדויות... נשמעו... הגישו השלמות טיעון, והשתתפו בסיור."
+
+---
+
+### בקשות לפסילת חברי הוועדה
+
+**העיקרון**: צעד חריג, דורש ביסוס ממשי.
+
+**תקדמים**:
+- **ערר 1112/22 ירושלים שקופה** (מצוטט ב-1079-24)
+
+**ביטוי המסגרת**:
+> "בקשה לפסילת חבר ועדת ערר היא צעד חריג הדורש ביסוס ממשי"
+
+**מתי לדחות**:
+- תרומה זניחה (₪1,000) שאין בה זיקה אישית
+- כתב מינוי תקין מרשות מוסמכת
+- טענה שכבר נדונה בפני מותב אחר
+
+---
+
+### עבירות בנייה כשיקול
+
+**העיקרון**: עבירות בנייה במגרש המתנגד / מבקש ההיתר — שיקול ודאי, **לא חזות הכל**.
+
+**תקדמים**:
+1. **בג"ץ 609/75 ישראלי נ' עיריית ת"א** — לגבי מבקש ההיתר
+2. **ערר 152/07 עמירה אורלי** — לגבי מתנגד עם עבירות
+3. **ערר 1175/18 בן שבתאי עליזה** — עקרון כללי
+4. **ערר 1173/23 רחמים כהן** — סיכום הפסיקה ("חוסר תום לב")
+5. **עע"מ 9387/17 המרכז למשפטים ולעסקים** — "השיקולים של הגנה על שלטון החוק... אינם חזות הכל"
+
+**ביטוי המסגרת**:
+> "מתנגדים אשר באמתחתם עבירות בניה, עבירות אלו יש ויהוו טעם לדחיית התנגדותם" / "יש טעם לפגם"
+
+---
+
+## 2. סוגיות מהותיות
+
+### תכנון נקודתי vs תכנון כולל
+
+**העיקרון**: תכנון כולל מועדף, אבל לא תנאי מוחלט. שינוי נסיבות + חלוף זמן יכולים להצדיק נקודתי.
+
+**תקדמים מנחים**:
+1. **עע"מ 8909/13 הרמלין** — תקדים מנחה. "אשר לתכנון כולל, מדובר בהעדפה מוצדקת, אך רק בהעדפה; לא בחזות הכל"
+2. **בג"צ 581/87 צוקר** — אין הוראה ברורה שתכנית פרטנית חייבת להמתין לכוללת
+3. **בג"צ 2920/94 אדם טבע ודין** — דימוי "מבעד עינית המיקרוסקופ"
+4. **ערר (מטה) 45/17 אעבלין** — ניתוח עומק של היחס
+5. **ערר (מרכז) 1078-12-24 חפץ חיים פ"ת** — הקריטריונים העדכניים
+6. **עניין גלובלינקס** — "מידה מסוימת של ודאות"
+
+**תקדם אישי שלה**:
+- **1130-25** (תקדים שלה עצמה — לעתיד יקרא בתיקי קריית יערים)
+
+**ביטוי המסגרת**:
+> "אין חולק כי דרך המלך, הדרך העדיפה היא התכנון הכולל ולאחריו הפרטני, יחד עם זאת המציאות מוכיחה כי לעיתים נכון לקדם תכנון נקודתי כאשר אילוצים שונים אינם מצדיקים הקפאת קידום תכנון שנמצא כראוי"
+
+---
+
+### תוקף תכנית כדין מחייב
+
+**העיקרון**: תכנית מתאר היא חיקוק. לא ניתן לתקוף את הוראותיה במסגרת ערר על היתר.
+
+**תקדמים**:
+1. **ע"א 3213/97 נקר נ' הוועדה המקומית הרצליה** — "תכנית מתאר הינה חיקוק"
+2. **ע"א 398/63 ליבוביץ** — מקור המסורת
+3. **ע"א 119/86 קני בתים** — חוקי עזר ותכניות הן "חיקוקים"
+4. **בג"ץ 25/82 רוסיניק** — חזקת תקינות פרסום
+5. **ערר (צפון) 314/11 שלום יוקנעם** — "משאושרה תכנית, הפכה היא לדין"
+
+**ביטוי המסגרת**:
+> "אין חולק כי תכנית מתאר הינה חיקוק ופרסומה ברשומות הוא הפרסום המחייב... הטוען נגד תוכנה של תכנית, הנטל על שכמו רובץ הוא להוכיח כי נפל שיבוש בפרסום"
+
+---
+
+### סטייה ניכרת — תקנה 2(19) ופרשנות הלכת בן יקר גת
+
+**העיקרון**: תקנה 2(19) **לא** ביטלה את הלכת בן יקר גת — רק צמצמה. הוראות גורפות בתכנית בטלות; הוראות ספציפיות תקפות.
+
+**תקדמים**:
+1. **ע"א 6291/95 בן יקר גת** — "הלכת בן יקר גת" — הוראה גורפת בטלה
+2. **עת"ם (י-ם) 400/07 מרדכי חי ארנון** — פרשנות תקנה 2(19) אחרי בן יקר גת
+3. **ערר (י-ם) 293/13 פרופ' חיים סומר** — דיון מעמיק (חבר ועדה אחר — "ג.ה.")
+4. **ערר (מרכז) 352/14 מנצ'ר דוד** — מודיעין
+
+**ביטוי המסגרת**:
+> "מתקין התכנית רשאי היה לקבוע שורה של נושאים לגביהם בלבד סטייה מהתכנית תהווה סטייה ניכרת, ומתקין התכנית אינו מוגבל לקביעת נושא אחד בלבד"
+
+---
+
+### סמכות ועדה מקומית — שילוב סעיפי 62א
+
+**העיקרון**: ועדה מקומית רשאית לצרף בתכנית אחת סמכויות מסעיפי משנה אחדים של 62א.
+
+**תקדם יסודי**:
+1. **בג"ץ 5145/00 חוף השרון** (הרכב מורחב 7 שופטים) — תקדים מנחה
+2. **עת"מ (ת"א) 70495-01-20 ג'יבלי** — שילוב 62א(א)(4א) ו-(5)
+
+**תקדם אישי**:
+- ערר 198/09 פן (מצוטט אבל **מובחן** ב-1130-25 — "אותו ערר עסק בהקשר שונה")
+
+**ביטוי המסגרת**:
+> "ועדה מקומית רשאית לצרף בתכנית אחת סמכויות המוקנות לה בסעיפי-משנה אחדים שבסעיף 62א(א)"
+
+---
+
+### חניה — תקן ופתרון
+
+**העיקרון**: דחייה ליועץ תנועה. טענת מתנגד צריכה חוו"ד.
+
+**תקדמים**:
+1. **ערר (צפון) 1015-06-19 אבו נימר אנס** — נטל הוכחה על מתנגד
+2. **ב"ש 6001/06 פלדמן** — אותו עיקרון
+3. **ערר ת"א 1090-07-19 אלמוג ים סוף**
+
+**ביטוי המסגרת**:
+> "טענות העורר... לא נתמכו בכל חוו"ד ונותרו בגדר חשש לא מבוסס בעוד שמנגד קיים אישור של יועץ התנועה"
+
+---
+
+### תמ"א 38 / 10038 — שיקול דעת תכנוני
+
+**העיקרון**: זכויות תמ"א 38 הן זכויות שבשק"ד, לא מוקנות. הוועדה המקומית שוקלת מאפיינים מקומיים.
+
+**תקדמים אישיים** (אקוסיסטם של דפנה):
+- **ערר 1181/22 אדלר** ("עניין אדלר") — תקדים מרכזי
+- **ערר 1192/18 חגית אילן** — שילוב תמ"א 38 + שימור
+- **ערר 100/17 בן שטרית** — תכנון מתאים
+- **ערר 503/15 שולמן** — תוספת יחידות
+
+**ביטוי המסגרת**:
+> "תמ"א 38 מאפשרת אישור תוספת זכויות ללא הליך תכנוני מפורט, ומשכך הזכויות מכוחה אינן זכויות מוקנות. במסגרת שיקול הדעת התכנוני המוקנה בהליכים לפי תמ"א 38 ותכנית 10038, לוועדה המקומית שיקול דעת תכנוני רחב"
+
+---
+
+### תכניות ישנות (לפני 1996) — סעיף 145(ז)
+
+**העיקרון**: תכניות ישנות לא חייבות בפירוט סעיף 145(ז), אבל "סמכות לחוד שיקול דעת לחוד".
+
+**תקדמים מנחים**:
+1. **ע"א 7654/00 ועדת ערר חיפה נ' הירדן** — חולשה של "עקרונות כלליים בלבד"
+2. **עע"מ 241/12 פז בית הזיקוק אשדוד** — קריטריון "פירוט מספק"
+3. **עת"מ (ת"א) 6/97 ועד אמנים** — בעיית תכניות בינוי
+4. **עע"מ 7171/11 איכות חיים נהריה** — "סמכות לחוד שיקול דעת לחוד"
+
+**תקדמים אישיים** (אקוסיסטם דפנה):
+- **ערר 1110/20 תלמוד תורה בעלז** — תקדים מרכזי
+- **ערר 1029/18 המועצה לשימור**
+- **ערר 1255/18 גבעת מרדכי**
+- **ערר 1155/19 המנהל הקהילתי ברוממה** — "דיון עקרוני ארוך"
+- **ערר 1079/22 ארביטשר**
+- **ערר 287/14 ספדי** — מבנים אופייניים
+- **ערר 1044-05-24 שריגים**
+
+**ביטוי המסגרת**:
+> "אכן יתכנו מקרים בהם הבינוי המבוקש... יהא בינוי בהיקף בניה סביר וראוי התואם את רוח התקופה בה אושרו התכניות הישנות... אולם לטעמנו עלולה היא להיות נגועה באי יעילות תכנונית"
+
+---
+
+### שימוש חורג — "כבדהו וחשדהו"
+
+**העיקרון**: כלי "רע הכרחי" שיש להימנע משימוש בו במידת האפשר.
+
+**תקדמים**:
+1. **בג"ץ 389/87 סלומון** — מקור הזהירות
+2. **ע"א 5927/98 בחוס** — "מעין רע הכרחי"
+3. **עע"מ 109/12 גבעת האירוסים** — "כבדהו וחשדהו" + "כביש עוקף תכנית"
+4. **עע"מ 402/03 עמותת העצמאים אילת** — מגבלות זמן
+5. **עע"מ 10089/07 אירוס הגלבוע** — אזהרה
+6. **עת"מ (ת"א) 1254/07 לאה ברוך** — "במשורה"
+
+**ביטוי המסגרת**:
+> "התפיסה הראויה ביחס לכלי השימוש החורג מתבטאת היטב במכתם 'כבדהו וחשדהו'... אין שימוש חורג בחינת 'כביש עוקף תכנית'"
+
+---
+
+### שיקולים תכנוניים רחבים
+
+**העיקרון**: מוסד תכנון שוקל מגוון שיקולים — לא רק "תכנוניים צרים".
+
+**תקדם מנחה**:
+- **עע"מ 9387/17 המרכז למשפטים ולעסקים נ' ועדת המשנה לעררים** — "שיקולים תכנוניים במובן הרחב"
+
+**תקדמים תומכים**:
+- עע"מ 3319/05 פונטה
+- עע"מ 65/13 נאות מזרחי
+- עניין איגנר
+
+---
+
+## 3. סוגיות פרוצדורליות
+
+### שיהוי בהגשת ערר
+
+**העיקרון**: עמידה בסדרי דין חובה. בקשת הארכה מנומקת.
+
+**תקדם**:
+- **ערר 1018/20 ירושלים שקופה** — סמכות ועדת ערר להארכת מועד
+
+---
+
+### שינוי נסיבות מהותי
+
+**העיקרון**: שינוי בעמדת הוועדה המחוזית, חלוף זמן + תכניות מקבילות = שינוי נסיבות.
+
+**יישום אישי** (1130-25): "מדיניות הוועדה המחוזית השתנתה מהותית מאז 2017" — בסיס לקבלה חלקית.
+
+---
+
+### החלטה על דיון חוזר במליאת ועדה
+
+**העיקרון**: רשאית להותיר על כנה (חותמת גומי לגיטימית).
+
+**תקדם**:
+- **תקנות התכנון והבנייה (סדרי הדיון בקיום דיון חוזר במוסד תכנון) תשס"ג-2003** — "מוסד תכנון המקיים דיון חוזר רשאי להותיר את החלטת ועדת המשנה על כנה"
+
+---
+
+## 4. התקדמים החיצוניים שדפנה לא מצטטת — אבהרה לסוכן
+
+מה ש**אינו** בקאנון של דפנה (ולכן הסוכן לא צריך להמציא):
+- ❌ ספרות אקדמית כללית (פרט לכרם בנאמנות, נמדר בעלות עודפת)
+- ❌ פסקי דין רוסיים/אמריקאיים
+- ❌ פסיקה משנות ה-50 וה-60 (פרט לליבוביץ ע"א 398/63 הקלאסי)
+
+מה ש**כן** מועדף:
+- ✓ פסיקת בג"ץ ועליון לאחר שנות ה-2000
+- ✓ פסיקת בית המשפט לעניינים מנהליים
+- ✓ ועדות ערר מקבילות (חיפה, מרכז, ת"א, דרום, צפון) — בכבוד
+- ✓ דעות מיעוט שלה / החלטות שלה עצמן
+
+---
+
+## 5. הוראות אופרטיביות לסוכן
+
+### לפני כתיבת בלוק י — שלב חיפוש תקדים
+
+1. **זהה את הסוגיות המשפטיות** בתיק (סף + מהות).
+2. **לכל סוגיה — בדוק האם היא במפת הקאנון לעיל**. אם כן → השתמש בתקדם המועדף, לא תקדמים אקראיים.
+3. **חפש תקדמים אישיים של דפנה** — `search_decisions` בקטגוריה זהה. אם יש → ציטוט בנוסחת:
+   - "כפי שקבענו בהחלטתנו ב<תיק>, ..."
+   - "נפנה להנמקה המפורטת בהחלטתנו ב<תיק>"
+   - "בניגוד למקרה ב<תיק>, שם <X>, הרי שכאן <Y>"
+
+### שיטת ציטוט
+
+- **תמיד ציטוט מלא** של הפסקה הרלוונטית (4-15 שורות)
+- הפניה: `(פורסם בנבו)` או `[נבו]` עם תאריך אם זמין
+- ל-תקדם שיחזור — תן כינוי: "(להלן: 'עניין X')"
+
+### חברי ועדה אחרים
+
+כשמצטטים החלטה של חבר ועדה אחר — לציין **בכבוד**:
+> "ראו לעניין זה החלטת ועדת הערר בראשות כב' היו"ר X..."
+
+---
+
+## 6. תוספת — מה שדפנה תוסיף ככל שהקאנון יתפתח
+
+הקורפוס הזה (33 קבצים) הוא נקודה בזמן. דפנה ממשיכה לכתוב והקאנון שלה ימשיך לגדול. **כל החלטה שלה הופכת לתקדם פוטנציאלי**. הסוכן צריך לרענן את הרשימה הזו אחרי כל קליטת החלטה סופית באמצעות `ingest_final_version`.
+
+---
+
+## 7. נקודות הערה לעריכה ידנית של דפנה
+
+ייתכן שדפנה תרצה להוסיף או להחריג תקדמים מהקאנון. המסמך הזה הוא **ההצעה שלי** המבוססת על קריאת 33 החלטות. דפנה מוזמנת לסמן (1) תקדמים שאין צורך לאזכר; (2) תקדמים שחסרים; (3) תקדמים מועדפים יותר.

docs/daphna-voice-fingerprint.md

@@ -0,0 +1,423 @@
+# טביעת אצבע של הקול — ניתוח הקורפוס המלא של דפנה
+
+מסמך מטא-סגנון מבוסס על קריאה עמוקה של 23 החלטות 1xxx + 10 החלטות 8xxx/9xxx. מטרתו: לזקק את ה**קבועים** האמיתיים של דפנה, מעבר לפרטי תיק או סוג ערר, באופן שניתן להזריק ל-system prompt של `legal-writer`.
+
+## רכיבי הקול — שישה מסמכים משלימים
+
+המסמך הזה הוא **המסגרת הכללית**. הוא מתואם עם חמישה מסמכים תפעוליים:
+
+0. **[daphna-decision-tree.md](daphna-decision-tree.md)** — **כלי הפעולה היומיומי**. מאחד את כל המסמכים לעץ החלטה תפעולי. כשהסוכן בא לכתוב — להתחיל כאן.
+1. **[voice-1130-25.md](voice-1130-25.md)** — קריאה עמוקה של תיק יחיד (1130-25) המראה איך הקול עובד בקונקרטית. סעיף 11 בו מרחיב להשוואה 1130 vs 1194.
+2. **[daphna-precedent-network.md](daphna-precedent-network.md)** — מיפוי הקאנון המשפטי: לכל סוגיה משפטית, איזה תקדם דפנה מצטטת. **קריאת חובה לפני בלוק י.**
+3. **[daphna-architecture-by-outcome.md](daphna-architecture-by-outcome.md)** — איך משתנה מבנה בלוק י לפי סוג התוצאה. כולל עץ החלטה לסוכן. **קריאת חובה לפני בלוק י.**
+4. **[daphna-acceptance-architecture.md](daphna-acceptance-architecture.md)** — חמש תבניות שונות לקבלת ערר. **קריאת חובה כשהתוצאה צפויה להיות קבלה (לא חלקית).**
+5. **[daphna-block-zayin-claims.md](daphna-block-zayin-claims.md)** — כללי כתיבה של בלוק ז (טענות הצדדים): מבנה, ניטרליות, ביטויי קישור, אנטי-דפוסים. **קריאת חובה לפני בלוק ז.**
+
+---
+
+## 0. הקורפוס שניתח
+
+**גרסה 1 — 10 החלטות מתוך `data/training/`:**
+
+| תיק | סוג | מילים בבלוק י | תוצאה |
+|------|-----|---------------|-------|
+| גמר בניה | 8xxx (פטור) | 6,047 | קבלה |
+| **החלטה-1130-25** | 1xxx (תכנית) | 4,409 | קבלה חלקית |
+| ורדיה | 8xxx (השבחה) | 1,954 | חלקית |
+| זכרון דברים | 8xxx (מימוש) | 3,368 | דחייה |
+| טור סיני | 8xxx (השבחה) | 3,255 | קבלה (חלקית) |
+| כלמוביל | 8xxx (השבחה) | 4,325 | מינוי שמאי מייעץ |
+| נאמנות | 8xxx (פטור) | 5,330 | קבלה |
+| סופר נוח | 8xxx (השבחה) | 2,208 | קבלה |
+| עלות עודפת בחניה | 8xxx (השבחה) | 555 | דחייה |
+| קרקעות ירושלים | 9xxx (פיצויים) | 4,314 | דחייה |
+
+**גרסה 2 — הרחבה ל-48 החלטות מ-`style_corpus` ב-DB:**
+- 24 building_permit (1xxx)
+- 22 betterment_levy (8xxx)
+- 2 compensation_197 (9xxx)
+
+מתוך ה-24 1xxx, 23 קבצים בעלי content מספיק נותחו. רובם מתפלגים בין 2,000-8,500 מילים בבלוק י.
+
+**הסקה משולבת**: עכשיו הקורפוס מאוזן יותר (24 1xxx, 22 8xxx, 2 9xxx). הדפוסים שמתחת מבוססים על המכלול.
+
+---
+
+## 1. הקבועים (Daphna Invariants) — תקפים בכל סוג ערר
+
+### 1.1 כותרת בלוק י = "דיון והכרעה" (תמיד)
+ב-10/10 ההחלטות. אין וריאציה. לא "דיון", לא "ההכרעה" — תמיד `דיון והכרעה` ללא מספור.
+
+### 1.2 הקול ה-"אנחנו" הפעיל
+דפנה לעולם לא כותבת בקול שלישי ("הוועדה מוצאת"). תמיד גוף ראשון רבים פעיל. הפועלים הקבועים:
+
+| פועל | תפקיד | תכיפות (מתוך 10) |
+|-------|--------|-------------------|
+| **אנו סבורים** | שיפוט ערכי | 10/10 |
+| **מצאנו / לא מצאנו** | קביעת ממצא | 10/10 |
+| **נציין** | תצפית צדדית | 9/10 |
+| **נפנה** | מעבר לסוגיה/פסיקה | 9/10 |
+| **נחדד** | הבהרה שלא תיטשטש | 7/10 |
+| **קראנו / שמענו / ערכנו / ביקשנו / המתנו** | תיעוד תהליכי | 7/10 |
+| **נקדים ונציין** | פתיחת בלוק | 6/10 |
+| **נוסיף** | חיזוק אגב | 6/10 |
+| **התרשמנו** | רושם תהליכי | 4/10 |
+| **נשוב על כך / נחזור על כך** | חזרה ביודעין | 4/10 |
+| **נבהיר** | הבהרת מה לא הוכרע | 4/10 |
+| **ודוק** | reductio ad absurdum | 3/10 |
+
+**עיקרון**: אין פועל "אנחנו" שמשמש כקישור סתמי. כל אחד נושא תפקיד אינטלקטואלי. **לא להשתמש ב"נחדד" כפתיחת פסקה אם אין חידוד אמיתי.**
+
+### 1.3 דפוס "אישור-לפני-דחייה" (אכן... אולם)
+מופיע ב-8/10. במקרים של דחיית טענה משמעותית, דפנה תמיד **מאשרת את הטענה בנקודה הכי גבוהה שלה** ואז מסבירה למה לא מכריעה. הביטויים החליפיים:
+- `אכן [טענה אמיתית]... אולם [למה לא מכריע]`
+- `אכן צדק [צד]... יחד עם זאת...`
+- `יש ממש בטענת [צד]... אך מאידך...`
+- `דא עקא [תפנית]`
+
+**חריגים**: רק במקרים של דחיית סף קצרה ומובהקת, או כשאין טענה ראויה לאישור, דפנה מדלגת על הדפוס. ב-8/10 היא משתמשת בו לפחות פעם.
+
+### 1.4 מעבר עם נקודה-פסיק
+לפני הצללת דיון פנימי, דפנה משתמשת ב-`;` במקום `:` או `.`:
+- `ונפרט;` (1130, 1194)
+- `להלן נבחן את הדברים;` (טור סיני)
+- `ברוח הדברים לעיל נבחן את טענות הצדדים;` (ורדיה)
+
+זה דקדוק רטורי ייחודי: "הפסקה הסתיימה אבל הרעיון נמשך".
+
+### 1.5 ציטוטים מלאים, לא תמציות
+כשמובא תקדים — מובא במלואו (לפעמים פסקאות שלמות), עם ההפניה הסטנדרטית `(פורסם בנבו)` או `[נבו]` ותאריך. **לא** תמצית, **לא** "כפי שנקבע" בלי ציטוט. ב-9/10 ציטוטים בני 4-15 שורות.
+
+### 1.6 הצמדה לטקסט החוק
+כשמדובר בסעיף חוק רלוונטי — דפנה מצטטת אותו במלואו (לפעמים את כל סעיפי המשנה הרלוונטיים, גם אם רק אחד נדון). דוגמאות: סעיף 100 ב-1130, סעיף 197 ב-קרקעות ירושלים, סעיף 19(ג) ב-גמר בניה.
+
+### 1.7 מתח מנוסח במפורש
+ב-7/10 דפנה מנסחת את המתח/האיזון העומד בלב התיק במשפט ייחודי, לפעמים בפסקה הראשונה:
+- `דיני התכנון נדרשים מעצם טיבם ליישב מתחים מובנים בין X לבין Y` (1130)
+- `הסוגייה... מעמידה במבחן את נקודת המפגש בין X לבין Y` (נאמנות)
+- `המחוקק הגביל את הזמן... הגבלה המהווה איזון אינטרסים בין הפרט לציבור` (קרקעות ירושלים)
+
+### 1.8 דחייה ל"גורם מקצועי"
+ב-8/10 דפנה לא קובעת ערכים טכניים בעצמה אלא דוחה למומחה (שמאי, מהנדס, יועץ תנועה). זה לא חולשה — זו דוקטרינה. הדפוסים:
+- `לא מצאנו פגם בהכרעת השמאי המכריע` (כלמוביל, ורדיה)
+- `נקודת העוגן למסקנתנו זו היא המלצת הגורם המקצועי בוועדה` (1130)
+- `ההיקף המדויק... ייקבעו על ידי מהנדס הוועדה המקומית` (1130)
+
+### 1.9 "למעלה מן הצורך" כסגירת חלון לערעור
+ב-7/10 אחרי הכרעה משפטית עיקרית, דפנה מוסיפה טיעון חלופי:
+- `למעלה מן הצורך נוסיף כי גם אם היינו מקבלים את פרשנות העורר... התוצאה הייתה זהה` (1130)
+- `מכל מקום, אין בכך כדי לשנות את מסקנתנו` (1194)
+- `שוב בהנחה כי המדובר בשינוי מהותי...` (קרקעות ירושלים)
+
+זה לא ייתור — זה הגנה אסטרטגית מפני ערעור.
+
+### 1.10 פורמט הסיום
+3 רכיבים קבועים, בסדר זה:
+
+```
+1. הצהרת תוצאה: "הערר נדחה / מתקבל / מתקבל באופן חלקי"
+2. הוצאות: "העורר ישא בהוצאות בסך X ₪ שישולם תוך 14 יום" 
+   או: "בנסיבות העניין, כל צד ישא בהוצאותיו"
+3. תאריך + "ניתנה פה אחד"
+```
+
+---
+
+## 2. המשתנים — לפי סוג תיק וסוג תוצאה
+
+### 2.1 פתיחת בלוק י — בחירה מבין 5 מודים
+
+לפי הקורפוס, יש 5 מודי פתיחה. הבחירה ביניהם **לא רנדומלית** — היא תלויה במורכבות וודאות התוצאה:
+
+| מוד | מתי | דוגמה |
+|------|------|--------|
+| **A. בוטם-ליין** | תוצאה ברורה (דחייה / קבלה מובהקת) | "לאחר ששמענו... הגענו לכלל מסקנה כי דין הערר להידחות" (עלות עודפת, גמר בניה — מסיים מסיים אבל פותח עם השאלה) |
+| **B. תיעוד תהליכי** | תוצאה מורכבת + תהליך מקיף | "נקדים ונציין כי נערך דיון בפנינו... התבקשה התייחסותם" (ורדיה, 1130 — וריאציה פילוסופית) |
+| **C. ניסוח סוגיה** | תיק עם שאלה משפטית מובחנת | "הסוגייה... מעמידה במבחן את נקודת המפגש בין X לבין Y" (נאמנות, זכרון דברים) |
+| **D. ישיר-עובדתי** | התיק מסובך עובדתית, התוצאה מהנתונים | "הצדדים הרבו בטענות... התבהרה תמונה עובדתית ומשפטית כלהלן" (טור סיני) |
+| **E. תרכובת** | קבלה חלקית | "בכל הנוגע לטענה המרכזית... נקדים ונציין כי אנו מקבלים את עמדת [צד] כי..." (סופר נוח) |
+
+**כלל אצבע לסוכן**:
+- אם התוצאה דחייה מוחלטת ופשוטה → **A**
+- אם התוצאה דחייה אבל יש תהליך מקיף או טיעון מורכב → **B**
+- אם זה מקרה משפטי עם שאלה מהותית (פטור, מימוש, סטאטוס) → **C**
+- אם זה תיק עם הרבה עובדות מבולבלות → **D**
+- אם התוצאה קבלה חלקית → **E**
+
+### 2.2 פתיח דוקטרינלי לתיקי 8xxx (היטל השבחה / שמאי)
+
+**כמעט חובה** בכל תיק 8xxx שכולל הכרעה שמאית: ציטוט בר"מ 3644/13 (גלר/משרד התחבורה) — "התערבות ועדת הערר תיעשה במשורה". מופיע ב-7/9 תיקי 8xxx בקורפוס.
+
+תבנית קבועה לפסקה:
+```
+בטרם נתייחס לטענות הצדדים נזכיר כי כידוע הלכה היא כי התערבות 
+ועדת הערר בשיקול דעתו המקצועי של השמאי [המכריע/המייעץ] תיעשה 
+במשורה. להלן מפסק דינו של בית המשפט העליון בבר"מ 3644/13 משרד 
+התחבורה נ' גלר דוד ואארורה ואח' (פורסם בנבו):
+
+"7. שמאי מכריע ... [ציטוט מלא של פסקאות 7-8 או חלק מהן]"
+```
+
+**לסוכן ב-8xxx**: לכלול את הציטוט הזה בפתיחה אלא אם התיק לא נוגע להכרעה שמאית.
+
+### 2.3 פתיח פילוסופי לתיקי 1xxx (תכנון)
+
+ב-1130-25 דפנה פתחה במשפט פילוסופי על המתחים המובנים בדיני התכנון. **הקורפוס שלי מכיל רק 2 תיקי 1xxx** (1130, 1194), אז זה מבוסס על מדגם קטן. אבל בולט: ב-1xxx יש פתיחה ערכית-תיאורטית, ב-8xxx יש פתיחה דוקטרינלית-טכנית.
+
+### 2.4 אורך — תלוי בתפקיד התקדים
+
+| משקל בהכרעה | אורך משוער |
+|--------------|------------|
+| תיק "פולחני" — דחיה ברורה של ערר שמאי | 500-2,200 מילים |
+| תיק שמאי רגיל עם אנליזה כמותית | 2,000-4,000 |
+| תיק עם שאלה משפטית מהותית | 3,000-5,500 |
+| תיק שמבסס תקדים חוצה תיקים | 4,000-6,000+ |
+
+**עיקרון לסוכן**: לא לכוון לאורך מסוים. לכוון לאורך הנדרש להכרעה.
+
+---
+
+## 3. אנטי-דפוסים — מה דפנה לעולם **לא** עושה
+
+מבוסס על קריאת ה-10 החלטות + ההשוואה לטיוטות ה-AI:
+
+### 3.1 ❌ אסור: רשימה ממוספרת בתוך פסקה
+**ב-0/33** מהחלטות הסופיות יש `(1) ... (2) ... (3) ...` בתוך פסקת אנליזה אחת.
+**ב-3/3 טיוטות AI** שראיתי הופיעה רשימה ממוספרת — שהוסרה בעריכה.
+
+⚠️ **הבחנה חשובה**: זה שונה ממספור פסקאות סדרתי (1, 2, 3 ... כאוטוט-של-פסקאות), שכן עד 2025 דפנה כן השתמשה במספור סדרתי (כמו פסיקה מסורתית). מ-2025-מאוחר זה נטוש; ההחלטות החדשות (1126-25, 1128-25, 1130-25, 1194-25) **ללא** מספור פסקאות. **המגמה החדשה** היא נרטיב רציף ללא מספור.
+
+### 3.2 ⚠️ מותנה: כותרת משנה בלב בלוק י
+
+**מקרים שבהם דפנה משתמשת בכותרות משנה** (מתוך 33+ קבצים שנבדקו):
+- **1079-24** (1xxx, 8,440 מילים): "הבקשות לפסילה" / "מעמד המבקשת וזכות עמידה" / "עותרים ציבוריים" — מכיוון שהיו 3+ סוגיות משפטיות מובחנות (פסילת חבר ועדה, זכות עמידה, מהות ההיתר)
+- **נאמנות** (8xxx, 5,330 מילים): "מהותו של מוסד הנאמנות" — תיק אקדמי-משפטי מובהק
+
+**כלל אצבע**:
+- ✅ כותרת משנה **כן** — אם בלוק י כולל 3+ סוגיות מובחנות לחלוטין (לא רק שיקולים בתוך סוגיה אחת)
+- ❌ כותרת משנה **לא** — אם זו סוגיה אחת עם תת-שיקולים. הזרימה רציפה.
+
+**טון הכותרת**: שם הסוגיה בלבד, ללא מספור, ללא מילות "סעיף" / "פרק". דוגמאות: `הבקשות לפסילה`, `מעמד המבקשת וזכות עמידה`, `מהותו של מוסד הנאמנות`.
+
+### 3.3 ❌ אסור: סיכום מנוקד של החלטה אחרת
+לעולם דפנה לא תכתוב "החלטת הוועדה המקומית הייתה: (1) ..., (2) ..., (3) ...". במקום זאת היא תביא את ההחלטה ב**ציטוט מלא** עם ביטוי המעבר: `להלן ההחלטה אשר תובא במלואה לאור פירוטה וחשיבותה כמענה לערר`.
+
+### 3.4 ❌ אסור: רטוריקה דרמטית של הצדדים בקול ההכרעה
+ב-1130-25 העוררים תיארו "חטא קדמון תכנוני". דפנה ציטטה אבל **לא אימצה**: "לא נוכל להתייחס לאמירות עבר שעה שעסקינן בתכנית שאושרה כדין". העיקרון: לתעד דרמטיות, לא להתחבר אליה.
+
+### 3.5 ❌ אסור: תוצאה שלמה לטובת צד אחד בתיק עם טענות מהותיות משני הצדדים
+ב-7/10 התוצאות הן חלקיות / מותנות / עם איזון. דפנה מעדיפה איזון על קביעות חדות.
+
+### 3.6 ❌ אסור: דחיית טענה ב-משפט אחד
+לכל טענה משמעותית של הצדדים, דפנה מקדישה לפחות פסקה אחת — עם או בלי "אכן... אולם". דחיית טענה ב"טענה זו נדחית" סתם **לא נמצאה ב-0/10** מההחלטות.
+
+### 3.7 ❌ אסור: עדיף "העורר טוען ש..." על "טענת העורר היא..."
+דפנה משתמשת בפעלים פעילים: `העורר טוען`, `המשיבה טוענת`, `מבקשי התכנית מבקשים`. **לא** "טענות העורר היו ש..." (פסיביזציה).
+
+---
+
+## 4. תבניות מועתקות (Copy-Paste Templates)
+
+ניתן להזין ישירות ל-system prompt. כל אחת היא תבנית **מינימלית** — הסוכן ימלא את החלל.
+
+### 4.1 פתיחה — מוד A (בוטם-ליין)
+```
+לאחר ששמענו את טענות הצדדים, ועיינו ב<חומרים>, הגענו לכלל 
+מסקנה כי <תוצאה>. <משפט מעבר>;
+```
+
+### 4.2 פתיחה — מוד B (תיעוד תהליכי)
+```
+נקדים ונציין כי <אירועי התהליך הרלוונטיים — דיון, סיור, 
+השלמות טיעון>. <מסקנה כללית>. ונפרט;
+```
+
+### 4.3 פתיחה — מוד C (ניסוח סוגיה)
+```
+הסוגייה שנדונה בערר שלפנינו מעמידה במבחן את נקודת המפגש 
+בין <תחום משפטי 1> לבין <תחום משפטי 2> הנוגעים למקרה מושא הערר.
+השאלה המרכזית מתמקדת בסוגיה האם <שאלה ספציפית>.
+```
+
+### 4.4 פתיח דוקטרינלי לשמאי
+```
+בטרם נתייחס לטענות הצדדים נזכיר כי כידוע הלכה היא כי 
+התערבות ועדת הערר בשיקול דעתו המקצועי של השמאי [המכריע/המייעץ] 
+תיעשה במשורה. להלן מפסק דינו של בית המשפט העליון בבר"מ 3644/13 
+משרד התחבורה נ' גלר דוד ואארורה ואח' (פורסם בנבו):
+
+[ציטוט מלא של 5-15 שורות מפסקאות 7-8]
+
+ברוח הדברים לעיל נבחן את טענות הצדדים;
+```
+
+### 4.5 דיון בטענת סף
+```
+נפנה עתה לטענה <X>. <צד> טוען כי <הצגת הטענה במלואה>. 
+<אם רלוונטי: ציטוט סעיף החוק במלואו>
+<ציטוט פסיקה מלא>
+<יישום על העובדות>
+<אם רלוונטי: "אכן [נקודה תקפה]... אולם [למה לא מכריע]">
+<הכרעה>
+<אם רלוונטי: "למעלה מן הצורך נוסיף...">
+```
+
+### 4.6 פסקת איזון
+```
+לאחר <תהליכים שעשינו>, אנו סבורים כי האיזון הראוי הינו 
+<צמצום / קבלה חלקית / תיקון>. <נימוק>. <ההחלטה אינה דחיית 
+זכויות X אלא דווקא הכרה בהן + מימוש Y תוך איזון>.
+```
+
+### 4.7 פסקת סיום
+```
+לאור כל האמור, הערר <מתקבל/נדחה/מתקבל באופן חלקי, וזאת כדלקמן:>.
+
+<אם דחייה מוחלטת + הוצאות:> 
+העורר/ת ישא בהוצאות ההליך בסך של X ₪ שישולם למשיבה בתוך 14 יום.
+
+<אם קבלה חלקית או סוגיה מורכבת:>
+בנסיבות העניין, ומאחר ו<נימוק>, איננו מוצאים מקום לחייב 
+את מי מהצדדים בהוצאות וכל צד ישא בהוצאותיו.
+
+ניתנה פה אחד, <תאריך עברי>, <תאריך לועזי>.
+```
+
+---
+
+## 5. הוראות אופרטיביות לסוכן הכותב
+
+מקובץ עם סעיף 10 ב-[voice-1130-25.md](voice-1130-25.md), אלה ההוראות שאמורות להיכנס ל-system prompt של `legal-writer`:
+
+### 5.1 לפני כתיבת בלוק י — החלטות מנחות
+1. **מהי התוצאה הצפויה?** דחייה / קבלה / חלקית?
+2. **מהו המתח / האיזון בלב התיק?** נסח אותו במשפט אחד — זה הולך לפתיחה (אם מוד B/C/E).
+3. **איזה מוד פתיחה מתאים?** A/B/C/D/E (ראה טבלה 2.1)
+4. **האם זה תיק 8xxx עם הכרעה שמאית?** אם כן → לכלול ציטוט בר"מ 3644/13.
+5. **האם דפנה הכריעה בתיק קשור?** אם כן → search_decisions ולכלול הפנייה / הבחנה (ראה sec 11.2 ב-voice-1130-25).
+6. **מה האורך הצפוי לפי משקל בהכרעה?** (ראה 2.4)
+
+### 5.2 בכתיבה — איך לבנות פסקה
+1. שימוש מודע ב"אנחנו" — בחירת פועל לפי תפקיד (טבלה 1.2)
+2. כל טענה משמעותית → פסקה מלאה. לא דחייה במשפט.
+3. אם דוחים טענה → "אכן [נקודה תקפה]... אולם [למה לא מכריע]"
+4. ציטוטים → במלואם, לא תמציות
+5. סעיפי חוק → במלואם
+6. "למעלה מן הצורך" → לטיעונים מרכזיים
+7. דחייה למומחים → לסוגיות תכנוניות-טכניות
+8. **ללא רשימות ממוספרות** באנליזה
+
+### 5.3 חיפוש תקדימים אישיים
+לפני כתיבה — `search_decisions` בקטגוריה זהה. אם יש תקדים של דפנה עצמה — חובה להפנות אליו ב-3 מודים אפשריים:
+- חיסכון: "סוגיה זו נדונה בהרחבה בהחלטתנו ב<תיק>"
+- דחייה: "נפנה להנמקה המפורטת בהחלטתנו ב<תיק>"
+- הבחנה: "בניגוד לתכנית שנדונה ב<תיק>, שם <X>, הרי שבמקרה הנדון <Y>"
+
+### 5.4 אנטי-דפוסים — בדיקה אחרי כתיבה
+- [ ] אין רשימות ממוספרות באנליזה
+- [ ] אין כותרות משנה (חוץ מתיקים אקדמיים-משפטיים מובהקים)
+- [ ] אין סיכומים של החלטות אחרות בנקודות
+- [ ] אין דחיית טענה במשפט אחד
+- [ ] אין רטוריקה דרמטית של הצדדים בקול ההכרעה
+- [ ] אין תוצאה הכל-או-לא-כלום בתיק עם טענות מהותיות משני הצדדים
+
+---
+
+## 6. תוספות מקריאת 23 קבצי 1xxx (אצוות 1-4)
+
+הרחבת הקריאה הניבה ממצאים שלא היו בדגימה הראשונית:
+
+### 6.1 מודי פתיחה — נוספו 2 לרשימת ה-5
+- **מוד F — "סף + מהות בכל זאת"** — דחיית סף ואז דיון מהותי "ועל מנת לא לצאת בחסר" (1180-1181, 1067-25, 1079-24)
+- **מוד G — "סקירה אחרי רמאנד"** — תיק חוזר; פתיחה מתעדת ציות / אי-ציות של הוועדה המקומית להנחיה הקודמת (1024-25, 1071-25)
+
+### 6.2 כותרות משנה — דיון מעובה
+לפי הקריאה: כותרות משנה מותרות **לא רק** "כשיש 3+ סוגיות מובחנות". הן מותרות:
+- כשיש סוגיות מובחנות פרוצדורליות vs מהותיות (1079-24)
+- כשיש 3+ נושאים מהותיים נפרדים (1041-24: קו בניין / פיתוח / עצים)
+- בתיק עם הירארכיה: סף → לגוף → סוגיה ספציפית (1067-25)
+- בתיק אנליזה משפטית טהורה כסעיף נפרד (1167-25: "הוראות סטיה")
+
+**אין** להשתמש בכותרות משנה כשהסוגיות הן שיקולים בתוך אותו עניין (1126-1141 — תוספת בנייה אחת עם 6 שיקולים — זרימה רציפה).
+
+### 6.3 ציטוט עצמי של בלוקים שלמים
+דפנה מעתיקה **בלוקים שלמים** של ניתוח בין תיקים דומים (1071-25 ↔ 1071-1077; 1126-25 ↔ 1126-1141; 1043-24 ↔ 1043-1054). היא מציינת בשקיפות:
+
+> "בהחלטה לעיל שבנו וחזרנו על חלק ניכר מקביעותינו... וזאת על מנת להבהיר שוב את מסקנתנו הגם שהיה מצופה כי תובן בשלב הראשוני"
+
+**עיקרון לסוכן**: כשתיק דומה לתיק אחר שלה — להעתיק את הניתוח שלה, לא להמציא מחדש.
+
+### 6.4 פעלי "אנחנו" שנוספו לקטלוג מטבלה 1.2
+
+| פועל | תפקיד |
+|-------|--------|
+| **נדגיש** | חיזוק נקודה מרכזית |
+| **לא נעלם מעניינו** | הכרה בקושי שלא נדון ישירות |
+| **לא נוכל להתעלם מ...** | קביעה קשה |
+| **מסקנתנו מתחזקת לאור...** | חיזוק חישובי |
+| **נחזור ונדגיש** | וריאציה של "נשוב" — חזרה מודעת |
+| **ונבהיר / נבהיר** | הבהרת מה לא הוכרע |
+| **ונחדד שוב כי...** | חידוד חוזר |
+| **שוב על מנת שלא לצאת בחסר** | להוצאת ערך נוסף |
+| **בשולי הדברים** | להבעת הסתייגות בעדינות |
+| **מצאנו להוסיף כי...** | תוספת חופשית |
+
+### 6.5 ביטויים מסורתיים שאומצו (כל אחד מקבל ציטוט מקורי)
+- **"כבדהו וחשדהו"** — לכלי השימוש החורג (מקור: עע"מ 109/12 גבעת האירוסים)
+- **"דבר מה נוסף"** — לזכות עמידה של עותר ציבורי (מקור: עע"ם 8723/03 הרצליה)
+- **"רע הכרחי"** — לשימוש החורג (מקור: בג"ץ 389/87 סלומון)
+- **"כביש עוקף תכנית"** — לשימוש חורג מסולף (מקור: עע"מ 109/12)
+- **"טעם לפגם"** — למתנגד עם עבירות בנייה
+- **"בלשון המעטה"** — להסתייגות מנומסת
+- **"בנדון דנא"** — נוסח מליצי לקדם דיון
+- **"דא עקא"** — לתפנית בטיעון
+- **"ודוק"** — להבהרה / reductio ad absurdum
+- **"ברי כי..."** — קביעה משכנעת
+- **"ללמדך כי..."** — מסקנה מציטוט
+
+### 6.6 הוצאות — מטריקס מורחב
+ראה טבלה ב-[daphna-architecture-by-outcome.md סעיף 8](daphna-architecture-by-outcome.md#8-סדר-ההוצאות) לפירוט מלא של 6 תרחישים.
+
+חידוש מהקריאה: כשהוועדה המקומית **עיכבה** או **לא צייתה לרמאנד**, דפנה מחייבת אותה (לא העוררים) בהוצאות:
+> "לאור התוצאה אלינו הגענו אנו מחייבים את הוועדה המקומית בהוצאות העוררים בסך של 5,000 ₪ לכל עורר"
+
+### 6.7 שקיפות לגבי מצב התקדמים
+דפנה מציינת בכל פעם **מה קרה לעתירה על החלטתה הקודמת**:
+> "ערר 1071/25 ... (שעתירה על החלטה זו נדחתה לאחר חזרת העותרת ממנה)"
+
+זה לא קישוט — זו מסירת מידע מלא לבית משפט מנהלי שיקרא בעתיד.
+
+### 6.8 עבירות בנייה כשיקול
+- מבקש היתר עם עבירות → "שיקול שלא לאשר" (בג"צ 609/75 ישראלי)
+- מתנגד עם עבירות → "טעם לפגם" / "חוסר תום לב" (ערר 152/07 עמירה אורלי)
+- אבל: "לא חזות הכל" — נשקלים יחד עם שיקולים אחרים (עע"מ 9387/17 המרכז למשפטים)
+
+### 6.9 אזהרה — תיקים שלא בקול דפנה
+**1015-24** נכתב בגוף ראשון יחיד ("אינני סבור", "לדעתי") — דעת מיעוט / חבר ועדה אחר. **לא לחקות.**
+
+### 6.10 מצב הרשתות — סטטיסטיקה
+- **24 תיקי 1xxx** + **22 תיקי 8xxx** + **2 תיקי 9xxx** = 48 בקורפוס
+- **~30 תקדמים חיצוניים** ש**דפנה מצטטת באופן עקבי** (ראה precedent-network.md)
+- **~15 תקדמים אישיים** שלה עצמה — מהווים את הקאנון האישי שלה
+
+---
+
+## 7. מה עדיין לא ראינו
+
+- **9xxx (פיצויים) דקה** — רק 2 תיקים בקורפוס
+- **תיקי דעת מיעוט** של דפנה — האם היא מבטאת מחלוקת אחרת?
+- **תקדמים שדפנה תוסיף בעתיד** — הקאנון מתפתח. הסוכן צריך לרענן אחרי כל ingest_final_version.
+
+---
+
+## 7. הצעד הבא — הזרקת הקול ל-`legal-writer`
+
+מסמך זה (יחד עם voice-1130-25.md) הוא הבסיס. הצעד הבא: לעדכן את ה-system prompt של `legal-writer` (ראה `~/.claude/agents/legal-writer.md` או `mcp-server/.../get_style_guide`) כך שיכלול:
+
+1. הקבועים מסעיף 1
+2. ההוראות האופרטיביות מסעיף 5
+3. תבניות העתקה מסעיף 4
+4. אנטי-דפוסים מסעיף 3
+5. הפנייה לטבלת מודי הפתיחה (2.1)
+
+זה דורש קריאה של ההגדרה הקיימת של `legal-writer` ועדכון מבני שלה.

docs/legal-decision-lessons.md

@@ -252,3 +252,136 @@ Total: ~340,000 words of source material.
 Intermediate extraction documents also saved:
 - `docs/fjc-principles-extraction.md` — 38 principles from FJC
 - `docs/garner-methodology-extraction.md` — ~50 principles from Garner/Scalia
+
+---
+
+## Lessons from הר הבשן 1033-25 (April 2026)
+
+### Source
+- Final decision: `data/cases/1033-25/exports/עריכה-v2.docx`
+- Our draft (v6): `data/cases/1033-25/exports/טיוטה-v6.docx`
+- Intermediate edit (v1): `data/cases/1033-25/exports/עריכה-v1.docx`
+- Date: April 2026
+- Result: Full acceptance (קבלה מלאה)
+- Word counts: Draft 2,126 → Final 2,299 (+8%)
+- Discussion section: Draft 960 words (19 paras) → Final 1,099 words (23 paras) (+14%)
+
+### What Our Draft Got Right
+- **12-block structure preserved** — all blocks in correct order, headings identical
+- **Opening formula** — bottom-line opening "מצאנו כי דין הערר להתקבל" (mode A adapted for acceptance) — used and kept
+- **Threshold claims treatment** — all 3 threshold claims handled correctly with same reasoning
+- **Central argument flow** — committee's own conditions → shadow plan → not feasible → appeal accepted — this was the exact structure Dafna kept
+- **Background neutrality** — facts-only background passed final review (no party quotes, no value words)
+- **Most paragraphs kept verbatim** — blocks ו (background), ז (claims), and most of ח (procedures) were kept nearly word-for-word
+- **Transition phrases** — "ונוסיף", "הנה כי כן", "הדברים מתחדדים שעה שנזכיר כי" — all used correctly and retained
+- **Direct quote from licensing rep** — "נכון, אני מסכימה, התבקשו הרחבות..." — kept verbatim
+- **"מסקנת ביניים"** technique — used correctly and retained
+- **"למען הסדר הטוב"** — correct usage for remaining claims section
+
+### What the Final Version Changed — Critical Gaps
+
+#### 20. Over-Doctrinal: Abstract Legal Framework Removed Entirely
+- **Draft:** Had a 101-word "נבאר" paragraph explaining the general legal authority of committees to require uniform building plans, covering advisory vs. mandatory annexes and administrative review processes — pure CREAC doctrine.
+- **Final:** Completely deleted. Went straight from conclusion ("מסקנתנו היא שהבקשה אינה עומדת") to factual evidence (shadow plan is theoretical).
+- **Lesson:** In "clean acceptance" cases where the committee's OWN conditions provide the anchor for the decision, skip the doctrinal framework. The committee said "show us X", the applicant didn't show X — no need to explain WHY committees can require X. CREAC is for contested legal rules, not for applying a committee's own explicitly-stated conditions. This is the most important lesson from this case: **match doctrinal depth to legal uncertainty**.
+
+#### 21. Background Enhanced with "ודוק" Foreshadowing
+- **Draft:** Simple description of the permit application: "ופורסמה כנדרש לפי סעיף 149 לחוק"
+- **Final:** Added 2 sentences after the permit description: "ודוק, בהתאם להוראות התכנית נספח הבינוי מחייב לגבי מספר הקומות המירבי ובכל הנוגע לדרישה להכנת תכנית אחידה הרי שזו מכח שלביות הביצוע של התכנית. על מנת לסטות מהוראות אלו התבקשו ההקלות."
+- **Lesson:** Dafna plants analytical seeds in the background. This "ודוק" paragraph in the background isn't neutrality-violating — it's explaining how plan provisions work as a matter of technical fact. But it foreshadows the fulcrum of the entire analysis (the reliefs are from MANDATORY provisions, not from advisory guidance). The background reader already understands what's at stake before reaching the discussion. **Rule**: when the decision hinges on a technical planning distinction, explain that distinction in the background (as fact, not as argument).
+
+#### 22. Procedures Section: Specific Dates → Summary Narrative
+- **Draft:** Listed specific dates and documents: "ביום 05.02.2026 ניתנה החלטת ביניים... הודעת עמדה מטעם העוררת גלנסקי מיום 23.02.2026, תגובת גבי אינגרם מיום 08.02.2026, ותגובת מבקשת ההיתר מיום 25.02.2026"
+- **Final:** Generalized: "לאחר מועד זה הוגשו בקשות, עדכונים ותגובות מטעם הצדדים לגבי ניסיון להגיע לידי הסכמות, וגם בניסיון לתכנן בקשה שונה ומכל מקום ועדת הערר אפשרה מרחב של זמן בתקווה כי ההחלטה תתייתר"
+- **Lesson:** For post-hearing procedural history that didn't change the outcome, Dafna prefers summary narrative over chronological detail. The intermediate decisions, update letters, and their specific dates don't matter to the reader — what matters is the narrative arc: "we gave them time to agree, they didn't, now we decide." Also: "ועדת הערר אפשרה מרחב של זמן בתקווה כי ההחלטה תתייתר" — this signals judicial patience and good faith before ruling.
+
+#### 23. Concrete Evidence Added: Specific Permits in Buildings 5, 7, 11
+- **Draft:** General statement that expansions were done ("הרחבות אלו, שחלקן כבר בוצעו וחלקן אושרו...")
+- **Final:** Added an entire new paragraph: "להלן כדוגמא מתוך היתרי הבניה בבתים מספר 5, 7, ו-11 (בניינים סמוכים ואף צמודים לזה מושא הערר), בהם התבקשו ואושרו תוספות בניה בהתאם להוראות התכנית בקומה ב' (מפלס 5.80+). משזכויות הבניה נוצלו כאמור, הרי שלא תהיה בידם האפשרות לנצל וליישם את הרחבת הבניה באופן דומה לזה המתבקש בענייננו, מה שיגרום לבית 13 להיות חריג לסביבתו" — with accompanying images of the permits.
+- **Lesson:** In acceptance decisions where you're overturning a committee, provide specific factual evidence that makes the conclusion inevitable. Not "other buildings already expanded" but "HERE are permits 5, 7, 11 showing exactly what was approved at level +5.80, making it physically impossible for the shadow plan to be implemented." The word "חריג לסביבתו" appears here as factual consequence, not as value judgment.
+
+#### 24. Plan-Provision Integration Paragraphs Added (נחדד + מקל וחומר)
+- **Draft:** None of this content existed
+- **Final:** Two new paragraphs:
+  - F13: "נחדד כי בהתאם להוראות התכנית נספח הבינוי מחייב לגבי מספר הקומות, ולכך מתווספת גם הוראת השלביות והדרישה להכנת תכנית אחידה לכל הבניין. ברי כי הכוונה לתכנית הממחישה ומבטיחה כי ההרחבות מושא התכנית יוכלו להתממש לגבי כלל בעלי הזכויות ובאופן המייצר מופע מקובל."
+  - F14: "הדברים מתחדדים ביתר שאת שעה שמבוקשת הקלה שמשמעותה חריגה מהוראות התכנית שאז בוודאי מקל וחומר נכון להכין תכנית אחידה."
+- **Lesson:** Where the draft used abstract doctrine, Dafna uses specific plan provisions. The "מקל וחומר" argument is new and powerful: if a uniform plan is required even for plan-conforming construction, then all the more so for construction that deviates from the plan. This replaces the general legal framework with a specific, irrefutable logical argument anchored in THIS plan's provisions.
+
+#### 25. Counter-Factual Reasoning: "Approved by Mistake" + "Barren Discussion"
+- **Draft:** Simple statement: "לאחר שהתברר בדיון בפנינו כי תכנית הצל אינה ישימה" followed by intermediate conclusion
+- **Final:** Added entirely new reasoning: "תכנית הצל אושרה מתוך טעות כי הרי לא נוכל להניח כי אושרה למראית עין וברי כי הועדה המקומית ביקשה להבטיח זכויות של אחרים והשתלבות בסביבה. במקום בו התכנית אינה ישימה דיון בה הינו דיון עקר."
+- **Lesson:** The "benefit of the doubt" technique — assume the committee acted in good faith (they didn't knowingly approve a hollow document), then show that this good-faith assumption actually STRENGTHENS the reversal (if they thought it was real, and it's not, then they were misled). "דיון עקר" = "barren discussion" — a phrase that shuts down any further argument about the shadow plan's merits. This is a new rhetorical move not seen in previous decisions.
+
+#### 26. Engineer Counter-Factual: "Had He Known..." (Two New Paragraphs)
+- **Draft:** Nothing about the engineer after the discussion section
+- **Final:** Two new paragraphs (F18-F19) adding meta-reasoning about the engineer's opinion:
+  - "חוות דעתו של מהנדס הוועדה כי התכנון המבוקש חורג לסביבתו נבחנה לאור תכנית הצל שהוגשה ומשזו הוגשה בחסר חוו"ד הגורם המקצועי נותרה גם היא בחסר."
+  - "ונציין כי חוו"ד מהנדס הוועדה ניתנה במקום בו היה סבור כי תכנית הצל ישימה ובהינתן כך קבע כי הינה עדיין חורגת לסביבה... היה והייתה מוצגת תכנית צל המאגדת את ההיתרים שאושרו וממחישה את חריגות הבניה במרחב, ניתן לשער כי חוו"ד המהנדס הייתה החלטית יותר"
+- **Lesson:** In acceptance decisions where you're overturning a committee that had professional support, explain WHY the professional got it wrong (or rather, why his analysis was based on faulty premises). The counter-factual "had the engineer known the shadow plan was not feasible, his opposition would have been even stronger" turns the committee's own professional opinion into evidence FOR the reversal. This is Dafna's way of being respectful to professionals while still overturning their conclusions.
+
+#### 27. "לא נעלם מעינינו" Acknowledge-Before-Reject Removed
+- **Draft:** Had a 66-word paragraph: "לא נעלם מעינינו כי נספח הבינוי הוגדר כ'מנחה' ולא כ'מחייב'... אולם אף בנספח מנחה, סטייה מהותית... אינה עניין טכני אלא שינוי מהותי"
+- **Final:** Completely removed
+- **Lesson:** The "אכן...אולם" or "לא נעלם מעינינו" pattern is for REJECTING an appeal — you need to show you considered the losing side's best argument. In ACCEPTANCE, the losing side is the committee/permit applicant, and the analysis already shows their conditions weren't met. No need to acknowledge the other side's argument when the factual record speaks for itself. **Rule**: "acknowledge-before-reject" = only in rejection decisions or on specific issues where you rule against a party. Don't use it prophylactically.
+
+#### 28. Committee Response: Personal Circumstances Added
+- **Draft:** Missing entirely — no mention of "פסק הלכתי" or "נסיבות אישיות חריגות"
+- **Final:** Added new paragraph in committee response section: "בין השיקולים ששקלו חברי הוועדה נלקחו בחשבון גם נסיבות אישיות חריגות של מבקשת ההיתר, ובכללן פסק הלכתי שהוצג בפני הוועדה, שלפיו בנות מתבגרות אינן יכולות להתגורר באותו מפלס עם שאר בני המשפחה"
+- **Lesson:** If a committee considered unusual factors (religious rulings, personal hardship), document them in the claims section for completeness, even if they're not addressed in the discussion. Omitting them would create a gap for judicial review — a judge reading the protocol would wonder why the decision doesn't mention them. Including them in the claims section without addressing them in the discussion implicitly signals: "we noted this but it doesn't change the planning analysis."
+
+#### 29. Opening Precision: Permit Number and Phrasing
+- **Draft:** "בקשה להיתר שמספרה" (placeholder — number missing!), "בהקלה לתוספת קומה"
+- **Final:** "בקשה להיתר מס' 20230614", "בקשה הכוללת הקלות 'הקלה לתוספת קומה ללא תכנית אחידה וללא אדריכלות חוץ'"
+- **Lesson:** (a) Never leave placeholders — "שמספרה" without the actual number is a production error. (b) The permit number is a legal identifier that must appear in the opening. (c) The phrasing "בקשה הכוללת הקלות" (application that includes reliefs) is more precise than "בהקלה" (with a relief). Also: the relief description is quoted in quotation marks from the official publication.
+
+#### 30. "ונפרט;" Not "נפרט."
+- **Draft:** "נפרט." (period)
+- **Final:** "ונפרט;" (ו prefix + semicolon)
+- **Lesson:** The transition from conclusion to detail uses "ו" prefix (connecting) and semicolon (flowing into the detail), not a period (which creates a full stop). This was already documented in the voice fingerprint ("מעבר עם נקודה-פסיק") but the draft didn't apply it. This confirms: **semicolons before elaboration are not optional — they are Dafna's standard punctuation for transitions into detail**.
+
+#### 31. Summary: No Forward-Looking Guidance to Losing Party
+- **Draft:** Had a forward-looking paragraph: "ככל שמבקשת ההיתר תבקש להגיש בקשה מחודשת עליה לעמוד בדרישות התכנית, לרבות הצגת תכנית אחידה ישימה לכל הבניין כנדרש"
+- **Final:** Replaced with simple restatement: "על כן, הבקשה להיתר לא עמדה בתנאים שהוועדה המקומית עצמה קבעה בהחלטתה מיום 8.7.2024."
+- **Lesson:** Dafna does NOT give advice to the losing party in the summary. The decision says what was decided, not what the applicant should do next. Forward-looking guidance would be an advisory opinion outside the scope of the decision. Also note: the final added "ולמעשה היא אינה ממחישה את המצב הפיזי והתכנוני 'האמיתי'" — a new phrase capturing the essence of why the shadow plan fails (it doesn't reflect reality).
+
+#### 32. Unit vs. Extension: Deference to Committee, Not Independent Analysis
+- **Draft:** "ניתן לקבל בדוחק את עמדת מבקשת ההיתר כי מדובר בתוספת לדירה קיימת" — expressing the committee's own hesitant view
+- **Final:** "עולה כי הועדה המקומית דנה בכך וקבעה כי מדובר ביחידת דיור אחת שבנייתה מיועדת לשימוש בן משפחה... אין אנו מוצאים להתערב בכך ראשית כי הדבר מקדים את זמנו... ושנית ככל שתאושר בניה זו יש לוודא כי לא תבנה יח"ד נוספת"
+- **Lesson:** When a secondary issue was resolved by the committee and you're not overturning THAT specific finding, use deference ("אין אנו מוצאים להתערב") rather than expressing your own opinion ("ניתן לקבל בדוחק"). The final also adds a CONDITION ("יש לוודא כי לא תבנה יח"ד נוספת") — practical safeguard rather than theoretical analysis.
+
+#### 33. No Expenses in Full Acceptance
+- **Draft:** No mention of expenses
+- **Final:** No mention of expenses
+- **Lesson confirmed:** In full acceptance of an appeal by neighbor-appellants against a permit applicant, Dafna does not award expenses to either side. This contrasts with rejection (הכט: appellants pay expenses). The pattern emerges: expenses = only in rejection. Acceptance or partial acceptance = no expenses order.
+
+### New Transition Phrases Discovered
+- **"ונפרט;"** — correct form (ו + semicolon, not "נפרט.")
+- **"דיון בה הינו דיון עקר"** — declaring a point moot
+- **"אושרה מתוך טעות כי הרי לא נוכל להניח כי אושרה למראית עין"** — benefit-of-the-doubt construction
+- **"ונציין כי חוו"ד... ניתנה במקום בו היה סבור כי..."** — counter-factual about professional opinion
+- **"להלן כדוגמא מתוך"** — introducing specific documentary evidence
+- **"ברי כי הכוונה ל..."** — explaining legislative intent of plan provisions
+- **"מה שיגרום לבית 13 להיות חריג לסביבתו"** — factual consequence language
+- **"ועדת הערר אפשרה מרחב של זמן בתקווה כי ההחלטה תתייתר"** — explaining judicial patience
+
+### Meta-Lesson
+This is the first "clean acceptance" in our training data (הכט = rejection, בית הכרם = partial acceptance). The key insight: **the draft was too careful**. It built a doctrinal framework (CREAC) as if it needed to justify overturning the committee from first principles, when in reality the committee's OWN conditions provided all the justification needed. Dafna's approach to acceptance:
+
+1. **Anchor in the committee's own conditions** — no need for external legal authority
+2. **Show concrete evidence** the conditions weren't met (specific permits, images)
+3. **Explain WHY the committee was misled** (shadow plan approved by mistake)
+4. **Counter-factual reasoning** about what professionals would have said with correct information
+5. **No abstract doctrine needed** when the facts are clear
+
+The draft's biggest structural error was adding the "נבאר" doctrinal paragraph and the "לא נעלם מעינינו" acknowledge-before-reject. Both are tools for CONTESTED or REJECTED cases. In a clean acceptance, the facts lead directly to the conclusion.
+
+### Applied To
+- [ ] Update SKILL.md: add "clean acceptance" track — skip doctrine, anchor in committee's conditions
+- [ ] Update SKILL.md: "acknowledge-before-reject" only in rejection/contested issues
+- [ ] Update SKILL.md: no forward-looking guidance in summary
+- [ ] Update SKILL.md: "ודוק" foreshadowing in background for technical planning distinctions
+- [ ] Update SKILL.md: counter-factual reasoning about professional opinions
+- [ ] Update SKILL.md: procedures section — summary narrative for post-hearing history
+- [ ] Update voice-fingerprint: add new transition phrases
+- [ ] Update architecture-by-outcome: add "clean acceptance" archetype
+- [ ] Fix agent opening punctuation: "ונפרט;" not "נפרט."

docs/new-company-setup-guide.md

@@ -0,0 +1,403 @@
+# מדריך הקמת חברה חדשה — היטלי השבחה (CMPA)
+
+> נוצר: 2026-04-15
+> מטרה: תיעוד מפורט של התהליך להקמת קורפוס אימון והגדרת חברה בשתי המערכות
+
+---
+
+## רקע
+
+המערכת שלנו בנויה מ-**2 חברות** (boards) ב-Paperclip, שמייצגות את שני תחומי העבודה העיקריים:
+
+| # | חברה | קוד | Prefix | סוגי תיקים | סטטוס קורפוס |
+|---|-------|------|--------|------------|---------------|
+| 1 | רישוי ובנייה | CMP | `42a7acd0...` | 1xxx | 24 החלטות אימון, ניתוח סגנון מלא |
+| 2 | היטלי השבחה + פיצויים | CMPA | `8639e837...` | 8xxx, 9xxx | **ריק — אין אף החלטת אימון** |
+
+**המצב היום**: חברת CMPA כבר קיימת ב-Paperclip ומופתה בקוד (ניתוב אוטומטי לפי מספר תיק). אבל אין לה **קורפוס אימון** — המערכת לא מכירה את הסגנון של דפנה בהחלטות היטל השבחה ולא יכולה לחפש תקדימים.
+
+**מה שצריך לעשות**: להעלות את ההחלטות, לעבד אותן, ולהריץ ניתוח סגנון — בדיוק כמו שנעשה עם 24 ההחלטות של רישוי ובנייה.
+
+---
+
+## שתי המערכות — הגדרת תפקידים
+
+### מערכת 1: עוזר משפטי (Legal-AI)
+
+**תפקיד**: מערכת הידע, הניתוח והניסוח — מחזיקה את כל התוכן המשפטי ומספקת כלים לכתיבת החלטות.
+
+**מה חי רק במערכת הזו**:
+
+| רכיב | תיאור | טבלת DB |
+|-------|--------|---------|
+| תיקים (Cases) | מספר תיק, כותרת, סטטוס, צדדים | `cases` |
+| מסמכי מקור | כתבי ערר, תגובות, פרוטוקולים (PDF/DOCX) | `documents` + filesystem |
+| חלקים סמנטיים (Chunks) | embeddings לחיפוש RAG (Voyage AI, 1024 ממדים) | `document_chunks` + pgvector |
+| קורפוס אימון | החלטות קודמות של דפנה — גרסאות מנוקות | `style_corpus` |
+| דפוסי סגנון | ביטויי מעבר, נוסחאות פתיחה/סיום, מבנה ניתוח | `style_patterns` |
+| בלוקי החלטה | 12 בלוקים (מבנה ההחלטה) + פסקאות | `decision_blocks`, `decision_paragraphs` |
+| טענות צדדים | טענות שחולצו מכתבי טענות | `claims` |
+| תקדימים (פסיקה) | ספריית case law + embeddings | `case_law`, `case_law_embeddings` |
+| חקיקה | סעיפי חוק שאוזכרו | `statutory_provisions` |
+| הערות יו"ר | feedback של דפנה על טיוטות | `chair_feedback` |
+| לקחים | תובנות שחולצו מ-feedback | `lessons_learned` |
+| צ'קליסטים | רשימות בדיקה לבלוק דיון (לפי סוג ערר) | hardcoded ב-`lessons.py` |
+| מיפוי חברות | קישור appeal_subtype ← company_id | `tag_company_mappings` |
+
+**שירותי הליבה**:
+- **RAG** — חיפוש סמנטי בתקדימים ובמסמכי מקור, מסונן לפי `appeal_subtype`
+- **Proofreading** — ניקוי מסמכי נבו מ-artifacts
+- **Style Analysis** — ניתוח קורפוס וחילוץ דפוסי כתיבה
+- **Decision Drafting** — ייצור טיוטות לפי ארכיטקטורת 12 בלוקים
+- **DOCX Export** — מסמך מעוצב מוכן להגשה
+
+---
+
+### מערכת 2: Paperclip
+
+**תפקיד**: מערכת התזמור והסוכנים — מנהלת את תהליך העבודה, מפעילה סוכני AI, ומספקת ממשק Kanban.
+
+**מה חי רק במערכת הזו**:
+
+| רכיב | תיאור | טבלת DB |
+|-------|--------|---------|
+| חברות (Companies) | CMP (רישוי), CMPA (היטלי השבחה) — boards נפרדים | `companies` |
+| פרויקטים | כרטיס Kanban לכל תיק | `projects` |
+| Issues | משימות עבודה (CMP-123, CMPA-456) | `issues` |
+| תגובות | דיון בין סוכנים ומשתמשים | `issue_comments` |
+| סוכנים (Agents) | CEO, Researcher, Writer — Claude Code agents | מערכת agents |
+| SOUL.md | הנחיות לכל סוכן | קונפיגורציית agent |
+| Skills | workflows לשימוש חוזר (SKILL.md) | `company_skills` + filesystem |
+| Plugin state | נתוני plugin (case_number ← issue) | `plugin_state` |
+
+**תפקידי הליבה**:
+- **תזמור** — CEO agent מקבל בקשות, מנתב לסוכן המתאים
+- **ניהול משימות** — Kanban board עם issues, מעקב סטטוס
+- **הפעלת סוכנים** — wakeup mechanism, heartbeat cycle
+- **ממשק דיון** — comments על issues (משתמש ← agent ← agent)
+
+---
+
+### תהליכי גומלין — מי מדבר עם מי
+
+```
+┌──────────────────────────────────────────────────────────────────────────┐
+│                          תהליכי גומלין                                  │
+│                                                                          │
+│   LEGAL-AI                              PAPERCLIP                        │
+│   ════════                              ═════════                        │
+│                                                                          │
+│   ┌─────────┐   יצירת project+issue     ┌─────────┐                     │
+│   │  Cases   │ ─────── DB insert ──────→ │Projects │                     │
+│   │         │ ─────── DB insert ──────→ │ Issues  │                     │
+│   └─────────┘                            └─────────┘                     │
+│                                                                          │
+│   ┌─────────┐   wakeup signal            ┌─────────┐                     │
+│   │Workflow │ ─────── HTTP POST ───────→ │  CEO    │                     │
+│   │ Start   │   (issueId + mutation)     │ Agent   │                     │
+│   └─────────┘                            └─────────┘                     │
+│                                                                          │
+│   ┌─────────┐   קריאת case_number        ┌─────────┐                     │
+│   │  Data   │ ←──── plugin_state ──────  │ Plugin  │                     │
+│   │ (API)   │ ←──── HTTP GET/POST ─────  │legal-ai │                     │
+│   └─────────┘   (תקדימים, טענות, סגנון)  └─────────┘                     │
+│                                                                          │
+│   ┌─────────┐   skill sync               ┌─────────┐                     │
+│   │ Skills  │ ──── DB + filesystem ────→ │company_ │                     │
+│   │ (disk)  │                            │ skills  │                     │
+│   └─────────┘                            └─────────┘                     │
+│                                                                          │
+│   ┌─────────┐   שאילתת חברות             ┌─────────┐                     │
+│   │Settings │ ←──── DB query ──────────  │companies│                     │
+│   │  UI     │                            │  table  │                     │
+│   └─────────┘                            └─────────┘                     │
+└──────────────────────────────────────────────────────────────────────────┘
+```
+
+#### כיוון 1: Legal-AI → Paperclip (יצירה ושליטה)
+
+| פעולה | מנגנון | מתי |
+|-------|--------|-----|
+| יצירת Project | DB insert ישיר ב-Paperclip | יצירת תיק חדש |
+| יצירת Issue | DB insert ישיר ב-Paperclip | יצירת תיק / התחלת workflow |
+| קישור case ← issue | DB insert ב-`plugin_state` | יצירת project |
+| הערת אימות | DB insert ב-`issue_comments` | אחרי יצירת project |
+| הפעלת CEO | **HTTP POST** ל-`/api/agents/{id}/wakeup` | התחלת workflow |
+| סנכרון skill | DB insert/update ב-`company_skills` | התקנת/עדכון skill |
+
+#### כיוון 2: Paperclip → Legal-AI (שאילתות וקריאות חזרה)
+
+| פעולה | מנגנון | מתי |
+|-------|--------|-----|
+| קריאת case_number | plugin קורא `plugin_state` | סוכן מקבל issue |
+| שליפת מסמכים | HTTP GET/POST ל-API של legal-ai | סוכן עובד על תיק |
+| חיפוש תקדימים | HTTP ל-`/api/precedents/search` | researcher מחפש |
+| קריאת style guide | HTTP ל-MCP / API | writer כותב טיוטה |
+| רשימת חברות | DB query ישיר מ-`companies` | UI הגדרות |
+
+#### החוליה המקשרת: `plugin_state`
+
+```
+plugin_state:
+  plugin_id  = "53461b5a..." (marcusgroup.legal-ai)
+  scope_kind = "issue"
+  scope_id   = "{issue-uuid}"
+  state_key  = "legal-case-number"
+  value_json = "\"1234\""
+```
+
+זו ה"כתובת" שמאפשרת לסוכן Paperclip לדעת איזה תיק ב-Legal-AI שייך ל-issue שהוא עובד עליו.
+
+---
+
+### מצב קיים לכל חברה
+
+#### CMP — רישוי ובנייה (מוכן לעבודה)
+
+**ב-Legal-AI**:
+- 24 החלטות אימון בקורפוס
+- ניתוח סגנון מלא (דפוסים, ביטויים, יחסי אורך)
+- content checklists ל-3 סוגי משנה (substantive, threshold, property)
+- RAG פעיל עם chunks + embeddings
+
+**ב-Paperclip**:
+- חברה CMP פעילה
+- סוכנים מוגדרים ופעילים
+- Plugin פעיל
+- Skills מותקנים
+
+#### CMPA — היטלי השבחה (דורש הקמה)
+
+**ב-Legal-AI**:
+- appeal_subtype `betterment_levy` מוגדר בקוד
+- ניתוב אוטומטי (8xxx → CMPA) עובד
+- **חסר**: 0 החלטות אימון, 0 style patterns, 0 chunks, אין content checklist
+
+**ב-Paperclip**:
+- חברה CMPA קיימת
+- **לוודא**: סוכנים מקושרים, plugin פעיל, skills מותקנים
+
+---
+
+## התהליך המלא — צעד אחר צעד
+
+### שלב 1: הכנת הקבצים
+
+**מיקום**: הנח את כל קבצי ה-DOCX בתיקייה נגישה (למשל `~/Downloads/hitlei-hashbacha/`)
+
+**בדיקות מקדימות**:
+1. וודא שכל הקבצים בפורמט DOCX או PDF
+2. וודא שהשמות כוללים מספר תיק (לצורך metadata)
+3. ספור כמה החלטות יש — זה ישפיע על זמן העיבוד
+
+**דגשים**:
+- ההחלטות מגיעות מנבו — יש להן watermarks, headers, footnotes שצריך לנקות
+- מערכת ה-proofreading שלנו מטפלת בזה אוטומטית
+
+---
+
+### שלב 2: העלאה — 3 נתיבים אפשריים
+
+#### נתיב א: ממשק Web (מומלץ להעלאה המונית)
+
+```
+כתובת: https://legal-ai.nautilus.marcusgroup.org
+נתיב: /api/training/upload
+```
+
+**מה קורה מאחורי הקלעים**:
+1. הקובץ נשמר כ-temp file
+2. **Proofreading** — ניקוי אוטומטי של תוספות נבו:
+   - הסרת watermarks ("ספרות:", "חקיקה שאוזכרה:")
+   - הסרת headers/footers של עמודים
+   - הסרת קודי נבו inline
+   - הסרת URLs וזכויות יוצרים
+3. **שמירת גרסה מנוקה** → `data/training/proofread/{filename}.md`
+4. **שמירת מקור** → `data/training/{filename}.docx`
+5. **הוספה ל-DB** → טבלת `style_corpus` עם metadata
+6. **חיתוך לחלקים** → chunks סמנטיים
+7. **יצירת embeddings** → Voyage AI → וקטורים 1024 ממדים
+8. **שמירה ב-RAG** → טבלת `document_chunks` (עם practice_area + appeal_subtype)
+
+#### נתיב ב: MCP Tool (מ-Claude Code)
+
+```
+tool: document_upload_training
+params:
+  file_path: "/path/to/file.docx"
+  decision_number: "ARAR-24-8001"
+  decision_date: "2024-06-15"
+  subject_categories: ["היטל השבחה"]
+  title: "שם ההחלטה"
+  practice_area: "appeals_committee"
+  appeal_subtype: "betterment_levy"
+```
+
+#### נתיב ג: Skill Command (אינטראקטיבי)
+
+```
+/upload-training
+```
+עונים על שאלות: נתיב קובץ, מספר החלטה, תאריך, קטגוריות.
+
+---
+
+### שלב 3: ביקורת (Proofreading QA)
+
+**קריטי**: לפני שממשיכים לניתוח — **לבדוק כל החלטה שהועלתה**.
+
+**מה לבדוק**:
+- [ ] הטקסט המנוקה (`data/training/proofread/`) קריא ושלם
+- [ ] לא נחתכו חלקים מהותיים
+- [ ] ה-metadata נכון (מספר תיק, תאריך, קטגוריה)
+- [ ] אין שאריות של artifacts מנבו
+- [ ] appeal_subtype = `betterment_levy` (ולא `building_permit`)
+
+**כלי בדיקה**:
+```
+GET /api/training/status  — סטטוס העלאה ועיבוד
+```
+
+---
+
+### שלב 4: ניתוח סגנון (Style Analysis)
+
+אחרי שכל ההחלטות הועלו ונבדקו, מריצים ניתוח סגנון:
+
+```
+POST /api/training/analyze-style
+```
+
+**מה קורה**:
+1. שליפת כל ההחלטות מ-`style_corpus` (לפי practice_area/subtype)
+2. בדיקת תקציב tokens:
+   - עד 900K tokens → pass יחיד (הכל ל-Claude בבת אחת)
+   - מעל 900K → multi-pass (כל החלטה בנפרד + סינתזה)
+3. **חילוץ דפוסים** באמצעות Claude:
+   - נוסחאות פתיחה
+   - ביטויי מעבר
+   - סגנון ציטוט פסיקה
+   - מבנה ניתוח
+   - נוסחאות סיום
+   - ביטויים אופייניים
+   - זרימת טיעון
+   - טיפול בראיות
+4. שמירה בטבלת `style_patterns` עם תדירות, הקשר, ודוגמאות
+
+**תוצר**: מדריך סגנון מבוסס-נתונים ספציפי להיטלי השבחה.
+
+---
+
+### שלב 5: ניתוח קורפוס (Corpus Analysis)
+
+בדומה ל-`docs/corpus-analysis.md` שנבנה עבור רישוי ובנייה, צריך ליצור ניתוח מקביל:
+
+**מה לנתח**:
+- הרכב הקורפוס: כמה החלטות, תוצאות (קבלה/דחייה/חלקית)
+- אורך פרק דיון טיפוסי
+- נושאים ייחודיים להיטלי השבחה:
+  - שומות (שומה מוסכמת, שומה אחרת, שמאי מכריע)
+  - תכנית משביחה — זיהוי, פרשנות
+  - מועד השבחה / "מועד אישור התכנית"
+  - חישוב עליית ערך (לפני/אחרי)
+  - פטורים (ס' 19 לתוספת השלישית)
+  - שיעור היטל
+  - דיני ראיות שמאיים
+- ביטויי מעבר ייחודיים
+- סגנון דיון — "קר ומקצועי" (לפי CLAUDE.md)
+- השוואה לרישוי ובנייה (מה שונה)
+
+**תוצר**: מסמך `docs/corpus-analysis-betterment.md`
+
+---
+
+### שלב 6: עדכון Content Checklists
+
+הקובץ `lessons.py` מכיל צ'קליסטים לבלוק י (דיון) לפי סוג ערר.
+
+**מה צריך**:
+- ליצור `CONTENT_CHECKLISTS["betterment_levy"]` עם נושאים ייחודיים
+- נושאים צפויים: שומות, תכנית משביחה, מועד, חישוב, פטורים, ראיות שמאיות
+- הצ'קליסט ייבנה מתוך ניתוח הקורפוס (שלב 5)
+
+---
+
+### שלב 7: אימות Paperclip
+
+לוודא שחברת CMPA מוגדרת נכון:
+
+**בדיקות**:
+- [ ] חברה CMPA קיימת ופעילה ב-Paperclip DB
+- [ ] Issue prefix = CMPA
+- [ ] Plugin `legal-ai` פעיל בחברה
+- [ ] סוכנים (CEO, researcher, writer) מוגדרים
+- [ ] tag_company_mappings נכון ב-legal-ai DB:
+  - `betterment_levy` → `8639e837...`
+  - `compensation_197` → `8639e837...`
+- [ ] יצירת תיק 8xxx מנותבת נכון
+
+**כלי בדיקה**:
+```
+GET /api/settings/tag-mappings
+GET /api/paperclip/companies
+```
+
+---
+
+## סיכום — סדר פעולות
+
+| # | שלב | מה | כלי | זמן משוער |
+|---|------|----|------|-----------|
+| 1 | הכנה | איסוף קבצי DOCX, בדיקת פורמט | ידני | — |
+| 2 | העלאה | העלאת כל ההחלטות + proofreading אוטומטי | Web API / MCP | דקות לכל החלטה |
+| 3 | ביקורת | בדיקת כל טקסט מנוקה + metadata | ידני / Claude | כמה שעות |
+| 4 | ניתוח סגנון | חילוץ דפוסים מהקורפוס | API analyze-style | ~30 דק |
+| 5 | ניתוח קורפוס | מפת תוכן + נושאים + השוואה | Claude + מסמך | כמה שעות |
+| 6 | צ'קליסט | יצירת content checklist להיטלי השבחה | עדכון קוד | — |
+| 7 | אימות Paperclip | בדיקת הגדרות חברה + ניתוב | API / DB | — |
+
+---
+
+## הערות חשובות
+
+### ההבדל בין רישוי ובנייה להיטלי השבחה (מ-CLAUDE.md)
+
+| מאפיין | רישוי ובנייה (1xxx) | היטלי השבחה (8xxx) |
+|---------|---------------------|-------------------|
+| טון | חם יחסית | קר ומקצועי |
+| תוכן | הקשר תכנוני רחב, אלמנטים אנושיים | יבש, ללא רגשות |
+| נושאי דיון | תכניות, חניה, קווי בניין, שכנים | שומות, חישובי השבחה, פטורים |
+| פסיקה | ס' 152, הלכת שפר, דיני הקלה | ס' 196-198, תוספת שלישית, שמאי מכריע |
+
+### סינון RAG לפי סוג
+כל ה-chunks נשמרים עם `appeal_subtype`, כך שחיפוש סמנטי בתיק היטל השבחה ימצא רק תקדימים רלוונטיים מהתחום — לא יערבב עם רישוי ובנייה.
+
+### ניתוח סגנון נפרד
+ייתכן שנצטרך **מדריך סגנון נפרד** להיטלי השבחה, כי הטון שונה מהותית. הניתוח בשלב 4 יחשוף את ההבדלים.
+
+---
+
+## סוכנים — שיתוף בין החברות
+
+### עיקרון: אותם סוכנים, הקשר שונה
+
+**אין צורך בסוכנים נפרדים** לכל חברה. הסוכנים (CEO, researcher, writer) עובדים לפי **מתודולוגיה** — ארכיטקטורת 12 בלוקים, CREAC, מבחן השופט — שחלה על כל סוגי העררים.
+
+**מה שמשתנה אוטומטית לפי `appeal_subtype`**:
+
+| רכיב | מקור | מנגנון הפרדה |
+|-------|------|--------------|
+| Style patterns | טבלת `style_patterns` | ניתוח סגנון נפרד per-subtype |
+| Content checklists | `lessons.py` | key שונה: `building_permit` vs `betterment_levy` |
+| תקדימים (RAG) | טבלת `document_chunks` | סינון לפי `appeal_subtype` בחיפוש |
+| טון | style guide + patterns | דפוסים שונים מהקורפוס |
+
+**למה שיתוף סוכנים עדיף**:
+1. שיפור במתודולוגיה חל אוטומטית על שני התחומים
+2. אין כפילות בתחזוקת סוכנים
+3. ההפרדה היא **ברמת הנתונים**, לא ברמת הלוגיקה
+
+**מה כן צריך לוודא**:
+- [ ] הסוכנים ב-Paperclip מקושרים לשתי החברות (CMP + CMPA)
+- [ ] כש-issue נפתח ב-CMPA, הסוכנים מופעלים באותו אופן
+- [ ] ה-context שהסוכן מקבל כולל את ה-`appeal_subtype` הנכון

docs/voice-1130-25.md

@@ -0,0 +1,460 @@
+# הקול של דפנה — קריאה עמוקה של תיק 1130-25
+
+**מסמך פנימי לסוכן הכותב.** המטרה: לא לתעד דפוסים שטחיים, אלא **להפנים את הקול**. לא "ביטויים שדפנה משתמשת בהם" — אלא "איך דפנה חושבת, מארגנת, מאזנת, ומתעדת את עצמה ככותבת."
+
+המסמך מבוסס על קריאה איטית של בלוק י (פסקאות 92-176) ב-`עריכה-v5.docx` של תיק 1130-25, והשוואה לטיוטת ה-AI ב-DB.
+
+---
+
+## 0. התובנה המרכזית: שלד מול גוף
+
+| שלב | מספר מילים בבלוק י | תוכן |
+|------|-------------------|------|
+| טיוטת AI | **314** | שלד: סמכות, היסטוריה בקצרה, מסקנה |
+| גרסה סופית | **~5,000** | גוף שלם: מבוא פילוסופי, סף, מהות, דוקטרינה, יישום, אגב |
+
+**הגרסה הסופית לא "תיקנה" את הטיוטה — היא בנתה את הדיון מהיסוד.**
+
+מה זה אומר לסוכן? ההנחה הסמויה ש"ה-AI כותב טיוטה ו-דפנה מתקנת אותה" שגויה. דפנה כותבת **את הדיון** מההתחלה — הטיוטה היא רק נקודת התחלה רעיונית. לכן, אם רוצים שהסוכן יכתוב כמוה, הוא לא יכול לחזור על השלד; הוא צריך **להחליף לב**.
+
+---
+
+## 1. ארכיטקטורת הטיעון: מבנה משפך
+
+דפנה מסדרת את בלוק י לפי 9 תנועות, מהרחב לצר:
+
+```
+[1] מסגור התחים (93-97)        — דיני התכנון מיישבים מתחים מובנים
+   ↓
+[2] תיעוד תהליך ההכרעה (98)    — מה עשינו לפני ההחלטה
+   ↓
+[3] טענות סף (99-115)           — זכות עמידה, זכות טיעון, פרסום
+   ↓
+[4] סמכות וטכניקה (116-124)     — סעיף 62א, חישוב 50%
+   ↓
+[5] רקע היסטורי (125-143)       — תכנית 135 → 135א → 2017 → 2023-2025
+   ↓
+[6] דוקטרינה (144-159)         — תכנון נקודתי מול כולל, פסיקה
+   ↓
+[7] השאלה האמיתית (160)        — לא "האם" אלא "כמה"
+   ↓
+[8] ההכרעה (161-166)           — קבלה חלקית עם נסיגה
+   ↓
+[9] עניינים נוספים (167-176)   — מרפסות, חניה, תחבורה
+```
+
+**העיקרון**: לפני שמכריעים בשאלה הספציפית, דפנה מסלקת מהדרך כל מה שיכול להפריע — הליך, סמכות, חישוב — ובונה את התשתית העובדתית והדוקטרינלית. ההכרעה האופרטיבית באה רק כשהקרקע מוכנה.
+
+**ניגוד מובהק לטיוטה**: הטיוטה דילגה ישר לסמכות (טענת סף #4), ואז לרקע היסטורי, ואז למסקנה. ללא מסגור, ללא טענות סף, ללא דוקטרינה. דילוג ישיר ללב יוצר החלטה שטחית.
+
+---
+
+## 2. תבניות הנמקה לפי סוג סוגיה
+
+דפנה משתמשת ב-7-8 **תבניות הנמקה** קבועות לפי סוג הסוגיה. הן לא רנדומליות — הן בוחרות לפי מהות העניין.
+
+### תבנית A — סוגיית סף (זכות עמידה, פסקאות 99-113)
+
+```
+1. הצגת הטענה של הצד שמתנגד (הוועדה: "מעמדו מקהה את טענותיו")
+2. ציטוט סעיף החוק במלואו (סעיף 100)
+3. ציטוט פסיקה מנחה (עניין עירון)
+4. הוספת קביעות בית המשפט מסביב לציטוט המרכזי
+5. הפניה לפסיקה רחבה יותר ("מגמה כללית של הקלה" — עניין פז)
+6. **יישום על העובדות** ("העורר מחזיק כשוכר... 8 שנים")
+7. **הסתייגות מבוקרת** ("אכן, יש לזכור כי ההתנגדות הינה של שוכר... אמורות להיות בגדר פגיעה בהנאה של שוכר ולא של בעל קניין")
+8. הכרעה
+```
+
+**מתי להשתמש**: כשהטענה היא פרוצדורלית/פורמלית והדיון קובע תקדים שיחזור.
+**הסיבה לאורך**: דפנה כותבת לא רק לתיק זה — היא מבססת עיקרון לתיקים הבאים.
+
+### תבנית B — סוגיית סמכות חוקית (פסקאות 116-123)
+
+```
+1. הצגת הקריאה של המתנגד לסעיף החוק
+2. **קביעה ברורה ומיידית** ("אין בידנו לקבל טענה זו")
+3. ציטוט פסק דין מנחה — בג"ץ חוף השרון, ציטוט נרחב
+4. **חידוד** ("נחדד כי הסייג שבסעיף... מגדיר את גבולות אותה פסקה בלבד")
+5. ציטוט פסיקה תומכת נוספת — ג'יבלי
+6. הבחנה בין הפסיקה שהמתנגד הביא (פן 198/09) — "אותו ערר עסק בהקשר שונה, אולם העיקרון... זהה"
+7. **טיעון "למעלה מן הצורך"** — "גם אם היינו מקבלים את פרשנות העורר, הרי שסעיף 62א(א)(13ב)..."
+```
+
+**מתי להשתמש**: כשיש פרשנות לסעיף חוק והמתנגד מציע פרשנות מצמצמת.
+**הסיבה לתבנית הזו**: בנייה מצטברת של ביטחון. הקובע הראשון, הציטוט מחזק, החידוד ממקד, "למעלה מן הצורך" סוגר חלון לערעור.
+
+### תבנית C — מחלוקת כמותית (פסקה 124, רק פסקה אחת)
+
+```
+1. הצגת המחלוקת (העורר: 67%, הוועדה: 50%)
+2. הצדה (חלק) — "מקובלת עלינו עמדת הוועדה"
+3. נימוק קצר
+4. **התייתרות** ("מכל מקום, כפי שיפורט להלן... סוגיית החישוב מתייתרת")
+```
+
+**מתי להשתמש**: כשיש מחלוקת טכנית שתוצאת התיק תייתר.
+**הסיבה לקיצור**: לא לבזבז קשב על מה שלא מכריע.
+
+### תבנית D — נרטיב היסטורי (פסקאות 125-143)
+
+```
+1. הצהרת רלוונטיות ("ההיסטוריה התכנונית נדרשת להכרעתנו ולהלן נפרטה")
+2. כרונולוגיה לפי תאריכים: 1977 → 1992 → 2017 → 2023-2025
+3. ציטוטים נרחבים מהחלטות (לא סיכום)
+4. **חידודים פנימיים** ("נחדד, טענות הנוגעות להיזק ראיה ולהסתרה היו רלוונטיות כבר במועד אישור תכנית 135א")
+5. **זיהוי תפנית** ("בנקודה זו חלה תפנית ואושרו תכניות")
+6. **מקבילים נוכחיים** (חלקה 240, ערר 1194-25)
+7. **מסקנה ביניים** מההיסטוריה
+```
+
+**מתי להשתמש**: כשההיסטוריה נושאת משקל ראייתי-משפטי (לא סתם רקע).
+**הסיבה לאורך**: בלוק ו של הטיוטה אמור היה לכלול את הרקע, אבל ההיסטוריה התכנונית **מבססת את ההכרעה** — לכן היא חוזרת בבלוק י עם משקל אנליטי.
+
+### תבנית E — הצגה דוקטרינלית (פסקאות 144-159)
+
+```
+1. הצגת העיקרון בפשטות ("אין חולק כי דרך המלך... היא התכנון הכולל")
+2. **הסתייגות מובנית** ("אך רק בהעדפה; לא בחזות הכל" — ציטוט מהרמלין)
+3. ציטוטים מ-3-4 פסקי דין מתחומים שונים: עליון, מחוזי, ועדת ערר
+4. ציטוט מתקדים שדפנה עצמה הייתה כותבת ("בעניין גלובלינקס קבענו")
+5. **הבחנת מקבילים** — חלקה 240 (תיק אחר באותה ועדה)
+6. **חזרה לעיקרון** עם ניסוח מתון ("אינו תנאי אשר שולל בחינת תכנון נקודתי")
+7. **חיבור לזמן** ("חלפו למעלה מ-8 שנים מאז החלטת 2017")
+```
+
+**מתי להשתמש**: כשנושא בעל אופי דוקטרינלי דורש הצגה רחבה לפני יישום.
+**הסיבה לאורך**: בנייה איטית של "מותחם הסבירות" — דפנה לא קופצת ל-"לכן מותר לאשר תכנון נקודתי" — היא מציגה את הספקטרום ומסבירה איפה התיק שלפניה ניצב בו.
+
+### תבנית F — יישום והכרעה (פסקאות 160-166)
+
+```
+1. **דא עקא** — איתור השאלה המדויקת ("השאלה שלפנינו אינה רק האם... אלא מהו ההיקף הראוי")
+2. נתונים כמותיים (50%, 328.5 מ"ר, 4 קומות)
+3. **התרשמות שלוש-שכבתית** ("לאחר בחינת הבינוי המבוקש, לאחר שמיעת הצדדים ולאחר סיור במקום אנו סבורים")
+4. **ניסוח האיזון** ("האיזון הראוי הינו צמצום מסוים")
+5. **הסבר חיובי של הצמצום** ("צמצום הבינוי אינו דחייה של התכנית אלא ניסיון מאזן")
+6. **בדיקת חלופה** ("גם אם היינו מקבלים את טענת העורר... הרי שקומה מצומצמת... עונה במהותה על ליבת הדרישות")
+7. **עוגן מקצועי** ("נקודת העוגן למסקנתנו זו היא המלצת הגורם המקצועי בוועדה, מהנדס הוועדה המקומית")
+8. **חזרה לעיקרון מארגן** ("נשוב על כך כי ההחלטה להתנות... אינה דחיית זכויות הקניין... אלא דווקא הכרה בהן, מימוש יחידת הדיור השישית")
+9. **דחייה לוועדה המקומית** לפרטים טכניים ("ההיקף המדויק ופרמטרי הנסיגה ייקבעו על ידי מהנדס הוועדה המקומית")
+```
+
+**זה הלב.** התבנית הזו היא איפה דפנה מכריעה, וכל מהלך בה משרת מטרה: לבסס שההחלטה היא **תוצר תהליך**, לא קביעה שרירותית.
+
+### תבנית G — נושא נלווה מהיר (פסקה 167)
+
+```
+1. תיאור קצר של הסוגיה (סגירת מרפסות)
+2. **הבחנה ברורה** ("בניגוד לתוספת הקומה, סגירת מרפסות אינה מגדילה את גובה הבניין")
+3. אישור פשוט
+```
+
+### תבנית H — נושא מהותי-משני עם נטל הוכחה (פסקאות 168-176)
+
+```
+1. הצגת המחלוקת (חניה)
+2. **קביעה של חוסר הוכחה** ("טענות העורר... לא נתמכו בכל חוו"ד ונותרו בגדר חשש לא מבוסס")
+3. ציטוט מקצועי תומך (מערר אבו נימר)
+4. **הבחנה תכנית-טכנית** (אישור יועץ תנועה קיים)
+5. הכרעה ("אין אנו מוצאים מקום להתערב")
+6. **למעלה מן הצורך** — תוספת על תכנון כבישים עתידי
+```
+
+---
+
+## 3. הקול של ה"אנחנו" — נרטור מנחה
+
+דפנה לא כותבת בקול שיפוטי כללי ("הוועדה מוצאת ש..."). היא משתמשת ב**גוף ראשון רבים פעיל**, וכל פועל ממלא תפקיד שונה:
+
+| ביטוי | תפקיד | דוגמה |
+|--------|--------|--------|
+| **נקדים ונציין** | פתיחת בלוק עם מסגור רעיוני | "כידוע דיני התכנון... נדרשים מעצם טיבם ליישב מתחים מובנים" (93) |
+| **נחדד** | חידוד פנימי בתוך טיעון | "נחדד כי הסייג... מגדיר את גבולות אותה פסקה בלבד" (118, 128) |
+| **נציין** | הוספת תצפית צדדית | "נציין כי גם בחלקה הסמוכה... אושרה תכנית" (159) |
+| **נשוב על כך** | חזרה מודעת לרעיון מרכזי | "נשוב על כך כי ההחלטה להתנות... אינה דחייה" (166) |
+| **נפנה (עתה / לפסיקה)** | מעבר לסוגיה הבאה | "נפנה עתה לטענה" (116), "נפנה לפסיקת בית המשפט" (145) |
+| **נוסיף** | חיזוק אגב | "נוסיף כי נתנו את דעתנו" (174) |
+| **אנו סבורים** | שיפוט (לא קביעה) | "אנו סבורים כי האיזון הראוי הינו" (162) |
+| **התרשמנו** | רושם תהליכי | "התרשמנו כי מוסדות התכנון ערים לכך" (164) |
+| **אנו מכירים** | הכרה ערכית | "אנו מכירים בערך שינוי הנסיבות" (163) |
+| **קראנו / שמענו / ערכנו / ביקשנו / המתנו** | תיעוד תהליך | "קראנו את כתבי הטענות... שמענו את הצדדים" (98) |
+| **להלן נתאר ונרחיב** | התראה לקורא | "להלן נתאר ונרחיב את הדברים" (132) |
+
+**העיקרון**: כל "נחדד" הוא לא סתם פתיחת פסקה — הוא **סימון** לקורא: "זה מקום שבו אני, הכותבת, מתערבת בנרטיב המשפטי כדי להבהיר משהו שעלול להישכח". כל "נשוב על כך" אומר: "זה רעיון מרכזי, אני חוזרת אליו ביודעין".
+
+לסוכן הכותב: אם הוא משתמש ב-"נחדד" כסתם מילת מעבר — הוא מאבד את העיקר. "נחדד" צריך להיות **פעולה אינטלקטואלית** — חידוד אמיתי של נקודה שעלולה להיטשטש.
+
+---
+
+## 4. דפוס "אכן... אולם" — אישור-לפני-דחייה
+
+דפוס שחוזר 5+ פעמים בבלוק י. הסכמה מודעת לעוצמת טיעון הצד השני, ואז הסבר למה זה לא משנה את התוצאה:
+
+| מקום | אישור | עוקר |
+|-------|--------|--------|
+| 94 | "אכן העורר והמשיב 3 מעלים מספר טענות בעלות טעם הראויות להיבחן" | (ממשיך לדון בהן ברצינות) |
+| 113 | "אכן, יש לזכור כי ההתנגדות הינה של שוכר... אמורות להיות בגדר פגיעה בהנאה של שוכר ולא של בעל קניין" | "בכל מקרה כפי שציינו, הכבדה תנועתית והסתרה הינם פגיעות שככל וקיימות פוגעות גם במחזיק" |
+| 114 | "אכן, טענה זו אינה מבוטלת ולו מפני שהודיע והתריע על כך בזמן אמת" | "אולם משהמשיב קיבל את מלוא יומו בפני ועדת הערר... הרי שגם אם היה חסר מסויים בשמיעתו הרי שזה נרפא" |
+| 123 | "אותו ערר עסק בהקשר שונה" | "אולם העיקרון שנקבע בו זהה" |
+| 130 | "אכן כפי שנטען בהרחבה, בשנת 2016 הוגשה תכנית מס' 152-0137067... ביום 29.6.2017... דחתה אותה" | "כפי שפירטנו לעיל, הדחייה לא הייתה לגופה" |
+| 132 | "הוועדה לא דחתה את ההצעה לגופה של הבנייה המוצעת" | "אלא קבעה כי כל עוד לא הוצגה ראייה תכנונית כוללת" |
+| 160 | (פתיחה: "דא עקא") | מעבר משאלה אחת לשאלה אחרת |
+
+**העיקרון**: דפנה לא דוחה טענות. היא **מקבלת אותן בנקודה הכי גבוהה שלהן** ואז מסבירה למה הן לא מכריעות. זה מונע מהקורא (במיוחד שופט בית משפט מנהלי בעתיד) להרגיש שהיא הייתה שטחית.
+
+לסוכן: לעולם לא להיכנס למצב של "טענת X נדחית". תמיד "אכן [X טוען]... אולם [למה זה לא מכריע]". אם אין לך "אולם" משכנע — אולי X צודק.
+
+---
+
+## 5. היררכיית הערכים של דפנה
+
+ב-93 היא מנסחת את שלושת המתחים המובנים בדיני תכנון:
+
+1. **זכות הקניין vs הסדרה תכנונית**
+2. **מגמות ציפוף vs שמירה על אופי מקום**
+3. **סמכות מקומית vs עמדת ועדה מחוזית**
+
+ובמהלך הדיון מתבררים מתחים נוספים:
+
+4. תכנון נקודתי vs תכנון כולל (144)
+5. פגמים פרוצדורליים vs ריפוי בפועל (114-115)
+6. אינטרסים אישיים של מתנגד vs פורמליזם של זכויות עמידה (113)
+7. פרשנות מילולית של חוק vs פרשנות תכליתית (118)
+
+**איך היא פותרת את כולם?** מילת המפתח: **איזון** (חוזרת בפסקאות 162, 163, 166, 142).
+
+- אם ערך A מוחלט → היא תמנע אותו ("אינו תנאי אשר שולל בחינת תכנון נקודתי")
+- אם ערך A קל מדי → היא תחזק אותו ("יש לקבוע לו גבולות ראויים")
+- ההכרעה שלה היא תמיד **לא הכל-או-לא-כלום** — צמצום מסוים, אישור חלקי, נסיגה
+
+**ערכים מטא** (לא נאמרים בפירוש אבל מובלעים):
+- **זהירות שיפוטית**: "צמצום הבינוי אינו דחייה של התכנית אלא ניסיון מאזן" (163)
+- **דחייה לבעלי מקצוע**: "נקודת העוגן למסקנתנו זו היא המלצת הגורם המקצועי" (165)
+- **כתיבה לתיק הבא**: 14 פסקאות על זכות עמידה — לא בגלל שהמקרה מורכב, אלא בגלל שהיא מבססת תקדים
+
+**לסוכן**: כשהוא בונה הכרעה, הוא צריך לשאול **לא** "מי צודק?" אלא "מה האיזון הנכון בין הערכים שמוצגים בפניי?". אם המסקנה היא "X זכה במלואו" — אולי האיזון לא נמצא.
+
+---
+
+## 6. החלטות קצב
+
+| איפה דפנה מאריכה | למה | פסקאות |
+|--------------------|------|---------|
+| זכות עמידה | מבססת עיקרון לתיקים הבאים | 99-113 (15) |
+| היסטוריה תכנונית | תשתית עובדתית להכרעה | 125-143 (19) |
+| תכנון נקודתי vs כולל | דוקטרינה שתחזור | 144-159 (16) |
+| ההכרעה האמצעית | הלב של ההחלטה | 160-166 (7, צפופים) |
+
+| איפה דפנה מקצרת | למה | פסקאות |
+|-------------------|------|---------|
+| חישוב 50%/67% | מתייתר בהינתן הצמצום שייקבע | 124 (1) |
+| סגירת מרפסות | אגב, אין מחלוקת אמיתית | 167 (1) |
+| חניה | פתרון מאושר; הדיון קצר | 168-176 (4 מהותיים + 4 אגב) |
+
+**העיקרון**: דפנה לא מקדישה אורך לפי "מורכבות הסוגיה" אלא לפי **המשקל בהכרעה**. סוגיה טכנית-מורכבת מקבלת 1 פסקה אם היא לא מכריעה. סוגיה פשוטה מקבלת 15 פסקאות אם היא מבססת תקדים.
+
+**לסוכן**: לפני שהוא כותב על סוגיה — לשאול "כמה משקל יש לה בהכרעה?" ולא "כמה כתבו עליה הצדדים?". טענה ארוכה של עורר על פגם פרסום יכולה לקבל פסקה אחת אם הפגם נרפא.
+
+---
+
+## 7. השתיקות (מה דפנה בחרה לא לדון בו)
+
+מה שלא נכלל בבלוק י של 1130-25 הוא לפעמים מלמד יותר ממה שכן.
+
+1. **לא דנה בערכים אסתטיים סובייקטיביים** — אף שמטמון תיאר את "החטא הקדמון" של הוועדה ושירה תלמי-באבאי על "אין לקחת בניין שהוחרג ולהחריגו שוב", דפנה ציטטה את שקד ב-127 וניטרלה: **"לא נוכל להתייחס לאמירות עבר שעה שעסקינן בתכנית שאושרה כדין"**. זה דפוס: היא מקבלת רטוריקה צבעונית מהצדדים, אבל לא מאמצת אותה.
+
+2. **לא נכנסה לסוגיה הקניינית של מתקן ההכפלה** (העורר טען ש"בעיות קנייניות" מונעות ביצוע) — היא לא הכריעה בה. הצביעה רק על אישור יועץ התנועה.
+
+3. **לא קבעה ערכים מספריים סופיים** לתוספת המאושרת — דחתה לוועדה המקומית. **למה?** דחייה למומחים שראו בשטח.
+
+4. **לא דנה בהשלכות לסביבה** במובן הסוציולוגי-קהילתי שמטמון העלה — נשארה בגבולות תכנון פיזי.
+
+**לסוכן**: שתיקה היא בחירה מודעת. אם הצד מעלה טענה רגשית-נרטיבית, דפנה מציינת אותה (לא מתעלמת) אבל מסיגה אותה לתחום שיפוטי-תכנוני. **לא לאמץ את הדרמטיות של הצדדים בקול ההכרעה.**
+
+---
+
+## 8. הנרטיב המטא — הפרסונה הדליברטיבית
+
+לאורך בלוק י (וגם בלוק יא — "סוף דבר"), דפנה משלבת **תיעוד תהליכי**:
+
+- (98) "קראנו את כתבי הטענות על נספחיהם, שמענו את הצדדים בדיון מיום 27.10.2025, ערכנו סיור במקום ביום 30.11.2025, ביקשנו השלמות טיעון מכלל הצדדים, והמתנו לשמיעת העררים המקבילים"
+- (131) "לצורך הכרעתנו נדרשנו לעיין ביסודיות בפרוטוקולים ובתמלולים של דיוני הוועדה המחוזית משנת 2017"
+- (162) "לאחר בחינת הבינוי המבוקש, לאחר שמיעת הצדדים ולאחר סיור במקום אנו סבורים"
+- (165) "מהנדס הוועדה... בחן את הנתונים בשטח ומכיר את הסביבה"
+- (177, בלוק יא) "טרם סיום נבקש לציין כי ערר זה נדון לפנינו ביסודיות רבה בדיון, בסיור, בהשלמות טיעון, ובהמתנה לשמיעת העררים המקבילים. עשינו כן..."
+
+**העיקרון**: התהליך עצמו הופך לטיעון ללגיטימיות ההחלטה. כשבית משפט מנהלי יקרא את ההחלטה, הוא יראה לא רק "מה" הוועדה החליטה, אלא **"איך"** היא החליטה. תיעוד תהליכי הוא **הגנה מפני ביקורת על שרירותיות**.
+
+**לסוכן**: לפני סיום בלוק י וכניסה לבלוק יא — לציין מה הוועדה עשתה לפני שהחליטה. זה לא "קישוט" — זה חלק מההיגיון של ההחלטה.
+
+---
+
+## 9. המסגרת הסמויה — דוקטרינת השופט
+
+מתוך הקריאה, דפנה פועלת לפי דוקטרינה מובלעת שלא מנוסחת בשום מקום מפורש:
+
+**עיקרון 1 — איזון על פני קביעות חדות**
+לעולם לא הכל-או-לא-כלום. כל הכרעה היא איזון בין שני ערכים לפחות.
+
+**עיקרון 2 — תהליך מבסס תוצאה**
+ההחלטה לא משכנעת רק בזכות הנימוקים — אלא גם בזכות התהליך הקפדני שקדם לה.
+
+**עיקרון 3 — דחייה למקצוענים**
+כששאלה תכנונית-טכנית עומדת על הפרק, היא דוחה למהנדס/יועץ תנועה/לוועדה המקומית. שופט-ועדת ערר אינו מתכנן.
+
+**עיקרון 4 — כתיבה לתיקים הבאים**
+היקף הדיון בכל סוגיה משקף לא רק את התיק שלפניה אלא את התרומה לדוקטרינה. זכות עמידה מקבלת 15 פסקאות אף שהמקרה ברור — כי זו תרומה כללית.
+
+**עיקרון 5 — פרשנות תכליתית עם הסתייגויות**
+היא מאמצת פרשנות תכליתית של חוקי תכנון (62א), אבל לא ב"קול גס" — תמיד עם "נחדד", "אולם", הכרה במגבלות.
+
+**עיקרון 6 — שינוי נסיבות כעיקרון מערך**
+8 שנים מאז 2017 + תכניות מקבילות שאושרו = שינוי נסיבות שמשנה את התשובה. דפנה רגישה לזמן בצורה לא טריוויאלית.
+
+**עיקרון 7 — אובייקטיביזציה של מצוקות סובייקטיביות**
+"בעלי אופי שונה מזה הבנוי על המגרש והמתוכנן" (94) — זו דרך אובייקטיבית להגיד "השכנים גרים בבתים פרטיים והתכנית מכניסה בניין רב-קומות". היא לא מאמצת את הרגש, היא תרגמה אותו לקטגוריה שיפוטית.
+
+---
+
+## 10. הוראות קונקרטיות לסוכן הכותב
+
+מבוסס על הקריאה, להוסיף ל-system prompt של `legal-writer`:
+
+### 10.1 לפני כתיבת בלוק י
+שאל את עצמך:
+- **מהם 2-3 המתחים המובנים** בערר הזה? (לדוגמא: זכות קניין vs רגישות סביבתית)
+- **איזה תקדים אני מבסס?** (אם הכל "פרטי לתיק" — אין סיבה לכתוב הרבה)
+- **איפה האיזון?** (אם המסקנה הצפויה היא "X צודק במלואו" — בדיקה נוספת)
+
+### 10.2 ארכיטקטורה
+התחל ב**מסגור פילוסופי** (1-2 פסקאות) → **תיעוד תהליכי** → **טענות סף** (גם אם לא הועלו במפורש — לבדוק) → **סוגיות טכניות** → **רקע מהותי** → **דוקטרינה** → **השאלה האמיתית** → **הכרעה** → **נושאים נלווים**.
+
+### 10.3 כל סוגיה — תבנית "אכן... אולם"
+התחל בקבלת הטענה של הצד שאתה דוחה בנקודתה הגבוהה ביותר. אם אתה לא יכול לנסח אותה ברצינות — אתה לא מבין אותה.
+
+### 10.4 שימוש מדוייק ב"אנחנו"
+- "נחדד" — רק כשמחדדים נקודה שמסתכנת בטשטוש
+- "נשוב על כך" — רק כשחוזרים ביודעין לרעיון מרכזי
+- "נציין" — לתצפית צדדית
+- "נפנה" — למעבר לסוגיה
+- "אנו סבורים" — לשיפוט (לא ל"קביעה" של עובדה)
+- "התרשמנו" — לרושם תהליכי
+
+### 10.5 אורך בלוק = משקל בהכרעה (לא מורכבות)
+לפני כתיבת תת-סעיף, שאל "כמה משקל יש לזה בהכרעה?". סוגיה משנית מקבלת פסקה. סוגיה שמבססת תקדים מקבלת עמוד.
+
+### 10.6 ציטוטים — מלאים, לא תמציתיים
+ציטוט מפסיקה הוא ציטוט. אם רוצים תמצית — לא לצטט בכלל ולכתוב ב"נמצא ב-X ש...".
+
+### 10.7 "למעלה מן הצורך"
+אחרי כל הכרעה משפטית עיקרית, שקול הוספת טיעון חלופי: "גם אם היינו מקבלים את פרשנות העורר... התוצאה הייתה זהה". זה סוגר חלון לערעור.
+
+### 10.8 תיעוד תהליכי בסוף
+לפני "סוף דבר", לציין קצרות מה הוועדה עשתה: דיון, סיור, השלמות טיעון, המתנה לתיקים מקבילים. זה לא קישוט — זו לגיטימציה.
+
+### 10.9 דחייה למומחים
+כשהשאלה תכנונית-טכנית — דחייה למהנדס/יועץ. הוועדה אינה מתכננת.
+
+### 10.10 קולות לרסן
+- לא לאמץ רטוריקה דרמטית של הצדדים ("חטא קדמון", "חטא") — לציין אבל לא לאמץ
+- לא להגיע ל"הכל-או-לא-כלום"
+- לא לדחות טענה במשפט אחד ללא ציטוט/הסבר
+
+---
+
+## 11. הרחבה — תיק 1194-25 כמקרה בוחן משלים
+
+תיק 1194-25 דן במגרש סמוך (חלקה 240) באותה שכונה. דפנה דחתה את הערר במלואו (בעוד שב-1130 קיבלה חלקית). הפער מספק הזדמנות **להבחין מה משתנה לפי המקרה ומה קבוע אצל דפנה.**
+
+### 11.1 שני מודי פתיחה — לפי ודאות התוצאה
+
+**מוד פילוסופי** (1130-25, פס' 93):
+> "כידוע דיני התכנון והבנייה נדרשים מעצם טיבם ליישב מתחים מובנים בין זכות הקניין לבין הסדרה תכנונית..."
+
+**מוד בוטם-ליין** (1194-25, פס' 60):
+> "נקדים ונציין כי לאחר שבחנו את מכלול הטענות... מצאנו כי אין בטענות העוררים כדי להצדיק התערבותנו בהחלטת הוועדה המקומית, ועל כן הערר נדחה. **ונפרט;**"
+
+**העיקרון**: כשהתוצאה ברורה (דחיית ערר על כל טענותיו) — דפנה פותחת בתוצאה ואז מפרטת. כשהתוצאה מורכבת (קבלה חלקית עם שינויים) — היא פותחת בפילוסופיה כדי לבסס את האיזון. הבחירה אינה סגנונית; היא **כלי שכנוע**.
+
+**הסימן ייחודי**: `ונפרט;` עם **נקודה-פסיק**. לא נקודה (סוף סופי), לא נקודתיים (פתיחה לרשימה). נקודה-פסיק = "פסקה אחת מסיימת, אבל הרעיון נמשך". זה דקדוק רטורי.
+
+### 11.2 מהלך חדש — ציטוט עצמי כתקדים
+
+ב-1194-25, דפנה מתייחסת ל-1130-25 שלה עצמה **חמש פעמים**:
+
+| פסקה | ניסוח | תפקיד |
+|-------|--------|--------|
+| 61 | "סוגיה זו נדונה בהרחבה בהחלטתנו בערר 1130/25... כפי שקבענו שם" | **חיסכון** דוקטרינרי |
+| 64 | "וכפי שקבענו בהחלטתנו בערר 1130/25" | תמיכה |
+| 97 | "כפי שקבענו בהרחבה בהחלטתנו בערר 1130/25, מדיניות הוועדה המחוזית השתנתה" | תמיכה רעיונית |
+| 98 | "נפנה להנמקה המפורטת בהחלטתנו בערר 1130/25" | **דחייה** ולא חזרה |
+| 99 | **"בניגוד לתכנית שנדונה בערר 1130/25, שם קיבלנו באופן חלקי את טענת המתנגדים שמדובר במבנה חריג, הרי שבמקרה הנדון מדובר בבנייה מצומצמת יותר"** | **הבחנה — distinguishing** |
+
+**הזה דבר חדש לחלוטין שלא הופיע ב-1130 לבד**: דפנה לא רק כותבת לתיק הבא — היא **בונה ג'וריספרודנציה אישית מתמשכת**. ההחלטות שלה מתייחסות זו לזו כמערכת. תיק 1130 הוא לא רק "תקדים מאחורי הקלעים" — הוא **תקדים מצוטט בפני שופט עתידי**.
+
+**העקרון להבחנה (פס' 99)**: דפנה לא מסתפקת ב"זה מקרה אחר". היא **מנסחת את ההבחנה בקול ברור**: "בניגוד ל-X, שם Y, הרי שכאן Z". זה הניסוח של שופט מנוסה שיודע שבית משפט מנהלי יבדוק עקביות בין החלטותיה.
+
+**להוסיף ל-system prompt של legal-writer**: כשעורר/תיק חדש קשור לתיק שדפנה כבר הכריעה בו (אותה שכונה, אותו צד, אותה סוגיה משפטית) — **חובה** לחפש את התקדים הקודם של דפנה (`search_decisions`) ולהשתמש בו ב-3 דרכים: (1) הפניה לחיסכון; (2) דחייה לדיון מפורט; (3) הבחנה אם התוצאה שונה.
+
+### 11.3 דחיסה דרך הפנייה
+
+בלוק י של 1194 בכ-3,500 מילים, של 1130 בכ-5,000. ההפרש הוא בעיקר **דחיסה דוקטרינית**:
+
+- 1130 הקדיש 16 פסקאות לדוקטרינת תכנון נקודתי vs כולל (פס' 144-159)
+- 1194 הקדיש 1 פסקה אחת + הפניה: "כפי שקבענו בהרחבה בהחלטתנו בערר 1130/25, מדיניות הוועדה המחוזית השתנתה מהותית..." (פס' 97)
+
+**עקרון לסוכן**: לפני כתיבת דוקטרינה — לבדוק האם דפנה כבר ניסחה אותה בתיק קודם בקטגוריה דומה. אם כן — להפנות, לא לחזור.
+
+### 11.4 פעלי "אנחנו" חדשים
+
+בנוסף לרשימה מסעיף 3, ב-1194 הופיעו:
+
+| ביטוי | תפקיד | דוגמה |
+|--------|--------|--------|
+| **ונבהיר** | הבהרת מה **לא** הוכרע | "ונבהיר כי התכנית לא אושרה מכח סעיף 62א(א)(9) אלא מכח..." (67) |
+| **ודוק** | reductio ad absurdum | "ודוק, אם נקבל את פרשנות העוררים... המשמעות היא הקפאת מצב... תוצאה שאינה סבירה" (66) |
+| **נחזור על כך** (variant של "נשוב") | חזרה לעובדה מארגנת | "נחזור על כך כי בתכנית כפי שהופקדה צוין..." (82) |
+
+### 11.5 הבדל סוגיית הפתיחה: מה הוועדה לא דנה בו
+
+**1130** דן בזכות עמידה בהרחבה (15 פסקאות) — כי הוועדה המקומית הלינה.
+**1194** **לא דן בזכות עמידה כלל** — הסוגיה לא הועלתה.
+
+**עקרון**: דפנה לא דנה בסוגיות שלא הועלו על ידי הצדדים. אין ניסיון להציג את "כל הספקטרום". מה שלא נטען — לא נדון.
+
+### 11.6 איזון משתנה לפי מקרה
+
+ב-1130, האיזון היה: לאשר תוספת קומה אבל לצמצם.
+ב-1194, האיזון היה: לאשר את הכל (ולא, כפי שטענו העוררים, להחיל אותם נימוקים שתמכו בצמצום ב-1130).
+
+**פסקה 99 היא קלאסיקה של הבחנה**: "בניגוד לתכנית שנדונה בערר 1130/25, שם קיבלנו באופן חלקי את טענת המתנגדים שמדובר במבנה חריג, הרי שבמקרה הנדון מדובר בבנייה מצומצמת יותר במגרש, בהיקף שאינו חריג לסביבה."
+
+זה לא "אנחנו פוסקים שונה" — זה "השונות בעובדות מצדיקה שונות בתוצאה". קביעה תכלית-יישומית קלאסית.
+
+### 11.7 השוואה כוללת — קבועים ומשתנים
+
+| היבט | קבוע אצל דפנה | משתנה לפי תיק |
+|--------|---------------|----------------|
+| הקול ה"אנחנו" הפעיל | ✓ | – |
+| תבנית "אכן... אולם" | ✓ | – |
+| נקודה-פסיק "ונפרט;" | ✓ | – |
+| דחייה למקצוענים | ✓ | – |
+| ארכיטקטורת משפך | ✓ | סדר הסעיפים בתוך טענות סף |
+| מסגור פילוסופי בפתיחה | – | רק כשהתוצאה מורכבת |
+| הבחנה מתקדים שלה עצמה | – | רק כשיש תקדים רלוונטי |
+| אורך מוחלט של בלוק י | – | תלוי במורכבות + יכולת לחיסכון |
+| השאלה האם זכות העמידה נדונה | – | תלוי בטענות הצדדים |
+
+---
+
+## 12. מה לא ראינו בקריאה הזו (פערים)
+
+הקריאה הייתה על תיק אחד. כדי לבסס את הקול בצורה יציבה, יידרש:
+
+1. **קריאה חוצת-קורפוס** של 6 קבצי האימון (ורדיה, סופר נוח, נאמנות, כלמוביל, עלות עודפת בחניה, החלטה-1130-25 final) — לראות אילו דפוסים קבועים אצל דפנה ואילו ייחודיים לתיק 1130-25 (תיק רישוי-וועדה-מחוזית מורכב)
+2. **ניתוח דיפרנציאלי בין סוגי ערר** — האם הקול ב-8xxx (היטל השבחה) שונה מהותית? האם הסכימה בולעת איזון או נטייה לקראת תיק קר ויבש?
+3. **דפוסי תקדימים** — אילו פסקי דין דפנה חוזרת אליהם (חוף השרון, הרמלין, פז) — זה ה"קאנון" שלה
+4. **בלוקים אחרים מלבד י** — איך נשמע הקול שלה בבלוק ז (טענות), בבלוק י-א (סוף דבר), בבלוק י-ב (הוראה אופרטיבית)?
+
+**המלצה**: אחרי שחיים יקרא את המסמך הזה, אם הוא חש שאנחנו "תופסים את העיקר" — להמשיך לקריאה חוצת-קורפוס. אם לא — לחזור ולהעמיק עוד בתיק 1130-25.

mcp-server/pyproject.toml

@@ -19,6 +19,7 @@ dependencies = [
     "google-cloud-vision>=3.7.0",
     "fastapi>=0.115.0",
     "uvicorn[standard]>=0.30.0",
+    "httpx>=0.27.0",
 ]
 
 [build-system]

mcp-server/src/legal_mcp/server.py

@@ -165,10 +165,13 @@ async def document_upload_training(
     decision_date: str = "",
     subject_categories: list[str] | None = None,
     title: str = "",
+    practice_area: str = "appeals_committee",
+    appeal_subtype: str = "",
 ) -> str:
-    """העלאת החלטה קודמת של דפנה לקורפוס הסגנון. קטגוריות: בנייה, שימוש חורג, תכנית, היתר, הקלה, חלוקה, תמ"א 38, היטל השבחה, פיצויים 197."""
+    """העלאת החלטה קודמת של דפנה לקורפוס הסגנון. קטגוריות: בנייה, שימוש חורג, תכנית, היתר, הקלה, חלוקה, תמ"א 38, היטל השבחה, פיצויים 197. סוג ערר: building_permit / betterment_levy / compensation_197 (ריק = אוטומטי ממספר ההחלטה)."""
     return await documents.document_upload_training(
         file_path, decision_number, decision_date, subject_categories, title,
+        practice_area, appeal_subtype,
     )
 
 
@@ -184,6 +187,17 @@ async def document_list(case_number: str) -> str:
     return await documents.document_list(case_number)
 
 
+@mcp.tool()
+async def document_update(
+    case_number: str,
+    doc_id: str,
+    doc_type: str = "",
+    appraiser_side: str = "",
+) -> str:
+    """עדכון תיוג מסמך — doc_type ו/או appraiser_side (committee/appellant/deciding). ריק = ללא שינוי."""
+    return await documents.document_update(case_number, doc_id, doc_type, appraiser_side)
+
+
 # Claims extraction
 @mcp.tool()
 async def extract_claims(
@@ -220,9 +234,14 @@ async def search_decisions(
     query: str,
     limit: int = 10,
     section_type: str = "",
+    practice_area: str = "",
+    appeal_subtype: str = "",
+    case_number: str = "",
 ) -> str:
-    """חיפוש סמנטי בהחלטות קודמות ובמסמכים."""
+    """חיפוש סמנטי בהחלטות קודמות ובמסמכים — מסונן לפי תחום משפטי."""
-    return await search.search_decisions(query, limit, section_type)
+    return await search.search_decisions(
+        query, limit, section_type, practice_area, appeal_subtype, case_number,
+    )
 
 
 @mcp.tool()
@@ -239,9 +258,14 @@ async def search_case_documents(
 async def find_similar_cases(
     description: str,
     limit: int = 5,
+    practice_area: str = "",
+    appeal_subtype: str = "",
+    case_number: str = "",
 ) -> str:
-    """מציאת תיקים דומים על בסיס תיאור."""
+    """מציאת תיקים דומים על בסיס תיאור — מסונן לפי תחום משפטי."""
-    return await search.find_similar_cases(description, limit)
+    return await search.find_similar_cases(
+        description, limit, practice_area, appeal_subtype, case_number,
+    )
 
 
 # Drafting
@@ -309,9 +333,46 @@ async def export_docx(case_number: str, output_path: str = "") -> str:
 
 
 @mcp.tool()
-async def analyze_style() -> str:
+async def extract_appraiser_facts(case_number: str) -> str:
-    """ניתוח סגנון על קורפוס ההחלטות של דפנה. מחלץ ושומר דפוסי כתיבה."""
+    """חילוץ תכניות והיתרים מכל השומות בתיק וזיהוי סתירות בין שמאים. הכנה לטיוטת ביניים."""
-    return await drafting.analyze_style()
+    return await drafting.extract_appraiser_facts(case_number)
+
+
+@mcp.tool()
+async def write_interim_draft(case_number: str, instructions: str = "") -> str:
+    """כתיבת ארבעת הבלוקים לטיוטת ביניים (רקע, תכניות+היתרים, טענות, הליכים) — אותו skill וטמפלט."""
+    return await drafting.write_interim_draft(case_number, instructions)
+
+
+@mcp.tool()
+async def export_interim_draft(case_number: str, output_path: str = "") -> str:
+    """ייצוא טיוטת ביניים ל-DOCX — סדר חדש (רקע → תכניות+היתרים → טענות → הליכים), ללא דיון/סיכום."""
+    return await drafting.export_interim_draft(case_number, output_path)
+
+
+@mcp.tool()
+async def apply_user_edit(case_number: str, edit_filename: str) -> str:
+    """רישום עריכה שהעלה המשתמש (עריכה-v*.docx) כמקור האמת החדש — מזריק bookmarks אם חסר."""
+    return await drafting.apply_user_edit(case_number, edit_filename)
+
+
+@mcp.tool()
+async def list_bookmarks(case_number: str) -> str:
+    """רשימת bookmarks הקיימים ב-active_draft של התיק (אנקורים ל-revisions)."""
+    return await drafting.list_bookmarks(case_number)
+
+
+@mcp.tool()
+async def revise_draft(case_number: str, revisions_json: str,
+                       author: str = "מערכת AI") -> str:
+    """החלת revisions (Track Changes) על ה-active_draft, יוצר טיוטה-v{N+1}.docx חדשה."""
+    return await drafting.revise_draft(case_number, revisions_json, author)
+
+
+@mcp.tool()
+async def analyze_style(appeal_subtype: str = "") -> str:
+    """ניתוח סגנון על קורפוס ההחלטות של דפנה. מחלץ ושומר דפוסי כתיבה. סוג ערר: building_permit / betterment_levy / compensation_197 (ריק = הכל)."""
+    return await drafting.analyze_style(appeal_subtype)
 
 
 @mcp.tool()

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

@@ -0,0 +1,503 @@
+"""Export the legal analysis (analysis-and-research.md + precedents) to a
+DOCX file that uses דפנה's decision template styles.
+
+The template lives at `skills/docx/decision_template.docx` (converted once
+from `טיוטת החלטה.dotx` via `scripts/convert_decision_template.py`).
+We open it, wipe the sample body paragraphs, and write new content by
+applying style names only — never by hand-setting font/size/RTL/margins,
+because the template's styles.xml already carries those.
+
+Style mapping:
+    "Title"            → the document title (case number, date)
+    "Heading 2"        → top-level section headers
+                         (טענות סף / סוגיות להכרעה / מסקנות)
+    "Normal" + bold    → subsection headers (individual claim/issue)
+    "Normal"           → field label (bold run) + value
+    "Quote"            → precedent quote text
+    "Normal" (italic)  → precedent citation
+
+Output: data/cases/{case_number}/exports/ניתוח-משפטי-v{N}.docx
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+from uuid import UUID
+
+from docx import Document
+from docx.document import Document as DocumentT
+from docx.oxml.ns import qn
+from docx.oxml import OxmlElement
+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
+
+
+def _mark_run_rtl(run: Run) -> None:
+    """Mark a run as complex-script (Hebrew/Arabic) so Word uses the `cs`
+    font slot from the style (David) rather than `ascii` (Times New Roman).
+
+    Without this, runs we add programmatically render Hebrew in the ascii
+    font — even though the paragraph style has `<w:rFonts cs="David"/>`.
+    """
+    rPr = run._r.get_or_add_rPr()
+    if rPr.find(qn("w:rtl")) is None:
+        rPr.append(OxmlElement("w:rtl"))
+
+
+def _mark_paragraph_rtl(paragraph: Paragraph) -> None:
+    """Add `<w:rtl/>` inside the paragraph's rPr so the paragraph mark
+    itself is treated as RTL. The paragraph style already sets bidi
+    direction, but empty paragraphs and trailing marks need this flag.
+    """
+    pPr = paragraph._p.get_or_add_pPr()
+    rPr = pPr.find(qn("w:rPr"))
+    if rPr is None:
+        rPr = OxmlElement("w:rPr")
+        pPr.append(rPr)
+    if rPr.find(qn("w:rtl")) is None:
+        rPr.append(OxmlElement("w:rtl"))
+
+# Path to the converted template. Static — populated by
+# scripts/convert_decision_template.py.
+TEMPLATE_PATH = (
+    Path(__file__).resolve().parents[4]
+    / "skills"
+    / "docx"
+    / "decision_template.docx"
+)
+
+CHAIR_POSITION_LABEL = "עמדת ועדת הערר"
+CHAIR_POSITION_PLACEHOLDER = "[טרם מולאה עמדת ועדת הערר]"
+
+NUMBERED_LINE_RE = re.compile(r"^\s*(\d+)[.)]\s+(.+)$")
+BULLET_LINE_RE = re.compile(r"^\s*[\-\u2022\*\u25CF\u25E6]\s+(.+)$")
+# (א) (ב) (ג) ... — Hebrew-letter enumeration used by the authors.
+# We keep the marker inside the text (the author wrote it), but render the
+# paragraph as "List Paragraph" without the numPr so the visual indentation
+# matches the template's list style without adding a double "1." prefix.
+HEB_LETTER_LINE_RE = re.compile(r"^\s*\([א-ת]\)\s+")
+
+# A standalone **LABEL:** line (the whole trimmed line is wrapped in ** **)
+STANDALONE_LABEL_RE = re.compile(r"^\s*\*\*([^\n*]+?):\*\*\s*$")
+# A short standalone "XYZ:" line (no ** **) — acts as a sub-heading for the
+# paragraphs that follow. Limit to short phrases to avoid eating real
+# sentences that happen to end with a colon.
+PLAIN_LABEL_RE = re.compile(r"^\s*([^\n:]{2,40}):\s*$")
+# "**LABEL:** value" inline — bold label followed by prose on the same line.
+INLINE_LABEL_RE = re.compile(r"^\s*\*\*([^\n*]+?):\*\*\s+(.+)$")
+
+
+def _classify_line(line: str) -> tuple[str, str]:
+    """Return (kind, clean_text) where kind ∈ {numbered, bullet, heb_letter,
+    label_heading, inline_label, plain}.
+
+    clean_text conventions:
+      - numbered/bullet — marker stripped
+      - heb_letter — marker kept (author supplied it)
+      - label_heading — surrounding ** and trailing : stripped
+      - inline_label — "LABEL\x00VALUE" (NUL-separated; _emit splits it)
+    """
+    m = STANDALONE_LABEL_RE.match(line)
+    if m:
+        return "label_heading", m.group(1).strip()
+    m = INLINE_LABEL_RE.match(line)
+    if m:
+        return "inline_label", f"{m.group(1).strip()}\x00{m.group(2).strip()}"
+    m = NUMBERED_LINE_RE.match(line)
+    if m:
+        return "numbered", m.group(2).strip()
+    m = BULLET_LINE_RE.match(line)
+    if m:
+        inner = m.group(1).strip()
+        # A bullet whose only content is **LABEL:** is a heading, not a list item.
+        # E.g. "- **נקודות פתוחות:**"
+        m2 = STANDALONE_LABEL_RE.match(inner)
+        if m2:
+            return "label_heading", m2.group(1).strip()
+        # A bullet of the form "- **LABEL:** value" → inline label.
+        m3 = INLINE_LABEL_RE.match(inner)
+        if m3:
+            return "inline_label", f"{m3.group(1).strip()}\x00{m3.group(2).strip()}"
+        return "bullet", inner
+    if HEB_LETTER_LINE_RE.match(line):
+        return "heb_letter", line.strip()
+    m = PLAIN_LABEL_RE.match(line)
+    if m:
+        return "label_heading", m.group(1).strip()
+    return "plain", line.strip()
+
+
+def _strip_numpr(paragraph: Paragraph) -> None:
+    """Remove any <w:numPr> from the paragraph's pPr.
+
+    Used when we want the visual styling of `List Paragraph` (indent,
+    font) without Word's auto-decimal "1." prefix — e.g. for Hebrew-
+    letter enumeration where the author wrote (א) (ב) (ג) manually.
+    """
+    pPr = paragraph._p.get_or_add_pPr()
+    for numPr in pPr.findall(qn("w:numPr")):
+        pPr.remove(numPr)
+
+
+# Characters that the code should never emit (user instruction: "no dashes").
+# Applied only to code-generated text, not to user content from the md file.
+_CODE_DASH_RE = re.compile(r"[\u2013\u2014]")
+
+# Markdown inline bold — `**...**`
+_INLINE_BOLD_RE = re.compile(r"\*\*([^\n*]+?)\*\*")
+
+
+def _no_dash(text: str) -> str:
+    """Strip em/en dashes from text the code emits (not from source content)."""
+    return _CODE_DASH_RE.sub("", text)
+
+
+def _add_runs_with_inline_bold(paragraph: Paragraph, text: str) -> None:
+    """Split `text` on `**...**` markers, adding alternating plain and bold
+    runs to `paragraph`. All runs are marked RTL and passed through
+    `_no_dash`.
+
+    This keeps `**טענה חשובה**` rendering as bold (as the author intended)
+    instead of leaving the literal asterisks in the output.
+    """
+    text = _no_dash(text)
+    pos = 0
+    for m in _INLINE_BOLD_RE.finditer(text):
+        if m.start() > pos:
+            plain = paragraph.add_run(text[pos : m.start()])
+            _mark_run_rtl(plain)
+        bold = paragraph.add_run(m.group(1))
+        bold.bold = True
+        _mark_run_rtl(bold)
+        pos = m.end()
+    if pos < len(text):
+        tail = paragraph.add_run(text[pos:])
+        _mark_run_rtl(tail)
+
+
+def _clear_body(doc: DocumentT) -> None:
+    """Remove every paragraph currently in the document body.
+
+    The template ships with example paragraphs ("רקע", "דיון והכרעה"…)
+    that we don't want in the output. Section properties (sectPr) are
+    kept so page size / margins / RTL / footer remain intact.
+    """
+    body = doc.element.body
+    for p in list(body.findall(qn("w:p"))):
+        body.remove(p)
+    # Leave sectPr alone — it carries page setup including bidi.
+
+
+def _add_paragraph(doc: DocumentT, text: str, style: str) -> Paragraph:
+    p = doc.add_paragraph(style=style)
+    _mark_paragraph_rtl(p)
+    if text:
+        _add_runs_with_inline_bold(p, text)
+    return p
+
+
+def _add_label_value(
+    doc: DocumentT, label: str, value: str, *, value_italic: bool = False
+) -> Paragraph:
+    """Add a paragraph with a bold label and an inline value.
+
+    Example rendering:   **עמדת המבקשת:** The party argues that…
+    """
+    p = doc.add_paragraph(style="Normal")
+    _mark_paragraph_rtl(p)
+    run_label = p.add_run(f"{_no_dash(label)}: ")
+    run_label.bold = True
+    _mark_run_rtl(run_label)
+    if value:
+        if value_italic:
+            # Placeholder text — italic, no inline-bold handling.
+            run_value = p.add_run(_no_dash(value))
+            run_value.italic = True
+            _mark_run_rtl(run_value)
+        else:
+            _add_runs_with_inline_bold(p, value)
+    return p
+
+
+def _add_multiline_value(
+    doc: DocumentT, label: str, value: str
+) -> None:
+    """Render a field (label + value).
+
+    Multi-line values get the label as its own Heading 2 paragraph (so the
+    structure visually breaks between fields), then each body line as its
+    own paragraph routed through `_emit_content_line`.
+
+    Single-line values stay inline (bold label + text) — a Heading 2 for
+    a one-liner would look inflated.
+    """
+    lines = [ln for ln in value.splitlines() if ln.strip()]
+    if not lines:
+        _add_label_value(doc, label, "")
+        return
+    if len(lines) == 1:
+        kind, text = _classify_line(lines[0])
+        # Single-line — inline with label regardless of kind
+        _add_label_value(doc, label, text)
+        return
+    # Multi-line: label as Heading 2, then each line via _emit_content_line
+    _add_paragraph(doc, label, "Heading 2")
+    for line in lines:
+        _emit_content_line(doc, line)
+
+
+def _emit_content_line(doc: DocumentT, line: str) -> None:
+    """Render a single line of content using the right template style.
+
+    - `label_heading` (e.g. "**נקודות פתוחות:**" alone)  →  Heading 2
+    - `numbered`  ("1. ...")                            →  List Paragraph
+                                                           (auto-decimal)
+    - `heb_letter` ("(א) ...")                          →  List Paragraph
+                                                           with numPr stripped
+                                                           (author supplied
+                                                           the marker)
+    - `bullet`    ("- ...")                             →  Normal (marker
+                                                           stripped)
+    - `plain`                                           →  Normal
+    """
+    kind, text = _classify_line(line)
+
+    if kind == "label_heading":
+        _add_paragraph(doc, text, "Heading 2")
+        return
+
+    if kind == "inline_label":
+        label, value = text.split("\x00", 1)
+        _add_label_value(doc, label, value)
+        return
+
+    if kind == "numbered":
+        para = doc.add_paragraph(style="List Paragraph")
+    elif kind == "heb_letter":
+        para = doc.add_paragraph(style="List Paragraph")
+        _strip_numpr(para)
+    else:
+        para = doc.add_paragraph(style="Normal")
+    _mark_paragraph_rtl(para)
+    _add_runs_with_inline_bold(para, text)
+
+
+def _format_subsection_title(item: dict[str, Any], kind_label: str) -> str:
+    """Return '{kind_label} {number}: {title}' e.g. 'טענת סף 1: חוסר סמכות'."""
+    number = item.get("number") or ""
+    title = item.get("title", "").strip()
+    if number and title:
+        return f"{kind_label} {number}: {title}"
+    if title:
+        return title
+    return f"{kind_label} {number}".strip()
+
+
+def _write_subsection(
+    doc: DocumentT,
+    item: dict[str, Any],
+    precedents_for_item: list[dict[str, Any]],
+    kind_label: str,
+) -> None:
+    # Subsection header — bolded Normal paragraph, not a Heading,
+    # so it visually sits under the section's Heading 2.
+    header_text = _format_subsection_title(item, kind_label)
+    p = doc.add_paragraph(style="Normal")
+    _mark_paragraph_rtl(p)
+    run = p.add_run(_no_dash(header_text))
+    run.bold = True
+    _mark_run_rtl(run)
+
+    # Regular fields (party positions, legal questions, etc.)
+    for field in item.get("fields", []):
+        label = field.get("label", "").strip()
+        content = field.get("content", "").strip()
+        if not label:
+            continue
+        _add_multiline_value(doc, label, content)
+
+    # Chair position — special handling: always render, use placeholder if empty.
+    chair_position = (item.get("chair_position") or "").strip()
+    if chair_position:
+        _add_multiline_value(doc, CHAIR_POSITION_LABEL, chair_position)
+    else:
+        _add_label_value(
+            doc, CHAIR_POSITION_LABEL, CHAIR_POSITION_PLACEHOLDER,
+            value_italic=True,
+        )
+
+    # Precedents attached to this subsection
+    if precedents_for_item:
+        p = doc.add_paragraph(style="Normal")
+        _mark_paragraph_rtl(p)
+        run = p.add_run("פסיקה רלוונטית:")
+        run.bold = True
+        _mark_run_rtl(run)
+        for prec in precedents_for_item:
+            quote = (prec.get("quote") or "").strip()
+            citation = (prec.get("citation") or "").strip()
+            if quote:
+                _add_paragraph(doc, quote, "Quote")
+            if citation:
+                cite_p = doc.add_paragraph(style="Normal")
+                _mark_paragraph_rtl(cite_p)
+                cite_run = cite_p.add_run(_no_dash(citation))
+                cite_run.italic = True
+                _mark_run_rtl(cite_run)
+
+
+def _add_background_section(
+    doc: DocumentT, title: str, body: str | None
+) -> None:
+    """Render a background H2 section (e.g. "רקע דיוני") from a prose
+    body. Lines are routed through `_emit_content_line` so bullets,
+    `**labels:**`, and (א) enumerations all get the template styles.
+    """
+    if not body or not body.strip():
+        return
+    _add_paragraph(doc, title, "Heading 2")
+    for raw in body.splitlines():
+        if not raw.strip():
+            continue
+        _emit_content_line(doc, raw)
+
+
+def _group_precedents(
+    precedents: list[dict[str, Any]],
+) -> tuple[list[dict], dict[str, list[dict]]]:
+    """Split the flat precedent list into case-level and per-section maps.
+
+    Returns (case_level_precedents, {section_id: [precedents]}).
+    """
+    case_level: list[dict] = []
+    by_section: dict[str, list[dict]] = {}
+    for p in precedents:
+        sid = p.get("section_id")
+        if sid is None:
+            case_level.append(p)
+        else:
+            by_section.setdefault(sid, []).append(p)
+    return case_level, by_section
+
+
+def _next_version(export_dir: Path) -> int:
+    """Return the next version number for ניתוח-משפטי-v{N}.docx."""
+    existing = sorted(export_dir.glob("ניתוח-משפטי-v*.docx"))
+    next_ver = 1
+    for p in existing:
+        try:
+            ver = int(p.stem.split("-v")[1])
+        except (IndexError, ValueError):
+            continue
+        next_ver = max(next_ver, ver + 1)
+    return next_ver
+
+
+async def build_analysis_docx(case_number: str) -> Path:
+    """Build a DOCX of the legal analysis for a case using the template
+    styles, and save a versioned copy under the case's exports folder.
+
+    Raises FileNotFoundError if no analysis file or template exists.
+    """
+    if not TEMPLATE_PATH.exists():
+        raise FileNotFoundError(
+            f"Template not found at {TEMPLATE_PATH}. "
+            "Run: python scripts/convert_decision_template.py"
+        )
+
+    case_dir = config.find_case_dir(case_number)
+    analysis_path = case_dir / "documents" / "research" / "analysis-and-research.md"
+    if not analysis_path.exists():
+        raise FileNotFoundError(
+            f"Analysis file not found for case {case_number}"
+        )
+
+    parsed = research_md.parse(analysis_path)
+
+    # Resolve case_id so we can fetch precedents. Missing case → proceed
+    # without precedents rather than failing the export.
+    case_level_precedents: list[dict] = []
+    precedents_by_section: dict[str, list[dict]] = {}
+    case = await db.get_case_by_number(case_number)
+    if case:
+        precedents = await db.list_case_precedents(UUID(case["id"]))
+        case_level_precedents, precedents_by_section = _group_precedents(precedents)
+
+    doc = Document(str(TEMPLATE_PATH))
+    _clear_body(doc)
+
+    # Document title
+    header = parsed.get("header", {})
+    date = header.get("date", "").strip()
+    title_text = f"ניתוח משפטי וכתיבת עמדה בערר {case_number}"
+    _add_paragraph(doc, title_text, "Heading 1")
+    if date:
+        p_date = doc.add_paragraph(style="Normal")
+        _mark_paragraph_rtl(p_date)
+        run_date = p_date.add_run(f"תאריך: {date}")
+        _mark_run_rtl(run_date)
+
+    # Background sections — printed first so the reader gets context
+    # before any claims/precedents. These come only in the exported DOCX,
+    # not in the web UI (the UI renders them elsewhere).
+    _add_background_section(doc, "רקע לניתוח", parsed.get("represented_party"))
+    _add_background_section(doc, "רקע דיוני", parsed.get("procedural_background"))
+    _add_background_section(doc, "עובדות מוסכמות", parsed.get("agreed_facts"))
+    _add_background_section(
+        doc, "עובדות שנויות במחלוקת", parsed.get("disputed_facts")
+    )
+
+    # Case-level precedents appear at the top (they cut across claims/issues)
+    if case_level_precedents:
+        _add_paragraph(doc, "פסיקה כללית", "Heading 2")
+        for prec in case_level_precedents:
+            quote = (prec.get("quote") or "").strip()
+            citation = (prec.get("citation") or "").strip()
+            if quote:
+                _add_paragraph(doc, quote, "Quote")
+            if citation:
+                cp = doc.add_paragraph(style="Normal")
+                _mark_paragraph_rtl(cp)
+                cr = cp.add_run(_no_dash(citation))
+                cr.italic = True
+                _mark_run_rtl(cr)
+
+    # Threshold claims
+    threshold_claims = parsed.get("threshold_claims", [])
+    if threshold_claims:
+        _add_paragraph(doc, "טענות סף", "Heading 2")
+        for tc in threshold_claims:
+            _write_subsection(
+                doc, tc, precedents_by_section.get(tc["id"], []), "טענת סף"
+            )
+
+    # Issues
+    issues = parsed.get("issues", [])
+    if issues:
+        _add_paragraph(doc, "סוגיות להכרעה", "Heading 2")
+        for iss in issues:
+            _write_subsection(
+                doc, iss, precedents_by_section.get(iss["id"], []), "סוגיה"
+            )
+
+    # Conclusions
+    conclusions = (parsed.get("conclusions") or "").strip()
+    if conclusions:
+        _add_paragraph(doc, "מסקנות", "Heading 2")
+        for raw in conclusions.splitlines():
+            if not raw.strip():
+                continue
+            _emit_content_line(doc, raw)
+
+    # Save versioned
+    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"
+    doc.save(str(out_path))
+    return out_path

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

@@ -0,0 +1,264 @@
+"""חילוץ עובדות מובנות משומות שמאי: תכניות חלות והיתרים שניתנו במקרקעין.
+
+תכלית: לבנות את תת-פרק ההיתרים בבלוק ט (תכניות חלות) של ההחלטה, ובמיוחד
+לאפשר זיהוי אוטומטי של סתירות בין שמאים שונים על אותו זיהוי (תכנית או היתר).
+
+שמירה ב-DB: טבלת appraiser_facts (case_id, document_id, appraiser_name,
+appraiser_side, fact_type, identifier, details JSONB, page_number).
+
+Precondition: כל מסמך doc_type='appraisal' חייב להיות מתויג עם
+metadata.appraiser_side מתוך {committee, appellant, deciding}. החילוץ עוצר
+ומחזיר status='sides_missing' אם יש מסמכים לא מתויגים.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from uuid import UUID
+
+from legal_mcp.services import claude_session, db
+
+logger = logging.getLogger(__name__)
+
+
+# Allowed sides for an appraiser in an appeals committee case.
+# committee = שמאי הוועדה המקומית
+# appellant = שמאי העורר / הצד שכנגד הוועדה
+# deciding  = שמאי מכריע
+VALID_APPRAISER_SIDES = {"committee", "appellant", "deciding"}
+
+
+EXTRACT_FACTS_PROMPT = """אתה מנתח שומות מקרקעין לטובת ועדת ערר לתכנון ובניה.
+
+תפקידך: לחלץ מתוך השומה שתי קטגוריות של עובדות אובייקטיביות שעליהן השמאי מבסס את חוות דעתו:
+1. **תכניות חלות** — כל תכנית/תמ"א/תב"ע/תכנית מתאר/תכנית מפורטת שצוינה כתקפה על המקרקעין.
+2. **היתרים** — כל היתר בנייה/היתר שימוש/היתר חורג שצוין כאילו ניתן (או שלא ניתן) במקרקעין.
+
+## כללים
+- חילוץ עובדתי בלבד — לא לפרש, לא להסיק, לא להעתיק טיעונים משפטיים. רק העובדה היבשה שהשמאי מציין.
+- שמור על נאמנות מוחלטת לזיהוי כפי שמופיע במקור (למשל "תמ"א 38" ולא "תמא 38" או "תכנית מתאר ארצית 38").
+- אם השמאי מזכיר אותה תכנית/היתר מספר פעמים — החזר רשומה אחת מאוחדת.
+- אם יש סתירה פנימית בשומה (השמאי כותב דבר אחד ואז את ההיפך) — שתי רשומות נפרדות.
+- ציטוט המקור (raw_quote) חייב להיות העתקה מילולית של המשפט הרלוונטי, עד 200 תווים.
+
+## פלט
+החזר JSON array בלבד — ללא markdown, ללא הסברים:
+[
+  {
+    "fact_type": "plan" | "permit",
+    "identifier": "תמ\\"א 38" | "היתר 2018/0123",
+    "details": {
+      "date": "תאריך אישור/הוצאה אם צוין, אחרת ריק",
+      "scope": "תיאור היקף/שימוש/זכויות בנייה — בקצרה",
+      "conditions": "תנאים מיוחדים אם צוינו",
+      "status": "תקף / פקע / מבוטל / לא צוין",
+      "raw_quote": "ציטוט מילולי מהשומה"
+    },
+    "page_number": null
+  }
+]
+
+אם אין תכניות או היתרים בשומה — החזר [].
+"""
+
+
+def _chunk_text(text: str, max_chars: int = 25000) -> list[str]:
+    """Split a long document at paragraph boundaries."""
+    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
+
+
+def _normalize_identifier(identifier: str) -> str:
+    """Light normalization so trivial spacing differences don't mask conflicts."""
+    return " ".join(identifier.strip().split())
+
+
+async def extract_facts_from_document(
+    case_id: UUID,
+    document_id: UUID,
+    appraiser_name: str,
+    appraiser_side: str,
+    text: str,
+) -> list[dict]:
+    """Extract structured facts from a single appraisal document via Claude Code."""
+    chunks = _chunk_text(text)
+    all_facts: list[dict] = []
+
+    for i, chunk in enumerate(chunks):
+        chunk_label = f" (חלק {i+1}/{len(chunks)})" if len(chunks) > 1 else ""
+        prompt = (
+            f"{EXTRACT_FACTS_PROMPT}\n\n"
+            f"שמאי: {appraiser_name}{chunk_label}\n\n"
+            f"--- תחילת שומה ---\n{chunk}\n--- סוף שומה ---"
+        )
+        result = claude_session.query_json(prompt, timeout=180)
+        if not isinstance(result, list):
+            logger.warning(
+                "extract_facts_from_document: chunk %d returned non-list (%s) for doc=%s",
+                i, type(result).__name__, document_id,
+            )
+            continue
+        for item in result:
+            if not isinstance(item, dict):
+                continue
+            if item.get("fact_type") not in ("plan", "permit"):
+                continue
+            ident = item.get("identifier", "").strip()
+            if not ident:
+                continue
+            all_facts.append({
+                "appraiser_name": appraiser_name,
+                "appraiser_side": appraiser_side,
+                "fact_type": item["fact_type"],
+                "identifier": _normalize_identifier(ident),
+                "details": item.get("details") or {},
+                "page_number": item.get("page_number"),
+            })
+
+    await db.replace_appraiser_facts(case_id, document_id, all_facts)
+    return all_facts
+
+
+def _doc_metadata(doc: dict) -> dict:
+    metadata = doc.get("metadata") or {}
+    if isinstance(metadata, str):
+        try:
+            metadata = json.loads(metadata)
+        except json.JSONDecodeError:
+            metadata = {}
+    return metadata if isinstance(metadata, dict) else {}
+
+
+def _infer_appraiser_name(doc: dict) -> str:
+    """Best-effort extraction of the appraiser's name from document title/metadata."""
+    meta = _doc_metadata(doc)
+    name = meta.get("appraiser_name")
+    if name:
+        return name
+    title = doc.get("title", "")
+    return title or f"שמאי (מסמך {doc.get('id', '')[:8]})"
+
+
+def _get_appraiser_side(doc: dict) -> str:
+    """Return the tagged side, or '' if not tagged."""
+    return _doc_metadata(doc).get("appraiser_side", "") or ""
+
+
+def _validate_sides_tagged(appraisals: list[dict]) -> list[dict]:
+    """Return the subset of appraisals missing a valid appraiser_side tag."""
+    missing: list[dict] = []
+    for doc in appraisals:
+        side = _get_appraiser_side(doc)
+        if side not in VALID_APPRAISER_SIDES:
+            missing.append({
+                "document_id": doc["id"],
+                "title": doc.get("title", ""),
+                "current_side": side,
+            })
+    return missing
+
+
+async def extract_appraiser_facts(case_id: UUID) -> dict:
+    """Extract facts from every appraisal document in the case + detect conflicts.
+
+    Blocks if any appraisal is missing metadata.appraiser_side — the chair must
+    tag each one via the UI before extraction runs, so that conflict rendering
+    in block-tet can identify the deciding appraiser's view as authoritative.
+
+    Returns a summary dict ready for serialization back to the caller.
+    """
+    docs = await db.list_documents(case_id)
+    appraisals = [d for d in docs if d.get("doc_type") == "appraisal"]
+
+    if not appraisals:
+        return {
+            "status": "no_appraisals",
+            "appraisal_count": 0,
+            "total_facts": 0,
+            "conflicts": [],
+        }
+
+    missing_sides = _validate_sides_tagged(appraisals)
+    if missing_sides:
+        return {
+            "status": "sides_missing",
+            "appraisal_count": len(appraisals),
+            "missing": missing_sides,
+            "message": (
+                "חסר תיוג appraiser_side במסמכי שומה. תייג כל שומה דרך ה-UI "
+                "(ועדה / עורר / מכריע) והרץ שוב."
+            ),
+        }
+
+    by_doc = []
+    total_facts = 0
+    for doc in appraisals:
+        text = await db.get_document_text(UUID(doc["id"]))
+        if not text:
+            by_doc.append({
+                "document_id": doc["id"],
+                "title": doc.get("title", ""),
+                "status": "no_text",
+                "facts_extracted": 0,
+            })
+            continue
+
+        appraiser_name = _infer_appraiser_name(doc)
+        appraiser_side = _get_appraiser_side(doc)
+        try:
+            facts = await extract_facts_from_document(
+                case_id=case_id,
+                document_id=UUID(doc["id"]),
+                appraiser_name=appraiser_name,
+                appraiser_side=appraiser_side,
+                text=text,
+            )
+        except Exception as e:
+            logger.exception("Failed to extract facts for document %s", doc["id"])
+            by_doc.append({
+                "document_id": doc["id"],
+                "title": doc.get("title", ""),
+                "status": "error",
+                "error": str(e),
+                "facts_extracted": 0,
+            })
+            continue
+
+        total_facts += len(facts)
+        by_doc.append({
+            "document_id": doc["id"],
+            "title": doc.get("title", ""),
+            "appraiser_name": appraiser_name,
+            "appraiser_side": appraiser_side,
+            "status": "completed",
+            "facts_extracted": len(facts),
+            "plans": sum(1 for f in facts if f["fact_type"] == "plan"),
+            "permits": sum(1 for f in facts if f["fact_type"] == "permit"),
+        })
+
+    conflicts = await db.detect_appraiser_conflicts(case_id)
+
+    return {
+        "status": "completed",
+        "appraisal_count": len(appraisals),
+        "total_facts": total_facts,
+        "conflicts": conflicts,
+        "by_document": by_doc,
+    }
+
+
+async def detect_conflicts(case_id: UUID) -> list[dict]:
+    """Convenience wrapper around db.detect_appraiser_conflicts."""
+    return await db.detect_appraiser_conflicts(case_id)

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

@@ -27,8 +27,8 @@ logger = logging.getLogger(__name__)
 
 # ── Block configuration ───────────────────────────────────────────
 
-# Output token limits per Anthropic docs (April 2026):
+# Output token limits per Anthropic docs:
-# Opus 4.6: up to 128K output tokens
+# Opus 4.7: up to 128K output tokens (new tokenizer — ~35% more tokens)
 # Sonnet 4.6: up to 64K output tokens
 # Streaming required when max_tokens > 21,333
 BLOCK_CONFIG = {
@@ -48,7 +48,7 @@ BLOCK_CONFIG = {
 
 MODEL_MAP = {
     "sonnet": "claude-sonnet-4-20250514",
-    "opus": "claude-opus-4-20250514",
+    "opus": "claude-opus-4-7",
 }
 
 
@@ -165,9 +165,10 @@ BLOCK_PROMPTS = {
     "block-chet": """כתוב את בלוק ההליכים (בלוק ח, "ההליכים בפני ועדת הערר") של החלטת ועדת ערר.
 
 ## כללים:
-- תיעוד כרונולוגי: דיון → סיור → השלמות טיעון → החלטות ביניים
+- תיעוד כרונולוגי: דיון → סיור → השלמות טיעון → משא-ומתן לפשרה (אם היה) → החלטות ביניים
 - תאריכים מדויקים
-- תוכן כל השלמת טיעון בסעיף נפרד
+- אם בדיון עלו נקודות חדשות או הובהרו סוגיות משפטיות — ציין זאת במפורש בסעיף נפרד
+- תוכן כל השלמת טיעון/הצעת פשרה בסעיף נפרד עם תאריך
 - סמן תמונות מסיור: [📷 צילום מסיור]
 - אין ניתוח או הערכה
 - מספור רציף
@@ -175,24 +176,43 @@ BLOCK_PROMPTS = {
 ## פרטי התיק:
 {case_context}
 
+## מסמכים שהוגשו לאחר הדיון (אם יש):
+{post_hearing_context}
+
 ## חומרי מקור:
 {source_context}""",
 
-    "block-tet": """כתוב את בלוק התכניות החלות (בלוק ט) של החלטת ועדת ערר.
+    "block-tet": """כתוב את בלוק התכניות החלות (בלוק ט) של החלטת ועדת ערר, **כולל תת-פרק היתרים**.
 
-## כללים:
+## מבנה נדרש:
-- ציטוט ישיר מהוראות תכנית עם **הדגשה** של מילים מכריעות
+1. **תכניות חלות** — מבנה הירכי: תכניות ארציות → מחוזיות → מקומיות. ציטוט ישיר מהוראות תכנית עם **הדגשה** של מילים מכריעות.
-- מבנה הירכי: תכניות ארציות → מחוזיות → מקומיות
+2. **תת-פרק היתרים** — כותרת משנה "היתרים" (או "היתרי בנייה שניתנו במקרקעין"). פירוט ההיתרים הרלוונטיים על פי השומות שהוגשו לתיק.
+
+## כללי ציון סתירות בין שמאים (קריטי):
+- אם שני שמאים או יותר מסרו מידע שונה על אותה תכנית או היתר — חובה לסמן זאת במפורש בנוסח ניטרלי, למשל:
+  > "יצוין כי שמאי הוועדה ציין כי תכנית פלונית חלה על המקרקעין במלואה, בעוד שמאי העורר סבר כי חלקה של התכנית בלבד חל"
+- **כשקיים שמאי מכריע** — השומה שלו היא הקובעת עובדתית. סמן זאת במפורש בסוף הדיון בסתירה, בנוסח: "ואולם, השמאי המכריע קבע כי..." או "השמאי המכריע, שבחן את עמדות הצדדים, הכריע כי...". הצג את עמדת המכריע **אחרונה** כדי שההקשר יבנה אליה.
+- השתמש בתוויות הצד המדויקות: "שמאי הוועדה המקומית", "שמאי העורר", "שמאי מכריע" — ולא בשמות פרטיים אלא אם נדרש לבהירות.
+- אין להכריע בסתירה משפטית או להגיע למסקנה נורמטיבית בבלוק זה — ההכרעה המשפטית (אם נדרשת) תבוא בבלוק י. כאן מציגים רק את הממצא העובדתי כפי שהוא, כולל הכרעת המכריע העובדתית.
+- אם אין סתירה — אין להזכיר זאת.
+
+## כללים נוספים:
 - אין ניתוח מעמיק (→ בלוק י), אין הכרעה בין פרשנויות
 - מספור רציף
-- בלוק אופציונלי — כתוב רק אם יש מורכבות תכנונית
+- אם אין שומות בתיק — דווח רק על תכניות שזוהו ממסמכים אחרים, וציין במשפט אחד שלא הוגשו שומות
 
 ## פרטי התיק:
 {case_context}
 
-## תכניות שזוהו:
+## תכניות שזוהו (ממטא-דאטה של מסמכים):
 {plans_context}
 
+## עובדות שמאיות שחולצו (תכניות + היתרים, פרק לכל שמאי):
+{appraiser_facts_context}
+
+## סתירות שזוהו בין שמאים (חובה לסמן בנוסח):
+{appraiser_conflicts_context}
+
 ## חומרי מקור:
 {source_context}""",
 
@@ -301,6 +321,9 @@ async def write_block(
     precedents_context = await _build_precedents_context(case_id, block_id)
     style_context = await _build_style_context()
     discussion_context = await _build_previous_blocks_context(case_id, decision)
+    appraiser_facts_context = await _build_appraiser_facts_context(case_id)
+    appraiser_conflicts_context = await _build_appraiser_conflicts_context(case_id)
+    post_hearing_context = await _build_post_hearing_context(case_id)
 
     outcome = (decision or {}).get("outcome", "rejected")
     structure_guidance = STRUCTURE_GUIDANCE.get(outcome, "")
@@ -332,6 +355,9 @@ async def write_block(
         structure_guidance=structure_guidance,
         content_checklist=content_checklist,
         methodology_guidance=methodology_guidance,
+        appraiser_facts_context=appraiser_facts_context,
+        appraiser_conflicts_context=appraiser_conflicts_context,
+        post_hearing_context=post_hearing_context,
     )
 
     # Restructure: sources first, then instructions
@@ -478,6 +504,142 @@ async def _build_plans_context(case_id: UUID) -> str:
     return "(לא זוהו תכניות)"
 
 
+APPRAISER_SIDE_LABEL_HE = {
+    "committee": "שמאי הוועדה המקומית",
+    "appellant": "שמאי העורר",
+    "deciding":  "שמאי מכריע",
+    "":          "שמאי (לא תויג)",
+}
+
+# Sort key: committee → appellant → deciding → untagged. This matches the order
+# used by db.detect_appraiser_conflicts so the deciding appraiser is last —
+# i.e. the conclusion reads most naturally ("...and the deciding appraiser ruled...").
+_SIDE_ORDER = {"committee": 1, "appellant": 2, "deciding": 3, "": 4}
+
+
+def _side_label(side: str) -> str:
+    return APPRAISER_SIDE_LABEL_HE.get(side or "", APPRAISER_SIDE_LABEL_HE[""])
+
+
+async def _build_appraiser_facts_context(case_id: UUID) -> str:
+    """Group appraiser_facts by side (then name), list each appraiser's plans+permits."""
+    facts = await db.list_appraiser_facts(case_id)
+    if not facts:
+        return "(לא חולצו עובדות שמאיות. הרץ extract_appraiser_facts.)"
+
+    # (side, name) → {plan: [...], permit: [...]}
+    groups: dict[tuple[str, str], dict[str, list[dict]]] = {}
+    for f in facts:
+        key = (f.get("appraiser_side", "") or "", f["appraiser_name"])
+        bucket = groups.setdefault(key, {"plan": [], "permit": []})
+        bucket[f["fact_type"]].append(f)
+
+    ordered_keys = sorted(groups.keys(), key=lambda k: (_SIDE_ORDER.get(k[0], 9), k[1]))
+
+    lines: list[str] = []
+    for side, name in ordered_keys:
+        lines.append(f"\n### {_side_label(side)} — {name}")
+        for label, key in (("תכניות", "plan"), ("היתרים", "permit")):
+            items = groups[(side, name)][key]
+            if not items:
+                continue
+            lines.append(f"**{label}:**")
+            for item in items:
+                details = item.get("details") or {}
+                ident = item["identifier"]
+                scope = (details.get("scope") or "").strip()
+                date_s = (details.get("date") or "").strip()
+                status = (details.get("status") or "").strip()
+                quote = (details.get("raw_quote") or "").strip()
+                bits = [ident]
+                if date_s:
+                    bits.append(f"תאריך: {date_s}")
+                if status:
+                    bits.append(f"סטטוס: {status}")
+                if scope:
+                    bits.append(f"היקף: {scope}")
+                line = " | ".join(bits)
+                if quote:
+                    line += f"\n  ציטוט: \"{quote[:200]}\""
+                lines.append(f"- {line}")
+    return "\n".join(lines)
+
+
+async def _build_appraiser_conflicts_context(case_id: UUID) -> str:
+    """Render conflict groups so the prompt can quote them in the body.
+
+    Entries arrive pre-ordered from the DB by side (committee→appellant→deciding).
+    When a deciding appraiser exists, the prompt must treat their view as the
+    governing factual determination.
+    """
+    conflicts = await db.detect_appraiser_conflicts(case_id)
+    if not conflicts:
+        return "(אין סתירות בין שמאים)"
+
+    type_label = {"plan": "תכנית", "permit": "היתר"}
+    lines: list[str] = []
+    for c in conflicts:
+        has_deciding = any(e.get("appraiser_side") == "deciding" for e in c["entries"])
+        header = f"\n### סתירה — {type_label.get(c['fact_type'], c['fact_type'])}: {c['identifier']}"
+        if has_deciding:
+            header += "  _(יש שמאי מכריע — עמדתו קובעת)_"
+        lines.append(header)
+        for entry in c["entries"]:
+            side = entry.get("appraiser_side", "") or ""
+            details = entry.get("details") or {}
+            scope = (details.get("scope") or "").strip()
+            status = (details.get("status") or "").strip()
+            quote = (details.get("raw_quote") or "").strip()
+            marker = "★ " if side == "deciding" else ""
+            parts = [f"**{marker}{_side_label(side)} — {entry['appraiser_name']}**"]
+            if status:
+                parts.append(f"סטטוס: {status}")
+            if scope:
+                parts.append(f"היקף: {scope}")
+            line = " | ".join(parts)
+            if quote:
+                line += f"\n  ציטוט: \"{quote[:200]}\""
+            lines.append(f"- {line}")
+    return "\n".join(lines)
+
+
+async def _build_post_hearing_context(case_id: UUID) -> str:
+    """List documents flagged as submitted after the hearing.
+
+    Convention: documents.metadata.is_post_hearing == True.
+    """
+    docs = await db.list_documents(case_id)
+    items: list[dict] = []
+    for d in docs:
+        meta = d.get("metadata") or {}
+        if isinstance(meta, str):
+            meta = json.loads(meta)
+        if not meta.get("is_post_hearing"):
+            continue
+        items.append({
+            "title": d.get("title", ""),
+            "doc_type": d.get("doc_type", ""),
+            "submitted_on": meta.get("submitted_on", ""),
+            "kind": meta.get("post_hearing_kind", ""),  # "supplementary_brief" | "settlement_proposal" | ...
+        })
+
+    if not items:
+        return "(לא הוגשו מסמכים לאחר הדיון, או שהם לא סומנו כ-post_hearing)"
+
+    lines: list[str] = []
+    for it in items:
+        meta_bits = []
+        if it["submitted_on"]:
+            meta_bits.append(f"הוגש: {it['submitted_on']}")
+        if it["kind"]:
+            meta_bits.append(f"סוג: {it['kind']}")
+        if it["doc_type"]:
+            meta_bits.append(f"doc_type={it['doc_type']}")
+        meta_str = f" ({', '.join(meta_bits)})" if meta_bits else ""
+        lines.append(f"- {it['title']}{meta_str}")
+    return "\n".join(lines)
+
+
 async def _build_precedents_context(case_id: UUID, block_id: str) -> str:
     """Search for similar precedent paragraphs from other decisions and case law."""
     parts = []
@@ -654,6 +816,9 @@ async def get_block_context(case_id: UUID, block_id: str, instructions: str = ""
     precedents_context = await _build_precedents_context(case_id, block_id)
     style_context = await _build_style_context()
     discussion_context = await _build_previous_blocks_context(case_id, decision)
+    appraiser_facts_context = await _build_appraiser_facts_context(case_id)
+    appraiser_conflicts_context = await _build_appraiser_conflicts_context(case_id)
+    post_hearing_context = await _build_post_hearing_context(case_id)
 
     outcome = (decision or {}).get("outcome", "rejected")
     structure_guidance = STRUCTURE_GUIDANCE.get(outcome, "")
@@ -681,6 +846,9 @@ async def get_block_context(case_id: UUID, block_id: str, instructions: str = ""
         structure_guidance=structure_guidance,
         content_checklist=content_checklist,
         methodology_guidance=methodology_guidance,
+        appraiser_facts_context=appraiser_facts_context,
+        appraiser_conflicts_context=appraiser_conflicts_context,
+        post_hearing_context=post_hearing_context,
     )
 
     if instructions:

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

@@ -104,6 +104,8 @@ CREATE TABLE IF NOT EXISTS style_corpus (
     summary TEXT DEFAULT '',
     outcome TEXT DEFAULT '',
     key_principles JSONB DEFAULT '[]',
+    practice_area TEXT DEFAULT 'appeals_committee',
+    appeal_subtype TEXT DEFAULT '',
     created_at TIMESTAMPTZ DEFAULT now()
 );
 
@@ -114,6 +116,7 @@ CREATE TABLE IF NOT EXISTS style_patterns (
     frequency INTEGER DEFAULT 1,
     context TEXT DEFAULT '',
     examples JSONB DEFAULT '[]',
+    appeal_subtype TEXT DEFAULT '',
     created_at TIMESTAMPTZ DEFAULT now()
 );
 
@@ -156,6 +159,20 @@ ALTER TABLE decisions ADD COLUMN IF NOT EXISTS outcome_reasoning TEXT DEFAULT ''
 
 -- הרחבת cases עם appeal_type (אם לא קיים)
 ALTER TABLE cases ADD COLUMN IF NOT EXISTS appeal_type TEXT DEFAULT '';
+ALTER TABLE cases ADD COLUMN IF NOT EXISTS practice_area TEXT DEFAULT 'appeals_committee';
+ALTER TABLE cases ADD COLUMN IF NOT EXISTS appeal_subtype TEXT DEFAULT '';
+-- active_draft_path = path to the DOCX that is the current source of truth
+-- for this case's decision text. Set to the latest טיוטה-v*.docx after export,
+-- or the latest עריכה-v*.docx after user upload. Used by revise_draft to know
+-- what file to base Track Changes revisions on.
+ALTER TABLE cases ADD COLUMN IF NOT EXISTS active_draft_path TEXT;
+
+-- הרחבת style_corpus עם practice_area / appeal_subtype
+ALTER TABLE style_corpus ADD COLUMN IF NOT EXISTS practice_area TEXT DEFAULT 'appeals_committee';
+ALTER TABLE style_corpus ADD COLUMN IF NOT EXISTS appeal_subtype TEXT DEFAULT '';
+
+-- הרחבת style_patterns עם appeal_subtype לניתוח סגנון נפרד לכל סוג ערר
+ALTER TABLE style_patterns ADD COLUMN IF NOT EXISTS appeal_subtype TEXT DEFAULT '';
 
 -- טבלת qa_results
 CREATE TABLE IF NOT EXISTS qa_results (
@@ -374,6 +391,16 @@ CREATE TABLE IF NOT EXISTS chair_feedback (
     created_at TIMESTAMPTZ DEFAULT now()
 );
 
+CREATE TABLE IF NOT EXISTS tag_company_mappings (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    tag TEXT NOT NULL,                            -- appeal_subtype value (e.g. building_permit)
+    tag_label TEXT NOT NULL DEFAULT '',            -- Hebrew display label
+    company_id TEXT NOT NULL,                     -- Paperclip company UUID
+    company_name TEXT NOT NULL DEFAULT '',         -- cached company name for display
+    created_at TIMESTAMPTZ DEFAULT now(),
+    UNIQUE(tag, company_id)
+);
+
 -- ═══════════════════════════════════════════════════════════════════
 -- Indexes
 -- ═══════════════════════════════════════════════════════════════════
@@ -442,6 +469,55 @@ CREATE INDEX IF NOT EXISTS idx_case_law_level ON case_law(precedent_level);
 """
 
 
+# ── Phase 5: Interim draft (appraiser facts + post-hearing flag) ───
+
+SCHEMA_V5_SQL = """
+
+-- appraiser_facts: תכניות והיתרים שצוינו ע"י כל שמאי בנפרד.
+-- בשונה מ-claims (שהוא טענה משפטית), כאן מאוחסנת עובדה עניינית מתוך השומה.
+-- שימוש ראשי: זיהוי סתירות בין שמאים על איזו תכנית או היתר חל בנכס.
+CREATE TABLE IF NOT EXISTS appraiser_facts (
+    id UUID PRIMARY KEY DEFAULT uuid_generate_v4(),
+    case_id UUID NOT NULL REFERENCES cases(id) ON DELETE CASCADE,
+    document_id UUID NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+    appraiser_name TEXT NOT NULL,
+    fact_type TEXT NOT NULL CHECK (fact_type IN ('plan', 'permit')),
+    identifier TEXT NOT NULL,
+    details JSONB NOT NULL DEFAULT '{}',
+    page_number INTEGER,
+    created_at TIMESTAMPTZ DEFAULT now()
+);
+
+CREATE INDEX IF NOT EXISTS idx_appraiser_facts_case ON appraiser_facts(case_id, fact_type);
+CREATE INDEX IF NOT EXISTS idx_appraiser_facts_identifier ON appraiser_facts(case_id, identifier);
+
+-- V5.1: appraiser_side — which party this appraiser represents.
+-- Values: 'committee' (הוועדה), 'appellant' (העורר), 'deciding' (מכריע).
+-- Required by extract_appraiser_facts; the chair tags it via the UI before extraction.
+-- Set via documents.metadata.appraiser_side at upload/edit time, then propagated here
+-- so that conflict rendering in block-tet can label each entry with its side.
+ALTER TABLE appraiser_facts ADD COLUMN IF NOT EXISTS appraiser_side TEXT DEFAULT '';
+CREATE INDEX IF NOT EXISTS idx_appraiser_facts_side ON appraiser_facts(case_id, appraiser_side);
+
+-- documents.metadata.is_post_hearing: flag for materials submitted after the hearing
+-- (השלמות טיעון, הצעות פשרה). Used by block-chet to include them in the proceedings narrative.
+-- documents.metadata.appraiser_side: which side the appraiser represents (see above).
+-- No schema change needed — uses existing JSONB metadata column.
+"""
+
+# ── V6: Case archiving ────────────────────────────────────────────
+
+SCHEMA_V6_SQL = """
+-- archived_at: timestamp when the case was moved to the archive screen.
+-- NULL = active (default). Set via POST /api/cases/{case_number}/archive.
+-- Cleared via POST /api/cases/{case_number}/restore.
+-- The /api/cases endpoint filters out archived cases by default;
+-- pass ?include_archived=true (or use /api/cases/archived) to see them.
+ALTER TABLE cases ADD COLUMN IF NOT EXISTS archived_at TIMESTAMPTZ;
+CREATE INDEX IF NOT EXISTS idx_cases_archived ON cases(archived_at) WHERE archived_at IS NOT NULL;
+"""
+
+
 async def init_schema() -> None:
     pool = await get_pool()
     async with pool.acquire() as conn:
@@ -450,7 +526,9 @@ async def init_schema() -> None:
         await conn.execute(SCHEMA_V2_SQL)
         await conn.execute(SCHEMA_V3_SQL)
         await conn.execute(SCHEMA_V4_SQL)
-    logger.info("Database schema initialized (v1 + v2 + v3 + v4)")
+        await conn.execute(SCHEMA_V5_SQL)
+        await conn.execute(SCHEMA_V6_SQL)
+    logger.info("Database schema initialized (v1-v6)")
 
 
 # ── Case CRUD ───────────────────────────────────────────────────────
@@ -467,6 +545,8 @@ async def create_case(
     hearing_date: date | None = None,
     notes: str = "",
     expected_outcome: str = "",
+    practice_area: str = "appeals_committee",
+    appeal_subtype: str = "",
 ) -> dict:
     pool = await get_pool()
     case_id = uuid4()
@@ -474,13 +554,15 @@ async def create_case(
         await conn.execute(
             """INSERT INTO cases (id, case_number, title, appellants, respondents,
                subject, property_address, permit_number, committee_type,
-               hearing_date, notes, expected_outcome)
+               hearing_date, notes, expected_outcome,
-               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)""",
+               practice_area, appeal_subtype)
+               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)""",
             case_id, case_number, title,
             json.dumps(appellants or []),
             json.dumps(respondents or []),
             subject, property_address, permit_number, committee_type,
             hearing_date, notes, expected_outcome,
+            practice_area, appeal_subtype,
         )
     return await get_case(case_id)
 
@@ -494,6 +576,25 @@ async def get_case(case_id: UUID) -> dict | None:
     return _row_to_case(row)
 
 
+async def set_active_draft_path(case_id: UUID, path: str | None) -> None:
+    """Update the case's active_draft_path (the DOCX that is source of truth)."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        await conn.execute(
+            "UPDATE cases SET active_draft_path = $1, updated_at = now() WHERE id = $2",
+            path, case_id,
+        )
+
+
+async def get_active_draft_path(case_id: UUID) -> str | None:
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(
+            "SELECT active_draft_path FROM cases WHERE id = $1", case_id,
+        )
+    return row["active_draft_path"] if row else None
+
+
 async def get_case_by_number(case_number: str) -> dict | None:
     pool = await get_pool()
     async with pool.acquire() as conn:
@@ -505,18 +606,27 @@ async def get_case_by_number(case_number: str) -> dict | None:
     return _row_to_case(row)
 
 
-async def list_cases(status: str | None = None, limit: int = 50) -> list[dict]:
+async def list_cases(
+    status: str | None = None,
+    limit: int = 50,
+    include_archived: bool = False,
+    archived_only: bool = False,
+) -> list[dict]:
     pool = await get_pool()
-    async with pool.acquire() as conn:
+    where = []
+    args: list = []
     if status:
-            rows = await conn.fetch(
+        where.append(f"status = ${len(args) + 1}")
-                "SELECT * FROM cases WHERE status = $1 ORDER BY updated_at DESC LIMIT $2",
+        args.append(status)
-                status, limit,
+    if archived_only:
-            )
+        where.append("archived_at IS NOT NULL")
-        else:
+    elif not include_archived:
-            rows = await conn.fetch(
+        where.append("archived_at IS NULL")
-                "SELECT * FROM cases ORDER BY updated_at DESC LIMIT $1", limit
+    where_clause = f"WHERE {' AND '.join(where)}" if where else ""
-            )
+    args.append(limit)
+    sql = f"SELECT * FROM cases {where_clause} ORDER BY updated_at DESC LIMIT ${len(args)}"
+    async with pool.acquire() as conn:
+        rows = await conn.fetch(sql, *args)
     return [_row_to_case(r) for r in rows]
 
 
@@ -547,6 +657,30 @@ def _row_to_case(row: asyncpg.Record) -> dict:
     return d
 
 
+async def archive_case(case_id: UUID) -> dict | None:
+    """Mark a case as archived. Returns updated row, or None if not found."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(
+            "UPDATE cases SET archived_at = now(), updated_at = now() "
+            "WHERE id = $1 RETURNING *",
+            case_id,
+        )
+    return _row_to_case(row) if row else None
+
+
+async def restore_case(case_id: UUID) -> dict | None:
+    """Clear the archived_at timestamp. Returns updated row, or None if not found."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        row = await conn.fetchrow(
+            "UPDATE cases SET archived_at = NULL, updated_at = now() "
+            "WHERE id = $1 RETURNING *",
+            case_id,
+        )
+    return _row_to_case(row) if row else None
+
+
 # ── Document CRUD ───────────────────────────────────────────────────
 
 async def create_document(
@@ -809,6 +943,8 @@ async def search_similar(
     limit: int = 10,
     case_id: UUID | None = None,
     section_type: str | None = None,
+    practice_area: str | None = None,
+    appeal_subtype: str | None = None,
 ) -> list[dict]:
     """Cosine similarity search on document chunks."""
     pool = await get_pool()
@@ -824,6 +960,14 @@ async def search_similar(
         conditions.append(f"dc.section_type = ${param_idx}")
         params.append(section_type)
         param_idx += 1
+    if practice_area:
+        conditions.append(f"c.practice_area = ${param_idx}")
+        params.append(practice_area)
+        param_idx += 1
+    if appeal_subtype:
+        conditions.append(f"c.appeal_subtype = ${param_idx}")
+        params.append(appeal_subtype)
+        param_idx += 1
 
     where = f"WHERE {' AND '.join(conditions)}" if conditions else ""
 
@@ -856,6 +1000,8 @@ async def add_to_style_corpus(
     summary: str = "",
     outcome: str = "",
     key_principles: list[str] | None = None,
+    practice_area: str = "appeals_committee",
+    appeal_subtype: str = "",
 ) -> UUID:
     pool = await get_pool()
     corpus_id = uuid4()
@@ -863,11 +1009,13 @@ async def add_to_style_corpus(
         await conn.execute(
             """INSERT INTO style_corpus
                (id, document_id, decision_number, decision_date,
-                subject_categories, full_text, summary, outcome, key_principles)
+                subject_categories, full_text, summary, outcome, key_principles,
-               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)""",
+                practice_area, appeal_subtype)
+               VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)""",
             corpus_id, document_id, decision_number, decision_date,
             json.dumps(subject_categories), full_text, summary, outcome,
             json.dumps(key_principles or []),
+            practice_area, appeal_subtype,
         )
     return corpus_id
 
@@ -937,12 +1085,14 @@ async def upsert_style_pattern(
     pattern_text: str,
     context: str = "",
     examples: list[str] | None = None,
+    appeal_subtype: str = "",
 ) -> None:
     pool = await get_pool()
     async with pool.acquire() as conn:
         existing = await conn.fetchrow(
-            "SELECT id, frequency FROM style_patterns WHERE pattern_type = $1 AND pattern_text = $2",
+            "SELECT id, frequency FROM style_patterns "
-            pattern_type, pattern_text,
+            "WHERE pattern_type = $1 AND pattern_text = $2 AND appeal_subtype = $3",
+            pattern_type, pattern_text, appeal_subtype,
         )
         if existing:
             await conn.execute(
@@ -951,17 +1101,26 @@ async def upsert_style_pattern(
             )
         else:
             await conn.execute(
-                """INSERT INTO style_patterns (pattern_type, pattern_text, context, examples)
+                """INSERT INTO style_patterns (pattern_type, pattern_text, context, examples, appeal_subtype)
-                   VALUES ($1, $2, $3, $4)""",
+                   VALUES ($1, $2, $3, $4, $5)""",
                 pattern_type, pattern_text, context,
                 json.dumps(examples or []),
+                appeal_subtype,
             )
 
 
-async def clear_style_patterns() -> None:
+async def clear_style_patterns(appeal_subtype: str = "") -> None:
-    """Delete all existing style patterns (used before re-analysis)."""
+    """Delete style patterns, optionally filtered by appeal_subtype.
+
+    Empty appeal_subtype = delete ALL patterns.
+    """
     pool = await get_pool()
     async with pool.acquire() as conn:
+        if appeal_subtype:
+            await conn.execute(
+                "DELETE FROM style_patterns WHERE appeal_subtype = $1", appeal_subtype
+            )
+        else:
             await conn.execute("DELETE FROM style_patterns")
 
 
@@ -1218,3 +1377,124 @@ async def resolve_chair_feedback(
                WHERE id = $1""",
             feedback_id, applied_to,
         )
+
+
+# ── Appraiser facts (V5 — for interim drafts) ─────────────────────
+
+async def replace_appraiser_facts(
+    case_id: UUID,
+    document_id: UUID,
+    facts: list[dict],
+) -> int:
+    """Replace all appraiser_facts for a given document.
+
+    Each fact dict: appraiser_name, appraiser_side, fact_type ('plan'|'permit'),
+    identifier, details (dict), page_number (optional).
+    """
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        async with conn.transaction():
+            await conn.execute(
+                "DELETE FROM appraiser_facts WHERE document_id = $1", document_id,
+            )
+            for f in facts:
+                await conn.execute(
+                    """INSERT INTO appraiser_facts
+                       (case_id, document_id, appraiser_name, appraiser_side,
+                        fact_type, identifier, details, page_number)
+                       VALUES ($1, $2, $3, $4, $5, $6, $7, $8)""",
+                    case_id, document_id,
+                    f["appraiser_name"],
+                    f.get("appraiser_side", ""),
+                    f["fact_type"],
+                    f["identifier"],
+                    json.dumps(f.get("details", {}), ensure_ascii=False),
+                    f.get("page_number"),
+                )
+    return len(facts)
+
+
+async def list_appraiser_facts(
+    case_id: UUID,
+    fact_type: str | None = None,
+) -> list[dict]:
+    """List appraiser_facts for a case, optionally filtered by fact_type."""
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        if fact_type:
+            rows = await conn.fetch(
+                """SELECT * FROM appraiser_facts
+                   WHERE case_id = $1 AND fact_type = $2
+                   ORDER BY identifier, appraiser_name""",
+                case_id, fact_type,
+            )
+        else:
+            rows = await conn.fetch(
+                """SELECT * FROM appraiser_facts
+                   WHERE case_id = $1
+                   ORDER BY fact_type, identifier, appraiser_name""",
+                case_id,
+            )
+    results = []
+    for r in rows:
+        d = dict(r)
+        d["id"] = str(d["id"])
+        d["case_id"] = str(d["case_id"])
+        d["document_id"] = str(d["document_id"])
+        if isinstance(d.get("details"), str):
+            d["details"] = json.loads(d["details"])
+        results.append(d)
+    return results
+
+
+async def detect_appraiser_conflicts(case_id: UUID) -> list[dict]:
+    """Detect conflicts: identifiers cited by 2+ different appraisers in this case.
+
+    A conflict exists when the SAME identifier (e.g., "תמ"א 38") was reported
+    differently by two appraisers — different details, or one cited it and the
+    other did not. Returns list of conflict groups. Each entry in a group
+    carries the appraiser's side so the caller can label it as committee /
+    appellant / deciding.
+    """
+    pool = await get_pool()
+    async with pool.acquire() as conn:
+        rows = await conn.fetch(
+            """SELECT identifier, fact_type,
+                      json_agg(jsonb_build_object(
+                          'appraiser_name', appraiser_name,
+                          'appraiser_side', appraiser_side,
+                          'details', details,
+                          'page_number', page_number,
+                          'document_id', document_id
+                      ) ORDER BY
+                          CASE appraiser_side
+                              WHEN 'committee' THEN 1
+                              WHEN 'appellant' THEN 2
+                              WHEN 'deciding'  THEN 3
+                              ELSE 4
+                          END,
+                          appraiser_name
+                      ) AS entries,
+                      COUNT(DISTINCT appraiser_name) AS n_appraisers
+               FROM appraiser_facts
+               WHERE case_id = $1
+               GROUP BY identifier, fact_type
+               HAVING COUNT(DISTINCT appraiser_name) > 1""",
+            case_id,
+        )
+    conflicts = []
+    for r in rows:
+        entries = r["entries"]
+        if isinstance(entries, str):
+            entries = json.loads(entries)
+        # Parse nested details if still strings
+        for e in entries:
+            if isinstance(e.get("details"), str):
+                e["details"] = json.loads(e["details"])
+        conflicts.append({
+            "identifier": r["identifier"],
+            "fact_type": r["fact_type"],
+            "n_appraisers": r["n_appraisers"],
+            "entries": entries,
+        })
+    return conflicts

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

@@ -15,118 +15,312 @@ from docx import Document
 from docx.enum.text import WD_ALIGN_PARAGRAPH
 from docx.oxml import OxmlElement
 from docx.oxml.ns import qn
-from docx.shared import Cm, Pt, RGBColor
 
 from legal_mcp import config
 from legal_mcp.services import db
 
 logger = logging.getLogger(__name__)
 
-# ── Constants ─────────────────────────────────────────────────────
+# Path to the converted decision template. Carries David font, RTL, margins,
-
+# and styles (Title / Heading 1-2 / Normal / Quote / List Paragraph).
-FONT_NAME = "David"
+# Populated once by `scripts/convert_decision_template.py` from `.dotx`.
-FONT_SIZE_BODY = Pt(12)
+TEMPLATE_PATH = (
-FONT_SIZE_TITLE = Pt(16)
+    Path(__file__).resolve().parents[4]
-FONT_SIZE_HEADING = Pt(14)
+    / "skills" / "docx" / "decision_template.docx"
-LINE_SPACING = 1.5
+)
-PAGE_MARGIN = Cm(2.5)
 
 
 # ── RTL helpers ───────────────────────────────────────────────────
+# Three layers of RTL are required (per skills/docx/SKILL.md):
+#   1. Section: <w:bidi/> in sectPr (inherited from template)
+#   2. Paragraph: <w:bidi/> directly in pPr — paragraph direction
+#   3. Run: <w:rtl/> in rPr — tells Word to use cs (complex-script) font
+# Without explicit font on run, Hebrew can render in the ascii slot
+# (Times New Roman) — so we also force David on all four font slots.
 
-def _set_rtl_paragraph(paragraph) -> None:
+HEBREW_FONT = "David"
-    """Set paragraph-level RTL properties."""
+
-    pPr = paragraph._element.get_or_add_pPr()
+
+def _mark_run_rtl(run) -> None:
+    """Force David font on all four slots, then add <w:rtl/>."""
+    rPr = run._r.get_or_add_rPr()
+    if rPr.find(qn("w:rFonts")) is None:
+        fonts = OxmlElement("w:rFonts")
+        fonts.set(qn("w:ascii"), HEBREW_FONT)
+        fonts.set(qn("w:hAnsi"), HEBREW_FONT)
+        fonts.set(qn("w:cs"), HEBREW_FONT)
+        fonts.set(qn("w:eastAsia"), HEBREW_FONT)
+        rPr.insert(0, fonts)
+    if rPr.find(qn("w:rtl")) is None:
+        rPr.append(OxmlElement("w:rtl"))
+
+
+def _mark_paragraph_rtl(paragraph) -> None:
+    """Add <w:bidi/> directly to pPr (paragraph direction) and <w:rtl/>
+    to the paragraph-mark rPr (affects trailing ¶ glyph)."""
+    pPr = paragraph._p.get_or_add_pPr()
+    # (2) <w:bidi/> directly in pPr — paragraph direction
+    if pPr.find(qn("w:bidi")) is None:
         bidi = OxmlElement("w:bidi")
-    bidi.set(qn("w:val"), "1")
+        pstyle = pPr.find(qn("w:pStyle"))
-    pPr.append(bidi)
+        if pstyle is not None:
-
+            pstyle.addnext(bidi)
-
-def _set_rtl_run(run) -> None:
-    """Set run-level RTL properties."""
-    rPr = run._element.get_or_add_rPr()
-    rtl = OxmlElement("w:rtl")
-    rtl.set(qn("w:val"), "1")
-    rPr.append(rtl)
-
-
-def _set_rtl_section(section) -> None:
-    """Set section-level RTL (bidi)."""
-    sectPr = section._sectPr
-    bidi = OxmlElement("w:bidi")
-    bidi.set(qn("w:val"), "1")
-    sectPr.append(bidi)
-
-
-def _add_paragraph(doc, text: str, style: str = "Normal",
-                   bold: bool = False, font_size=None,
-                   alignment=None, space_after: Pt | None = None) -> None:
-    """Add an RTL paragraph with David font."""
-    para = doc.add_paragraph()
-    _set_rtl_paragraph(para)
-
-    if alignment:
-        para.alignment = alignment
         else:
-        para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+            pPr.insert(0, bidi)
-
+    # paragraph-mark rPr gets <w:rtl/> so ¶ inherits RTL too
-    run = para.add_run(text)
+    rPr = pPr.find(qn("w:rPr"))
-    run.font.name = FONT_NAME
+    if rPr is None:
-    run.font.size = font_size or FONT_SIZE_BODY
+        rPr = OxmlElement("w:rPr")
-    run.bold = bold
+        pPr.append(rPr)
-    _set_rtl_run(run)
+    if rPr.find(qn("w:rtl")) is None:
-
+        rPr.append(OxmlElement("w:rtl"))
-    # Line spacing
-    pf = para.paragraph_format
-    pf.line_spacing = LINE_SPACING
-    if space_after is not None:
-        pf.space_after = space_after
 
 
-def _add_centered_paragraph(doc, text: str, bold: bool = True,
+def _set_paragraph_jc(paragraph, value: str) -> None:
-                            font_size=None) -> None:
+    """Force <w:jc w:val="..."/> on a paragraph, overriding style-inherited jc.
-    """Add centered RTL paragraph."""
+
-    _add_paragraph(doc, text, bold=bold, font_size=font_size,
+    Needed because Heading 3 in the template ships with jc=center — we want
+    body headings justified right (jc=both) like Normal.
+    """
+    pPr = paragraph._p.get_or_add_pPr()
+    existing = pPr.find(qn("w:jc"))
+    if existing is not None:
+        pPr.remove(existing)
+    jc = OxmlElement("w:jc")
+    jc.set(qn("w:val"), value)
+    pPr.append(jc)
+
+
+def _suppress_paragraph_numbering(paragraph) -> None:
+    """Kill any style-inherited auto-numbering on this paragraph.
+
+    Heading styles linked to outline lists can auto-inject א./ב./ג. markers
+    in some Word versions even when the style we read doesn't show numPr.
+    Setting numId=0 explicitly removes the paragraph from any list.
+    """
+    pPr = paragraph._p.get_or_add_pPr()
+    existing = pPr.find(qn("w:numPr"))
+    if existing is not None:
+        pPr.remove(existing)
+    numPr = OxmlElement("w:numPr")
+    ilvl = OxmlElement("w:ilvl")
+    ilvl.set(qn("w:val"), "0")
+    numId = OxmlElement("w:numId")
+    numId.set(qn("w:val"), "0")
+    numPr.append(ilvl)
+    numPr.append(numId)
+    pPr.append(numPr)
+
+
+def _clear_body(doc) -> None:
+    """Remove all paragraphs in the document body while keeping sectPr.
+
+    The template ships with sample paragraphs we don't want. Section
+    properties (page size, margins, bidi) stay intact.
+    """
+    body = doc.element.body
+    for p in list(body.findall(qn("w:p"))):
+        body.remove(p)
+
+
+# ── Bookmark helpers ──────────────────────────────────────────────
+
+# Keep a per-document bookmark id counter. Bookmarks must have unique ids
+# across the whole document; we start from a high value to avoid collisions
+# with whatever Word's default template already assigned.
+_BOOKMARK_ID_START = 10000
+
+
+def _insert_bookmark_start(paragraph, name: str, bm_id: int) -> None:
+    """Insert a <w:bookmarkStart> at the beginning of a paragraph."""
+    el = OxmlElement("w:bookmarkStart")
+    el.set(qn("w:id"), str(bm_id))
+    el.set(qn("w:name"), name)
+    paragraph._p.insert(0, el)
+
+
+def _insert_bookmark_end(paragraph, bm_id: int) -> None:
+    """Insert a <w:bookmarkEnd> at the end of a paragraph."""
+    el = OxmlElement("w:bookmarkEnd")
+    el.set(qn("w:id"), str(bm_id))
+    paragraph._p.append(el)
+
+
+def _wrap_block_with_bookmarks(doc, block_name: str,
+                               write_block_fn, bm_counter: list[int]) -> None:
+    """Write a block with bookmarkStart before and bookmarkEnd after.
+
+    Uses a mutable counter (list of one int) so the caller keeps state
+    across multiple blocks.
+    """
+    # Record paragraph count before writing
+    body = doc.element.body
+    before_count = len([c for c in body if c.tag == qn("w:p")])
+
+    write_block_fn()
+
+    after_count = len([c for c in body if c.tag == qn("w:p")])
+    if after_count == before_count:
+        # Block produced no paragraphs — nothing to wrap
+        return
+
+    # Use python-docx's paragraph indexing
+    first_new = doc.paragraphs[before_count]
+    last_new = doc.paragraphs[after_count - 1]
+
+    bm_counter[0] += 1
+    bm_id = bm_counter[0]
+    _insert_bookmark_start(first_new, block_name, bm_id)
+    _insert_bookmark_end(last_new, bm_id)
+
+
+# ── Content cleanup ──────────────────────────────────────────────
+
+# Em-dash (—, U+2014) and en-dash (–, U+2013) — per chair's no-dash policy,
+# strip from body text. Surrounding spaces collapse.
+_DASH_RE = re.compile(r"\s*[—–]\s*")
+_MULTI_SPACE_RE = re.compile(r" {2,}")
+
+
+def _strip_dashes(text: str) -> str:
+    """Remove em/en-dashes and collapse surrounding whitespace."""
+    text = _DASH_RE.sub(" ", text)
+    return _MULTI_SPACE_RE.sub(" ", text).strip()
+
+
+# Numbered paragraph: "1. content", "23. content" — auto-numbered via
+# List Paragraph style so order reflects emission, not literal prefix.
+_NUM_PREFIX_RE = re.compile(r"^(\d+)\.\s+(.*)$", re.DOTALL)
+
+
+# Markdown inline bold — `**...**`
+_INLINE_BOLD_RE = re.compile(r"\*\*([^\n*]+?)\*\*")
+
+
+def _add_runs_with_inline_bold(paragraph, text: str, *, bold_all: bool = False) -> None:
+    """Split text on `**...**` markers, alternating plain and bold runs.
+
+    Keeps `**טענה חשובה**` rendering as bold instead of leaving literal
+    asterisks. When bold_all is True, every run is bold (used for headings
+    that still carry inline-bold markup).
+    """
+    pos = 0
+    for m in _INLINE_BOLD_RE.finditer(text):
+        if m.start() > pos:
+            plain = paragraph.add_run(text[pos:m.start()])
+            if bold_all:
+                plain.bold = True
+            _mark_run_rtl(plain)
+        run_bold = paragraph.add_run(m.group(1))
+        run_bold.bold = True
+        _mark_run_rtl(run_bold)
+        pos = m.end()
+    if pos < len(text):
+        tail = paragraph.add_run(text[pos:])
+        if bold_all:
+            tail.bold = True
+        _mark_run_rtl(tail)
+
+
+def _add_styled_paragraph(doc, text: str, style: str = "Normal",
+                          bold: bool = False,
+                          alignment=None):
+    """Add a paragraph using a template style.
+
+    Font, size, RTL direction and spacing all come from the style
+    definition in the template — we only pick the style by name.
+    Renders `**...**` markdown as inline bold runs.
+
+    Returns the paragraph so callers can apply further overrides.
+    """
+    para = doc.add_paragraph(style=style)
+    _mark_paragraph_rtl(para)
+
+    if alignment is not None:
+        para.alignment = alignment
+
+    if text:
+        _add_runs_with_inline_bold(para, text, bold_all=bold)
+
+    return para
+
+
+def _add_centered_paragraph(doc, text: str, *, bold: bool = True,
+                            style: str = "Normal") -> None:
+    _add_styled_paragraph(doc, text, style=style, bold=bold,
                           alignment=WD_ALIGN_PARAGRAPH.CENTER)
 
 
+def _add_heading(doc, text: str, *, style: str) -> None:
+    """Heading with overrides: jc=both (overrides style-center / style-left)
+    and suppressed auto-numbering (so style-linked outline lists don't inject
+    א./ב./ג. — chair manages markers manually in content)."""
+    para = doc.add_paragraph(style=style)
+    _mark_paragraph_rtl(para)
+    _set_paragraph_jc(para, "both")
+    _suppress_paragraph_numbering(para)
+    if text:
+        _add_runs_with_inline_bold(para, text)
+
+
 def _add_blockquote(doc, text: str) -> None:
-    """Add indented blockquote paragraph."""
+    """Indented quote using the template's Quote style."""
-    para = doc.add_paragraph()
+    _add_styled_paragraph(doc, text, style="Quote")
-    _set_rtl_paragraph(para)
-    para.alignment = WD_ALIGN_PARAGRAPH.RIGHT
-
-    run = para.add_run(text)
-    run.font.name = FONT_NAME
-    run.font.size = Pt(11)
-    run.italic = True
-    _set_rtl_run(run)
-
-    pf = para.paragraph_format
-    pf.left_indent = Cm(1.5)
-    pf.right_indent = Cm(1.5)
-    pf.line_spacing = LINE_SPACING
 
 
 def _add_image_placeholder(doc, description: str) -> None:
-    """Add image placeholder box."""
+    _add_styled_paragraph(doc, f"[{description}]", style="Normal",
-    _add_paragraph(doc, f"[{description}]",
+                          alignment=WD_ALIGN_PARAGRAPH.CENTER)
-                   alignment=WD_ALIGN_PARAGRAPH.CENTER,
+
-                   font_size=Pt(10))
+
+def _add_spacer(doc) -> None:
+    """Add an empty paragraph as a visual spacer."""
+    para = doc.add_paragraph(style="Normal")
+    _mark_paragraph_rtl(para)
 
 
 # ── Main export ───────────────────────────────────────────────────
 
-async def export_decision(case_id: UUID, output_path: str | None = None) -> str:
+# Order in which blocks are emitted for each export mode.
+# 'final' = standard 12-block decision in canonical order (block_index).
+# 'interim' = pre-ruling draft requested by the chair before ratio decidendi
+# is set: רקע → תכניות+היתרים → טענות → הליכים, omitting opening (ה),
+# ruling (י), summary (יא), and signatures (יב).
+_INTERIM_BLOCK_ORDER = [
+    "block-alef",   # institutional header (skipped if empty — first page optional)
+    "block-bet",    # panel (skipped if empty)
+    "block-gimel",  # parties (skipped if empty)
+    "block-dalet",  # "החלטה" title (skipped if empty)
+    "block-vav",    # רקע עובדתי
+    "block-tet",    # תכניות + היתרים (extended)
+    "block-zayin",  # טענות הצדדים
+    "block-chet",   # הליכים (incl. post-hearing)
+]
+
+
+def _draft_filename_prefix(mode: str) -> str:
+    return "טיוטת-ביניים" if mode == "interim" else "טיוטה"
+
+
+async def export_decision(
+    case_id: UUID,
+    output_path: str | None = None,
+    mode: str = "final",
+) -> str:
     """ייצוא החלטה ל-DOCX.
 
     Args:
         case_id: מזהה התיק
         output_path: נתיב לשמירה (אופציונלי)
+        mode: 'final' (ברירת מחדל) או 'interim' (טיוטת ביניים — ללא
+              דיון/סיכום/חתימות, סדר חדש: רקע → תכניות+היתרים → טענות → הליכים)
 
     Returns:
         נתיב הקובץ שנוצר
     """
+    if mode not in ("final", "interim"):
+        raise ValueError(f"Unknown export mode: {mode}")
+
     case = await db.get_case(case_id)
     if not case:
         raise ValueError(f"Case {case_id} not found")
@@ -138,7 +332,7 @@ async def export_decision(case_id: UUID, output_path: str | None = None) -> str:
     # Get blocks
     pool = await db.get_pool()
     async with pool.acquire() as conn:
-        blocks = await conn.fetch(
+        rows = await conn.fetch(
             """SELECT block_id, block_index, title, content, word_count
                FROM decision_blocks
                WHERE decision_id = $1
@@ -146,35 +340,52 @@ async def export_decision(case_id: UUID, output_path: str | None = None) -> str:
             UUID(decision["id"]),
         )
 
-    if not blocks:
+    if not rows:
         raise ValueError("No blocks in decision")
 
-    # Create document
+    by_id = {r["block_id"]: r for r in rows}
-    doc = Document()
 
-    # Set page margins
+    if mode == "interim":
-    for section in doc.sections:
+        ordered_blocks = [by_id[bid] for bid in _INTERIM_BLOCK_ORDER if bid in by_id]
-        section.top_margin = PAGE_MARGIN
+        if not ordered_blocks:
-        section.bottom_margin = PAGE_MARGIN
+            raise ValueError(
-        section.left_margin = PAGE_MARGIN
+                "אין בלוקים מתאימים לטיוטת ביניים. הרץ write_interim_draft קודם."
-        section.right_margin = PAGE_MARGIN
+            )
-        _set_rtl_section(section)
+    else:
+        ordered_blocks = list(rows)
 
-    # Write blocks
+    if not TEMPLATE_PATH.exists():
-    for block in blocks:
+        raise FileNotFoundError(
+            f"Template not found at {TEMPLATE_PATH}. "
+            "Run scripts/convert_decision_template.py first."
+        )
+
+    doc = Document(str(TEMPLATE_PATH))
+    _clear_body(doc)
+
+    # Write blocks with bookmarks wrapping each block (anchors for revisions)
+    bm_counter = [_BOOKMARK_ID_START]
+    for block in ordered_blocks:
         block_id = block["block_id"]
         content = block["content"] or ""
         if not content.strip():
             continue
 
-        _write_block_to_docx(doc, block_id, block["title"], content)
+        _wrap_block_with_bookmarks(
+            doc,
+            f"block-{block_id}",
+            lambda b=block, bid=block_id, c=content: _write_block_to_docx(
+                doc, bid, b["title"], c,
+            ),
+            bm_counter,
+        )
 
     # Determine output path — versioned under cases/{case_number}/exports/
     if not output_path:
         export_dir = config.find_case_dir(case["case_number"]) / "exports"
         export_dir.mkdir(parents=True, exist_ok=True)
-        # Find next version number
+        prefix = _draft_filename_prefix(mode)
-        existing = sorted(export_dir.glob("טיוטה-v*.docx"))
+        existing = sorted(export_dir.glob(f"{prefix}-v*.docx"))
         next_ver = 1
         for p in existing:
             try:
@@ -182,102 +393,141 @@ async def export_decision(case_id: UUID, output_path: str | None = None) -> str:
                 next_ver = max(next_ver, ver + 1)
             except (IndexError, ValueError):
                 pass
-        output_path = str(export_dir / f"טיוטה-v{next_ver}.docx")
+        output_path = str(export_dir / f"{prefix}-v{next_ver}.docx")
 
     Path(output_path).parent.mkdir(parents=True, exist_ok=True)
     doc.save(output_path)
-    logger.info("DOCX exported: %s", output_path)
+    logger.info("DOCX exported (mode=%s): %s", mode, output_path)
     return output_path
 
 
 def _write_block_to_docx(doc, block_id: str, title: str, content: str) -> None:
-    """Write a single block to the DOCX document."""
+    """Write a single block to the DOCX document using template styles."""
     # Header blocks (א-ד)
     if block_id == "block-alef":
         for line in content.split("\n"):
             if line.strip():
-                _add_centered_paragraph(doc, line.strip(), bold=True, font_size=FONT_SIZE_HEADING)
+                _add_styled_paragraph(doc, line.strip(), style="Heading 1",
+                                      alignment=WD_ALIGN_PARAGRAPH.CENTER)
         return
 
     if block_id == "block-bet":
-        _add_paragraph(doc, "", space_after=Pt(6))  # spacer
+        _add_spacer(doc)
         for line in content.split("\n"):
             if line.strip():
-                _add_centered_paragraph(doc, line.strip(), bold=False, font_size=FONT_SIZE_BODY)
+                _add_centered_paragraph(doc, line.strip(), bold=False)
         return
 
     if block_id == "block-gimel":
-        _add_paragraph(doc, "", space_after=Pt(6))
+        _add_spacer(doc)
-        lines = content.split("\n")
+        for line in content.split("\n"):
-        for line in lines:
             stripped = line.strip()
             if not stripped:
                 continue
             if stripped == "נגד":
-                _add_centered_paragraph(doc, "— נגד —", bold=True, font_size=FONT_SIZE_BODY)
+                _add_centered_paragraph(doc, "— נגד —", bold=True)
             else:
-                _add_centered_paragraph(doc, stripped, bold=False, font_size=FONT_SIZE_BODY)
+                _add_centered_paragraph(doc, stripped, bold=False)
         return
 
     if block_id == "block-dalet":
-        _add_paragraph(doc, "", space_after=Pt(12))  # spacer
+        _add_spacer(doc)
-        _add_centered_paragraph(doc, "החלטה", bold=True, font_size=FONT_SIZE_TITLE)
+        # Avoid style=Title: its rFonts use theme fonts (majorHAnsi / majorBidi)
-        _add_paragraph(doc, "", space_after=Pt(12))
+        # and 28pt size — renders Hebrew oversized and in the wrong face.
+        # Heading 1 carries David and proper RTL, bold + center gives the
+        # same visual weight.
+        para = _add_styled_paragraph(doc, "החלטה", style="Heading 1",
+                                     alignment=WD_ALIGN_PARAGRAPH.CENTER,
+                                     bold=True)
+        _suppress_paragraph_numbering(para)
+        _add_spacer(doc)
         return
 
     if block_id == "block-yod-bet":
-        _add_paragraph(doc, "", space_after=Pt(24))  # spacer
+        _add_spacer(doc)
         for line in content.split("\n"):
             if line.strip():
-                _add_centered_paragraph(doc, line.strip(), bold=False, font_size=FONT_SIZE_BODY)
+                _add_centered_paragraph(doc, line.strip(), bold=False)
         return
 
     # Content blocks (ה-יא) — parse paragraphs
-    paragraphs = content.split("\n")
+    for para_text in content.split("\n"):
-    for para_text in paragraphs:
+        stripped = _strip_dashes(para_text.strip())
-        stripped = para_text.strip()
         if not stripped:
             continue
 
-        # Section headings (e.g., "תמצית טענות הצדדים", "טענות העוררים")
+        # Markdown H1/H2/H3 → template heading styles
-        if _is_section_heading(stripped):
+        md_heading = re.match(r"^(#{1,6})\s+(.*)$", stripped)
-            _add_paragraph(doc, stripped, bold=True, font_size=FONT_SIZE_HEADING,
+        if md_heading:
-                           space_after=Pt(6))
+            level = len(md_heading.group(1))
+            heading_text = md_heading.group(2).strip()
+            style = "Heading 1" if level == 1 else f"Heading {min(level, 3)}"
+            _add_heading(doc, heading_text, style=style)
+            continue
+
+        # Standalone `**...**` line — treat as a sub-heading (Heading 3)
+        stand_bold = re.match(r"^\*\*([^\n*]+?)\*\*$", stripped)
+        if stand_bold:
+            _add_heading(doc, stand_bold.group(1).strip(), style="Heading 3")
+            continue
+
+        if _is_section_heading(stripped):
+            _add_heading(doc, stripped, style="Heading 2")
             continue
 
-        # Blockquotes (indented quotes from protocols/rulings)
         if stripped.startswith('"') or stripped.startswith("״") or stripped.startswith(">"):
             clean = stripped.lstrip(">").strip().strip('"').strip("״").strip('"')
             _add_blockquote(doc, clean)
             continue
 
-        # Image placeholders
+        if "📷" in stripped or (stripped.startswith("[") and "תמונה" in stripped):
-        if "📷" in stripped or stripped.startswith("[") and "תמונה" in stripped:
             _add_image_placeholder(doc, stripped.strip("[]📷 "))
             continue
 
-        # Regular numbered paragraph or plain text
+        # Numbered body paragraph ("1. text") → List Paragraph with auto-num.
-        _add_paragraph(doc, stripped)
+        # The literal prefix is dropped; Word renders "1. 2. 3. ..." via numId.
+        num_match = _NUM_PREFIX_RE.match(stripped)
+        if num_match:
+            body_text = num_match.group(2).strip()
+            _add_styled_paragraph(doc, body_text, style="List Paragraph")
+            continue
+
+        _add_styled_paragraph(doc, stripped, style="Normal")
 
 
-def _is_section_heading(text: str) -> bool:
+_SECTION_HEADING_PATTERNS = [
-    """Detect section headings in decision text."""
+    re.compile(p) for p in (
-    heading_patterns = [
+        # Block-level titles
+        r"^פתח\s+דבר",
+        r"^רקע\s+עובדתי",
         r"^תמצית\s+טענות",
+        r"^טענות\s+הצדדים",
         r"^טענות\s+העוררי",
+        r"^טענות\s+המשיב",
         r"^עמדת\s+הוועדה",
         r"^עמדת\s+מבקשי",
         r"^ההליכים\s+בפני",
+        r"^הליכים\s+בפני",
         r"^דיון\s+והכרעה",
         r"^סוף\s+דבר",
         r"^סיכום",
-        r"^פתח\s+דבר",
+        # Subsection titles produced by legal-writer inside block-vav/block-tet
+        r"^המצב\s+התכנוני",
+        r"^הליכי\s+הרישוי",
+        r"^שומת\s+ההשבחה",
+        r"^הליך\s+השומה",
+        r"^הגשת\s+הערר",
+        r"^תכניות\s+מתאר",
+        r"^תכניות\s+מפורטות",
         r"^תכניות\s+חלות",
-    ]
+        r"^תכניות\s+החלות",
-    for pattern in heading_patterns:
+        r"^מדיניות\s+מהנדס",
-        if re.search(pattern, text):
+        r"^היתרי\s+בני",
-            return True
+        r"^היתר\s+בני",
-    # Short bold-like lines (under 60 chars, not numbered)
+    )
-    if len(text) < 60 and not re.match(r"^\d+\.", text):
+]
-        return False
+
-    return False
+
+def _is_section_heading(text: str) -> bool:
+    """Detect legal-decision section headings — mapped to Heading 2 style."""
+    return any(p.search(text) for p in _SECTION_HEADING_PATTERNS)

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

@@ -0,0 +1,336 @@
+"""הזרקת bookmarks רטרואקטיבית ל-DOCX שלא נוצרו ע"י ה-exporter.
+
+כאשר משתמש מעלה `עריכה-v*.docx` שנערך ב-Word מחוץ למערכת, אין בו את ה-
+bookmarks שאנו מצפים להם (block-alef ... block-yod-bet). השירות כאן
+מזהה את תחילת כל בלוק לפי סימני הפתיחה העבריים (א., ב., ... יב.) ב-
+הפסקאות הראשונות שלו, ומזריק bookmarkStart/bookmarkEnd בהתאם.
+
+נעשה בצורה defensive — אם לא מצליחים לזהות בלוק, הוא פשוט לא יקבל
+bookmark (`missing_blocks` בתוצאה). השרת אמור להתריע למשתמש.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import shutil
+import zipfile
+from io import BytesIO
+from pathlib import Path
+
+from lxml import etree
+
+from legal_mcp.services.docx_reviser import (
+    NSMAP,
+    _load_docx_xml,
+    _save_docx_xml,
+    _w,
+)
+
+logger = logging.getLogger(__name__)
+
+# ── Block identification ──────────────────────────────────────────
+
+# The 12 blocks in order, with their Hebrew letter marker
+BLOCK_ORDER = [
+    ("block-alef",     "א"),
+    ("block-bet",      "ב"),
+    ("block-gimel",    "ג"),
+    ("block-dalet",    "ד"),
+    ("block-heh",      "ה"),
+    ("block-vav",      "ו"),
+    ("block-zayin",    "ז"),
+    ("block-chet",     "ח"),
+    ("block-tet",      "ט"),
+    ("block-yod",      "י"),
+    ("block-yod-alef", "יא"),
+    ("block-yod-bet",  "יב"),
+]
+
+# Regex matching a paragraph that begins with a Hebrew block marker
+# followed by '.', ')', ' ', or end-of-string. The marker must be followed
+# either by whitespace/punctuation or end of text to avoid matching longer
+# words that happen to start with these letters.
+_BLOCK_MARKERS_BY_LETTER: dict[str, str] = {letter: name for name, letter in BLOCK_ORDER}
+
+# Longer markers (יא, יב) first so regex matches them before falling back to 'י'
+_MARKER_ALTERNATION = "|".join(
+    re.escape(letter)
+    for letter in sorted(_BLOCK_MARKERS_BY_LETTER, key=len, reverse=True)
+)
+_BLOCK_MARKER_RE = re.compile(
+    rf"^\s*({_MARKER_ALTERNATION})\s*[\.\)\-]\s*"
+)
+
+# Secondary heuristic: Hebrew section headings that reliably mark the
+# start of each block in the Daphna Tamir style (used when markers
+# "א.", "ב." etc. are missing — common in user-edited Word files).
+#
+# Key observations from the 12-block schema:
+#   block-alef:   "בפני: דפנה תמיר" or decision number page
+#   block-bet:    "ערר מספר" line
+#   block-gimel:  appellants vs respondents (parties)
+#   block-dalet:  bold "החלטה" centered
+#   block-heh:    "רקע" / "רקע עובדתי" / "פתח דבר"
+#   block-vav:    "תכניות חלות" / "ההליך שבפנינו" / "ההליכים בפני"
+#   block-zayin:  "תמצית טענות" / "טענות הצדדים"
+#   block-chet:   "תגובת המשיבה" / "עמדת הוועדה"
+#   block-tet:    "ההליכים בפני ועדת הערר" / "הדיון בפנינו"
+#   block-yod:    "דיון והכרעה" / "דיון"
+#   block-yod-alef: "סוף דבר" / "סיכום"
+#   block-yod-bet: "ההחלטה" (signature / closing block)
+_BLOCK_HEADING_PATTERNS: list[tuple[str, list[str]]] = [
+    ("block-alef", [r"בפני[:\s]", r"ועדת הערר"]),
+    ("block-bet",  [r"^ערר\s+מספר", r"^ערר\s+\d"]),
+    ("block-gimel", [r"^נגד\s*$", r"^—\s*נגד\s*—"]),
+    ("block-dalet", [r"^החלטה\s*$"]),
+    ("block-heh",  [r"^רקע\s*$", r"^רקע\s+עובדתי", r"^פתח\s+דבר"]),
+    ("block-vav",  [
+        r"^תכניות\s+חלות",
+        r"^ההליכים?\s+שבפנינו",
+        r"^ההליכים?\s+בפני\s+הוועדה\s+המקומית",
+        r"^על\s+המקרקעין\s+חלות",
+        r"^התכניות?\s+החלות",
+        r"^במצב\s+התכנוני",
+    ]),
+    ("block-zayin", [
+        r"^תמצית\s+טענות",
+        r"^טענות\s+הצדדים",
+        r"^טענות\s+העוררי",
+        r"^טענות\s+העוררת",
+    ]),
+    ("block-chet", [
+        r"^תגובת\s+המשיב",
+        r"^עמדת\s+הוועדה\s+המקומית",
+        r"^תשובת",
+        r"^עיקר\s+תגובת\s+המשיב",
+    ]),
+    ("block-tet",  [
+        r"^ההליכים?\s+בפני\s+ועדת\s+הערר",
+        r"^הדיון\s+בפנינו",
+        r"^הדיון\s+בוועדת\s+הערר",
+    ]),
+    ("block-yod",  [r"^דיון\s+והכרעה", r"^דיון\s*$", r"^ההכרעה"]),
+    ("block-yod-alef", [r"^סוף\s+דבר", r"^סיכום\s*$"]),
+    # block-yod-bet "על כן" must be operative — paired with אנו/הערר/הוועדה.
+    # Loose `^על כן` alone matches mid-discussion transitions ("על כן, במקום בו...")
+    # and steals the bookmark from block-yod-alef via forward-scan.
+    ("block-yod-bet", [
+        r"^ההחלטה\s*$",
+        r"^על\s+כן[,\.\s]+(?:אנו|הערר|הוועדה|ועדת\s+הערר)\b",
+    ]),
+]
+
+_COMPILED_HEADING_PATTERNS: list[tuple[str, list[re.Pattern[str]]]] = [
+    (name, [re.compile(p) for p in patterns])
+    for name, patterns in _BLOCK_HEADING_PATTERNS
+]
+
+
+def _paragraph_text(p: etree._Element) -> str:
+    """Return the full text of a paragraph, joining all w:t nodes."""
+    return "".join(p.itertext()).strip()
+
+
+def _detect_block_starts(
+    paragraphs: list[etree._Element],
+) -> dict[str, int]:
+    """Return a mapping of block_name → paragraph index (start of that block).
+
+    Uses a greedy scan: for each paragraph, if its text starts with an
+    expected block marker and the block hasn't been assigned yet, assign
+    this paragraph as the block's start.
+    """
+    found: dict[str, int] = {}
+    expected_order = [name for name, _ in BLOCK_ORDER]
+    pointer = 0  # index into expected_order — next expected block
+
+    for i, p in enumerate(paragraphs):
+        text = _paragraph_text(p)
+        if not text:
+            continue
+
+        matched_name: str | None = None
+
+        # Try marker-based (א., ב., ...) first
+        m = _BLOCK_MARKER_RE.match(text)
+        if m:
+            letter = m.group(1)
+            matched_name = _BLOCK_MARKERS_BY_LETTER.get(letter)
+
+        # Fall back to heading-keyword heuristic (Daphna style)
+        if matched_name is None:
+            for name, patterns in _COMPILED_HEADING_PATTERNS:
+                if name in found:
+                    continue
+                # Only check patterns for blocks we haven't assigned yet
+                # AND that come at/after the current pointer — to keep the
+                # greedy forward-scan semantics consistent with markers.
+                if expected_order.index(name) < pointer:
+                    continue
+                if any(pat.search(text) for pat in patterns):
+                    matched_name = name
+                    break
+
+        if matched_name is None:
+            continue
+        if matched_name in found:
+            continue
+        if pointer >= len(expected_order):
+            continue
+        name_idx_in_order = expected_order.index(matched_name)
+        if name_idx_in_order >= pointer:
+            found[matched_name] = i
+            pointer = name_idx_in_order + 1
+    return found
+
+
+def _insert_bookmark_around_range(
+    body: etree._Element,
+    paragraphs: list[etree._Element],
+    start_idx: int,
+    end_idx: int,
+    name: str,
+    bm_id: int,
+) -> None:
+    """Insert bookmarkStart at the start of paragraph start_idx and
+    bookmarkEnd at the end of paragraph end_idx."""
+    start_el = etree.Element(_w("bookmarkStart"))
+    start_el.set(_w("id"), str(bm_id))
+    start_el.set(_w("name"), name)
+
+    end_el = etree.Element(_w("bookmarkEnd"))
+    end_el.set(_w("id"), str(bm_id))
+
+    start_p = paragraphs[start_idx]
+    end_p = paragraphs[end_idx]
+    start_p.insert(0, start_el)
+    end_p.append(end_el)
+
+
+def _next_bookmark_id(doc_tree: etree._Element) -> int:
+    """Find max existing bookmark id and return next unused."""
+    max_id = 9999
+    for el in doc_tree.iterfind(".//w:bookmarkStart", NSMAP):
+        wid = el.get(_w("id"))
+        if wid:
+            try:
+                max_id = max(max_id, int(wid))
+            except ValueError:
+                pass
+    return max_id + 1
+
+
+# ── Public API ────────────────────────────────────────────────────
+
+
+def retrofit_bookmarks(
+    docx_path: str | Path,
+    *,
+    output_path: str | Path | None = None,
+    backup: bool = True,
+) -> dict:
+    """Inject block-* bookmarks into an existing DOCX via heuristic detection.
+
+    Args:
+        docx_path: path to DOCX file (modified in place unless output_path set).
+        output_path: if given, write to this path instead of overwriting.
+        backup: if True and writing in place, save the original as
+                `<path>.pre-retrofit.docx` first.
+
+    Returns:
+        {
+          'bookmarks_added': ['block-alef', ...],
+          'missing_blocks':  ['block-dalet', ...],
+          'existing_bookmarks': [...]   # bookmarks already on the doc
+        }
+    """
+    docx_path = Path(docx_path)
+    if not docx_path.exists():
+        raise FileNotFoundError(str(docx_path))
+
+    if output_path is None:
+        output_path = docx_path
+    output_path = Path(output_path)
+
+    members, doc_tree, settings_tree = _load_docx_xml(docx_path)
+
+    # Existing bookmarks
+    existing_names: list[str] = []
+    for el in doc_tree.iterfind(".//w:bookmarkStart", NSMAP):
+        name = el.get(_w("name"))
+        if name:
+            existing_names.append(name)
+
+    # Collect *top-level* body paragraphs (don't descend into tables etc.
+    # for now — MVP). The XPath ".//w:p" would include table cells too;
+    # for retrofitting we only care about the main flow.
+    body = doc_tree.find(f".//{_w('body')}")
+    if body is None:
+        raise ValueError("document has no <w:body>")
+    paragraphs = [p for p in body if p.tag == _w("p")]
+
+    if not paragraphs:
+        return {
+            "bookmarks_added": [],
+            "missing_blocks": [n for n, _ in BLOCK_ORDER],
+            "existing_bookmarks": existing_names,
+        }
+
+    block_starts = _detect_block_starts(paragraphs)
+
+    # Cover-block fallback: alef/bet/gimel/dalet are template metadata
+    # (judges, case number, parties, "החלטה" title) that don't appear in
+    # the body of user-edited DOCX files — they live in headers/template.
+    # Inject zero-content anchors at paragraph 0 so apply_user_edit can
+    # still target them later.
+    structural_fallback: list[str] = []
+    cover_blocks = ["block-alef", "block-bet", "block-gimel", "block-dalet"]
+    first_detected_idx = min(block_starts.values()) if block_starts else 0
+    for i, name in enumerate(cover_blocks):
+        if name not in block_starts:
+            idx = min(i, max(0, first_detected_idx - 1))
+            block_starts[name] = idx
+            structural_fallback.append(name)
+
+    # Calculate end_idx for each block = paragraph before the next block's start,
+    # or last paragraph if this is the last block found.
+    ordered_found = sorted(block_starts.items(), key=lambda kv: kv[1])
+    ranges: list[tuple[str, int, int]] = []
+    for i, (name, start_idx) in enumerate(ordered_found):
+        if i + 1 < len(ordered_found):
+            end_idx = ordered_found[i + 1][1] - 1
+        else:
+            end_idx = len(paragraphs) - 1
+        ranges.append((name, start_idx, max(start_idx, end_idx)))
+
+    # Backup if overwriting in place
+    if backup and output_path.resolve() == docx_path.resolve():
+        backup_path = docx_path.with_suffix(".pre-retrofit.docx")
+        shutil.copy2(str(docx_path), str(backup_path))
+
+    # Inject bookmarks, skipping any that already exist
+    next_id = _next_bookmark_id(doc_tree)
+    added: list[str] = []
+    for name, s, e in ranges:
+        if name in existing_names:
+            continue
+        _insert_bookmark_around_range(body, paragraphs, s, e, name, next_id)
+        added.append(name)
+        next_id += 1
+
+    _save_docx_xml(members, doc_tree, settings_tree, output_path)
+
+    missing = [
+        n for n, _ in BLOCK_ORDER
+        if n not in block_starts
+        and n not in existing_names
+    ]
+    logger.info("retrofit %s: added=%s missing=%s structural=%s",
+                docx_path.name, added, missing, structural_fallback)
+    return {
+        "bookmarks_added": added,
+        "missing_blocks": missing,
+        "structural_fallback": structural_fallback,
+        "existing_bookmarks": existing_names,
+    }

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

@@ -0,0 +1,514 @@
+"""עריכת DOCX עם Track Changes אמיתיים של Word.
+
+השירות מיועד לקבל DOCX קיים (עם bookmarks שזיהו אנקורים) ולהחיל עליו
+עריכות מסומנות כ-w:ins / w:del, שבאים לידי ביטוי ב-Word כ-Track Changes
+שהמשתמש יכול Accept/Reject.
+
+אסטרטגיית אנקורים: bookmarks בשמות כגון 'block-yod', 'block-yod-para-3'
+שמוכנסים בזמן הייצוא הראשוני (docx_exporter.py) או רטרואקטיבית
+(docx_retrofit.py).
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+import zipfile
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from io import BytesIO
+from pathlib import Path
+from typing import Literal
+
+from lxml import etree
+
+logger = logging.getLogger(__name__)
+
+# ── XML namespaces ─────────────────────────────────────────────────
+
+W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
+NSMAP = {"w": W_NS}
+
+
+def _w(tag: str) -> str:
+    """Build a fully qualified tag name in the w: namespace."""
+    return f"{{{W_NS}}}{tag}"
+
+
+# ── Data models ────────────────────────────────────────────────────
+
+
+RevisionType = Literal["insert_after", "insert_before", "replace", "delete"]
+StyleType = Literal["body", "quote", "heading", "bold"]
+
+
+@dataclass
+class Revision:
+    """A single tracked change to apply to the DOCX."""
+
+    id: str
+    type: RevisionType
+    anchor_bookmark: str
+    content: str = ""
+    style: StyleType = "body"
+    reason: str = ""
+    anchor_position: Literal["start", "end"] = "end"
+
+
+@dataclass
+class RevisionResult:
+    """Result of applying a single revision."""
+
+    id: str
+    status: Literal["applied", "failed"]
+    error: str | None = None
+    ins_id: int | None = None
+
+
+@dataclass
+class RevisionBatchResult:
+    """Aggregate result of applying a revision batch."""
+
+    applied: int = 0
+    failed: int = 0
+    results: list[RevisionResult] = field(default_factory=list)
+    output_path: str = ""
+
+
+# ── XML helpers ────────────────────────────────────────────────────
+
+
+def _load_docx_xml(docx_path: Path) -> tuple[dict[str, bytes], etree._Element, etree._Element]:
+    """Load a DOCX as a dict of zip members + parsed document/settings trees."""
+    members: dict[str, bytes] = {}
+    with zipfile.ZipFile(docx_path, "r") as zf:
+        for name in zf.namelist():
+            members[name] = zf.read(name)
+
+    if "word/document.xml" not in members:
+        raise ValueError(f"{docx_path}: missing word/document.xml")
+
+    document_tree = etree.fromstring(members["word/document.xml"])
+    settings_bytes = members.get("word/settings.xml")
+    if settings_bytes:
+        settings_tree = etree.fromstring(settings_bytes)
+    else:
+        settings_tree = etree.Element(_w("settings"), nsmap=NSMAP)
+
+    return members, document_tree, settings_tree
+
+
+def _save_docx_xml(
+    members: dict[str, bytes],
+    document_tree: etree._Element,
+    settings_tree: etree._Element,
+    output_path: Path,
+) -> None:
+    """Write a DOCX back to disk with updated document/settings XML."""
+    members = dict(members)
+    members["word/document.xml"] = etree.tostring(
+        document_tree, xml_declaration=True, encoding="UTF-8", standalone=True
+    )
+    members["word/settings.xml"] = etree.tostring(
+        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)
+    output_path.write_bytes(buffer.getvalue())
+
+
+def _ensure_track_revisions(settings_tree: etree._Element) -> None:
+    """Ensure <w:trackRevisions/> is present in settings.xml.
+
+    Note: This enables *display* of track changes — actual w:ins/w:del nodes
+    are rendered as tracked regardless. Word respects trackRevisions for
+    recording further user edits too.
+    """
+    existing = settings_tree.find(_w("trackRevisions"))
+    if existing is None:
+        el = etree.SubElement(settings_tree, _w("trackRevisions"))
+        el.set(_w("val"), "true")
+
+
+def _next_revision_id(document_tree: etree._Element) -> int:
+    """Find max existing w:id on w:ins/w:del/w:bookmarkStart and return next."""
+    max_id = 0
+    for xpath in (
+        ".//w:ins", ".//w:del", ".//w:bookmarkStart", ".//w:bookmarkEnd",
+        ".//w:commentRangeStart", ".//w:comment",
+    ):
+        for el in document_tree.iterfind(xpath, NSMAP):
+            val = el.get(_w("id"))
+            if val:
+                try:
+                    max_id = max(max_id, int(val))
+                except ValueError:
+                    pass
+    return max_id + 1
+
+
+def _find_bookmark(
+    document_tree: etree._Element, name: str
+) -> tuple[etree._Element | None, etree._Element | None]:
+    """Find w:bookmarkStart and w:bookmarkEnd elements by bookmark name."""
+    start = None
+    end = None
+    for el in document_tree.iterfind(".//w:bookmarkStart", NSMAP):
+        if el.get(_w("name")) == name:
+            start = el
+            break
+    if start is None:
+        return None, None
+    bm_id = start.get(_w("id"))
+    for el in document_tree.iterfind(".//w:bookmarkEnd", NSMAP):
+        if el.get(_w("id")) == bm_id:
+            end = el
+            break
+    return start, end
+
+
+def _find_enclosing_paragraph(element: etree._Element) -> etree._Element | None:
+    """Walk up from an element to find its enclosing w:p."""
+    cur = element
+    while cur is not None:
+        if cur.tag == _w("p"):
+            return cur
+        cur = cur.getparent()
+    return None
+
+
+# ── Paragraph builders ─────────────────────────────────────────────
+
+
+def _build_run(text: str, *, bold: bool = False, italic: bool = False,
+               font: str = "David", size_half_pt: int | None = None) -> etree._Element:
+    """Build a w:r (run) element with RTL/David defaults and given text."""
+    r = etree.Element(_w("r"))
+    rPr = etree.SubElement(r, _w("rPr"))
+
+    rFonts = etree.SubElement(rPr, _w("rFonts"))
+    rFonts.set(_w("ascii"), font)
+    rFonts.set(_w("hAnsi"), font)
+    rFonts.set(_w("cs"), font)
+    rFonts.set(_w("hint"), "cs")
+
+    if size_half_pt is not None:
+        sz = etree.SubElement(rPr, _w("sz"))
+        sz.set(_w("val"), str(size_half_pt))
+        szCs = etree.SubElement(rPr, _w("szCs"))
+        szCs.set(_w("val"), str(size_half_pt))
+
+    if bold:
+        etree.SubElement(rPr, _w("b"))
+        etree.SubElement(rPr, _w("bCs"))
+    if italic:
+        etree.SubElement(rPr, _w("i"))
+        etree.SubElement(rPr, _w("iCs"))
+
+    etree.SubElement(rPr, _w("rtl"))
+
+    t = etree.SubElement(r, _w("t"))
+    t.set("{http://www.w3.org/XML/1998/namespace}space", "preserve")
+    t.text = text
+    return r
+
+
+def _build_paragraph(text: str, *, style: StyleType = "body") -> etree._Element:
+    """Build a w:p (paragraph) with RTL + David + given text."""
+    p = etree.Element(_w("p"))
+    pPr = etree.SubElement(p, _w("pPr"))
+    bidi = etree.SubElement(pPr, _w("bidi"))
+    bidi.set(_w("val"), "1")
+
+    # Right alignment for body/RTL
+    jc = etree.SubElement(pPr, _w("jc"))
+    jc.set(_w("val"), "right")
+
+    rPr_p = etree.SubElement(pPr, _w("rPr"))
+    etree.SubElement(rPr_p, _w("rtl"))
+
+    bold = style in ("heading", "bold")
+    italic = style == "quote"
+    size = None
+    if style == "heading":
+        size = 28  # 14pt
+    elif style == "quote":
+        size = 22  # 11pt
+    run = _build_run(text, bold=bold, italic=italic, size_half_pt=size)
+    p.append(run)
+    return p
+
+
+def _wrap_in_ins(elements: list[etree._Element], *, ins_id: int,
+                 author: str, date_iso: str) -> etree._Element:
+    """Wrap a list of *run-level* elements in a single <w:ins>."""
+    ins = etree.Element(_w("ins"))
+    ins.set(_w("id"), str(ins_id))
+    ins.set(_w("author"), author)
+    ins.set(_w("date"), date_iso)
+    for el in elements:
+        ins.append(el)
+    return ins
+
+
+def _make_tracked_paragraph_insert(
+    text: str, *, style: StyleType, ins_id: int, author: str, date_iso: str,
+    mark_id: int | None = None,
+) -> etree._Element:
+    """Build a whole tracked-inserted paragraph.
+
+    DOCX convention for a fully-inserted paragraph:
+      1. All <w:r> runs are wrapped in a single <w:ins> (own id).
+      2. The paragraph's pPr/rPr gets an <w:ins> marker for the paragraph
+         mark itself (pilcrow) — this uses its *own* id.
+    """
+    if mark_id is None:
+        mark_id = ins_id
+    p = _build_paragraph(text, style=style)
+    pPr = p.find(_w("pPr"))
+    assert pPr is not None
+    rPr = pPr.find(_w("rPr"))
+    if rPr is None:
+        rPr = etree.SubElement(pPr, _w("rPr"))
+    ins_mark = etree.SubElement(rPr, _w("ins"))
+    ins_mark.set(_w("id"), str(mark_id))
+    ins_mark.set(_w("author"), author)
+    ins_mark.set(_w("date"), date_iso)
+
+    runs = [child for child in list(p) if child.tag == _w("r")]
+    if runs:
+        for r in runs:
+            p.remove(r)
+        ins = _wrap_in_ins(runs, ins_id=ins_id, author=author, date_iso=date_iso)
+        p.append(ins)
+    return p
+
+
+def _mark_runs_as_deleted(paragraph: etree._Element, *, del_id: int,
+                          author: str, date_iso: str) -> None:
+    """Convert all <w:r> in a paragraph to <w:del>-wrapped runs.
+
+    Within a <w:del>, <w:t> must become <w:delText>.
+    """
+    runs = [child for child in list(paragraph) if child.tag == _w("r")]
+    if not runs:
+        return
+    # Convert <w:t> → <w:delText> inside each run
+    for r in runs:
+        for t in r.findall(_w("t")):
+            t.tag = _w("delText")
+        paragraph.remove(r)
+    wrapper = etree.Element(_w("del"))
+    wrapper.set(_w("id"), str(del_id))
+    wrapper.set(_w("author"), author)
+    wrapper.set(_w("date"), date_iso)
+    for r in runs:
+        wrapper.append(r)
+    paragraph.append(wrapper)
+
+
+# ── Revision application ───────────────────────────────────────────
+
+
+def _apply_insert(
+    document_tree: etree._Element,
+    revision: Revision,
+    *,
+    ins_id: int,
+    author: str,
+    date_iso: str,
+) -> RevisionResult:
+    """Apply insert_after / insert_before relative to a bookmark."""
+    start, end = _find_bookmark(document_tree, revision.anchor_bookmark)
+    if start is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error=f"bookmark '{revision.anchor_bookmark}' not found")
+
+    # Pick anchor element based on position
+    if revision.type == "insert_before":
+        anchor = start
+    else:  # insert_after — default
+        anchor = end if end is not None else start
+
+    enclosing_p = _find_enclosing_paragraph(anchor)
+    if enclosing_p is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error="anchor has no enclosing paragraph")
+
+    # Build new tracked paragraph. ins_id for run wrapper, ins_id+1 for mark.
+    new_p = _make_tracked_paragraph_insert(
+        revision.content, style=revision.style,
+        ins_id=ins_id, mark_id=ins_id + 1,
+        author=author, date_iso=date_iso,
+    )
+
+    parent = enclosing_p.getparent()
+    if parent is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error="enclosing paragraph has no parent")
+    idx = list(parent).index(enclosing_p)
+    insert_idx = idx if revision.type == "insert_before" else idx + 1
+    parent.insert(insert_idx, new_p)
+
+    return RevisionResult(id=revision.id, status="applied", ins_id=ins_id)
+
+
+def _apply_delete(
+    document_tree: etree._Element,
+    revision: Revision,
+    *,
+    del_id: int,
+    author: str,
+    date_iso: str,
+) -> RevisionResult:
+    """Mark the paragraph enclosed by a bookmark as deleted."""
+    start, end = _find_bookmark(document_tree, revision.anchor_bookmark)
+    if start is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error=f"bookmark '{revision.anchor_bookmark}' not found")
+
+    enclosing_p = _find_enclosing_paragraph(start)
+    if enclosing_p is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error="anchor has no enclosing paragraph")
+
+    _mark_runs_as_deleted(enclosing_p, del_id=del_id,
+                          author=author, date_iso=date_iso)
+    return RevisionResult(id=revision.id, status="applied", ins_id=del_id)
+
+
+def _apply_replace(
+    document_tree: etree._Element,
+    revision: Revision,
+    *,
+    ins_id: int,
+    del_id: int,
+    author: str,
+    date_iso: str,
+) -> RevisionResult:
+    """Replace = delete the existing paragraph + insert new one after it."""
+    start, end = _find_bookmark(document_tree, revision.anchor_bookmark)
+    if start is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error=f"bookmark '{revision.anchor_bookmark}' not found")
+
+    enclosing_p = _find_enclosing_paragraph(start)
+    if enclosing_p is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error="anchor has no enclosing paragraph")
+
+    parent = enclosing_p.getparent()
+    if parent is None:
+        return RevisionResult(id=revision.id, status="failed",
+                              error="enclosing paragraph has no parent")
+
+    new_p = _make_tracked_paragraph_insert(
+        revision.content, style=revision.style,
+        ins_id=ins_id, mark_id=ins_id + 1,
+        author=author, date_iso=date_iso,
+    )
+    idx = list(parent).index(enclosing_p)
+    parent.insert(idx + 1, new_p)
+
+    _mark_runs_as_deleted(enclosing_p, del_id=del_id,
+                          author=author, date_iso=date_iso)
+    return RevisionResult(id=revision.id, status="applied", ins_id=ins_id)
+
+
+# ── Public API ─────────────────────────────────────────────────────
+
+
+def apply_tracked_revisions(
+    source_path: str | Path,
+    output_path: str | Path,
+    revisions: list[Revision],
+    *,
+    author: str = "מערכת AI",
+    date: datetime | None = None,
+) -> RevisionBatchResult:
+    """Apply a batch of tracked revisions to a DOCX, producing a new DOCX.
+
+    The source file is never mutated. Output is a new DOCX with <w:ins> /
+    <w:del> markers that Word renders as Track Changes (Accept/Reject).
+
+    Args:
+        source_path: existing DOCX (e.g. עריכה-v1.docx) — retains user edits.
+        output_path: where to write the revised DOCX (e.g. טיוטה-v6.docx).
+        revisions: list of Revision objects. Anchors are bookmark names.
+        author: displayed as the revision author in Word.
+        date: revision timestamp (defaults to now, UTC).
+
+    Returns:
+        RevisionBatchResult with per-revision status.
+    """
+    source_path = Path(source_path)
+    output_path = Path(output_path)
+
+    if date is None:
+        date = datetime.now(timezone.utc)
+    date_iso = date.strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    members, doc_tree, settings_tree = _load_docx_xml(source_path)
+    _ensure_track_revisions(settings_tree)
+
+    next_id = _next_revision_id(doc_tree)
+
+    batch = RevisionBatchResult()
+    for rev in revisions:
+        try:
+            if rev.type in ("insert_after", "insert_before"):
+                result = _apply_insert(doc_tree, rev, ins_id=next_id,
+                                       author=author, date_iso=date_iso)
+                # insert consumes 2 IDs: run-wrapper + paragraph-mark
+                next_id += 2
+            elif rev.type == "delete":
+                result = _apply_delete(doc_tree, rev, del_id=next_id,
+                                       author=author, date_iso=date_iso)
+                next_id += 1
+            elif rev.type == "replace":
+                result = _apply_replace(doc_tree, rev,
+                                        ins_id=next_id, del_id=next_id + 2,
+                                        author=author, date_iso=date_iso)
+                # replace consumes 3 IDs: ins-run, ins-mark, del
+                next_id += 3
+            else:
+                result = RevisionResult(id=rev.id, status="failed",
+                                        error=f"unknown type: {rev.type}")
+        except Exception as e:  # pragma: no cover - defensive
+            logger.exception("revision %s failed", rev.id)
+            result = RevisionResult(id=rev.id, status="failed", error=str(e))
+
+        batch.results.append(result)
+        if result.status == "applied":
+            batch.applied += 1
+        else:
+            batch.failed += 1
+
+    _save_docx_xml(members, doc_tree, settings_tree, output_path)
+    batch.output_path = str(output_path)
+    logger.info("applied %d revisions (failed %d) → %s",
+                batch.applied, batch.failed, output_path)
+    return batch
+
+
+def list_bookmarks(docx_path: str | Path) -> list[str]:
+    """Return bookmark names present in the DOCX (excluding '_' internal ones)."""
+    docx_path = Path(docx_path)
+    members, doc_tree, _ = _load_docx_xml(docx_path)
+    names: list[str] = []
+    for el in doc_tree.iterfind(".//w:bookmarkStart", NSMAP):
+        name = el.get(_w("name"))
+        if name and not name.startswith("_"):
+            names.append(name)
+    return names
+
+
+def copy_with_revisions(
+    source_path: str | Path, output_path: str | Path,
+) -> None:
+    """Copy source → output unchanged (used when revisions list is empty)."""
+    shutil.copy2(str(source_path), str(output_path))

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

@@ -1,7 +1,8 @@
-"""Text extraction from PDF, DOCX, and RTF files.
+"""Text extraction from PDF, DOCX, DOC, and RTF files.
 
 Primary PDF extraction: PyMuPDF direct text (for born-digital PDFs).
 Fallback: Google Cloud Vision OCR (for scanned documents).
+DOC files: converted to DOCX via LibreOffice before extraction.
 Post-processing: Hebrew abbreviation quote fixer.
 """
 
@@ -10,6 +11,8 @@ from __future__ import annotations
 import asyncio
 import logging
 import re
+import subprocess
+import tempfile
 from pathlib import Path
 
 import fitz  # PyMuPDF
@@ -129,6 +132,8 @@ async def extract_text(file_path: str) -> tuple[str, int]:
         return await _extract_pdf(path)
     elif suffix == ".docx":
         return _extract_docx(path), 0
+    elif suffix == ".doc":
+        return _extract_doc(path), 0
     elif suffix == ".rtf":
         return _extract_rtf(path), 0
     elif suffix in (".txt", ".md"):
@@ -187,6 +192,21 @@ def _ocr_with_google_vision(image_bytes: bytes, page_num: int) -> str:
     return _fix_hebrew_quotes(text)
 
 
+def _extract_doc(path: Path) -> str:
+    """Extract text from legacy .doc file by converting to .docx via LibreOffice."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        result = subprocess.run(
+            ["libreoffice", "--headless", "--convert-to", "docx", str(path), "--outdir", tmp_dir],
+            capture_output=True, text=True, timeout=120,
+        )
+        if result.returncode != 0:
+            raise RuntimeError(f"LibreOffice conversion failed: {result.stderr}")
+        docx_path = Path(tmp_dir) / f"{path.stem}.docx"
+        if not docx_path.exists():
+            raise FileNotFoundError(f"Converted file not found: {docx_path}")
+        return _extract_docx(docx_path)
+
+
 def _extract_docx(path: Path) -> str:
     """Extract text from DOCX file."""
     doc = DocxDocument(str(path))
@@ -198,3 +218,30 @@ def _extract_rtf(path: Path) -> str:
     """Extract text from RTF file."""
     rtf_content = path.read_text(encoding="utf-8", errors="replace")
     return rtf_to_text(rtf_content)
+
+
+# ── Nevo preamble stripping ──────────────────────────────────────
+
+_NEVO_MARKERS = ("ספרות:", "חקיקה שאוזכרה:", "מיני-רציו:", "פסקי דין שאוזכרו:",
+                 "כתבי עת:", "הועתק מנבו")
+
+_DECISION_START = re.compile(
+    r"^(בפנינו|לפנינו|הערר שבנדון|ועדת הערר לתכנון|רקע עובדתי|עסקינן)",
+    re.MULTILINE,
+)
+
+
+def strip_nevo_preamble(text: str) -> str:
+    """Remove Nevo database preamble (bibliography, legislation, mini-ratio) from decision text.
+
+    Returns the original text unchanged if no preamble is detected.
+    """
+    head = text[:400]
+    if not any(marker in head for marker in _NEVO_MARKERS):
+        return text
+    m = _DECISION_START.search(text)
+    if m and m.start() > 50:
+        stripped = text[m.start():]
+        logger.debug("Stripped %d chars of Nevo preamble", m.start())
+        return stripped
+    return text

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

@@ -0,0 +1,92 @@
+"""Git sync helpers for case repos.
+
+Each case lives in its own git repo with a Gitea remote. The remote URL
+embeds an auth token (https://chaim:TOKEN@host/...). When the token is
+rotated in Infisical, repos created with the old token will fail to
+push silently — only logged at WARNING level. ``commit_and_push``
+re-injects the *current* token into the existing origin URL on every
+call, so push survives token rotation.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import subprocess
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+def _gitea_token() -> str:
+    return os.environ.get("GITEA_ACCESS_TOKEN") or os.environ.get("GITEA_TOKEN", "")
+
+
+def _git_env() -> dict:
+    return {
+        "GIT_AUTHOR_NAME": "Ezer Mishpati",
+        "GIT_AUTHOR_EMAIL": "legal@local",
+        "GIT_COMMITTER_NAME": "Ezer Mishpati",
+        "GIT_COMMITTER_EMAIL": "legal@local",
+        "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
+        "GIT_TERMINAL_PROMPT": "0",
+    }
+
+
+def _refresh_remote_url(case_dir: Path, env: dict) -> bool:
+    result = subprocess.run(
+        ["git", "remote", "get-url", "origin"],
+        cwd=case_dir, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return False
+    current_url = result.stdout.strip()
+    if "@" in current_url and current_url.startswith("https://"):
+        bare_url = "https://" + current_url.split("@", 1)[1]
+    else:
+        bare_url = current_url
+    token = _gitea_token()
+    if not token:
+        return True  # Push without auth — will fail, but caller decides what to do
+    auth_url = bare_url.replace("https://", f"https://chaim:{token}@")
+    if auth_url != current_url:
+        subprocess.run(
+            ["git", "remote", "set-url", "origin", auth_url],
+            cwd=case_dir, capture_output=True, env=env,
+        )
+    return True
+
+
+def commit_and_push(case_dir: str | Path, message: str) -> bool:
+    """Stage, commit, refresh origin URL with current token, and push.
+
+    Best-effort: on failure logs at WARNING and returns False, but never
+    raises. Continues to push even if the commit was a no-op (in case
+    earlier commits are unpushed).
+    """
+    case_dir = Path(case_dir)
+    if not (case_dir / ".git").exists():
+        return False
+
+    env = _git_env()
+
+    subprocess.run(["git", "add", "."], cwd=case_dir, capture_output=True, env=env)
+    commit = subprocess.run(
+        ["git", "commit", "-m", message],
+        cwd=case_dir, capture_output=True, text=True, env=env,
+    )
+    if commit.returncode != 0 and "nothing to commit" not in commit.stdout:
+        logger.warning("Git commit failed in %s: %s", case_dir, commit.stderr or commit.stdout)
+
+    if not _refresh_remote_url(case_dir, env):
+        logger.warning("No origin remote configured in %s — skipping push", case_dir)
+        return False
+
+    push = subprocess.run(
+        ["git", "push"],
+        cwd=case_dir, capture_output=True, text=True, env=env,
+    )
+    if push.returncode != 0:
+        logger.warning("Git push failed in %s: %s", case_dir, push.stderr)
+        return False
+    return True

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

@@ -72,9 +72,14 @@ OPENING_STRATEGIES = {
         ),
     },
     "betterment_levy": {
-        "style": "direct_with_disclaimer",
+        "style": "direct_factual",
         "paragraphs": (1, 3),
-        "description": "פתיחה ישירה עם מסקנה + 'על מנת לא לצאת בחסר'",
+        "description": (
+            "פתיחה ישירה ועובדתית: 'בפנינו ערר על דרישת תשלום היטל השבחה מיום [תאריך] "
+            "בסך של [סכום] ₪' → רקע קצר (נכס, תכנית משביחה, מימוש) → "
+            "תמצית טענות הצדדים (עוררים + משיבה בנפרד). "
+            "אין הקשר תכנוני רחב. הפתיחה = עובדות בלבד."
+        ),
     },
 }
 
@@ -101,9 +106,16 @@ SUMMARY_STRATEGIES = {
         ),
     },
     "betterment_levy": {
-        "heading": "סיכום",
+        "heading": "various",
-        "format": "numbered_hebrew_dry",
+        "format": "dry_operative",
-        "description": "אותיות עבריות, סיום יבש ללא פסקה חמה",
+        "description": (
+            "סיום יבש ואופרטיבי. כותרת משתנה: 'סוף דבר' / 'לאור כל האמור לעיל' / ללא כותרת. "
+            "תוכן: 'הערר נדחה/מתקבל' + הוצאות ('כל צד ישא בהוצאותיו' / חיוב בסכום). "
+            "אם מתקבל: הוראות אופרטיביות (החזר, שומה מתוקנת, תנאים). "
+            "חתימה: 'ניתנה פה אחד היום, [תאריך עברי], [תאריך לועזי].' "
+            "לעיתים: 'התיק ייסגר.' / 'עומדת זכות ערר כדין.' "
+            "אין פסקה חמה. אין חזרה על נימוקים."
+        ),
     },
 }
 
@@ -129,7 +141,12 @@ DISCUSSION_RULES: dict[str, list[str]] = {
         "מבנה ישיר: נקודות עיקריות → ניתוח → מסקנה.",
     ],
     "betterment_levy": [
-        "מבנה ישיר עם מסקנה מוקדמת + 'על מנת לא לצאת בחסר' לנקודות נוספות.",
+        "פתיחת דיון: מסקנה מוקדמת ('לאחר שבחנו... מצאנו כי דין הערר להידחות/להתקבל').",
+        "תקן ביקורת: ציון רף ההתערבות בשומה מכרעת (בר\"ם 3644/13 גלר) — אבחנה בין שמאי למשפטי.",
+        "הצגת הלכה פסוקה: ציטוט ארוך מפס\"ד מרכזי → 'ברוח הדברים לעיל נבחן את טענות הצדדים'.",
+        "טיפול שיטתי: כל טענה/סוגיה בנפרד → ניתוח → מסקנת ביניים.",
+        "ביטויים: 'אין בידינו לקבל', 'לא מצאנו מקום להתערב', 'קביעה נכונה שאין מקום להתערב בה'.",
+        "'על מנת לא לצאת בחסר' — לנקודות obiter dicta בסוף הדיון.",
     ],
 }
 
@@ -448,26 +465,41 @@ CONTENT_CHECKLISTS: dict[str, str] = {
 """,
 
     "betterment_levy": """## צ'קליסט תוכן — ערר היטל השבחה
-⚠️ שים לב: אין עדיין החלטות היטל השבחה בקורפוס האימון.
+מבוסס על ניתוח 26 החלטות של דפנה תמיר (קורפוס CMPA, אפריל 2026).
-הצ'קליסט הזה מבוסס על ידע כללי — לא על ניתוח ספציפי של סגנון דפנה.
 
-### א. המסגרת הנורמטיבית
+### א. תקן ביקורת (חובה בפתיחת הדיון)
+- ציין את רף ההתערבות: "ועדת הערר תיטה לאמץ את חוות דעתו של השמאי..."
+- אבחנה: התערבות מצומצמת בעניינים שמאיים-מקצועיים, התערבות רחבה בעניינים משפטיים
+- הפניה ל-בר"ם 3644/13 גלר או פסיקה דומה
+
+### ב. המסגרת הנורמטיבית
 - התוספת השלישית לחוק התכנון והבנייה
-- אירוע מס — מה יצר את ההשבחה?
+- סעיפי הפטור הרלוונטיים (ס' 19(ג), ס' 19(ב) וכו')
+- אירוע מס — מה יצר את ההשבחה? (תכנית, היתר, מכר)
+- מועד המימוש ומועד הקובע
 
-### ב. שומה
+### ג. שומה ומתודולוגיה שמאית
-- שיטת השומה (שומה מכרעת / שמאי מייעץ)
+- שיטת השומה (שומה מכרעת / שומה מוסכמת / שמאי מייעץ)
-- מועד הקובע
+- מבחן השימוש הטוב והיעיל (highest and best use) — מצב קודם ומצב חדש
-- זכויות בנייה — לפני ואחרי
+- זכויות בנייה — לפני ואחרי (אחוזי בנייה, שטחים עיקריים, תמהיל שימושים)
+- שווי מקרקעין — מצב קודם ומצב חדש (שיטת השוואה / יחידות תועלת)
+- עלויות עודפות (חניה, מטלות ציבוריות, תשתיות)
+- מקדמי זמינות, שיעורי הפקעה
 
-### ג. שאלות משפטיות
+### ד. שאלות משפטיות (לפי רלוונטיות)
-- פטורים (ס' 19)
+- פטורים — דירת מגורים (ס' 19(ג)(1)), שטח עד 140 מ"ר, תא משפחתי
-- מועדי תשלום
+- מועד מימוש — זיכרון דברים vs הסכם מכר, העברת זכויות
-- שיערוך
+- זהות החייב — בעלים, חוכר, יזם, חברה בבעלות יזם
+- מקרקעי ישראל — הסדרים מיוחדים (ס' 21 לתוספת השלישית)
+- שומות מוסכמות — תוקף, משמעות, "בלתי נצפה מראש"
+- פרשנות תכניות — ייעוד, שימושים מותרים, מדיניות ועדה מקומית
 
-### ד. ניתוח שמאי
+### ה. ניתוח שמאי (כשיש שומה מכרעת)
-- האם השומה תקינה?
+- האם השומה מבוססת על מסד עובדתי הולם?
-- פערים בין השומות
+- האם השיטה השמאית מקובלת?
+- האם ההנחות סבירות והגיוניות?
+- טעות מהותית / דופי חמור?
+- פגם מינהלי (ניגוד עניינים, משוא פנים)?
 """,
 }
 

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

@@ -43,14 +43,17 @@ SUBTYPES_BY_AREA: dict[str, set[str]] = {
 
 # ── Derivation ─────────────────────────────────────────────────────
 
-_FIRST_DIGIT = re.compile(r"^\s*(\d)")
-
 _APPEALS_COMMITTEE_DIGIT_TO_SUBTYPE = {
     "1": "building_permit",
     "8": "betterment_levy",
     "9": "compensation_197",
 }
 
+# Match the case number (last numeric group) in formats like:
+#   ARAR-25-8126, ARAR-24-01-8007-33, 8126/25, 1170, ערר 1024-25
+_CASE_NUM = re.compile(r"(?:ARAR[-\s]*\d{2}[-\s]*(?:\d{2}[-\s]*)?)(\d{4})", re.IGNORECASE)
+_PLAIN_NUM = re.compile(r"(\d{4})")
+
 
 def derive_subtype(case_number: str, practice_area: str = DEFAULT_PRACTICE_AREA) -> str:
     """Infer the appeal_subtype from case_number.
@@ -58,15 +61,20 @@ def derive_subtype(case_number: str, practice_area: str = DEFAULT_PRACTICE_AREA)
     For appeals_committee, the convention is:
       1xxx → building_permit, 8xxx → betterment_levy, 9xxx → compensation_197.
 
-    For other practice areas there is no public numbering convention yet,
+    Handles multiple formats: ARAR-25-8126, 8126/25, 1170, ערר 1024-25.
-    so we return 'unknown' until a real rule is defined.
     """
     if practice_area != "appeals_committee":
         return "unknown"
-    m = _FIRST_DIGIT.match(case_number or "")
+    cn = case_number or ""
+    # Try ARAR format first (extracts the 4-digit case number after year prefix)
+    m = _CASE_NUM.search(cn)
+    if not m:
+        # Fallback: first 4-digit number in the string
+        m = _PLAIN_NUM.search(cn)
     if not m:
         return "unknown"
-    return _APPEALS_COMMITTEE_DIGIT_TO_SUBTYPE.get(m.group(1), "unknown")
+    first_digit = m.group(1)[0]
+    return _APPEALS_COMMITTEE_DIGIT_TO_SUBTYPE.get(first_digit, "unknown")
 
 
 # ── Validation ─────────────────────────────────────────────────────

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

@@ -109,13 +109,24 @@ SYNTHESIS_PROMPT = """\
 """
 
 
-async def analyze_corpus() -> dict:
+async def analyze_corpus(appeal_subtype: str = "") -> dict:
     """Analyze the style corpus and extract/update patterns.
 
+    Args:
+        appeal_subtype: filter by appeal subtype (e.g. 'betterment_levy', 'building_permit').
+                        Empty string = all decisions.
+
     Returns summary of patterns found.
     """
     pool = await db.get_pool()
     async with pool.acquire() as conn:
+        if appeal_subtype:
+            rows = await conn.fetch(
+                "SELECT full_text, decision_number FROM style_corpus "
+                "WHERE appeal_subtype = $1 ORDER BY decision_date DESC LIMIT 20",
+                appeal_subtype,
+            )
+        else:
             rows = await conn.fetch(
                 "SELECT full_text, decision_number FROM style_corpus ORDER BY decision_date DESC LIMIT 20"
             )
@@ -123,8 +134,8 @@ async def analyze_corpus() -> dict:
     if not rows:
         return {"error": "אין החלטות בקורפוס. העלה החלטות קודמות תחילה."}
 
-    # Clear old patterns before re-analysis
+    # Clear old patterns for this subtype (or all if unfiltered)
-    await db.clear_style_patterns()
+    await db.clear_style_patterns(appeal_subtype)
 
     # Calculate token budget
     total_chars = sum(len(row["full_text"]) for row in rows)
@@ -136,12 +147,12 @@ async def analyze_corpus() -> dict:
     )
 
     if estimated_tokens < MAX_INPUT_TOKENS:
-        return await _analyze_single_pass(rows)
+        return await _analyze_single_pass(rows, appeal_subtype)
     else:
-        return await _analyze_multi_pass(rows)
+        return await _analyze_multi_pass(rows, appeal_subtype)
 
 
-async def _analyze_single_pass(rows) -> dict:
+async def _analyze_single_pass(rows, appeal_subtype: str = "") -> dict:
     """Send all decisions in a single API call."""
     decisions_text = ""
     for row in rows:
@@ -153,10 +164,10 @@ async def _analyze_single_pass(rows) -> dict:
         timeout=claude_session.LONG_TIMEOUT,
     )
 
-    return await _parse_and_store_patterns(raw, len(rows))
+    return await _parse_and_store_patterns(raw, len(rows), appeal_subtype)
 
 
-async def _analyze_multi_pass(rows) -> dict:
+async def _analyze_multi_pass(rows, appeal_subtype: str = "") -> dict:
     """Analyze each decision individually, then synthesize patterns."""
     all_patterns = []
 
@@ -186,7 +197,7 @@ async def _analyze_multi_pass(rows) -> dict:
         timeout=claude_session.LONG_TIMEOUT,
     )
 
-    return await _parse_and_store_patterns(raw, len(rows))
+    return await _parse_and_store_patterns(raw, len(rows), appeal_subtype)
 
 
 def _extract_json(response_text: str) -> list | None:
@@ -237,14 +248,16 @@ def _extract_json(response_text: str) -> list | None:
     return None
 
 
-async def _parse_and_store_patterns(response_text: str, num_decisions: int) -> dict:
+async def _parse_and_store_patterns(
+    response_text: str, num_decisions: int, appeal_subtype: str = "",
+) -> dict:
     """Parse Claude's response and store patterns in the database."""
     patterns = _extract_json(response_text)
 
     if patterns is None:
         return {"error": "Could not parse analysis results", "raw": response_text}
 
-    # Store patterns
+    # Store patterns tagged by appeal_subtype
     count = 0
     for pattern in patterns:
         await db.upsert_style_pattern(
@@ -252,11 +265,13 @@ async def _parse_and_store_patterns(response_text: str, num_decisions: int) -> d
             pattern_text=pattern.get("text", ""),
             context=pattern.get("context", ""),
             examples=[pattern.get("example", "")],
+            appeal_subtype=appeal_subtype,
         )
         count += 1
 
     return {
         "patterns_found": count,
         "decisions_analyzed": num_decisions,
+        "appeal_subtype": appeal_subtype or "all",
         "pattern_types": list({p.get("type") for p in patterns}),
     }

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

@@ -3,13 +3,106 @@
 from __future__ import annotations
 
 import json
+import logging
+import os
 import shutil
 import subprocess
 from pathlib import Path
 from uuid import UUID
 
+import httpx
+
 from legal_mcp import config
-from legal_mcp.services import audit, db, practice_area as pa
+from legal_mcp.services import audit, db, git_sync, practice_area as pa
+
+logger = logging.getLogger(__name__)
+
+GITEA_ORG = "cases"
+
+
+def _gitea_host() -> str:
+    return os.environ.get("GITEA_HOST", "https://gitea.nautilus.marcusgroup.org")
+
+
+def _gitea_token() -> str:
+    return os.environ.get("GITEA_ACCESS_TOKEN") or os.environ.get("GITEA_TOKEN", "")
+
+
+async def _setup_gitea_remote(case_number: str, title: str, case_dir: Path) -> bool:
+    """Create Gitea repo and configure git remote. Best-effort — returns False on failure."""
+    token = _gitea_token()
+    if not token:
+        logger.info("No GITEA_TOKEN — skipping Gitea repo creation for %s", case_number)
+        return False
+
+    try:
+        async with httpx.AsyncClient(verify=False, timeout=30) as client:
+            resp = await client.post(
+                f"{_gitea_host()}/api/v1/orgs/{GITEA_ORG}/repos",
+                headers={"Authorization": f"token {token}"},
+                json={
+                    "name": case_number,
+                    "description": f"ערר {case_number} — {title}"[:255],
+                    "private": True,
+                    "auto_init": False,
+                },
+            )
+            if resp.status_code == 409:
+                resp2 = await client.get(
+                    f"{_gitea_host()}/api/v1/repos/{GITEA_ORG}/{case_number}",
+                    headers={"Authorization": f"token {token}"},
+                )
+                resp2.raise_for_status()
+                repo = resp2.json()
+            else:
+                resp.raise_for_status()
+                repo = resp.json()
+
+        clone_url = repo.get("clone_url", "")
+        if not clone_url:
+            return False
+
+        auth_url = clone_url.replace("https://", f"https://chaim:{token}@")
+
+        git_env = {
+            "GIT_AUTHOR_NAME": "Ezer Mishpati",
+            "GIT_AUTHOR_EMAIL": "legal@local",
+            "GIT_COMMITTER_NAME": "Ezer Mishpati",
+            "GIT_COMMITTER_EMAIL": "legal@local",
+            "PATH": os.environ.get("PATH", "/usr/bin:/bin"),
+        }
+
+        # Add or update remote
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=case_dir, capture_output=True, text=True,
+        )
+        if result.returncode == 0:
+            subprocess.run(
+                ["git", "remote", "set-url", "origin", auth_url],
+                cwd=case_dir, capture_output=True, env=git_env,
+            )
+        else:
+            subprocess.run(
+                ["git", "remote", "add", "origin", auth_url],
+                cwd=case_dir, capture_output=True, env=git_env,
+            )
+
+        # Push
+        push = subprocess.run(
+            ["git", "push", "-u", "origin", "HEAD"],
+            cwd=case_dir, capture_output=True, text=True, env=git_env,
+        )
+        if push.returncode != 0:
+            logger.warning("Gitea push failed for %s: %s", case_number, push.stderr)
+            return False
+
+        logger.info("Gitea repo created and pushed for %s", case_number)
+        return True
+
+    except Exception as exc:
+        logger.warning("Gitea setup failed for %s: %s", case_number, exc)
+        return False
 
 
 async def case_create(
@@ -92,7 +185,7 @@ async def case_create(
     case_dir.mkdir(parents=True, exist_ok=True)
     docs_dir = case_dir / "documents"
     docs_dir.mkdir(exist_ok=True)
-    (docs_dir / "original").mkdir(exist_ok=True)
+    (docs_dir / "originals").mkdir(exist_ok=True)
     (docs_dir / "extracted").mkdir(exist_ok=True)
     (docs_dir / "proofread").mkdir(exist_ok=True)
     (docs_dir / "backup").mkdir(exist_ok=True)
@@ -106,7 +199,8 @@ async def case_create(
     notes_file = case_dir / "notes.md"
     notes_file.write_text(f"# הערות - תיק {case_number}\n\n{notes}\n")
 
-    # Initialize git repo
+    # Initialize git repo (best-effort)
+    try:
         subprocess.run(["git", "init"], cwd=case_dir, capture_output=True)
         subprocess.run(["git", "add", "."], cwd=case_dir, capture_output=True)
         subprocess.run(
@@ -117,6 +211,14 @@ async def case_create(
                  "GIT_COMMITTER_NAME": "Ezer Mishpati", "GIT_COMMITTER_EMAIL": "legal@local",
                  "PATH": "/usr/bin:/bin"},
         )
+    except Exception:
+        pass  # git not available — non-critical
+
+    # Create Gitea repo and configure remote (best-effort)
+    try:
+        await _setup_gitea_remote(case_number, title, case_dir)
+    except Exception:
+        pass  # Gitea not available — non-critical
 
     return json.dumps(case, default=str, ensure_ascii=False, indent=2)
 
@@ -175,12 +277,26 @@ async def case_update(
     """
     from datetime import date as date_type
 
+    # Ordered workflow statuses — regression protection
+    STATUS_ORDER = [
+        "new", "uploading", "processing", "documents_ready",
+        "analyst_verified", "research_complete", "outcome_set",
+        "brainstorming", "direction_approved", "analysis_enriched", "ready_for_writing",
+        "drafting", "qa_review", "drafted",
+        "exported", "reviewed", "final",
+    ]
+
     case = await db.get_case_by_number(case_number)
     if not case:
         return f"תיק {case_number} לא נמצא."
 
     fields = {}
     if status:
+        current = case.get("status", "")
+        cur_idx = STATUS_ORDER.index(current) if current in STATUS_ORDER else -1
+        new_idx = STATUS_ORDER.index(status) if status in STATUS_ORDER else -1
+        # Only update if advancing or status is unknown to the order
+        if new_idx >= cur_idx or new_idx == -1:
             fields["status"] = status
     if title:
         fields["title"] = title
@@ -199,20 +315,15 @@ async def case_update(
 
     updated = await db.update_case(UUID(case["id"]), **fields)
 
-    # Git commit the update
+    # Git commit + push the update (best-effort)
+    try:
         case_dir = config.find_case_dir(case_number)
         if case_dir.exists():
             case_json = case_dir / "case.json"
             case_json.write_text(json.dumps(updated, default=str, ensure_ascii=False, indent=2))
-        subprocess.run(["git", "add", "case.json"], cwd=case_dir, capture_output=True)
+            git_sync.commit_and_push(case_dir, f"עדכון תיק: {', '.join(fields.keys())}")
-        subprocess.run(
+    except Exception:
-            ["git", "commit", "-m", f"עדכון תיק: {', '.join(fields.keys())}"],
+        pass  # git not available — non-critical
-            cwd=case_dir,
-            capture_output=True,
-            env={"GIT_AUTHOR_NAME": "Ezer Mishpati", "GIT_AUTHOR_EMAIL": "legal@local",
-                 "GIT_COMMITTER_NAME": "Ezer Mishpati", "GIT_COMMITTER_EMAIL": "legal@local",
-                 "PATH": "/usr/bin:/bin"},
-        )
 
     return json.dumps(updated, default=str, ensure_ascii=False, indent=2)
 

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

@@ -4,12 +4,11 @@ from __future__ import annotations
 
 import json
 import shutil
-import subprocess
 from pathlib import Path
 from uuid import UUID
 
 from legal_mcp import config
-from legal_mcp.services import db, processor
+from legal_mcp.services import db, git_sync, processor
 
 
 async def document_upload(
@@ -67,10 +66,10 @@ async def document_upload(
             await db.update_document(UUID(doc["id"]), doc_type=classified_type)
             doc["doc_type"] = classified_type
 
-    # Git commit
+    # Git commit + push (best-effort — don't fail upload on git errors)
+    try:
         repo_dir = config.find_case_dir(case_number)
         if repo_dir.exists():
-        subprocess.run(["git", "add", "."], cwd=repo_dir, capture_output=True)
             doc_type_hebrew = {
                 "appeal": "כתב ערר",
                 "response": "תשובה",
@@ -84,14 +83,9 @@ async def document_upload(
                 "exhibit": "נספח",
                 "reference": "מסמך עזר",
             }.get(actual_doc_type, actual_doc_type)
-        subprocess.run(
+            git_sync.commit_and_push(repo_dir, f"הוספת {doc_type_hebrew}: {title}")
-            ["git", "commit", "-m", f"הוספת {doc_type_hebrew}: {title}"],
+    except Exception:
-            cwd=repo_dir,
+        pass  # git not available in container — non-critical
-            capture_output=True,
-            env={"GIT_AUTHOR_NAME": "Ezer Mishpati", "GIT_AUTHOR_EMAIL": "legal@local",
-                 "GIT_COMMITTER_NAME": "Ezer Mishpati", "GIT_COMMITTER_EMAIL": "legal@local",
-                 "PATH": "/usr/bin:/bin"},
-        )
 
     return json.dumps({
         "document": doc,
@@ -136,14 +130,22 @@ async def document_upload_training(
         appeal_subtype = pa.derive_subtype(decision_number, practice_area)
     pa.validate(practice_area, appeal_subtype)
 
-    # Copy to training directory (skip if already there)
+    # Copy to training directory, organized by subtype
-    config.TRAINING_DIR.mkdir(parents=True, exist_ok=True)
+    _SUBTYPE_DIRS = {
-    dest = config.TRAINING_DIR / source.name
+        "betterment_levy": "cmpa",
+        "compensation_197": "cmpa",
+        "building_permit": "cmp",
+    }
+    subdir = _SUBTYPE_DIRS.get(appeal_subtype, "")
+    training_dest = config.TRAINING_DIR / subdir if subdir else config.TRAINING_DIR
+    training_dest.mkdir(parents=True, exist_ok=True)
+    dest = training_dest / source.name
     if source.resolve() != dest.resolve():
         shutil.copy2(str(source), str(dest))
 
-    # Extract text
+    # Extract text and strip Nevo preamble
     text, page_count = await extractor.extract_text(str(dest))
+    text = extractor.strip_nevo_preamble(text)
 
     # Parse date
     d_date = None
@@ -171,11 +173,12 @@ async def document_upload_training(
             title=f"[קורפוס] {title}",
             file_path=str(dest),
             page_count=page_count,
-            practice_area=practice_area,
-            appeal_subtype=appeal_subtype,
         )
         doc_id = UUID(doc["id"])
-        await db.update_document(doc_id, extracted_text=text, extraction_status="completed")
+        await db.update_document(
+            doc_id, extracted_text=text, extraction_status="completed",
+            metadata={"practice_area": practice_area, "appeal_subtype": appeal_subtype},
+        )
 
         # Generate embeddings and store chunks
         texts = [c.content for c in chunks]
@@ -190,10 +193,7 @@ async def document_upload_training(
             }
             for c, emb in zip(chunks, embs)
         ]
-        await db.store_chunks(
+        await db.store_chunks(doc_id, None, chunk_dicts)
-            doc_id, None, chunk_dicts,
-            practice_area=practice_area, appeal_subtype=appeal_subtype,
-        )
 
     return json.dumps({
         "corpus_id": str(corpus_id),
@@ -383,3 +383,98 @@ async def get_claims(case_number: str, party_role: str = "") -> str:
         })
 
     return json.dumps(formatted, default=str, ensure_ascii=False, indent=2)
+
+
+# Whitelist of doc_type values; mirrors web/app.py:DOC_TYPE_NAMES.
+ALLOWED_DOC_TYPES = {
+    "appeal", "response", "protocol", "plan", "decision",
+    "court_decision", "permit", "appraisal", "exhibit",
+    "objection", "reference",
+}
+
+# Allowed appraiser_side values; '' (empty) clears the tag.
+ALLOWED_APPRAISER_SIDES = {"committee", "appellant", "deciding", ""}
+
+
+async def document_update(
+    case_number: str,
+    doc_id: str,
+    doc_type: str = "",
+    appraiser_side: str = "",
+) -> str:
+    """עדכון תיוג מסמך — doc_type ו/או appraiser_side. ריק = אין שינוי.
+
+    הולידציה זהה ל-PATCH endpoint ב-web/app.py. appraiser_side נשמר ב-
+    documents.metadata JSONB (מתפרסם משם ע"י extract_appraiser_facts).
+
+    Args:
+        case_number: מספר תיק הערר (לאישור שייכות)
+        doc_id: UUID של המסמך
+        doc_type: ערך חדש (appeal/response/protocol/plan/decision/court_decision/
+                  permit/appraisal/exhibit/objection/reference). ריק = אין שינוי.
+        appraiser_side: ערך חדש (committee/appellant/deciding). ריק = אין שינוי;
+                        העבר במפורש מחרוזת ריקה לא-default אם רוצים לנקות.
+    """
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+
+    try:
+        doc_uuid = UUID(doc_id)
+    except ValueError:
+        return json.dumps({"status": "error",
+                           "message": f"doc_id לא תקין: {doc_id}"},
+                          ensure_ascii=False, indent=2)
+
+    doc = await db.get_document(doc_uuid)
+    if not doc:
+        return json.dumps({"status": "error",
+                           "message": f"מסמך {doc_id} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+
+    if doc.get("case_id") != case["id"]:
+        return json.dumps({"status": "error",
+                           "message": f"מסמך {doc_id} לא שייך לתיק {case_number}."},
+                          ensure_ascii=False, indent=2)
+
+    updates: dict = {}
+
+    if doc_type:
+        if doc_type not in ALLOWED_DOC_TYPES:
+            return json.dumps({
+                "status": "error",
+                "message": f"doc_type לא תקין: {doc_type}",
+                "allowed": sorted(ALLOWED_DOC_TYPES),
+            }, ensure_ascii=False, indent=2)
+        updates["doc_type"] = doc_type
+
+    # appraiser_side is optional. The MCP tool can't distinguish "skip" from
+    # "set to empty string", so we use the convention: only update if non-empty.
+    # To clear, the operator must edit metadata directly (rare).
+    if appraiser_side:
+        if appraiser_side not in ALLOWED_APPRAISER_SIDES:
+            return json.dumps({
+                "status": "error",
+                "message": f"appraiser_side לא תקין: {appraiser_side}",
+                "allowed": sorted(s for s in ALLOWED_APPRAISER_SIDES if s),
+            }, ensure_ascii=False, indent=2)
+        metadata = doc.get("metadata") or {}
+        if isinstance(metadata, str):
+            metadata = json.loads(metadata)
+        metadata["appraiser_side"] = appraiser_side
+        updates["metadata"] = metadata
+
+    if not updates:
+        return json.dumps({"status": "noop", "message": "אין שינוי לבצע."},
+                          ensure_ascii=False, indent=2)
+
+    await db.update_document(doc_uuid, **updates)
+    fresh = await db.get_document(doc_uuid)
+    return json.dumps({
+        "status": "completed",
+        "doc_id": doc_id,
+        "doc_type": fresh.get("doc_type"),
+        "metadata": fresh.get("metadata"),
+    }, default=str, ensure_ascii=False, indent=2)

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

@@ -384,6 +384,9 @@ async def validate_decision(case_number: str) -> str:
 async def export_docx(case_number: str, output_path: str = "") -> str:
     """ייצוא החלטה לקובץ DOCX מעוצב — גופן David, RTL, כותרות, מספור סעיפים.
 
+    הקובץ נוצר עם bookmarks ב-12 הבלוקים (אנקורים ל-revisions עתידיים),
+    ומסומן כ-active_draft_path של התיק.
+
     Args:
         case_number: מספר תיק הערר
         output_path: נתיב לשמירה (אופציונלי — ברירת מחדל: תיקיית התיק)
@@ -398,9 +401,12 @@ async def export_docx(case_number: str, output_path: str = "") -> str:
 
     try:
         path = await docx_exporter.export_decision(case_id, output_path or None)
+        # Register this export as the new source of truth
+        await db.set_active_draft_path(case_id, path)
         return json.dumps({
             "status": "completed",
             "path": path,
+            "active_draft_path": path,
             "message": f"DOCX נוצר: {path}",
         }, ensure_ascii=False, indent=2)
     except ValueError as e:
@@ -410,6 +416,288 @@ async def export_docx(case_number: str, output_path: str = "") -> str:
         }, ensure_ascii=False, indent=2)
 
 
+# ── Interim draft (pre-ruling) ────────────────────────────────────
+
+# Blocks written for the interim draft, in display order.
+# This is the same content the chair sees in the final decision (same template,
+# same skill, same prompts) — minus opening, ruling, summary, signatures.
+_INTERIM_BLOCKS = ["block-vav", "block-tet", "block-zayin", "block-chet"]
+
+
+async def extract_appraiser_facts(case_number: str) -> str:
+    """חילוץ תכניות והיתרים מכל השומות בתיק וזיהוי סתירות בין שמאים.
+
+    משמש כהכנה לטיוטת ביניים: בלוק ט (תכניות חלות) זקוק לעובדות מובנות
+    כדי לפרט תת-פרק היתרים ולסמן סתירות בנוסח ניטרלי.
+
+    Args:
+        case_number: מספר תיק הערר
+    """
+    from legal_mcp.services import appraiser_facts_extractor
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+    case_id = UUID(case["id"])
+    try:
+        result = await appraiser_facts_extractor.extract_appraiser_facts(case_id)
+        return json.dumps(result, default=str, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)},
+                          ensure_ascii=False, indent=2)
+
+
+async def write_interim_draft(case_number: str, instructions: str = "") -> str:
+    """כתיבת ארבעת הבלוקים לטיוטת ביניים: רקע (ו), תכניות+היתרים (ט),
+    טענות הצדדים (ז), הליכים (ח). אם לא חולצו עובדות שמאיות עדיין —
+    מריץ extract_appraiser_facts קודם כדי שבלוק ט יקבל פרק היתרים תקף.
+
+    הבלוקים נכתבים באותו skill, אותם prompts ואותו טמפלט כמו בטיוטה רגילה —
+    הסדר משתנה רק בעת הייצוא ל-DOCX (ראה export_interim_draft).
+
+    Args:
+        case_number: מספר תיק הערר
+        instructions: הנחיות נוספות (לכל הבלוקים)
+    """
+    from legal_mcp.services import appraiser_facts_extractor, block_writer
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+    case_id = UUID(case["id"])
+
+    # Make sure appraiser facts exist before writing block-tet (which depends on them).
+    facts = await db.list_appraiser_facts(case_id)
+    facts_run: dict | None = None
+    if not facts:
+        try:
+            facts_run = await appraiser_facts_extractor.extract_appraiser_facts(case_id)
+        except Exception as e:
+            facts_run = {"status": "error", "message": str(e)}
+
+    results = []
+    for bid in _INTERIM_BLOCKS:
+        try:
+            r = await block_writer.write_and_store_block(case_id, bid, instructions)
+            results.append({
+                "block_id": bid,
+                "title": r["title"],
+                "word_count": r["word_count"],
+                "status": "completed",
+            })
+        except Exception as e:
+            results.append({
+                "block_id": bid,
+                "status": "error",
+                "error": str(e),
+            })
+
+    return json.dumps({
+        "status": "completed",
+        "blocks": results,
+        "appraiser_facts_run": facts_run,
+        "total_words": sum(r.get("word_count", 0) for r in results),
+        "completed": sum(1 for r in results if r["status"] == "completed"),
+    }, default=str, ensure_ascii=False, indent=2)
+
+
+async def export_interim_draft(case_number: str, output_path: str = "") -> str:
+    """ייצוא טיוטת ביניים ל-DOCX — אותו עיצוב של טיוטה רגילה (David, RTL,
+    bookmarks), אבל בסדר חדש: רקע → תכניות+היתרים → טענות → הליכים, ללא
+    דיון/סיכום/חתימות. שם הקובץ: טיוטת-ביניים-v{N}.docx.
+
+    Args:
+        case_number: מספר תיק הערר
+        output_path: נתיב לשמירה (אופציונלי)
+    """
+    from legal_mcp.services import docx_exporter
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+    case_id = UUID(case["id"])
+
+    try:
+        path = await docx_exporter.export_decision(
+            case_id, output_path or None, mode="interim",
+        )
+        await db.set_active_draft_path(case_id, path)
+        return json.dumps({
+            "status": "completed",
+            "mode": "interim",
+            "path": path,
+            "active_draft_path": path,
+            "message": f"טיוטת ביניים נוצרה: {path}",
+        }, ensure_ascii=False, indent=2)
+    except ValueError as e:
+        return json.dumps({"status": "error", "message": str(e)},
+                          ensure_ascii=False, indent=2)
+
+
+async def apply_user_edit(case_number: str, edit_filename: str) -> str:
+    """רישום עריכה שהעלה המשתמש כמקור האמת החדש של התיק.
+
+    התהליך:
+    1. מאתר את הקובץ `עריכה-v*.docx` בתיקיית ה-exports
+    2. מזריק bookmarks רטרואקטיבית (אם אין) דרך docx_retrofit
+    3. מעדכן את cases.active_draft_path
+
+    Args:
+        case_number: מספר תיק הערר
+        edit_filename: שם הקובץ (למשל "עריכה-v1.docx") או נתיב מלא
+    """
+    from legal_mcp.services import docx_retrofit
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+
+    case_id = UUID(case["id"])
+    export_dir = config.find_case_dir(case_number) / "exports"
+    edit_path = export_dir / edit_filename if "/" not in edit_filename else Path(edit_filename)
+    if not edit_path.exists():
+        return json.dumps({"status": "error",
+                           "message": f"קובץ לא נמצא: {edit_path}"},
+                          ensure_ascii=False, indent=2)
+
+    try:
+        retrofit_result = docx_retrofit.retrofit_bookmarks(edit_path)
+        await db.set_active_draft_path(case_id, str(edit_path))
+        return json.dumps({
+            "status": "completed",
+            "active_draft_path": str(edit_path),
+            "bookmarks_added": retrofit_result.get("bookmarks_added", []),
+            "missing_blocks": retrofit_result.get("missing_blocks", []),
+            "structural_fallback": retrofit_result.get("structural_fallback", []),
+            "existing_bookmarks": retrofit_result.get("existing_bookmarks", []),
+        }, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)},
+                          ensure_ascii=False, indent=2)
+
+
+async def list_bookmarks(case_number: str) -> str:
+    """רשימת bookmarks הקיימים ב-active_draft של התיק.
+
+    משמש לסוכנים כדי לדעת אילו אנקורים זמינים לפני שליחת revisions.
+    """
+    from legal_mcp.services import docx_reviser
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+
+    active_path = await db.get_active_draft_path(UUID(case["id"]))
+    if not active_path or not Path(active_path).exists():
+        return json.dumps({"status": "no_active_draft",
+                           "message": "לא נמצא active_draft. הרץ ייצוא או העלה עריכה."},
+                          ensure_ascii=False, indent=2)
+
+    try:
+        names = docx_reviser.list_bookmarks(active_path)
+        return json.dumps({
+            "status": "completed",
+            "active_draft_path": active_path,
+            "bookmarks": names,
+        }, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)},
+                          ensure_ascii=False, indent=2)
+
+
+async def revise_draft(case_number: str, revisions_json: str,
+                       author: str = "מערכת AI") -> str:
+    """החלת revisions מסומנים כ-Track Changes על ה-active_draft של התיק.
+
+    יוצר קובץ חדש `טיוטה-v{N+1}.docx` (מגרסה הבאה בתור), ומעדכן את
+    active_draft_path אליו.
+
+    Args:
+        case_number: מספר תיק הערר
+        revisions_json: JSON string של array עם אובייקטים:
+            [{"id": "r1", "type": "insert_after"|"insert_before"|"replace"|"delete",
+              "anchor_bookmark": "block-yod", "content": "...", "style": "body"|"heading"|"quote",
+              "reason": "..."}, ...]
+        author: מחרוזת המחבר שתופיע ב-Track Changes
+    """
+    from legal_mcp.services import docx_reviser
+
+    case = await db.get_case_by_number(case_number)
+    if not case:
+        return json.dumps({"status": "error",
+                           "message": f"תיק {case_number} לא נמצא."},
+                          ensure_ascii=False, indent=2)
+
+    case_id = UUID(case["id"])
+    active_path = await db.get_active_draft_path(case_id)
+    if not active_path or not Path(active_path).exists():
+        return json.dumps({"status": "error",
+                           "message": "אין active_draft. הרץ ייצוא או apply_user_edit קודם."},
+                          ensure_ascii=False, indent=2)
+
+    try:
+        raw = json.loads(revisions_json) if isinstance(revisions_json, str) else revisions_json
+    except json.JSONDecodeError as e:
+        return json.dumps({"status": "error", "message": f"JSON לא תקף: {e}"},
+                          ensure_ascii=False, indent=2)
+
+    revisions = []
+    for item in raw:
+        revisions.append(docx_reviser.Revision(
+            id=item.get("id", ""),
+            type=item["type"],
+            anchor_bookmark=item["anchor_bookmark"],
+            content=item.get("content", ""),
+            style=item.get("style", "body"),
+            reason=item.get("reason", ""),
+            anchor_position=item.get("anchor_position", "end"),
+        ))
+
+    # Determine output path — next טיוטה-v{N}.docx
+    export_dir = config.find_case_dir(case_number) / "exports"
+    export_dir.mkdir(parents=True, exist_ok=True)
+    existing = list(export_dir.glob("טיוטה-v*.docx"))
+    next_ver = 1
+    for p in existing:
+        try:
+            ver = int(p.stem.split("-v")[1])
+            next_ver = max(next_ver, ver + 1)
+        except (IndexError, ValueError):
+            pass
+    output_path = export_dir / f"טיוטה-v{next_ver}.docx"
+
+    try:
+        result = docx_reviser.apply_tracked_revisions(
+            active_path, output_path, revisions, author=author,
+        )
+        await db.set_active_draft_path(case_id, str(output_path))
+        return json.dumps({
+            "status": "completed",
+            "output_path": str(output_path),
+            "version": next_ver,
+            "applied": result.applied,
+            "failed": result.failed,
+            "active_draft_path": str(output_path),
+            "results": [
+                {"id": r.id, "status": r.status, "error": r.error}
+                for r in result.results
+            ],
+        }, ensure_ascii=False, indent=2)
+    except Exception as e:
+        return json.dumps({"status": "error", "message": str(e)},
+                          ensure_ascii=False, indent=2)
+
+
 async def get_block_context(case_number: str, block_id: str, instructions: str = "") -> str:
     """קבלת הקשר מלא לכתיבת בלוק — ללא קריאה ל-API. Claude Code כותב את הבלוק.
 
@@ -454,11 +742,16 @@ async def save_block_content(case_number: str, block_id: str, content: str) -> s
         return str(e)
 
 
-async def analyze_style() -> str:
+async def analyze_style(appeal_subtype: str = "") -> str:
-    """הרצת ניתוח סגנון על קורפוס ההחלטות של דפנה. מחלץ דפוסי כתיבה ושומר אותם."""
+    """הרצת ניתוח סגנון על קורפוס ההחלטות של דפנה. מחלץ דפוסי כתיבה ושומר אותם.
+
+    Args:
+        appeal_subtype: סינון לפי סוג ערר (building_permit / betterment_levy / compensation_197).
+                        ריק = כל ההחלטות.
+    """
     from legal_mcp.services.style_analyzer import analyze_corpus
 
-    result = await analyze_corpus()
+    result = await analyze_corpus(appeal_subtype)
     return json.dumps(result, ensure_ascii=False, indent=2)
 
 

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

@@ -52,7 +52,7 @@ async def precedent_attach(
         pdf_document_id=pdf_uuid,
         practice_area=case.get("practice_area"),
     )
-    return json.dumps(row, ensure_ascii=False, indent=2)
+    return json.dumps(row, ensure_ascii=False, indent=2, default=str)
 
 
 async def precedent_list(case_number: str) -> str:
@@ -62,7 +62,7 @@ async def precedent_list(case_number: str) -> str:
         return json.dumps({"error": f"תיק {case_number} לא נמצא."}, ensure_ascii=False)
 
     rows = await db.list_case_precedents(UUID(case["id"]))
-    return json.dumps(rows, ensure_ascii=False, indent=2)
+    return json.dumps(rows, ensure_ascii=False, indent=2, default=str)
 
 
 async def precedent_remove(precedent_id: str) -> str:
@@ -92,4 +92,4 @@ async def precedent_search_library(
         return json.dumps([], ensure_ascii=False)
 
     rows = await db.search_precedent_library(query.strip(), practice_area, limit)
-    return json.dumps(rows, ensure_ascii=False, indent=2)
+    return json.dumps(rows, ensure_ascii=False, indent=2, default=str)

mcp-server/tests/test_docx_exporter_bookmarks.py

@@ -0,0 +1,227 @@
+"""בדיקות ל-bookmark helpers ב-docx_exporter.
+
+הבדיקות מתרכזות ב-helper functions בלבד (לא בכל ה-export flow שדורש DB).
+"""
+
+from __future__ import annotations
+
+import zipfile
+from pathlib import Path
+
+from docx import Document
+from lxml import etree
+
+from legal_mcp.services.docx_exporter import (
+    _BOOKMARK_ID_START,
+    HEBREW_FONT,
+    _add_styled_paragraph,
+    _insert_bookmark_end,
+    _insert_bookmark_start,
+    _mark_paragraph_rtl,
+    _mark_run_rtl,
+    _strip_dashes,
+    _wrap_block_with_bookmarks,
+    _write_block_to_docx,
+)
+from legal_mcp.services.docx_reviser import NSMAP, _w, list_bookmarks
+
+from docx.oxml.ns import qn
+
+
+def test_insert_bookmark_helpers_create_valid_xml(tmp_path: Path) -> None:
+    doc = Document()
+    p = doc.add_paragraph("תוכן בלוק י")
+    _insert_bookmark_start(p, "block-yod", 10001)
+    _insert_bookmark_end(p, 10001)
+
+    out = tmp_path / "out.docx"
+    doc.save(str(out))
+
+    # Verify via list_bookmarks (uses the same XML)
+    assert list_bookmarks(out) == ["block-yod"]
+
+
+def test_wrap_block_with_bookmarks_wraps_multiple_paragraphs(tmp_path: Path) -> None:
+    doc = Document()
+    doc.add_paragraph("ראשון — לפני")  # noise before
+
+    bm_counter = [_BOOKMARK_ID_START]
+
+    def writer() -> None:
+        doc.add_paragraph("בלוק — פסקה 1")
+        doc.add_paragraph("בלוק — פסקה 2")
+        doc.add_paragraph("בלוק — פסקה 3")
+
+    _wrap_block_with_bookmarks(doc, "block-yod", writer, bm_counter)
+    doc.add_paragraph("אחרי — אחרון")  # noise after
+
+    out = tmp_path / "out.docx"
+    doc.save(str(out))
+
+    # The bookmark should wrap exactly the 3 middle paragraphs
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+
+    paragraphs = tree.findall(".//w:p", NSMAP)
+    # Find para index of bookmarkStart and bookmarkEnd
+    start_idx = end_idx = None
+    for i, p in enumerate(paragraphs):
+        if p.find(".//w:bookmarkStart", NSMAP) is not None:
+            start_idx = i
+        if p.find(".//w:bookmarkEnd", NSMAP) is not None:
+            end_idx = i
+    assert start_idx is not None
+    assert end_idx is not None
+    # The paragraph containing start must be the first new one ("פסקה 1")
+    start_text = "".join(paragraphs[start_idx].itertext())
+    end_text = "".join(paragraphs[end_idx].itertext())
+    assert "פסקה 1" in start_text
+    assert "פסקה 3" in end_text
+
+
+def test_wrap_block_skipped_when_writer_adds_nothing(tmp_path: Path) -> None:
+    doc = Document()
+    bm_counter = [_BOOKMARK_ID_START]
+    _wrap_block_with_bookmarks(doc, "block-empty", lambda: None, bm_counter)
+    out = tmp_path / "out.docx"
+    doc.save(str(out))
+    assert list_bookmarks(out) == []
+
+
+def test_multiple_blocks_get_unique_bookmark_ids(tmp_path: Path) -> None:
+    doc = Document()
+    bm_counter = [_BOOKMARK_ID_START]
+    for name in ("block-alef", "block-bet", "block-gimel"):
+        _wrap_block_with_bookmarks(
+            doc, name,
+            lambda n=name: doc.add_paragraph(f"תוכן של {n}"),
+            bm_counter,
+        )
+    out = tmp_path / "out.docx"
+    doc.save(str(out))
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+
+    ids = [el.get(_w("id")) for el in tree.iterfind(".//w:bookmarkStart", NSMAP)]
+    assert len(ids) == 3
+    assert len(set(ids)) == 3
+
+    names = list_bookmarks(out)
+    assert set(names) == {"block-alef", "block-bet", "block-gimel"}
+
+
+# ── RTL / David-font invariants ───────────────────────────────────
+# These guard against regressions where Hebrew renders LTR or in the wrong
+# font slot (Times New Roman instead of David). See plan file for context.
+
+
+def test_mark_paragraph_rtl_adds_bidi_directly_in_pPr() -> None:
+    doc = Document()
+    p = doc.add_paragraph("טקסט בעברית")
+    _mark_paragraph_rtl(p)
+    pPr = p._p.find(qn("w:pPr"))
+    assert pPr is not None
+    # <w:bidi/> must be a direct child of pPr (paragraph direction),
+    # NOT nested inside <w:rPr>.
+    assert pPr.find(qn("w:bidi")) is not None
+    # paragraph-mark rPr still gets <w:rtl/>
+    rPr = pPr.find(qn("w:rPr"))
+    assert rPr is not None and rPr.find(qn("w:rtl")) is not None
+
+
+def test_mark_run_rtl_forces_david_on_all_font_slots() -> None:
+    doc = Document()
+    p = doc.add_paragraph()
+    run = p.add_run("טקסט")
+    _mark_run_rtl(run)
+    rPr = run._r.find(qn("w:rPr"))
+    assert rPr is not None
+    fonts = rPr.find(qn("w:rFonts"))
+    assert fonts is not None
+    for slot in ("w:ascii", "w:hAnsi", "w:cs", "w:eastAsia"):
+        assert fonts.get(qn(slot)) == HEBREW_FONT, f"{slot} not {HEBREW_FONT}"
+    assert rPr.find(qn("w:rtl")) is not None
+
+
+def test_styled_paragraph_applies_bidi_and_david() -> None:
+    """End-to-end: _add_styled_paragraph produces pPr/bidi + rFonts/cs=David."""
+    doc = Document()
+    _add_styled_paragraph(doc, "פסקה עברית", style="Normal")
+    p = doc.paragraphs[-1]
+    assert p._p.find(qn("w:pPr")).find(qn("w:bidi")) is not None
+    run = p.runs[0]
+    fonts = run._r.find(qn("w:rPr")).find(qn("w:rFonts"))
+    assert fonts.get(qn("w:cs")) == HEBREW_FONT
+
+
+def test_block_dalet_does_not_use_title_style() -> None:
+    """Title style uses theme fonts and 28pt — avoid for Hebrew."""
+    doc = Document()
+    _write_block_to_docx(doc, "block-dalet", title="", content="")
+    styles_used = {p.style.name for p in doc.paragraphs}
+    assert "Title" not in styles_used, (
+        f"block-dalet should not produce a Title-styled paragraph, got {styles_used}"
+    )
+    # The 'החלטה' text must still appear somewhere
+    texts = [p.text for p in doc.paragraphs]
+    assert any("החלטה" in t for t in texts)
+
+
+# ── Heading overrides, numbered-list, dash strip ──────────────────
+
+
+def test_strip_dashes_removes_em_and_en_dashes() -> None:
+    assert _strip_dashes("תכנית 1454198 — אושרה ביום") == "תכנית 1454198 אושרה ביום"
+    assert _strip_dashes("א – ב") == "א ב"
+    assert _strip_dashes("no dash") == "no dash"
+    # Collapsed whitespace
+    assert _strip_dashes("רקע  —  עובדתי") == "רקע עובדתי"
+
+
+def test_heading2_gets_justified_and_no_numbering() -> None:
+    """Section heading → Heading 2 with jc=both and numId=0."""
+    doc = Document()
+    _write_block_to_docx(doc, "block-vav", title="", content="דיון והכרעה")
+    heading = next(p for p in doc.paragraphs if p.style.name == "Heading 2")
+    pPr = heading._p.find(qn("w:pPr"))
+    jc = pPr.find(qn("w:jc"))
+    assert jc is not None and jc.get(qn("w:val")) == "both"
+    numPr = pPr.find(qn("w:numPr"))
+    assert numPr is not None
+    numId = numPr.find(qn("w:numId"))
+    assert numId is not None and numId.get(qn("w:val")) == "0"
+
+
+def test_heading3_gets_justified_not_centered() -> None:
+    """Heading 3 in template has jc=center — override to jc=both."""
+    doc = Document()
+    _write_block_to_docx(doc, "block-vav", title="", content="**המצב התכנוני**")
+    heading = next(p for p in doc.paragraphs if p.style.name == "Heading 3")
+    jc = heading._p.find(qn("w:pPr")).find(qn("w:jc"))
+    assert jc is not None and jc.get(qn("w:val")) == "both"
+
+
+def test_numbered_paragraph_uses_list_paragraph_and_strips_prefix() -> None:
+    """'1. text' → List Paragraph style, literal '1. ' removed."""
+    doc = Document()
+    _write_block_to_docx(
+        doc, "block-vav", title="",
+        content="1. עניינו של ערר זה.\n2. שכונת נווה יעקב.",
+    )
+    lp = [p for p in doc.paragraphs if p.style.name == "List Paragraph"]
+    assert len(lp) == 2
+    assert lp[0].text.startswith("עניינו")
+    assert not lp[0].text.startswith("1.")
+    assert lp[1].text.startswith("שכונת")
+
+
+def test_body_content_has_no_em_dashes() -> None:
+    """Content with em-dashes is rendered without them."""
+    doc = Document()
+    _write_block_to_docx(
+        doc, "block-vav", title="",
+        content="3. תכנית 5924 — קובעת את שטחי הבנייה.",
+    )
+    texts = "\n".join(p.text for p in doc.paragraphs)
+    assert "—" not in texts

mcp-server/tests/test_docx_retrofit.py

@@ -0,0 +1,219 @@
+"""בדיקות docx_retrofit — הזרקת bookmarks רטרואקטיבית."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from docx import Document
+
+from legal_mcp.services.docx_retrofit import (
+    BLOCK_ORDER,
+    retrofit_bookmarks,
+)
+from legal_mcp.services.docx_reviser import list_bookmarks
+
+
+def _make_docx_with_hebrew_blocks(path: Path, markers: list[str]) -> None:
+    """Create a DOCX where each paragraph starts with a Hebrew block marker."""
+    doc = Document()
+    for marker in markers:
+        doc.add_paragraph(f"{marker}. תוכן הבלוק שמתחיל ב-{marker}")
+        doc.add_paragraph(f"עוד פסקה בבלוק {marker}")
+    doc.save(str(path))
+
+
+def test_retrofit_detects_all_standard_blocks(tmp_path: Path) -> None:
+    src = tmp_path / "src.docx"
+    _make_docx_with_hebrew_blocks(
+        src, ["א", "ב", "ג", "ד", "ה", "ו", "ז", "ח", "ט", "י", "יא", "יב"],
+    )
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert len(result["bookmarks_added"]) == 12
+    assert result["missing_blocks"] == []
+
+    names = list_bookmarks(src)
+    expected = {name for name, _ in BLOCK_ORDER}
+    assert set(names) == expected
+
+
+def test_retrofit_reports_missing_blocks(tmp_path: Path) -> None:
+    src = tmp_path / "src.docx"
+    # Only 4 blocks present
+    _make_docx_with_hebrew_blocks(src, ["א", "ב", "ג", "ד"])
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert result["bookmarks_added"] == [
+        "block-alef", "block-bet", "block-gimel", "block-dalet",
+    ]
+    assert "block-heh" in result["missing_blocks"]
+    assert "block-yod-bet" in result["missing_blocks"]
+
+
+def test_retrofit_distinguishes_yod_from_yod_alef_yod_bet(tmp_path: Path) -> None:
+    """י, יא, יב must all be distinguished — longer markers win."""
+    src = tmp_path / "src.docx"
+    _make_docx_with_hebrew_blocks(src, ["ט", "י", "יא", "יב"])
+
+    result = retrofit_bookmarks(src, backup=False)
+    # The four content blocks must all be detected; cover blocks added via fallback.
+    assert {"block-tet", "block-yod", "block-yod-alef", "block-yod-bet"} <= set(
+        result["bookmarks_added"]
+    )
+
+
+def test_retrofit_skips_existing_bookmarks(tmp_path: Path) -> None:
+    """Running retrofit twice doesn't duplicate bookmarks."""
+    src = tmp_path / "src.docx"
+    _make_docx_with_hebrew_blocks(src, ["א", "ב"])
+
+    first = retrofit_bookmarks(src, backup=False)
+    # alef/bet from markers; gimel/dalet from cover-block fallback
+    assert {"block-alef", "block-bet"} <= set(first["bookmarks_added"])
+
+    second = retrofit_bookmarks(src, backup=False)
+    assert second["bookmarks_added"] == []  # nothing new
+    # All previously added bookmarks now exist on the document
+    assert set(first["bookmarks_added"]) <= set(second["existing_bookmarks"])
+
+
+def test_retrofit_creates_backup(tmp_path: Path) -> None:
+    src = tmp_path / "file.docx"
+    _make_docx_with_hebrew_blocks(src, ["א", "ב"])
+    retrofit_bookmarks(src)  # backup=True (default)
+    backup = src.with_suffix(".pre-retrofit.docx")
+    assert backup.exists()
+
+
+def test_retrofit_to_different_output_path_no_backup(tmp_path: Path) -> None:
+    src = tmp_path / "src.docx"
+    out = tmp_path / "out.docx"
+    _make_docx_with_hebrew_blocks(src, ["א", "ב"])
+    retrofit_bookmarks(src, output_path=out)
+    # source untouched
+    assert list_bookmarks(src) == []
+    # output has bookmarks (alef+bet from markers; gimel+dalet via fallback)
+    assert {"block-alef", "block-bet"} <= set(list_bookmarks(out))
+
+
+def test_retrofit_ignores_marker_in_middle_of_text(tmp_path: Path) -> None:
+    """A lone 'י' inside body text (not at start) should not be detected as block."""
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("א. תחילת הבלוק")
+    doc.add_paragraph("טקסט עם האות י לא בתחילת שורה, זה לא בלוק.")
+    doc.add_paragraph("ב. בלוק שני")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert "block-alef" in result["bookmarks_added"]
+    assert "block-bet" in result["bookmarks_added"]
+    # 'block-yod' should NOT be detected
+    assert "block-yod" not in result["bookmarks_added"]
+
+
+def test_retrofit_out_of_order_markers_picks_forward_only(tmp_path: Path) -> None:
+    """If a later-ordered marker appears first, earlier ones are treated as missing.
+
+    Scanner advances forward through BLOCK_ORDER — it won't go back to claim
+    an earlier marker after already seeing a later one. block-alef will be
+    surfaced via the cover-block fallback rather than from the actual marker.
+    """
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("ב. מופיע ראשון")
+    doc.add_paragraph("א. מופיע אחרי — יידחה כי 'א' לפני 'ב'")
+    doc.add_paragraph("ג. בלוק גימל")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert "block-bet" in result["bookmarks_added"]
+    assert "block-gimel" in result["bookmarks_added"]
+    # 'א' marker was skipped by forward-scan, so it appears as a structural
+    # fallback (no real content), not from real detection.
+    assert "block-alef" in result["structural_fallback"]
+
+
+def test_retrofit_empty_document_reports_all_missing(tmp_path: Path) -> None:
+    src = tmp_path / "empty.docx"
+    doc = Document()
+    doc.save(str(src))
+    result = retrofit_bookmarks(src, backup=False)
+    assert result["bookmarks_added"] == []
+    assert len(result["missing_blocks"]) == 12
+
+
+def test_retrofit_al_ken_midblock_does_not_capture_yod_bet(tmp_path: Path) -> None:
+    """'על כן, במקום בו...' באמצע block-yod לא צריך להיתפס כ-yod-bet."""
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("פתח דבר")
+    doc.add_paragraph("רקע עובדתי קצר.")
+    doc.add_paragraph("דיון והכרעה")
+    doc.add_paragraph("על כן, במקום בו קיים פתרון חניה אין מקום להתערב.")
+    doc.add_paragraph("סוף דבר")
+    doc.add_paragraph("פסק דין סופי.")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert "block-yod-alef" in result["bookmarks_added"]
+    assert "block-yod-bet" not in result["bookmarks_added"]
+
+
+def test_retrofit_al_ken_operative_captures_yod_bet(tmp_path: Path) -> None:
+    """'על כן, אנו מחליטים' באמת אופרטיבי — צריך להיתפס כ-yod-bet."""
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("דיון והכרעה")
+    doc.add_paragraph("נימוקים מפורטים.")
+    doc.add_paragraph("סוף דבר")
+    doc.add_paragraph("על כן, אנו מחליטים לקבל את הערר.")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert "block-yod-alef" in result["bookmarks_added"]
+    assert "block-yod-bet" in result["bookmarks_added"]
+
+
+def test_retrofit_vav_al_hamekarkein_pattern(tmp_path: Path) -> None:
+    """'על המקרקעין חלות התכניות' — דפוס block-vav מקורפוס 1130."""
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("פתח דבר")
+    doc.add_paragraph("המקרקעין מצויים בכתובת...")
+    doc.add_paragraph("על המקרקעין חלות התכניות הבאות")
+    doc.add_paragraph("פירוט תכניות.")
+    doc.add_paragraph("תמצית טענות הצדדים")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    assert "block-vav" in result["bookmarks_added"]
+
+
+def test_retrofit_cover_blocks_structural_fallback(tmp_path: Path) -> None:
+    """אם alef-dalet לא בקובץ — לקבל bookmarks ריקים בהתחלה (structural_fallback)."""
+    src = tmp_path / "src.docx"
+    doc = Document()
+    doc.add_paragraph("פתח דבר")
+    doc.add_paragraph("תוכן.")
+    doc.add_paragraph("דיון והכרעה")
+    doc.add_paragraph("הכרעה.")
+    doc.save(str(src))
+
+    result = retrofit_bookmarks(src, backup=False)
+    for name in ["block-alef", "block-bet", "block-gimel", "block-dalet"]:
+        assert name in result["bookmarks_added"]
+        assert name not in result["missing_blocks"]
+    assert set(result["structural_fallback"]) == {
+        "block-alef", "block-bet", "block-gimel", "block-dalet",
+    }
+
+
+def test_retrofit_no_double_fallback_when_cover_present(tmp_path: Path) -> None:
+    """אם block-alef קיים בקובץ אמיתית — לא לזרוק fallback מבני."""
+    src = tmp_path / "src.docx"
+    _make_docx_with_hebrew_blocks(
+        src, ["א", "ב", "ג", "ד", "ה", "ו", "ז", "ח", "ט", "י", "יא", "יב"],
+    )
+    result = retrofit_bookmarks(src, backup=False)
+    assert result["structural_fallback"] == []

mcp-server/tests/test_docx_reviser.py

@@ -0,0 +1,342 @@
+"""בדיקות docx_reviser — Track Changes XML surgery.
+
+הבדיקות יוצרות DOCX בסיסי עם bookmarks, מפעילות revisions, ובודקות:
+1. שה-XML שנוצר תקף ונטען חזרה כ-Document
+2. שה-<w:ins> / <w:del> קיימים בפורמט הנכון
+3. שה-bookmarks נשמרים אחרי עריכה
+4. שגופן David ו-RTL נשמרים
+5. שכשלונות מטופלים אלגנטית (bookmark חסר → failed, לא crash)
+"""
+
+from __future__ import annotations
+
+import zipfile
+from datetime import datetime, timezone
+from io import BytesIO
+from pathlib import Path
+
+import pytest
+from docx import Document
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from lxml import etree
+
+from legal_mcp.services import docx_reviser
+from legal_mcp.services.docx_reviser import (
+    NSMAP,
+    Revision,
+    _w,
+    apply_tracked_revisions,
+    list_bookmarks,
+)
+
+
+# ── Test fixtures ──────────────────────────────────────────────────
+
+
+def _insert_bookmark(paragraph, name: str, bm_id: int) -> None:
+    """Insert a <w:bookmarkStart> at the start of a paragraph and a
+    <w:bookmarkEnd> at the end."""
+    p_elem = paragraph._p
+
+    start = OxmlElement("w:bookmarkStart")
+    start.set(qn("w:id"), str(bm_id))
+    start.set(qn("w:name"), name)
+    p_elem.insert(0, start)
+
+    end = OxmlElement("w:bookmarkEnd")
+    end.set(qn("w:id"), str(bm_id))
+    p_elem.append(end)
+
+
+def _make_sample_docx(path: Path) -> None:
+    """Create a simple DOCX with 3 paragraphs, each with a bookmark."""
+    doc = Document()
+    for idx, name in enumerate(("block-alef", "block-yod", "block-yod-bet")):
+        p = doc.add_paragraph()
+        run = p.add_run(f"תוכן פסקה של {name}")
+        run.font.name = "David"
+        _insert_bookmark(p, name, idx + 1)
+    doc.save(str(path))
+
+
+@pytest.fixture
+def sample_docx(tmp_path: Path) -> Path:
+    path = tmp_path / "source.docx"
+    _make_sample_docx(path)
+    return path
+
+
+# ── list_bookmarks ────────────────────────────────────────────────
+
+
+def test_list_bookmarks_returns_all_named(sample_docx: Path) -> None:
+    names = list_bookmarks(sample_docx)
+    assert set(names) == {"block-alef", "block-yod", "block-yod-bet"}
+
+
+def test_list_bookmarks_excludes_internal(tmp_path: Path) -> None:
+    """Bookmarks starting with '_' (like _GoBack) should be filtered out."""
+    path = tmp_path / "internal.docx"
+    doc = Document()
+    p1 = doc.add_paragraph("visible")
+    _insert_bookmark(p1, "block-real", 1)
+    p2 = doc.add_paragraph("hidden")
+    _insert_bookmark(p2, "_GoBack", 2)
+    doc.save(str(path))
+
+    names = list_bookmarks(path)
+    assert names == ["block-real"]
+
+
+# ── apply_tracked_revisions: insert_after ─────────────────────────
+
+
+def test_insert_after_adds_tracked_paragraph(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(
+        id="r1",
+        type="insert_after",
+        anchor_bookmark="block-yod",
+        content="פסקה חדשה שהמערכת מוסיפה.",
+    )
+    result = apply_tracked_revisions(
+        sample_docx, out, [rev],
+        author="מערכת AI",
+        date=datetime(2026, 4, 16, 14, 0, tzinfo=timezone.utc),
+    )
+    assert result.applied == 1
+    assert result.failed == 0
+    assert out.exists()
+
+    # Verify <w:ins> present in document.xml
+    with zipfile.ZipFile(out, "r") as zf:
+        doc_xml = zf.read("word/document.xml")
+    tree = etree.fromstring(doc_xml)
+    ins_elements = tree.findall(".//w:ins", NSMAP)
+    assert len(ins_elements) >= 1
+    # Verify the content is there
+    all_text = "".join(tree.itertext())
+    assert "פסקה חדשה שהמערכת מוסיפה." in all_text
+    # Verify original content preserved
+    assert "תוכן פסקה של block-yod" in all_text
+
+
+def _find_ins_with_runs(tree: etree._Element) -> etree._Element | None:
+    """Pick the <w:ins> that actually wraps runs (not the pilcrow-marker one)."""
+    for ins in tree.iterfind(".//w:ins", NSMAP):
+        if ins.find(".//w:r", NSMAP) is not None:
+            return ins
+    return None
+
+
+def test_insert_after_ins_has_author_and_date(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="block-alef", content="test")
+    apply_tracked_revisions(sample_docx, out, [rev], author="דפנה")
+
+    with zipfile.ZipFile(out, "r") as zf:
+        doc_xml = zf.read("word/document.xml")
+    tree = etree.fromstring(doc_xml)
+    ins = _find_ins_with_runs(tree)
+    assert ins is not None
+    assert ins.get(_w("author")) == "דפנה"
+    date_str = ins.get(_w("date"))
+    assert date_str is not None
+    assert date_str.endswith("Z")  # ISO 8601 UTC
+
+
+def test_insert_after_uses_rtl_and_david(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="block-alef", content="מוסף")
+    apply_tracked_revisions(sample_docx, out, [rev])
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+
+    ins = _find_ins_with_runs(tree)
+    assert ins is not None
+    run = ins.find(".//w:r", NSMAP)
+    assert run is not None
+    rPr = run.find(_w("rPr"))
+    assert rPr is not None
+    assert rPr.find(_w("rtl")) is not None
+    rFonts = rPr.find(_w("rFonts"))
+    assert rFonts is not None
+    assert rFonts.get(_w("ascii")) == "David"
+
+
+# ── apply_tracked_revisions: insert_before ────────────────────────
+
+
+def test_insert_before_places_above_anchor(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_before",
+                   anchor_bookmark="block-yod", content="לפני י.")
+    result = apply_tracked_revisions(sample_docx, out, [rev])
+    assert result.applied == 1
+
+    # Order check: new paragraph's text must appear before "block-yod"
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    paragraphs = tree.findall(".//w:p", NSMAP)
+    texts = ["".join(p.itertext()) for p in paragraphs]
+    idx_new = next(i for i, t in enumerate(texts) if "לפני י." in t)
+    idx_yod = next(i for i, t in enumerate(texts) if "תוכן פסקה של block-yod" in t)
+    assert idx_new < idx_yod
+
+
+# ── apply_tracked_revisions: delete ───────────────────────────────
+
+
+def test_delete_wraps_runs_in_w_del(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="delete", anchor_bookmark="block-yod", content="")
+    result = apply_tracked_revisions(sample_docx, out, [rev])
+    assert result.applied == 1
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    dels = tree.findall(".//w:del", NSMAP)
+    assert len(dels) >= 1
+    # Inside w:del, text elements must become w:delText
+    del_texts = dels[0].findall(".//w:delText", NSMAP)
+    assert any("block-yod" in (t.text or "") for t in del_texts)
+
+
+# ── apply_tracked_revisions: replace ─────────────────────────────
+
+
+def test_replace_creates_both_ins_and_del(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="replace",
+                   anchor_bookmark="block-yod", content="תוכן חדש לחלוטין")
+    result = apply_tracked_revisions(sample_docx, out, [rev])
+    assert result.applied == 1
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    assert len(tree.findall(".//w:ins", NSMAP)) >= 1
+    assert len(tree.findall(".//w:del", NSMAP)) >= 1
+
+
+# ── Failure modes ─────────────────────────────────────────────────
+
+
+def test_missing_bookmark_returns_failed_not_crash(
+    sample_docx: Path, tmp_path: Path,
+) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="does-not-exist", content="x")
+    result = apply_tracked_revisions(sample_docx, out, [rev])
+    assert result.applied == 0
+    assert result.failed == 1
+    assert result.results[0].status == "failed"
+    assert "not found" in (result.results[0].error or "")
+    # Output file still produced (unchanged copy)
+    assert out.exists()
+
+
+def test_empty_revisions_list_produces_copy(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    result = apply_tracked_revisions(sample_docx, out, [])
+    assert result.applied == 0
+    assert result.failed == 0
+    assert out.exists()
+    # bookmarks should still be there
+    assert set(list_bookmarks(out)) == {"block-alef", "block-yod", "block-yod-bet"}
+
+
+# ── Track revisions flag in settings ──────────────────────────────
+
+
+def test_track_revisions_flag_is_enabled(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="block-alef", content="x")
+    apply_tracked_revisions(sample_docx, out, [rev])
+
+    with zipfile.ZipFile(out, "r") as zf:
+        settings_xml = zf.read("word/settings.xml")
+    settings_tree = etree.fromstring(settings_xml)
+    tr = settings_tree.find(_w("trackRevisions"))
+    assert tr is not None
+
+
+# ── Multiple revisions with unique IDs ────────────────────────────
+
+
+def test_multiple_revisions_get_unique_ids(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    revs = [
+        Revision(id="r1", type="insert_after",
+                 anchor_bookmark="block-alef", content="ראשון"),
+        Revision(id="r2", type="insert_after",
+                 anchor_bookmark="block-yod", content="שני"),
+        Revision(id="r3", type="delete", anchor_bookmark="block-yod-bet"),
+    ]
+    result = apply_tracked_revisions(sample_docx, out, revs)
+    assert result.applied == 3
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    all_ids: list[str] = []
+    for xpath in (".//w:ins", ".//w:del"):
+        for el in tree.iterfind(xpath, NSMAP):
+            wid = el.get(_w("id"))
+            if wid:
+                all_ids.append(wid)
+    assert len(all_ids) == len(set(all_ids)), f"duplicate IDs: {all_ids}"
+
+
+# ── DOCX remains openable as Document ─────────────────────────────
+
+
+def test_output_docx_is_openable_by_python_docx(
+    sample_docx: Path, tmp_path: Path,
+) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="block-yod", content="תוכן חדש")
+    apply_tracked_revisions(sample_docx, out, [rev])
+    # Must be openable as a valid DOCX by python-docx (no exceptions)
+    doc = Document(str(out))
+    # Original text is still accessible via python-docx
+    all_text = "\n".join(p.text for p in doc.paragraphs)
+    assert "block-yod" in all_text
+
+    # Inserted (tracked) text is present in the raw XML via itertext
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    raw_text = "".join(tree.itertext())
+    assert "תוכן חדש" in raw_text
+
+
+# ── Bookmarks preserved through revisions ─────────────────────────
+
+
+def test_bookmarks_preserved_after_insert(sample_docx: Path, tmp_path: Path) -> None:
+    out = tmp_path / "out.docx"
+    rev = Revision(id="r1", type="insert_after",
+                   anchor_bookmark="block-yod", content="x")
+    apply_tracked_revisions(sample_docx, out, [rev])
+    names = list_bookmarks(out)
+    assert set(names) == {"block-alef", "block-yod", "block-yod-bet"}
+
+
+# ── Idempotency of loading/saving without changes ────────────────
+
+
+def test_save_without_revisions_preserves_content(
+    sample_docx: Path, tmp_path: Path,
+) -> None:
+    out = tmp_path / "out.docx"
+    apply_tracked_revisions(sample_docx, out, [])
+    doc_orig = Document(str(sample_docx))
+    doc_new = Document(str(out))
+    orig_text = [p.text for p in doc_orig.paragraphs]
+    new_text = [p.text for p in doc_new.paragraphs]
+    assert orig_text == new_text

mcp-server/tests/test_track_changes_e2e.py

@@ -0,0 +1,237 @@
+"""בדיקות end-to-end לזרימה המלאה: exporter → retrofit → reviser.
+
+הבדיקות האלה מחברות את כל השכבות של ארכיטקטורת Track Changes ומוודאות
+שהזרימה עובדת על מסמכים שנוצרו על-ידי ה-exporter עצמו (בלוקים עם bookmarks
+מובנים) ועל מסמכים רגילים שעברו retrofit.
+"""
+
+from __future__ import annotations
+
+import zipfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+from docx import Document
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+from lxml import etree
+
+from legal_mcp.services import docx_retrofit, docx_reviser
+from legal_mcp.services.docx_exporter import (
+    _BOOKMARK_ID_START,
+    _wrap_block_with_bookmarks,
+)
+from legal_mcp.services.docx_reviser import (
+    NSMAP,
+    Revision,
+    _w,
+    apply_tracked_revisions,
+    list_bookmarks,
+)
+
+
+# ── Helpers ────────────────────────────────────────────────────────
+
+
+def _make_exporter_style_docx(path: Path) -> None:
+    """Simulate what docx_exporter produces: paragraphs wrapped in bookmarks
+    for each of the 12 blocks, with David font and RTL."""
+    doc = Document()
+    bm_counter = [_BOOKMARK_ID_START]
+
+    blocks = [
+        ("block-alef", "בפני: דפנה תמיר, יו\"ר ועדת הערר"),
+        ("block-bet",  "ערר מספר 1033-25"),
+        ("block-heh",  "רקע\nהנכס מצוי ברחוב הר בשן"),
+        ("block-yod",  "דיון והכרעה\nלאחר שבחנו את טענות הצדדים"),
+        ("block-yod-bet", "ההחלטה\nהערר מתקבל בחלקו"),
+    ]
+
+    for name, content in blocks:
+        def writer(c=content):
+            for line in c.split("\n"):
+                if line.strip():
+                    doc.add_paragraph(line.strip())
+        _wrap_block_with_bookmarks(doc, name, writer, bm_counter)
+
+    doc.save(str(path))
+
+
+def _make_user_edited_docx(path: Path) -> None:
+    """Simulate what a user produces by editing in Word: no bookmarks,
+    heading-style paragraphs in Daphna style."""
+    doc = Document()
+    for text in [
+        "בפני: דפנה תמיר, יו\"ר ועדת הערר מחוז ירושלים",
+        "ערר מספר 9999-25",
+        "רקע",
+        "הנכס מצוי ברחוב שמואל הנגיד 10, ירושלים",
+        "תמצית טענות הצדדים",
+        "העוררים טוענים שהבנייה חורגת מהתכנית",
+        "תגובת המשיבה",
+        "הוועדה המקומית טוענת שהבקשה תואמת",
+        "ההליכים בפני ועדת הערר",
+        "קיימנו דיון בנוכחות הצדדים",
+        "דיון והכרעה",
+        "לאחר שבחנו את טענות הצדדים בחון מעמיק",
+        "סוף דבר",
+        "הערר נדחה",
+    ]:
+        doc.add_paragraph(text)
+    doc.save(str(path))
+
+
+# ── Exporter-style (built-in bookmarks) ──────────────────────────
+
+
+def test_exporter_output_works_with_reviser(tmp_path: Path) -> None:
+    src = tmp_path / "exported.docx"
+    _make_exporter_style_docx(src)
+
+    # All 5 bookmarks should be present directly from "export"
+    bookmarks = list_bookmarks(src)
+    assert set(bookmarks) >= {"block-alef", "block-bet", "block-heh",
+                              "block-yod", "block-yod-bet"}
+
+    out = tmp_path / "revised.docx"
+    revs = [
+        Revision(id="r1", type="insert_after", anchor_bookmark="block-yod",
+                 content="תוספת מערכת: פסק הלכה חדש", style="body"),
+    ]
+    result = apply_tracked_revisions(src, out, revs)
+    assert result.applied == 1
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    raw_text = "".join(tree.itertext())
+    assert "תוספת מערכת" in raw_text
+    # The revision is tracked (inside <w:ins>)
+    ins_list = tree.findall(".//w:ins", NSMAP)
+    assert any("תוספת מערכת" in "".join(el.itertext()) for el in ins_list)
+
+
+# ── User-edited DOCX (no bookmarks) — needs retrofit first ──────
+
+
+def test_retrofit_then_revise_on_user_edit(tmp_path: Path) -> None:
+    user_file = tmp_path / "user_edit.docx"
+    _make_user_edited_docx(user_file)
+
+    # Initially no named bookmarks
+    assert list_bookmarks(user_file) == []
+
+    # Retrofit — should detect blocks via heading heuristic
+    result = docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+    added = set(result["bookmarks_added"])
+    # Must include at least block-yod (for common "insert pasak halacha" task)
+    assert "block-yod" in added
+    # Plus block-heh (רקע) and block-zayin (תמצית טענות)
+    assert "block-heh" in added
+    assert "block-zayin" in added
+
+    # Now apply a revision on the retrofitted file
+    out = tmp_path / "revised.docx"
+    revs = [Revision(id="r1", type="insert_after",
+                     anchor_bookmark="block-yod",
+                     content="פסק הלכה שהוסף: בבג\"ץ 1/23 נקבע כי...",
+                     style="body")]
+    rr = apply_tracked_revisions(user_file, out, revs)
+    assert rr.applied == 1
+
+    # Verify output has the insertion inside <w:ins>
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    ins_texts = ["".join(el.itertext()) for el in tree.iterfind(".//w:ins", NSMAP)]
+    assert any("פסק הלכה שהוסף" in t for t in ins_texts)
+
+
+def test_retrofit_preserves_original_paragraphs(tmp_path: Path) -> None:
+    user_file = tmp_path / "user.docx"
+    _make_user_edited_docx(user_file)
+
+    before_doc = Document(str(user_file))
+    before_texts = [p.text for p in before_doc.paragraphs]
+
+    docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+
+    after_doc = Document(str(user_file))
+    after_texts = [p.text for p in after_doc.paragraphs]
+    # Paragraph texts should be identical (we only added bookmark markers)
+    assert before_texts == after_texts
+
+
+def test_idempotent_retrofit_and_revise(tmp_path: Path) -> None:
+    """Running retrofit twice + revising should still produce valid output."""
+    user_file = tmp_path / "user.docx"
+    _make_user_edited_docx(user_file)
+
+    # First retrofit
+    r1 = docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+    # Second retrofit — should add no new bookmarks
+    r2 = docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+    assert r2["bookmarks_added"] == []
+    assert set(r2["existing_bookmarks"]) >= set(r1["bookmarks_added"])
+
+    # Then revise works normally
+    out = tmp_path / "revised.docx"
+    revs = [Revision(id="r1", type="insert_after",
+                     anchor_bookmark="block-yod", content="x")]
+    result = apply_tracked_revisions(user_file, out, revs)
+    assert result.applied == 1
+
+
+def test_multiple_revisions_all_tracked_independently(tmp_path: Path) -> None:
+    """Verify multiple tracked changes each get independent ins ids so
+    user can Accept/Reject each one separately in Word."""
+    user_file = tmp_path / "user.docx"
+    _make_user_edited_docx(user_file)
+    docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+
+    out = tmp_path / "revised.docx"
+    revs = [
+        Revision(id="r1", type="insert_after",
+                 anchor_bookmark="block-heh", content="תוספת 1"),
+        Revision(id="r2", type="insert_after",
+                 anchor_bookmark="block-yod", content="תוספת 2"),
+        Revision(id="r3", type="insert_before",
+                 anchor_bookmark="block-yod-alef", content="תוספת 3"),
+    ]
+    result = apply_tracked_revisions(user_file, out, revs)
+    assert result.applied == 3
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+    ins_ids = {el.get(_w("id")) for el in tree.iterfind(".//w:ins", NSMAP)}
+    assert len(ins_ids) >= 3  # at least one unique id per revision
+
+
+def test_rtl_preserved_in_tracked_insertion(tmp_path: Path) -> None:
+    """Inserted paragraph must have bidi + rtl + David font so it renders
+    correctly in Word alongside the user's content."""
+    user_file = tmp_path / "user.docx"
+    _make_user_edited_docx(user_file)
+    docx_retrofit.retrofit_bookmarks(user_file, backup=False)
+
+    out = tmp_path / "out.docx"
+    revs = [Revision(id="r1", type="insert_after",
+                     anchor_bookmark="block-yod", content="עברית RTL")]
+    apply_tracked_revisions(user_file, out, revs)
+
+    with zipfile.ZipFile(out, "r") as zf:
+        tree = etree.fromstring(zf.read("word/document.xml"))
+
+    # Find the ins that holds runs
+    for ins in tree.iterfind(".//w:ins", NSMAP):
+        runs = ins.findall(".//w:r", NSMAP)
+        for r in runs:
+            text_els = r.findall(".//w:t", NSMAP)
+            if any("עברית RTL" in (t.text or "") for t in text_els):
+                rPr = r.find(_w("rPr"))
+                assert rPr is not None
+                assert rPr.find(_w("rtl")) is not None
+                rFonts = rPr.find(_w("rFonts"))
+                assert rFonts is not None
+                assert rFonts.get(_w("ascii")) == "David"
+                return
+    pytest.fail("tracked insertion with 'עברית RTL' not found")

paperclip-bug-report.md

@@ -1,65 +0,0 @@
-# Bug: Skill import from Gitea — wrong raw URL format causes empty SKILL.md
-
-**File at:** https://github.com/paperclipai/paperclip/issues/new
-
-## Title
-Skill import from Gitea: wrong raw URL format causes empty SKILL.md
-
-## Body
-
-### Bug Summary
-
-When importing skills from a **Gitea** instance (self-hosted), Paperclip fetches the git tree successfully via the `/api/v3/` endpoint (which Gitea supports), but then uses the **wrong raw file URL format** to download `SKILL.md` content, resulting in a 404 and an almost-empty stub being saved.
-
-### Environment
-
-- Paperclip server: `@paperclipai/server@2026.403.0`
-- Gitea instance: self-hosted Gitea
-
-### Steps to Reproduce
-
-1. Host a skill repo on a Gitea instance with a `SKILL.md` (32KB+), `scripts/`, and `references/` directories
-2. Import the skill via URL: `https://my-gitea.example.com/org/skill-name.git`
-3. Observe that only a stub SKILL.md (~283 bytes) is saved, and subdirectories are missing
-
-### Root Cause
-
-In `server/dist/services/github-fetch.js`, the `resolveRawGitHubUrl()` function builds:
-
-```
-https://{hostname}/raw/{owner}/{repo}/{ref}/{file}
-```
-
-This format works for **GitHub Enterprise**, but **not for Gitea**. Gitea expects:
-
-```
-https://{hostname}/{owner}/{repo}/raw/branch/{ref}/{file}
-```
-
-### Proof
-
-```bash
-# Paperclip's URL format -> 404
-$ curl -s -o /dev/null -w "%{http_code}" "https://my-gitea.example.com/raw/org/skill-repo/main/SKILL.md"
-404
-
-# Correct Gitea format -> 200
-$ curl -s -o /dev/null -w "%{http_code}" "https://my-gitea.example.com/org/skill-repo/raw/branch/main/SKILL.md"
-200
-```
-
-### Secondary Issue
-
-When `SKILL.md` is at the repository root, `path.posix.dirname("SKILL.md")` returns `"."`, causing the inventory filter `entry.startsWith("./")` to miss all sibling directories (`scripts/`, `references/`). This means even if the raw URL worked, subdirectories would still be excluded from the file inventory.
-
-### Suggested Fix
-
-1. **Detect Gitea** vs GitHub Enterprise (e.g., check for `/api/v1/` endpoint which is Gitea-specific, vs `/api/v3/`)
-2. **Use the correct raw URL format** per platform:
-   - GitHub/GHE: `https://{hostname}/raw/{owner}/{repo}/{ref}/{file}`
-   - Gitea: `https://{hostname}/{owner}/{repo}/raw/branch/{ref}/{file}`
-3. **Fix root-level SKILL.md inventory**: when `skillDir === "."`, include all files instead of filtering by `entry.startsWith("./")`
-
-### Workaround
-
-Manually clone the repo into `~/.paperclip/instances/default/skills/{company_id}/{slug}/` and update the `company_skills` table directly with correct markdown content and file_inventory.

scripts/SCRIPTS.md

@@ -0,0 +1,54 @@
+# scripts/ — מדריך סקריפטים
+
+> **כלל:** כל עדכון, יצירה, או מחיקה של סקריפט בתיקייה זו מחייב עדכון של קובץ זה.
+
+---
+
+## סקריפטים פעילים
+
+| Script | Type | Purpose | Scheduled |
+|--------|------|---------|-----------|
+| `auto-sync-cases.sh` | bash | סנכרון תיקי ערר ל-Gitea — רץ כל דקה | `* * * * *` (cron) |
+| `backup-db.sh` | bash | גיבוי PostgreSQL יומי ל-`data/backups/` (gzip) | לתזמן: `0 2 * * *` |
+| `restore-db.sh` | bash | שחזור DB מגיבוי (companion ל-backup-db.sh) | ידני |
+| `notify.py` | python | שליחת מייל התראה מסוכנים via SMTP (Gmail) | נקרא ע"י סוכנים |
+| `bidi_table.py` | python | יצירת טבלאות box-drawing עם תמיכה ב-BiDi (עברית+אנגלית) | ספריית עזר |
+| `convert_decision_template.py` | python | המרת `data/training/טיוטת החלטה.dotx` → `skills/docx/decision_template.docx` לטעינה ב-python-docx | להריץ כשמתעדכנת התבנית |
+| `deploy-track-changes.sh` | bash | סנכרון skills CMP↔CMPA + בדיקות + הנחיות deploy לארכיטקטורת Track Changes | ידני |
+| `retrofit_case.py` | python | retrofit רטרואקטיבי — מזריק bookmarks לקובץ קיים של תיק ספציפי ומגדיר אותו כ-active_draft | ידני (חד-פעמי לתיק) |
+
+## תיקיית `.archive/` — סקריפטים שהושלמו
+
+סקריפטים חד-פעמיים שהפונקציונליות שלהם הוטמעה ב-MCP server או ב-API.
+נשמרים ב-git לצורך היסטוריה — **אין להריץ אותם**.
+
+| Script | Original Purpose | Superseded By |
+|--------|-----------------|---------------|
+| `backfill_pattern_frequency.py` | עדכון תדירות דפוסי סגנון ב-DB | `web/app.py::_extract_pattern_variants()` |
+| `batch_upload_training.py` | העלאת קורפוס אימון (16 קבצים) | Web UI: `/api/training/upload` |
+| `benchmark_embeddings.py` | השוואת מודלי embeddings (voyage-3 vs voyage-4) | הושלם — voyage-3-large נבחר |
+| `benchmark_new_vs_old.py` | השוואת Google Vision vs markdown קיים | הושלם — בדיקה חד-פעמית לתיק 1130-25 |
+| `decompose-decisions.py` | פירוק החלטות סופיות ל-12 בלוקים | MCP: `write_block()`, `write_all_blocks()` |
+| `export-decision-docx.py` | ייצוא החלטה ל-DOCX | MCP: `export_docx()` |
+| `extract-citations.py` | חילוץ ציטוטי פסיקה מבלוק י | MCP service: `references_extractor.py` |
+| `extract-claims.py` | חילוץ טענות מבלוק ז | MCP: `extract_claims()` + `claims_extractor.py` |
+| `extract_all_google_vision.py` | OCR בכמות עם Google Vision | MCP: `document_upload()` pipeline |
+| `extract_originals.py` | חילוץ טקסט מ-PDF עם Claude Opus | MCP service: `extractor.py` |
+| `extract_originals_ocr.py` | חילוץ OCR מלא מ-PDF | MCP service: `extractor.py` |
+| `generate-embeddings.py` | יצירת embeddings לבלוקים ופסיקה | אוטומטי — נוצרים עם יצירת בלוקים |
+| `link-claims-to-discussion.py` | קישור טענות לפסקאות דיון | MCP service: `qa_validator.py` |
+| `proofread_training_corpus.py` | ניקוי Nevo מ-DOCX/PDF ל-Markdown | MCP service: `proofreader.py` + Web UI |
+| `seed-appeals.py` | seeding תיקי ערר ראשוניים ל-DB | MCP: `case_create()` |
+| `seed-knowledge.py` | seeding לקחים, ביטויי מעבר, פסיקה | MCP: `record_chair_feedback()`, `precedent_attach()` |
+| `validate-decision.py` | ולידציה מול block-schema | MCP: `validate_decision()` + `qa_validator.py` |
+
+## סקריפטים שנמחקו (git history בלבד)
+
+| Script | Reason |
+|--------|--------|
+| `import-final-decisions.py` | מיגרציה הושלמה — כל ההחלטות ב-`data/training/` |
+| `compare_extractions.py` | בדיקה חד-פעמית לתיק 1130-25 |
+| `decompose-decisions-v2.py` | כפילות של v1 |
+| `extract_google_vision.py` | hardcoded לתיק בודד |
+| `extract_google_vision_single.py` | wrapper חד-פעמי |
+| `test-search.py` | סקריפט דיבאג |

scripts/auto-sync-cases.sh

@@ -4,13 +4,22 @@
 
 CASES_DIR="/home/chaim/legal-ai/data/cases"
 LOG="/home/chaim/legal-ai/data/.auto-sync.log"
-GIT_ENV="GIT_AUTHOR_NAME=Ezer Mishpati GIT_AUTHOR_EMAIL=legal@local GIT_COMMITTER_NAME=Ezer Mishpati GIT_COMMITTER_EMAIL=legal@local GIT_TERMINAL_PROMPT=0"
 
-for status_dir in "$CASES_DIR"/new "$CASES_DIR"/in-progress "$CASES_DIR"/completed; do
+export GIT_AUTHOR_NAME="Ezer Mishpati"
-    [ -d "$status_dir" ] || continue
+export GIT_AUTHOR_EMAIL="legal@local"
-    for case_dir in "$status_dir"/*/; do
+export GIT_COMMITTER_NAME="Ezer Mishpati"
+export GIT_COMMITTER_EMAIL="legal@local"
+export GIT_TERMINAL_PROMPT=0
+
+for case_dir in "$CASES_DIR"/*/; do
     [ -d "$case_dir/.git" ] || continue
 
+    case_name=$(basename "$case_dir")
+
+    # Ensure safe.directory is set for this repo
+    git config --global --get-all safe.directory | grep -qF "$case_dir" \
+        || git config --global --add safe.directory "$case_dir"
+
     cd "$case_dir" || continue
 
     # Check for any changes (modified, new, deleted)
@@ -20,18 +29,25 @@ for status_dir in "$CASES_DIR"/new "$CASES_DIR"/in-progress "$CASES_DIR"/complet
     # Stage all changes
     git add -A 2>/dev/null
 
-        # Build commit message from changed files
+    # Count changed files
-        changed_files=$(git diff --cached --name-only 2>/dev/null | head -5)
     count=$(git diff --cached --name-only 2>/dev/null | wc -l)
-        case_name=$(basename "$case_dir")
+    [ "$count" -eq 0 ] && continue
+
     msg="סנכרון אוטומטי — ${count} קבצים שונו"
 
     # Commit
-        env $GIT_ENV git commit -m "$msg" --quiet 2>/dev/null
+    if git commit -m "$msg" --quiet 2>/dev/null; then
-        if [ $? -eq 0 ]; then
+        # Push only if remote exists
-            # Push (non-blocking, ignore errors)
+        if git remote get-url origin >/dev/null 2>&1; then
-            git push origin main --quiet 2>/dev/null
+            if git push origin HEAD --quiet 2>/dev/null; then
-            echo "$(date '+%Y-%m-%d %H:%M:%S') | $case_name | $count files synced" >> "$LOG"
+                echo "$(date '+%Y-%m-%d %H:%M:%S') | $case_name | $count files synced + pushed" >> "$LOG"
+            else
+                echo "$(date '+%Y-%m-%d %H:%M:%S') | $case_name | $count files committed, push FAILED" >> "$LOG"
+            fi
+        else
+            echo "$(date '+%Y-%m-%d %H:%M:%S') | $case_name | $count files committed (no remote)" >> "$LOG"
+        fi
+    else
+        echo "$(date '+%Y-%m-%d %H:%M:%S') | $case_name | commit FAILED" >> "$LOG"
     fi
-    done
 done

scripts/compare_extractions.py

@@ -1,126 +0,0 @@
-"""Compare existing MD files with freshly extracted text from PDFs."""
-
-import difflib
-from pathlib import Path
-
-DOCS_DIR = Path("/home/chaim/legal-ai/data/cases/1130-25/documents")
-EXTRACTED_DIR = DOCS_DIR / "extracted"
-
-# Map: existing MD -> extracted MD
-PAIRS = [
-    ("2025-08-14-כתב-ערר-קובר.md", "מרק קובר-כתב ערר.md", "Appeal - Kuber"),
-    ("2025-09-01-כתב-תשובה-ליבמן-לערר.md", "תשובה לערר מטעם המשיבים.md", "Response - Livman"),
-    ("2025-09-02-כתב-תשובה-ועדת-הראל-לערר.md", "תשובת הועדה המרחבית לערר.md", "Response - Committee"),
-    ("2025-10-22-כתב-ערר-מטמון.md", "תשובת המשיב-יצחק מטמון.md", "Response - Matmon"),
-]
-
-
-def normalize(text: str) -> str:
-    """Normalize text for comparison."""
-    # Remove markdown formatting, extra whitespace
-    lines = text.strip().split("\n")
-    lines = [l.strip() for l in lines if l.strip()]
-    return "\n".join(lines)
-
-
-def word_overlap(a: str, b: str) -> float:
-    """Calculate word-level overlap ratio."""
-    words_a = set(a.split())
-    words_b = set(b.split())
-    if not words_a or not words_b:
-        return 0.0
-    intersection = words_a & words_b
-    return len(intersection) / max(len(words_a), len(words_b))
-
-
-def main():
-    print(f"{'=' * 70}")
-    print("COMPARISON: Existing MD vs Fresh PDF Extraction")
-    print(f"{'=' * 70}\n")
-
-    summary = []
-
-    for existing_name, extracted_name, label in PAIRS:
-        existing_path = DOCS_DIR / existing_name
-        extracted_path = EXTRACTED_DIR / extracted_name
-
-        if not existing_path.exists():
-            print(f"SKIP: {existing_name} not found")
-            continue
-        if not extracted_path.exists():
-            print(f"SKIP: {extracted_name} not found")
-            continue
-
-        existing_text = existing_path.read_text(encoding="utf-8")
-        extracted_text = extracted_path.read_text(encoding="utf-8")
-
-        existing_norm = normalize(existing_text)
-        extracted_norm = normalize(extracted_text)
-
-        # Stats
-        existing_chars = len(existing_text)
-        extracted_chars = len(extracted_text)
-        existing_words = len(existing_text.split())
-        extracted_words = len(extracted_text.split())
-
-        # Similarity
-        overlap = word_overlap(existing_norm, extracted_norm)
-
-        # Sequence matcher ratio (slower but more accurate)
-        # Use first 5000 chars for speed
-        sm = difflib.SequenceMatcher(None, existing_norm[:5000], extracted_norm[:5000])
-        seq_ratio = sm.ratio()
-
-        # Find lines in extracted but not in existing (new content)
-        existing_lines = set(existing_norm.split("\n"))
-        extracted_lines = set(extracted_norm.split("\n"))
-        new_lines = extracted_lines - existing_lines
-        missing_lines = existing_lines - extracted_lines
-
-        print(f"{'=' * 70}")
-        print(f"  {label}")
-        print(f"  Existing: {existing_name}")
-        print(f"  Extracted: {extracted_name}")
-        print(f"{'=' * 70}")
-        print(f"  {'Metric':<30} {'Existing MD':>15} {'Fresh PDF':>15} {'Diff':>10}")
-        print(f"  {'-' * 70}")
-        print(f"  {'Characters':<30} {existing_chars:>15,} {extracted_chars:>15,} {extracted_chars - existing_chars:>+10,}")
-        print(f"  {'Words':<30} {existing_words:>15,} {extracted_words:>15,} {extracted_words - existing_words:>+10,}")
-        print(f"  {'Lines':<30} {len(existing_lines):>15,} {len(extracted_lines):>15,} {len(extracted_lines) - len(existing_lines):>+10,}")
-        print(f"  {'Word overlap':<30} {overlap:>15.1%}")
-        print(f"  {'Sequence similarity':<30} {seq_ratio:>15.1%}")
-        print(f"  {'Lines only in fresh PDF':<30} {len(new_lines):>15}")
-        print(f"  {'Lines only in existing MD':<30} {len(missing_lines):>15}")
-
-        # Show sample differences
-        if new_lines:
-            print(f"\n  Sample lines ONLY in fresh extraction (first 3):")
-            for line in sorted(new_lines)[:3]:
-                print(f"    + {line[:100]}")
-        if missing_lines:
-            print(f"\n  Sample lines ONLY in existing MD (first 3):")
-            for line in sorted(missing_lines)[:3]:
-                print(f"    - {line[:100]}")
-
-        print()
-
-        summary.append({
-            "label": label,
-            "existing_words": existing_words,
-            "extracted_words": extracted_words,
-            "word_overlap": overlap,
-            "seq_similarity": seq_ratio,
-        })
-
-    # Summary table
-    print(f"\n{'=' * 70}")
-    print("SUMMARY")
-    print(f"{'=' * 70}")
-    print(f"  {'Document':<25} {'Existing':>10} {'Fresh':>10} {'Overlap':>10} {'Similarity':>12}")
-    print(f"  {'-' * 67}")
-    for s in summary:
-        print(f"  {s['label']:<25} {s['existing_words']:>10,} {s['extracted_words']:>10,} {s['word_overlap']:>10.1%} {s['seq_similarity']:>12.1%}")
-
-
-if __name__ == "__main__":
-    main()

scripts/convert_decision_template.py

@@ -0,0 +1,102 @@
+"""Convert דפנה's decision .dotx template to a loadable .docx file.
+
+python-docx cannot open .dotx files directly (content type is
+`...template.main+xml` rather than `...document.main+xml`). This script
+produces a sibling .docx by rewriting [Content_Types].xml and dropping
+the `word/glossary/` part (which is template-specific and can interfere
+with plain Document() loading).
+
+The output preserves every style definition, numbering, fonts, and
+section properties — the only things we want from the template.
+
+Run once (or whenever the source .dotx changes):
+
+    python scripts/convert_decision_template.py
+
+Input:  data/training/טיוטת החלטה.dotx
+Output: skills/docx/decision_template.docx
+"""
+
+from __future__ import annotations
+
+import re
+import sys
+import zipfile
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+SRC = REPO_ROOT / "data" / "training" / "טיוטת החלטה.dotx"
+DST = REPO_ROOT / "skills" / "docx" / "decision_template.docx"
+
+TEMPLATE_CONTENT_TYPE = (
+    "application/vnd.openxmlformats-officedocument."
+    "wordprocessingml.template.main+xml"
+)
+DOCUMENT_CONTENT_TYPE = (
+    "application/vnd.openxmlformats-officedocument."
+    "wordprocessingml.document.main+xml"
+)
+
+
+def convert(src: Path, dst: Path) -> None:
+    if not src.exists():
+        raise FileNotFoundError(f"Template not found: {src}")
+    dst.parent.mkdir(parents=True, exist_ok=True)
+
+    with zipfile.ZipFile(src, "r") as zin:
+        names = zin.namelist()
+        with zipfile.ZipFile(dst, "w", zipfile.ZIP_DEFLATED) as zout:
+            for name in names:
+                # Drop glossary part — template-only, confuses Document()
+                if name.startswith("word/glossary/"):
+                    continue
+                data = zin.read(name)
+                if name == "[Content_Types].xml":
+                    text = data.decode("utf-8")
+                    text = text.replace(
+                        TEMPLATE_CONTENT_TYPE, DOCUMENT_CONTENT_TYPE
+                    )
+                    # Drop every <Override> that points at /word/glossary/...
+                    text = re.sub(
+                        r'<Override\s+PartName="/word/glossary/[^"]*"[^>]*?/>',
+                        "",
+                        text,
+                    )
+                    data = text.encode("utf-8")
+                elif name == "word/_rels/document.xml.rels":
+                    # Strip the glossaryDocument relationship — the target
+                    # part is being removed, so the ref would dangle.
+                    text = data.decode("utf-8")
+                    text = re.sub(
+                        r'<Relationship\s+[^>]*?glossaryDocument[^>]*?/>',
+                        "",
+                        text,
+                    )
+                    data = text.encode("utf-8")
+                zout.writestr(name, data)
+
+
+def verify(dst: Path) -> None:
+    """Load with python-docx and print a few style names to confirm it works."""
+    from docx import Document
+
+    doc = Document(str(dst))
+    key_styles = {"Normal", "Heading 2", "Quote", "List Paragraph", "Title"}
+    found = {s.name for s in doc.styles if s.name in key_styles}
+    missing = key_styles - found
+    if missing:
+        print(f"WARN: missing styles: {missing}", file=sys.stderr)
+    else:
+        print(f"OK — all key styles present: {sorted(found)}")
+
+
+def main() -> None:
+    print(f"Source: {SRC}")
+    print(f"Dest:   {DST}")
+    convert(SRC, DST)
+    print(f"Wrote {DST.stat().st_size:,} bytes")
+    verify(DST)
+
+
+if __name__ == "__main__":
+    main()

scripts/decompose-decisions-v2.py

@@ -1,289 +0,0 @@
-#!/usr/bin/env python3
-"""Decompose final decisions into 12-block structure — V2 calibrated on הכט.
-
-Key insight: DOCX extraction strips header blocks (א-ד). The real content
-starts at block ה (opening "לפנינו"). We identify blocks by known section
-headers and line-by-line analysis.
-"""
-
-import asyncio
-import json
-import re
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "mcp-server" / "src"))
-
-from legal_mcp.services.db import get_pool, init_schema, close_pool
-
-
-BLOCK_DEFS = [
-    ("block-alef", 1, "כותרת מוסדית", "template-fill"),
-    ("block-bet", 2, "הרכב הוועדה", "template-fill"),
-    ("block-gimel", 3, "צדדים", "template-fill"),
-    ("block-dalet", 4, "כותרת החלטה", "template-fill"),
-    ("block-he", 5, "פתיחה", "paraphrase"),
-    ("block-vav", 6, "רקע עובדתי", "reproduction"),
-    ("block-zayin", 7, "טענות הצדדים", "paraphrase"),
-    ("block-chet", 8, "הליכים בפני ועדת הערר", "reproduction"),
-    ("block-tet", 9, "תכניות חלות", "guided-synthesis"),
-    ("block-yod", 10, "דיון והכרעה", "rhetorical-construction"),
-    ("block-yod-alef", 11, "סיכום", "paraphrase"),
-    ("block-yod-bet", 12, "חתימות", "template-fill"),
-]
-
-
-def find_line(lines: list[str], pattern: str, start: int = 0) -> int:
-    """Find first line matching pattern (substring or regex). Returns -1 if not found."""
-    pat = re.compile(pattern)
-    for i in range(start, len(lines)):
-        if pat.search(lines[i]):
-            return i
-    return -1
-
-
-def slice_text(lines: list[str], start: int, end: int) -> str:
-    """Join lines[start:end] into text."""
-    if start < 0 or end <= start:
-        return ""
-    return "\n".join(lines[start:end]).strip()
-
-
-def count_words(text: str) -> int:
-    return len(text.split()) if text else 0
-
-
-def decompose(text: str) -> dict[str, str]:
-    """Parse decision into blocks. Returns {block_id: content}."""
-    lines = text.split("\n")
-    n = len(lines)
-    blocks = {}
-
-    # Find key section headers
-    # Style 1: רישוי — descriptive headers ("תמצית טענות הצדדים", "דיון והכרעה")
-    # Style 2: היטל השבחה — numbered headers ("א. רקע עובדתי", "ו. דיון והכרעה")
-    opening = find_line(lines, r"^לפנינו\s|^בפנינו\s|^בפני\s*ועדת|^בפני\s*בקשה")
-
-    claims = find_line(lines, r"תמצית\s*טענות|טענות\s*הצדדים|טענות\s*העוררי")
-    if claims == -1:
-        claims = find_line(lines, r"^טענות\s*העוררי")
-    if claims == -1:
-        # היטל השבחה style: "ב. טענות העורר"
-        claims = find_line(lines, r"^[א-ת][\.\)]\s*טענות")
-
-    background = find_line(lines, r"^[א-ת][\.\)]\s*רקע\s*עובדתי")
-
-    proceedings = find_line(lines, r"ההליכים\s*בפני|הליכים\s*בפני|הדיון\s*בפני\s*ועדת\s*הערר")
-    if proceedings == -1:
-        # היטל השבחה: "ד. הבהרות השמאית" or similar procedural sections
-        proceedings = find_line(lines, r"^[א-ת][\.\)]\s*הבהרות|^[א-ת][\.\)]\s*ההליך")
-
-    plans = find_line(lines, r"תכניות\s*חלות|המסגרת\s*הנורמטיבית|הוראות\s*התכנית")
-    if plans == -1:
-        plans = find_line(lines, r"^[א-ת][\.\)]\s*המסגרת\s*הנורמטיבית")
-
-    discussion = find_line(lines, r"^דיון\s*והכרעה|^דיון$|^הכרעה$")
-    if discussion == -1:
-        discussion = find_line(lines, r"^[א-ת][\.\)]\s*דיון\s*והכרעה")
-
-    summary = find_line(lines, r"^סיכום\s*$|^סוף\s*דבר\s*$")
-    if summary == -1:
-        summary = find_line(lines, r"^[א-ת][\.\)]\s*סיכום")
-    signature = find_line(lines, r"^ניתנה?\s*(היום|פה\s*אחד|ביום)")
-
-    # If no explicit discussion header, look for the opening formula
-    if discussion == -1:
-        discussion = find_line(lines, r"לאחר\s*שבחנו\s*את\s*טענות")
-
-    # ── Header blocks (א-ד): everything before opening ──
-    if opening >= 0:
-        header_text = slice_text(lines, 0, opening)
-        if header_text:
-            # Try to split header, but usually DOCX extraction loses these
-            blocks["block-alef"] = header_text
-        else:
-            blocks["block-alef"] = ""
-    else:
-        blocks["block-alef"] = ""
-
-    blocks["block-bet"] = ""  # Usually lost in extraction
-    blocks["block-gimel"] = ""
-    blocks["block-dalet"] = "החלטה"
-
-    # ── Block ה: Opening — first 1-3 paragraphs from "לפנינו" ──
-    if opening >= 0:
-        next_section = claims if claims > opening else discussion if discussion > opening else n
-        opening_end = opening + 1
-        for i in range(opening + 1, min(opening + 5, next_section)):
-            line = lines[i].strip()
-            if not line:
-                break
-            opening_end = i + 1
-        blocks["block-he"] = slice_text(lines, opening, opening_end)
-    else:
-        blocks["block-he"] = ""
-
-    # ── Block ו: Background ──
-    # Style 1 (רישוי): after opening, before claims
-    # Style 2 (היטל השבחה): explicit "א. רקע עובדתי" section
-    if background >= 0:
-        # Explicit background header (היטל השבחה style)
-        bg_end = claims if claims > background else (proceedings if proceedings > background else (discussion if discussion > background else n))
-        blocks["block-vav"] = slice_text(lines, background, bg_end)
-        # In this case, opening (ה) might not exist — "לפנינו" may be absent
-    elif opening >= 0 and claims > opening:
-        bg_start = opening + 1
-        he_lines = count_words(blocks.get("block-he", ""))
-        if he_lines > 0:
-            he_end = opening
-            for i in range(opening, min(opening + 5, claims)):
-                if lines[i].strip():
-                    he_end = i + 1
-                else:
-                    break
-            bg_start = he_end
-        blocks["block-vav"] = slice_text(lines, bg_start, claims)
-    elif opening >= 0 and discussion > opening:
-        blocks["block-vav"] = slice_text(lines, opening + 1, discussion)
-    else:
-        blocks["block-vav"] = ""
-
-    # ── Block ז: Claims — from claims header to next section ──
-    if claims >= 0:
-        claims_end = min(
-            x for x in [proceedings, plans, discussion, summary, n]
-            if x > claims
-        )
-        blocks["block-zayin"] = slice_text(lines, claims, claims_end)
-    else:
-        blocks["block-zayin"] = ""
-
-    # ── Block ח: Proceedings (optional) ──
-    if proceedings >= 0:
-        proc_end = min(
-            x for x in [plans, discussion, summary, n]
-            if x > proceedings
-        )
-        blocks["block-chet"] = slice_text(lines, proceedings, proc_end)
-    else:
-        blocks["block-chet"] = ""
-
-    # ── Block ט: Plans (optional) ──
-    if plans >= 0 and (discussion == -1 or plans < discussion):
-        plans_end = min(
-            x for x in [discussion, summary, n]
-            if x > plans
-        )
-        blocks["block-tet"] = slice_text(lines, plans, plans_end)
-    else:
-        blocks["block-tet"] = ""
-
-    # ── Block י: Discussion ──
-    if discussion >= 0:
-        disc_end = summary if summary > discussion else (signature if signature > discussion else n)
-        blocks["block-yod"] = slice_text(lines, discussion, disc_end)
-    else:
-        blocks["block-yod"] = ""
-
-    # ── Block יא: Summary ──
-    if summary >= 0:
-        summ_end = signature if signature > summary else n
-        blocks["block-yod-alef"] = slice_text(lines, summary, summ_end)
-    else:
-        blocks["block-yod-alef"] = ""
-
-    # ── Block יב: Signatures ──
-    if signature >= 0:
-        blocks["block-yod-bet"] = slice_text(lines, signature, n)
-    else:
-        blocks["block-yod-bet"] = ""
-
-    return blocks
-
-
-async def main():
-    await init_schema()
-    pool = await get_pool()
-
-    async with pool.acquire() as conn:
-        decisions = await conn.fetch(
-            """SELECT d.id as decision_id, c.case_number, c.title,
-                      doc.extracted_text
-               FROM decisions d
-               JOIN cases c ON c.id = d.case_id
-               JOIN documents doc ON doc.case_id = d.case_id AND doc.doc_type = 'decision'
-               WHERE d.status = 'final'
-               ORDER BY c.case_number"""
-        )
-
-    for dec in decisions:
-        decision_id = dec["decision_id"]
-        case_number = dec["case_number"]
-        text = dec["extracted_text"]
-        total_words = count_words(text)
-
-        print(f"\n{'='*60}")
-        print(f"מפרק: {case_number} — {dec['title']}")
-        print(f"סה\"כ מילים: {total_words}")
-        print(f"{'='*60}")
-
-        parsed = decompose(text)
-
-        async with pool.acquire() as conn:
-            # Delete existing blocks
-            await conn.execute(
-                "DELETE FROM decision_blocks WHERE decision_id = $1", decision_id
-            )
-
-            total_parsed_words = 0
-            for block_id, block_index, title, gen_type in BLOCK_DEFS:
-                content = parsed.get(block_id, "")
-                wc = count_words(content)
-                weight = round(wc / total_words * 100, 1) if total_words > 0 and wc > 0 else 0
-                status = "final" if wc > 0 else "empty"
-                total_parsed_words += wc
-
-                await conn.execute(
-                    """INSERT INTO decision_blocks
-                       (decision_id, block_id, block_index, title, content,
-                        word_count, weight_percent, generation_type, status)
-                       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)""",
-                    decision_id, block_id, block_index, title,
-                    content, wc, weight, gen_type, status,
-                )
-
-                marker = "✅" if wc > 0 else "⬜"
-                print(f"  {marker} {block_id:18s} | {title:25s} | {wc:5d} מילים | {weight:5.1f}%")
-
-            # Update decision totals
-            disc_words = count_words(parsed.get("block-yod", ""))
-            disc_paras = len([p for p in parsed.get("block-yod", "").split("\n") if p.strip() and len(p.strip()) > 20])
-            await conn.execute(
-                "UPDATE decisions SET total_words = $1, total_paragraphs = $2, updated_at = now() WHERE id = $3",
-                total_words, disc_paras, decision_id,
-            )
-
-            coverage = round(total_parsed_words / total_words * 100, 1) if total_words > 0 else 0
-            print(f"  --- כיסוי: {total_parsed_words}/{total_words} מילים ({coverage}%)")
-
-    # Summary
-    async with pool.acquire() as conn:
-        stats = await conn.fetch(
-            """SELECT block_id, count(*) as decisions,
-                      avg(word_count) as avg_words,
-                      avg(weight_percent) as avg_weight
-               FROM decision_blocks
-               WHERE word_count > 0
-               GROUP BY block_id ORDER BY block_id"""
-        )
-
-    print(f"\n{'='*60}")
-    print("סטטיסטיקה לפי בלוק (רק בלוקים עם תוכן):")
-    for s in stats:
-        print(f"  {s['block_id']:18s} | {s['decisions']} החלטות | ממוצע {s['avg_words']:.0f} מילים | {s['avg_weight']:.1f}%")
-
-    await close_pool()
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

scripts/deploy-track-changes.sh

@@ -0,0 +1,86 @@
+#!/bin/bash
+# deploy-track-changes.sh — פריסת ארכיטקטורת Track Changes לשתי חברות (CMP + CMPA)
+#
+# מה זה עושה:
+# 1. מוודא ש-skills קיימים ומסונכרנים בשתי החברות
+# 2. git commit + push (אם יש שינויים)
+# 3. הודעה להפעלת Coolify deploy
+#
+# שימוש:
+#   scripts/deploy-track-changes.sh
+
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "$0")/.." && pwd)"
+CMP_DIR="/home/chaim/.paperclip/instances/default/skills/42a7acd0-30c5-4cbd-ac97-7424f65df294"
+CMPA_DIR="/home/chaim/.paperclip/instances/default/skills/8639e837-4c9d-47fa-a76b-95788d651896"
+COOLIFY_UUID="gyjo0mtw2c42ej3xxvbz8zio"
+
+echo "▶ שלב 1: סנכרון skills בין CMP ל-CMPA"
+
+SKILLS=(legal-docx attach-precedents review-analysis writer-readiness
+        appendix-expert-intern bidi-table-rtl revise-draft)
+
+mkdir -p "$CMPA_DIR"
+for skill in "${SKILLS[@]}"; do
+  if [ ! -d "$CMP_DIR/$skill" ]; then
+    echo "  ⚠ skill לא קיים ב-CMP: $skill — דילוג"
+    continue
+  fi
+  if [ -d "$CMPA_DIR/$skill" ]; then
+    # Update only — don't delete any CMPA-specific files
+    rsync -av --update "$CMP_DIR/$skill/" "$CMPA_DIR/$skill/" > /dev/null
+    echo "  ✓ $skill (עודכן ב-CMPA)"
+  else
+    cp -r "$CMP_DIR/$skill" "$CMPA_DIR/$skill"
+    echo "  ✓ $skill (הועתק ל-CMPA)"
+  fi
+done
+
+echo ""
+echo "▶ שלב 2: בדיקת פיתוח אחרונה"
+
+cd "$REPO_ROOT"
+
+# Run mcp-server tests
+if [ -f mcp-server/.venv/bin/pytest ]; then
+  echo "  מריץ pytest..."
+  (cd mcp-server && .venv/bin/pytest tests/ -q 2>&1 | tail -5) || {
+    echo "  ✗ בדיקות נכשלו — עצירה"
+    exit 1
+  }
+  echo "  ✓ כל הבדיקות עברו"
+fi
+
+# Run TypeScript check
+if [ -d web-ui/node_modules ]; then
+  echo "  מריץ tsc..."
+  (cd web-ui && npx tsc --noEmit 2>&1 | head -10) || {
+    echo "  ✗ שגיאות TypeScript — עצירה"
+    exit 1
+  }
+  echo "  ✓ TypeScript נקי"
+fi
+
+echo ""
+echo "▶ שלב 3: סטטוס git"
+
+if [ -n "$(git status --porcelain)" ]; then
+  echo "  יש שינויים ב-git — לא מבצע commit אוטומטי (ריצו ידנית)"
+  git status --short
+  echo ""
+  echo "  הפקודה להרצה:"
+  echo "    git add -A"
+  echo "    git commit -m \"Add Track Changes support for draft revisions (CMP + CMPA)\""
+  echo "    git push origin main"
+else
+  echo "  ✓ אין שינויים לא שמורים"
+fi
+
+echo ""
+echo "▶ שלב 4: Coolify deploy"
+echo "  לאחר push, הריצו:"
+echo "    mcp__coolify__deploy עם UUID=$COOLIFY_UUID"
+echo "  או דרך UI: https://coolify.nautilus.marcusgroup.org"
+echo ""
+echo "✓ הסקריפט הסתיים"

scripts/extract_google_vision.py

@@ -1,66 +0,0 @@
-"""Extract text from PDF using Google Cloud Vision API."""
-
-import io
-import time
-from pathlib import Path
-
-import fitz  # PyMuPDF for rendering pages to images
-from google.cloud import vision
-
-API_KEY = "AIzaSyDZgUsxsy_FHkkREU7R_oQLJALU3_V26j8"
-
-PDF_PATH = Path("/home/chaim/legal-ai/data/cases/1130-25/documents/originals/מרק קובר-כתב ערר.pdf")
-OUTPUT_DIR = Path("/home/chaim/legal-ai/data/cases/1130-25/documents/extracted")
-
-
-def main():
-    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-    client = vision.ImageAnnotatorClient(
-        client_options={"api_key": API_KEY}
-    )
-
-    doc = fitz.open(str(PDF_PATH))
-    page_count = len(doc)
-    print(f"Processing: {PDF_PATH.name} ({page_count} pages)\n")
-
-    pages_text = []
-    total_time = 0.0
-
-    for i in range(page_count):
-        page = doc[i]
-        pix = page.get_pixmap(dpi=300)
-        img_bytes = pix.tobytes("png")
-
-        image = vision.Image(content=img_bytes)
-
-        print(f"  Page {i+1}/{page_count}...", end=" ", flush=True)
-        t0 = time.time()
-        response = client.document_text_detection(
-            image=image,
-            image_context={"language_hints": ["he"]}
-        )
-        elapsed = time.time() - t0
-        total_time += elapsed
-
-        if response.error.message:
-            print(f"ERROR: {response.error.message}")
-            pages_text.append("")
-            continue
-
-        text = response.full_text_annotation.text if response.full_text_annotation else ""
-        pages_text.append(text)
-        print(f"{len(text):,} chars, {elapsed:.1f}s")
-
-    doc.close()
-
-    full_text = "\n\n".join(pages_text)
-    out_file = OUTPUT_DIR / f"{PDF_PATH.stem}.md"
-    out_file.write_text(full_text, encoding="utf-8")
-
-    print(f"\nTotal: {len(full_text):,} chars, {len(full_text.split()):,} words, {total_time:.1f}s")
-    print(f"Saved: {out_file}")
-
-
-if __name__ == "__main__":
-    main()

scripts/extract_google_vision_single.py

@@ -1,54 +0,0 @@
-"""Extract text from a single PDF using Google Cloud Vision API."""
-
-import sys
-import time
-from pathlib import Path
-
-import fitz
-from google.cloud import vision
-
-API_KEY = "AIzaSyDZgUsxsy_FHkkREU7R_oQLJALU3_V26j8"
-OUTPUT_DIR = Path("/home/chaim/legal-ai/data/cases/1130-25/documents/extracted")
-
-def main():
-    pdf_path = Path(sys.argv[1])
-    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-    client = vision.ImageAnnotatorClient(client_options={"api_key": API_KEY})
-    doc = fitz.open(str(pdf_path))
-    page_count = len(doc)
-    print(f"Processing: {pdf_path.name} ({page_count} pages)\n")
-
-    pages_text = []
-    total_time = 0.0
-
-    for i in range(page_count):
-        page = doc[i]
-        pix = page.get_pixmap(dpi=300)
-        img_bytes = pix.tobytes("png")
-        image = vision.Image(content=img_bytes)
-
-        print(f"  Page {i+1}/{page_count}...", end=" ", flush=True)
-        t0 = time.time()
-        response = client.document_text_detection(image=image, image_context={"language_hints": ["he"]})
-        elapsed = time.time() - t0
-        total_time += elapsed
-
-        if response.error.message:
-            print(f"ERROR: {response.error.message}")
-            pages_text.append("")
-            continue
-
-        text = response.full_text_annotation.text if response.full_text_annotation else ""
-        pages_text.append(text)
-        print(f"{len(text):,} chars, {elapsed:.1f}s")
-
-    doc.close()
-    full_text = "\n\n".join(pages_text)
-    out_file = OUTPUT_DIR / f"{pdf_path.stem}.md"
-    out_file.write_text(full_text, encoding="utf-8")
-    print(f"\nTotal: {len(full_text):,} chars, {len(full_text.split()):,} words, {total_time:.1f}s")
-    print(f"Saved: {out_file}")
-
-if __name__ == "__main__":
-    main()

scripts/import-final-decisions.py

@@ -1,202 +0,0 @@
-#!/usr/bin/env python3
-"""Import 6 final signed decisions: extract text, store in DB."""
-
-import asyncio
-import json
-import sys
-from datetime import date
-from pathlib import Path
-from uuid import UUID
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "mcp-server" / "src"))
-
-import fitz  # PyMuPDF
-from docx import Document as DocxDocument
-
-from legal_mcp.services.db import get_pool, init_schema, close_pool
-
-
-# ═══════════════════════════════════════════════════════════════════
-# 6 Final Decisions
-# ═══════════════════════════════════════════════════════════════════
-
-FINAL_DECISIONS = [
-    {
-        "case_number": "1180-1181",
-        "file_path": "legacy/dafna-tamir/04_Archive/ערר 1180-1181 הכט/החלטה/הכט 1180-1181.pdf",
-        "title": "החלטה סופית — הכט 1180-1181",
-        "outcome": "rejected",
-        "decision_date": date(2026, 2, 5),
-    },
-    {
-        "case_number": "8255-25",
-        "file_path": "legacy/dafna-tamir/04_Archive/בל\"מ 8255-25 אפרים אבי נ' הוועדה המקומית לתכנון ובניה/החלטה/אליהו הרנון - להפצה.docx",
-        "title": "החלטה סופית — אפרים אבי 8255-25",
-        "outcome": "rejected",
-        "decision_date": None,
-    },
-    {
-        "case_number": "8007-24",
-        "file_path": "legacy/dafna-tamir/04_Archive/ערר 8007-24-עומר דרוויש-ערר על שומה מכרעת/החלטה/החלטה-סופית.docx",
-        "title": "החלטה סופית — עומר דרוויש 8007-24",
-        "outcome": "",
-        "decision_date": None,
-    },
-    {
-        "case_number": "1113/25",
-        "file_path": "legacy/dafna-tamir/04_Archive/ערר-1113-25-אייל-מבורך/החלטה/החלטה-1113-25-טיוטה-סופית.docx",
-        "title": "החלטה סופית — מבורך 1113-25",
-        "outcome": "",
-        "decision_date": None,
-    },
-    {
-        "case_number": "1126/25+1141/25",
-        "file_path": "legacy/dafna-tamir/04_Archive/ערר-1126-25-תמא-38-בית-הכרם/החלטה/בית הכרם-טיוטת החלטה-9.pdf",
-        "title": "החלטה סופית — בית הכרם 1126/25",
-        "outcome": "partial",
-        "decision_date": date(2026, 3, 1),
-    },
-    {
-        "case_number": "1128/25",
-        "file_path": "legacy/dafna-tamir/04_Archive/ערר-1128-25-שטרית/החלטה/1128-25 החלטה להפצה.pdf",
-        "title": "החלטה סופית — שטרית 1128-25",
-        "outcome": "",
-        "decision_date": None,
-    },
-]
-
-PROJECT_ROOT = Path(__file__).parent.parent
-
-
-def extract_pdf_text(file_path: Path) -> str:
-    """Extract text from PDF using PyMuPDF."""
-    doc = fitz.open(str(file_path))
-    text_parts = []
-    for page in doc:
-        text_parts.append(page.get_text())
-    doc.close()
-    return "\n".join(text_parts)
-
-
-def extract_docx_text(file_path: Path) -> str:
-    """Extract text from DOCX."""
-    doc = DocxDocument(str(file_path))
-    return "\n".join(p.text for p in doc.paragraphs if p.text.strip())
-
-
-def extract_text(file_path: Path) -> str:
-    """Extract text based on file extension."""
-    suffix = file_path.suffix.lower()
-    if suffix == ".pdf":
-        return extract_pdf_text(file_path)
-    elif suffix == ".docx":
-        return extract_docx_text(file_path)
-    else:
-        raise ValueError(f"Unsupported format: {suffix}")
-
-
-def count_words(text: str) -> int:
-    return len(text.split())
-
-
-async def main():
-    await init_schema()
-    pool = await get_pool()
-
-    for d in FINAL_DECISIONS:
-        file_path = PROJECT_ROOT / d["file_path"]
-        if not file_path.exists():
-            print(f"❌ קובץ לא נמצא: {file_path}")
-            continue
-
-        # Extract text
-        print(f"\nמחלץ טקסט: {d['title']}...")
-        text = extract_text(file_path)
-        word_count = count_words(text)
-        print(f"   {word_count} מילים, {len(text)} תווים")
-
-        async with pool.acquire() as conn:
-            # Get case_id
-            case_id = await conn.fetchval(
-                "SELECT id FROM cases WHERE case_number = $1", d["case_number"]
-            )
-            if not case_id:
-                print(f"   ⚠ תיק {d['case_number']} לא נמצא ב-DB — מדלג")
-                continue
-
-            # Register document
-            existing_doc = await conn.fetchval(
-                "SELECT id FROM documents WHERE file_path = $1",
-                str(file_path),
-            )
-            if existing_doc:
-                doc_id = existing_doc
-                print(f"   מסמך כבר קיים ב-DB: {doc_id}")
-                # Update text
-                await conn.execute(
-                    """UPDATE documents SET extracted_text = $1, extraction_status = 'completed'
-                       WHERE id = $2""",
-                    text, doc_id,
-                )
-            else:
-                doc_id = await conn.fetchval(
-                    """INSERT INTO documents (case_id, doc_type, title, file_path, extracted_text, extraction_status, page_count)
-                       VALUES ($1, 'decision', $2, $3, $4, 'completed', $5)
-                       RETURNING id""",
-                    case_id, d["title"], str(file_path), text,
-                    len(fitz.open(str(file_path))) if file_path.suffix == ".pdf" else None,
-                )
-                print(f"   מסמך נרשם: {doc_id}")
-
-            # Create/update decision record
-            existing_decision = await conn.fetchval(
-                "SELECT id FROM decisions WHERE case_id = $1", case_id
-            )
-            if existing_decision:
-                await conn.execute(
-                    """UPDATE decisions SET status = 'final', outcome = $1, total_words = $2,
-                       decision_date = $3, updated_at = now() WHERE id = $4""",
-                    d["outcome"], word_count, d["decision_date"], existing_decision,
-                )
-                decision_id = existing_decision
-                print(f"   החלטה עודכנה: {decision_id}")
-            else:
-                decision_id = await conn.fetchval(
-                    """INSERT INTO decisions (case_id, version, status, outcome, outcome_summary,
-                       total_words, decision_date, author)
-                       VALUES ($1, 1, 'final', $2, $3, $4, $5, 'דפנה תמיר')
-                       RETURNING id""",
-                    case_id, d["outcome"], d["title"], word_count, d["decision_date"],
-                )
-                print(f"   החלטה נוצרה: {decision_id}")
-
-            # Update case status
-            await conn.execute(
-                "UPDATE cases SET status = 'final', expected_outcome = $1, updated_at = now() WHERE id = $2",
-                d["outcome"], case_id,
-            )
-
-        print(f"   ✅ הושלם: {d['case_number']}")
-
-    # Summary
-    async with pool.acquire() as conn:
-        doc_count = await conn.fetchval(
-            "SELECT count(*) FROM documents WHERE doc_type = 'decision' AND extraction_status = 'completed'"
-        )
-        dec_count = await conn.fetchval(
-            "SELECT count(*) FROM decisions WHERE status = 'final'"
-        )
-        total_words = await conn.fetchval(
-            "SELECT sum(total_words) FROM decisions WHERE status = 'final'"
-        )
-
-    await close_pool()
-
-    print(f"\n{'='*50}")
-    print(f"✅ סה\"כ מסמכי החלטה: {doc_count}")
-    print(f"✅ סה\"כ החלטות סופיות: {dec_count}")
-    print(f"✅ סה\"כ מילים: {total_words:,}")
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

scripts/notify.py

@@ -15,7 +15,7 @@ SMTP_HOST = "smtp.gmail.com"
 SMTP_PORT = 587
 FROM_EMAIL = "notify@marcus-law.co.il"
 FROM_PASS = "vuva jwed lbuz xjds"
-TO_EMAIL = "paperclip+chaim@marcus-law.co.il"
+TO_EMAIL = "chaim+paperclip@marcus-law.co.il"
 
 
 def send(subject: str, body: str) -> bool:

scripts/retrofit_case.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""retrofit_case.py — הזרקת bookmarks רטרואקטיבית לקובץ קיים בתיק.
+
+שימוש:
+    python scripts/retrofit_case.py <case_number> <filename>
+
+דוגמה:
+    python scripts/retrofit_case.py 1033-25 עריכה-v1.docx
+
+פעולה:
+    1. מזהה את הקובץ ב-data/cases/{case_number}/exports/
+    2. מזריק bookmarks ב-12 הבלוקים (heuristic)
+    3. שומר backup כ-{filename}.pre-retrofit.docx
+    4. מדפיס summary — אילו בלוקים זוהו, אילו חסרים
+
+לתיק 1033-25 — הריצו פעם אחת על עריכה-v1.docx הקיים. אחרי זה תוכלו
+להריץ revise_draft דרך ה-CEO.
+
+הערה: השירות הזה נקרא גם אוטומטית דרך apply_user_edit tool ב-MCP,
+אז אחרי deploy אין צורך להריץ ידנית. זה לגיבוי/ניפוי.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+# Make mcp-server importable when run from repo root
+REPO_ROOT = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(REPO_ROOT / "mcp-server" / "src"))
+
+
+def main() -> int:
+    if len(sys.argv) != 3:
+        print(__doc__)
+        return 2
+
+    case_number = sys.argv[1]
+    filename = sys.argv[2]
+
+    from legal_mcp.services import docx_retrofit, docx_reviser
+
+    case_dir = REPO_ROOT / "data" / "cases" / case_number / "exports"
+    file_path = case_dir / filename
+
+    if not file_path.exists():
+        print(f"✗ קובץ לא נמצא: {file_path}", file=sys.stderr)
+        return 1
+
+    print(f"מעבד: {file_path}")
+    print(f"  גודל: {file_path.stat().st_size:,} בייט")
+
+    # Existing bookmarks
+    before = docx_reviser.list_bookmarks(file_path)
+    print(f"  bookmarks קיימים: {before or '(ריק)'}")
+
+    result = docx_retrofit.retrofit_bookmarks(file_path)
+    print()
+    print("תוצאה:")
+    print(json.dumps(result, ensure_ascii=False, indent=2))
+
+    # Verify post-state
+    after = docx_reviser.list_bookmarks(file_path)
+    print()
+    print(f"bookmarks אחרי: {len(after)} — {after}")
+
+    backup = file_path.with_suffix(".pre-retrofit.docx")
+    if backup.exists():
+        print(f"גיבוי נשמר: {backup}")
+
+    # Build an MCP-callable invocation hint
+    rel = file_path.relative_to(REPO_ROOT)
+    print()
+    print("השלב הבא: לעדכן active_draft_path ב-DB. הפקודה:")
+    print(f'  mcp__legal-ai__apply_user_edit case_number="{case_number}" '
+          f'edit_filename="{filename}"')
+    print()
+    print(f"(זה ירוץ retrofit שוב idempotent ואז יעדכן את DB)")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/test-search.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-"""Test semantic search functions."""
-
-import asyncio
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent.parent / "mcp-server" / "src"))
-
-from legal_mcp.services.db import search_similar_paragraphs, search_similar_case_law, search_precedents, init_schema
-from legal_mcp.services.embeddings import embed_query
-
-
-async def main():
-    await init_schema()
-
-    queries = [
-        "טענות קנייניות רוב דרוש בעלי דירות רכוש משותף",
-        "חניה תנועה חניות מצוקת חניה",
-        "היטל השבחה שמאי מכריע התערבות",
-    ]
-
-    for query in queries:
-        print(f'=== שאילתה: "{query}" ===')
-        emb = await embed_query(query)
-        results = await search_precedents(emb, limit=3)
-
-        if not results:
-            print("  אין תוצאות")
-        else:
-            for i, r in enumerate(results):
-                score = r["score"]
-                cn = r["case_number"]
-                rtype = r["type"]
-                content = r["content"][:120].replace("\n", " ")
-                print(f"  {i+1}. [{rtype}] {score:.3f} | {cn} | {content}")
-        print()
-
-
-asyncio.run(main())

skills/dafna-decision-template/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: dafna-decision-template
+description: >
+  ייצוא מסמכי DOCX עבור ועדת ערר לתכנון ובניה מחוז ירושלים (יו"ר עו"ד דפנה תמיר),
+  באמצעות שימוש בסגנונות המוגדרים בטמפלט Word של דפנה (`טיוטת החלטה.dotx`).
+  הסקיל מחיל את סגנונות הטמפלט (Normal/Heading 1/Heading 2/Quote/List Paragraph)
+  על תוכן שנכתב מתוכנתית — בלי להגדיר פונט/גודל/RTL/שוליים ידנית.
+
+  טריגרים: "ייצוא החלטה", "ייצוא ניתוח משפטי", "DOCX של דפנה",
+  "טמפלט החלטה", "סגנונות החלטה", "Word עם David", "מסמך ועדת ערר",
+  "הורדת החלטה", "פסקה ממוספרת בעברית", "(א) (ב) (ג)",
+  כל בקשה להוציא מסמך Word המבוסס על טמפלט דפנה.
+---
+
+# Dafna Decision Template — ייצוא DOCX מסגנונות טמפלט
+
+## מה זה עושה
+
+סקיל זה הוא **layer דק מעל `python-docx`** שמטעין את הטמפלט של דפנה
+([skills/docx/decision_template.docx](../docx/decision_template.docx) —
+מומר מ-`data/training/טיוטת החלטה.dotx`) וכותב תוכן חדש על בסיסו, **על ידי
+שיוך שמות סגנונות בלבד** (`paragraph.style = "Heading 2"`). העיצוב —
+פונט David, RTL, גדלים, הזחות, מספור אוטומטי — מגיע מה-`styles.xml`
+של הטמפלט.
+
+השירות המעשי נמצא ב-
+[`mcp-server/src/legal_mcp/services/analysis_docx_exporter.py`](../../mcp-server/src/legal_mcp/services/analysis_docx_exporter.py).
+הסקיל מתעד את **הכללים** שה-service מיישם, כך שניתן לשחזר/להרחיב אותם
+בסקריפטים אחרים ללא צורך לגלות הכל מחדש.
+
+---
+
+## 🔴 קריטי — 5 עקרונות שחייבים לזכור
+
+### 1. **לא להגדיר font/size/indent ידנית** — תמיד style
+```python
+# ❌ אל
+run.font.name = "David"; run.font.size = Pt(13)
+paragraph.paragraph_format.alignment = WD_ALIGN_PARAGRAPH.RIGHT
+
+# ✅ כן
+paragraph = doc.add_paragraph(style="Normal")   # כל השאר מגיע מהטמפלט
+```
+
+### 2. **RTL חייב דגלים ב-paragraph וב-run — גם אם הסגנון כולל bidi**
+```python
+# ❌ אל — עברית תצא ב-Times New Roman כי Word לא יודע שזה complex-script
+p = doc.add_paragraph(style="Normal")
+p.add_run("טקסט בעברית")
+
+# ✅ כן — מסמנים את ה-run כ-RTL
+p = doc.add_paragraph(style="Normal")
+_mark_paragraph_rtl(p)
+run = p.add_run("טקסט בעברית")
+_mark_run_rtl(run)    # ← מוסיף <w:rtl/> ל-rPr
+```
+בלי הדגל הזה, Word נופל בחזרה ל-`ascii` font (Times New Roman) במקום
+ל-`cs` font (David). זו הסיבה הנפוצה ביותר לתוצאה "עברית ב-Times New Roman".
+
+ראה [references/rtl-runs.md](references/rtl-runs.md) לפרטים מלאים.
+
+### 3. **`.dotx` לא נטען ישירות** — יש להמיר ל-`.docx` פעם אחת
+python-docx פותח רק `.docx`. להמרה: `scripts/convert_decision_template.py`
+(בשורש הפרויקט). יש להסיר:
+- `word/glossary/*` parts
+- Override entries שמצביעים אליהם ב-`[Content_Types].xml`
+- Relationship `glossaryDocument` ב-`word/_rels/document.xml.rels`
+- להחליף content-type מ-`...template.main+xml` ל-`...document.main+xml`
+
+ראה [references/dotx-to-docx.md](references/dotx-to-docx.md).
+
+### 4. **Title לא טוב ככותרת עברית** — השתמש ב-Heading 1
+הסגנון `Title` בטמפלט מפנה ל-theme fonts (`majorFont`). ב-theme1.xml:
+`majorFont.latin = "Aptos Display"`, `majorFont.cs = ""` (ריק).
+לכן עברית תרונדר ב-Latin fallback.
+
+`Heading 1` יורש cs="David" מ-`Normal` — השתמש בו לכותרת ראשית.
+
+### 5. **מספור אוטומטי רק ב-`List Paragraph`** — decimal בלבד
+`List Paragraph` (styleId `a0`) מקושר ל-`numId=1 → numFmt=decimal`.
+כלומר Word יוסיף אוטומטית "1.", "2.", "3." לכל פסקה עם הסגנון הזה.
+
+- שורות שמתחילות ב-`N.` → הסר את המספר מהטקסט, החל `List Paragraph`.
+- שורות שמתחילות ב-`(א)` `(ב)` → השתמש ב-`List Paragraph` **עם הסרת `<w:numPr>`**,
+  כי המספור בעברית נכתב בעצמו על ידי המחבר.
+- Bullets (`- `, `• `) → הסר את הסימן, השאר `Normal`.
+
+ראה [references/style-mapping.md](references/style-mapping.md).
+
+---
+
+## הטמפלט — מיפוי סגנונות
+
+מיפוי מלא של הסגנונות בטמפלט ל-content type. זה ה"חוזה" של הסקיל —
+כל שינוי דרך השירות צריך להיצמד אליו.
+
+| תוכן | style name | הערה |
+|------|-----------|------|
+| כותרת מסמך ("ניתוח משפטי וכתיבת עמדה בערר X") | `Heading 1` | יורש cs="David" |
+| כותרת מקטע ראשי (רקע דיוני, פסיקה כללית, סוגיות להכרעה, מסקנות) | `Heading 2` | bold + underline |
+| כותרת משנה בתוך סוגיה (טענה (claim), תשובה, ניתוח, נקודות פתוחות, …) | `Heading 2` | |
+| שם subsection (טענת סף 1, סוגיה 2) | `Normal` + bold run | |
+| פסקת רקע רגילה | `Normal` | David 13pt, justify, RTL |
+| פסקת רשימה ממוספרת (1., 2., 3.) | `List Paragraph` | Word ימספר |
+| פסקת רשימה בעברית ((א), (ב)) | `List Paragraph` + `_strip_numpr()` | המספור נשאר בטקסט |
+| ציטוט פסיקה | `Quote` | bold + הזחה |
+| citation / מקור | `Normal` + italic | |
+
+ראה [references/style-mapping.md](references/style-mapping.md) לטבלה
+מורחבת עם ה-XML של כל סגנון.
+
+---
+
+## תוכן המקור — `analysis-and-research.md`
+
+הקובץ נכתב על ידי `legal-analyst` agent. מבנה מצופה:
+
+```markdown
+# ניתוח משפטי וכתיבת עמדה — ערר {case_number}
+תאריך: DD.MM.YYYY
+
+## רקע דיוני
+{prose content}
+
+## עובדות מוסכמות
+1. ...
+
+## עובדות שנויות במחלוקת
+1. ...
+
+## טענות סף
+### טענה {n}: {title}
+**עמדת המבקשת:** ...
+**עמדת ועדת הערר:** [ימולא ע"י יו"ר הוועדה]
+
+## סוגיות להכרעה
+### סוגיה {n}: {title}
+**ממצאים עובדתיים:**
+...
+**טענה (claim):**
+העורר טוען כי:
+(א) ...
+(ב) ...
+**ניתוח:**
+...
+- **נקודות פתוחות:**
+  1. ...
+- **הערכה ראשונית:** {prose}
+**עמדת ועדת הערר:** [ימולא ע"י יו"ר הוועדה]
+
+## מסקנות
+...
+```
+
+ה-parser (`research_md.py`) חולק את זה ל-`threshold_claims[]`, `issues[]`,
+prose sections, ו-`conclusions`. חשוב: **שמות sections חייבים להכיל את
+המילים המופתח** (`רקע דיוני`, `טענות סף`, …) — ה-parser עובד לפי matching של
+keywords, לא לפי מספר ה-H2.
+
+---
+
+## זרימת הייצוא
+
+סדר המקטעים ב-DOCX (גם אם סדר ה-H2 ב-MD שונה):
+
+1. **כותרת** (Heading 1) + שורת תאריך
+2. **רקע** (Heading 2) — `represented_party`, `procedural_background`,
+   `agreed_facts`, `disputed_facts` (אם קיימים)
+3. **פסיקה כללית** (Heading 2) — `case_precedents` עם `section_id=NULL`
+4. **טענות סף** (Heading 2) — לכל subsection: title, fields, chair_position, precedents
+5. **סוגיות להכרעה** (Heading 2) — אותה חלוקה
+6. **מסקנות** (Heading 2) — בסוף
+
+הסיבה: בקריאה משפטית נכון להציג תחילה רקע ועובדות, ואז את הדיון. פסיקה
+כללית מופיעה לפני הסוגיות כי היא רוחבית.
+
+---
+
+## עיבוד שורות — `_classify_line()`
+
+ה-service מפרש כל שורה של content לאחת מ-6 קטגוריות:
+
+| kind | דוגמה | מה קורה |
+|------|--------|---------|
+| `label_heading` | `**נקודות פתוחות:**` (שורה שלמה, כולל `- **X:**`) | Heading 2 |
+| `label_heading` (plain) | `העורר טוען כי:` (שורה קצרה שמסתיימת ב-`:`) | Heading 2 |
+| `inline_label` | `**שאלה עקרונית:** מה...` | Normal עם label bold inline |
+| `numbered` | `1. הנספח אינו מחייב` | List Paragraph, המספר מוסר |
+| `bullet` | `- nevo (קלאסי)...` | Normal, הסימן מוסר |
+| `heb_letter` | `(א) הנספח אינו...` | List Paragraph + strip numPr |
+| `plain` | רגיל | Normal |
+
+בנוסף, **inline `**...**`** מעובד בכל ריצה דרך `_add_runs_with_inline_bold`
+— כל `**word**` הופך ל-run נפרד עם `bold=True`.
+
+ראה [references/line-classification.md](references/line-classification.md).
+
+---
+
+## מקפים — מדיניות
+
+המשתמש (דפנה) ביקשה: **"לא רוצה מקפים בכלל"**. הסקיל מסיר:
+
+- `—` (em-dash, U+2014)
+- `–` (en-dash, U+2013)
+
+מכל טקסט שהקוד כותב למסמך (גם תוכן מהמקור). מקפים רגילים (`-`)
+נשמרים. הפונקציה: `_no_dash()`.
+
+---
+
+## שדות ריקים — placeholder
+
+שדה `chair_position` (עמדת ועדת הערר) שמכיל אחד מהסימנים הריקים
+(`[ימולא ע"י יו"ר הוועדה]`, `[טרם מולא]`, וכד') → מוחלף ב-
+`[טרם מולאה עמדת ועדת הערר]` בסגנון italic. זה סימן ויזואלי ברור
+שנשאר עדיין להשלים.
+
+---
+
+## שימוש — API
+
+```python
+from legal_mcp.services.analysis_docx_exporter import build_analysis_docx
+
+path = await build_analysis_docx("8070-25")
+# → data/cases/8070-25/exports/ניתוח-משפטי-v{N}.docx
+```
+
+Endpoint ציבורי: `GET /api/cases/{case_number}/research/analysis/export-docx`
+
+---
+
+## התמודדות עם בעיות נפוצות
+
+### "עברית יוצאת ב-Times New Roman"
+- חסר `<w:rtl/>` ב-run. הוסף `_mark_run_rtl(run)` אחרי כל `add_run`.
+- בדוק: הסגנון שאתה משתמש בו יש בו `cs="David"` (או יורש מ-Normal שיש לו)?
+
+### "המספור כפול: '1. (א) ...'"
+- אתה משתמש ב-`List Paragraph` על שורה עם `(א)`. צריך `_strip_numpr(para)`.
+
+### "כוכביות `**...**` מופיעות במסמך"
+- הקפד להעביר תוכן דרך `_add_runs_with_inline_bold()`, לא `paragraph.add_run()`.
+
+### "התבנית לא נטענת"
+- הרץ מחדש `python scripts/convert_decision_template.py`. בדוק שה-docx
+  שנוצר פותחיb ב-Word ללא שגיאות.
+
+### "המספור ברשימה השנייה ממשיך מהראשונה (4,5,6 במקום 1,2,3)"
+- ידוע. הפתרון: להוסיף override של `numId` ברמת ה-paragraph הראשון של
+  הרשימה החדשה. עדיין לא מיושם — ראה "שיפורים עתידיים".
+
+---
+
+## שיפורים עתידיים (TODO)
+
+- [ ] Reset של מספור List Paragraph בין רשימות נפרדות (לא רציף).
+- [ ] תמיכה ב-`פיסקת רשימה - ללא מספור` (styleId `-`) לbullets.
+- [ ] עיצוב מותאם לסוג הערר (1xxx/8xxx/9xxx) — כרגע אחיד.
+- [ ] אפשרות להוריד רק מקטעים נבחרים (רק טענות סף, רק מסקנות, וכו').
+
+---
+
+## מבנה קבצים
+
+```
+skills/dafna-decision-template/
+├── SKILL.md                              ← הקובץ הזה
+└── references/
+    ├── dotx-to-docx.md                  ← איך ממירים .dotx ל-.docx
+    ├── rtl-runs.md                       ← למה `<w:rtl/>` חשוב בכל run
+    ├── style-mapping.md                  ← מיפוי מלא של סגנונות הטמפלט
+    └── line-classification.md            ← לוגיקת _classify_line()
+
+mcp-server/src/legal_mcp/services/
+└── analysis_docx_exporter.py             ← המימוש המעשי
+
+scripts/
+└── convert_decision_template.py          ← המרת dotx → docx (חד-פעמי)
+
+skills/docx/
+└── decision_template.docx                ← הטמפלט המומר (artifact)
+```
+
+---
+
+## היסטוריה
+
+| גרסה | תאריך | שינוי |
+|-------|-------|-------|
+| v1.0  | 2026-04-16 | יצירת הסקיל. מיפוי ראשוני של סגנונות, תמיכה ב-RTL runs, inline bold, (א)(ב), Heading 1/2, מקטעי רקע. |

skills/dafna-decision-template/references/dotx-to-docx.md

@@ -0,0 +1,58 @@
+# המרת `.dotx` → `.docx` עבור python-docx
+
+## למה
+
+python-docx **לא יודע לפתוח** קובצי Word Template (`.dotx`). ניסיון לפתיחה
+זורק:
+```
+ValueError: file 'X.dotx' is not a Word file, content type is
+'application/vnd.openxmlformats-officedocument.wordprocessingml.template.main+xml'
+```
+
+כי `main document part` של `.dotx` מסומן כ-template, לא כ-document.
+
+## הפתרון — המרה חד-פעמית
+
+קובץ `.dotx` הוא ZIP שכולל את אותם parts כמו `.docx` + `word/glossary/`
+(building blocks). להמרה:
+
+1. פתח את ה-ZIP.
+2. **הסר** את כל ה-parts תחת `word/glossary/`.
+3. **תקן** `[Content_Types].xml`:
+   - החלף `template.main+xml` ב-`document.main+xml`
+   - הסר `<Override>` entries שמצביעים ל-`/word/glossary/...`
+4. **תקן** `word/_rels/document.xml.rels`:
+   - הסר את ה-`<Relationship>` עם
+     `Type=".../relationships/glossaryDocument"`
+5. שמור מחדש כ-ZIP עם סיומת `.docx`.
+
+## הסקריפט
+
+[`scripts/convert_decision_template.py`](../../../scripts/convert_decision_template.py)
+(בשורש הפרויקט) עושה את זה. הרץ אותו:
+
+- פעם אחת אחרי clone של הפרויקט (אם `skills/docx/decision_template.docx`
+  לא קיים).
+- בכל פעם שדפנה מעדכנת את `data/training/טיוטת החלטה.dotx`.
+
+```bash
+python scripts/convert_decision_template.py
+# → skills/docx/decision_template.docx
+```
+
+הסקריפט כולל verification שבודק שהקובץ שנוצר נטען נקי ב-python-docx
+ושהסגנונות הקריטיים (Normal, Heading 2, Quote, List Paragraph, Title)
+נמצאים בו.
+
+## למה לא `docxtpl`?
+
+`docxtpl` מיועד ל-**placeholder substitution** סגנון Jinja2
+(`{{ variable }}`). הטמפלט שלנו לא מכיל placeholders — אנחנו מרכיבים
+תוכן דינמי. `python-docx` על טמפלט `.docx` נקי מספיק לגמרי.
+
+## הימנע מ-
+
+- **אל תנסה** להוריד את ה-glossary רק מ-`[Content_Types].xml` בלי להסיר
+  את ה-`<Relationship>` שמפנה אליו → תקבל dangling reference.
+- **אל תנסה** להשתמש ב-`.dotx` ישירות דרך `zipfile` + לבנות Document
+  ידנית — חוסך 10 שורות אבל מאבד את כל ה-robustness של python-docx.

skills/dafna-decision-template/references/line-classification.md

@@ -0,0 +1,115 @@
+# סיווג שורות — `_classify_line()`
+
+כל שורה של content מה-MD עוברת דרך `_classify_line()` שמחזירה
+`(kind, clean_text)`. הקטגוריה מכתיבה איזה סגנון Word יוחל.
+
+## טבלת הקטגוריות
+
+| kind | regex | clean_text | נמפה ל-style |
+|------|--------|-----------|--------------|
+| `label_heading` | `^\s*\*\*([^\n*]+?):\*\*\s*$` | `"$1"` | `Heading 2` |
+| `label_heading` (plain) | `^\s*([^\n:]{2,40}):\s*$` | `"$1"` | `Heading 2` |
+| `inline_label` | `^\s*\*\*([^\n*]+?):\*\*\s+(.+)$` | `"$1\x00$2"` | `Normal` + bold label + value |
+| `numbered` | `^\s*(\d+)[.)]\s+(.+)$` | `"$2"` | `List Paragraph` |
+| `bullet` | `^\s*[\-\u2022\*\u25CF\u25E6]\s+(.+)$` | `"$1"` | `Normal` (marker stripped) |
+| `heb_letter` | `^\s*\([א-ת]\)\s+` | **full line** (marker kept) | `List Paragraph` + `_strip_numpr()` |
+| `plain` | fallback | line | `Normal` |
+
+## סדר הבדיקות (חשוב!)
+
+```
+1. STANDALONE_LABEL_RE      (**X:**)
+2. INLINE_LABEL_RE          (**X:** value)
+3. NUMBERED_LINE_RE         (1. X)
+4. BULLET_LINE_RE           (- X) + re-check inside:
+     4a. STANDALONE inside → label_heading
+     4b. INLINE inside → inline_label
+5. HEB_LETTER_LINE_RE       ((א) X)
+6. PLAIN_LABEL_RE           (X:)  — last because it's broad
+7. plain
+```
+
+## דוגמאות מהשטח
+
+### input: `- **נקודות פתוחות:**`
+- `BULLET_LINE_RE` תופס → `inner = "**נקודות פתוחות:**"`
+- `STANDALONE_LABEL_RE` על ה-inner → `label_heading`, text = `"נקודות פתוחות"`
+- יוצא כ-Heading 2.
+
+### input: `- **נקודות פתוחות:** האם המקדם...`
+- `BULLET_LINE_RE` תופס → inner = `"**נקודות פתוחות:** האם..."`
+- `INLINE_LABEL_RE` על ה-inner → `inline_label`
+- יוצא כ-Normal עם label "נקודות פתוחות:" bold + value רגיל.
+
+### input: `1. **שאלה עקרונית:** האם נספח...`
+- `NUMBERED_LINE_RE` תופס → `"**שאלה עקרונית:** האם נספח..."`
+- יוצא כ-List Paragraph. ה-`**...**` בתוכו יעובד על ידי
+  `_add_runs_with_inline_bold()` (bold inline run).
+
+### input: `(א) נספח הבינוי של תכנית...`
+- `HEB_LETTER_LINE_RE` תופס
+- יוצא כ-List Paragraph עם `_strip_numpr()` — כי המחבר כבר כתב "(א)".
+
+### input: `העורר טוען כי:`
+- לא תואם regex ספציפי
+- `PLAIN_LABEL_RE` תופס (23 תווים, מסתיים ב-`:`)
+- יוצא כ-Heading 2.
+
+### input: `פסקה ארוכה: עם עוד תוכן ופסיק, וסוגיה מורכבת.`
+- `PLAIN_LABEL_RE` לא תופס (יותר מ-40 תווים לפני `:`)
+- נשאר `plain` → Normal.
+
+## למה הגבלת `PLAIN_LABEL_RE` ל-`{2,40}`
+
+בלי הגבלה, כל פסקה עם `:` במקום כלשהו הייתה הופכת ל-Heading 2. דוגמה
+שצריך למנוע:
+```
+טענה חשובה כאן: היא שהוועדה שגתה בכל אופן.
+```
+אין כאן כוונה לכותרת — `:` הוא חלק ממשפט. ההגבלה ל-40 תווים מסננת את
+רוב המקרים האלה כי רוב headings אמיתיים הם קצרים.
+
+40 תווים זה ניחוש — אפשר לכוון אם מגלים false positives/negatives.
+
+## inline bold — `_add_runs_with_inline_bold()`
+
+אחרי סיווג, הטקסט עדיין יכול להכיל `**word**` באמצע. הפונקציה מחלקת
+את המחרוזת ל-runs מתחלפים:
+
+```
+"העורר טוען **שהתוצאה** שגויה"
+→ [
+    Run("העורר טוען ", bold=None),
+    Run("שהתוצאה", bold=True),
+    Run(" שגויה", bold=None),
+  ]
+```
+
+כל run מסומן RTL בנפרד. יוצא ב-Word עם הדגש המקומי בלבד על המילה
+`שהתוצאה`.
+
+## השלמת התמונה
+
+```
+md content
+    ↓ splitlines()
+for line in lines:
+    ↓ _classify_line(line)
+    → (kind, clean_text)
+    ↓ _emit_content_line(doc, line)
+    → paragraph with chosen style
+    ↓ _add_runs_with_inline_bold(paragraph, clean_text)
+    → runs with inline **bold** rendered
+    ↓ _mark_run_rtl / _mark_paragraph_rtl
+    → Hebrew renders in David (cs slot)
+```
+
+## הוספת קטגוריה חדשה
+
+אם יש דפוס שלא מזוהה ורצוי למפות אותו:
+
+1. הוסף regex constant (למעלה בקובץ, אחרי הקיימים).
+2. הוסף branch ב-`_classify_line()` לפי הסדר הנכון (ספציפי לפני כללי).
+3. הוסף branch ב-`_emit_content_line()` עם הסגנון המתאים.
+4. הוסף test case ב-references/line-classification.md (כאן).
+5. הרץ על תיק מייצג (למשל 8070-25) וראה שהתוצאה נכונה.

skills/dafna-decision-template/references/rtl-runs.md

@@ -0,0 +1,81 @@
+# למה `<w:rtl/>` חובה בכל run
+
+## הבעיה
+
+כשאתה יוצר `run` ב-python-docx על סגנון עברי מוגדר היטב (למשל Normal עם
+`cs="David"`) — עברית עדיין יוצאת ב-Times New Roman.
+
+## הסיבה
+
+Word משתמש ב-3 font slots בתוך `<w:rFonts>`:
+- `w:ascii` — תווים לטיניים
+- `w:hAnsi` — אותיות מיוחדות אירופיות
+- `w:cs` (complex script) — עברית, ערבית, תאית
+
+ההחלטה איזה slot להשתמש נעשית **לפי סוג הטקסט ב-run** ולפי **דגל רמת
+הריצה `<w:rtl/>`**. בלי הדגל, Word יכול להתייחס לטקסט העברי כ-LTR
+(למשל כשהוא מתערבב עם ספרות/לטינית) ולבחור את `ascii` — Times New Roman.
+
+## הפתרון
+
+מסמן כל run עברי כ-complex-script:
+
+```python
+from docx.oxml import OxmlElement
+from docx.oxml.ns import qn
+
+def _mark_run_rtl(run):
+    rPr = run._r.get_or_add_rPr()
+    if rPr.find(qn("w:rtl")) is None:
+        rPr.append(OxmlElement("w:rtl"))
+```
+
+וגם ברמת ה-paragraph (למקרה ש-paragraph mark עצמו משפיע):
+
+```python
+def _mark_paragraph_rtl(paragraph):
+    pPr = paragraph._p.get_or_add_pPr()
+    rPr = pPr.find(qn("w:rPr"))
+    if rPr is None:
+        rPr = OxmlElement("w:rPr"); pPr.append(rPr)
+    if rPr.find(qn("w:rtl")) is None:
+        rPr.append(OxmlElement("w:rtl"))
+```
+
+## תופעות לוואי של חוסר RTL ברמת ה-run
+
+1. **Font fallback ל-Times New Roman** — הסימפטום הנפוץ ביותר.
+2. **BiDi reordering של פיסוק** — נקודתיים, פסיקים, סוגריים עוברים למקום
+   הלא נכון. הסימפטום: `"(א)"` הופך ל-`")א("`.
+3. **מספרים "נוגדים" ברצף עברי** — `"בשנת 2024 פסקנו"` יכול להיראות
+   עם המספר במיקום הלא נכון.
+
+## איך לבדוק שה-RTL חל
+
+```python
+from docx.oxml.ns import qn
+
+for p in doc.paragraphs:
+    for r in p.runs:
+        rPr = r._r.find(qn("w:rPr"))
+        has_rtl = rPr is not None and rPr.find(qn("w:rtl")) is not None
+        if not has_rtl and any('\u0590' <= c <= '\u05FF' for c in r.text):
+            print(f"Missing RTL: {r.text[:40]!r}")
+```
+
+## זה לא מספיק רק ברמת הסגנון
+
+זו תפיסה מוטעית נפוצה: "אם הסגנון כולל `<w:rtl/>` ב-`rPr`, ירש כל ריצה".
+**לא נכון**. סגנון נותן ברירת מחדל ל-runs שעדיין לא נוצרו ב-Word GUI —
+אבל runs שנוצרו דרך python-docx מקבלים `rPr` ריק, שלא תורש אוטומטית
+את ה-rtl מהסגנון. לכן חייבים להוסיף ידנית.
+
+## הטמפלט של דפנה כדוגמה
+
+בוחנים את `word/document.xml` של הטמפלט המקורי — כל ריצה עברית כוללת:
+
+```xml
+<w:r><w:rPr><w:rFonts w:hint="cs"/><w:rtl/></w:rPr><w:t>רקע</w:t></w:r>
+```
+
+`<w:rtl/>` נמצא שם **במפורש**. אנחנו מחקים את זה.

skills/dafna-decision-template/references/style-mapping.md

@@ -0,0 +1,155 @@
+# מיפוי סגנונות — `טיוטת החלטה.dotx`
+
+מבוסס על ניתוח `word/styles.xml` של הטמפלט. כל הגדרות מצוטטות מה-XML
+המקורי.
+
+## סגנונות בסיסיים (Word-idioms)
+
+### `Normal` (styleId: `a1`)
+ברירת המחדל לפסקאות רגילות. **כל שאר הסגנונות יורשים ממנו**
+(`basedOn="a1"`).
+
+```xml
+<rPr>
+  <rFonts ascii="Times New Roman" hAnsi="Times New Roman" cs="David"/>
+  <sz val="26"/>   <!-- 13pt -->
+  <szCs val="26"/>
+</rPr>
+<pPr>
+  <bidi/>                                   <!-- RTL -->
+  <spacing before="120" after="120" line="360" lineRule="auto"/>
+  <ind left="-454"/>                        <!-- negative left indent -->
+  <jc val="both"/>                          <!-- justify -->
+</pPr>
+```
+
+**מה זה אומר לך:**
+- עברית תצא ב-David 13pt (דרך `cs`)
+- לטינית תצא ב-Times New Roman 13pt (דרך `ascii`)
+- יישור justify (דו-צדדי), RTL
+- מרווח 1.5 שורות (`line=360` = 1.5 × 240)
+
+### `Heading 1` (styleId: `10`, name: `heading 1`)
+לכותרת ראשית (כמו "ניתוח משפטי וכתיבת עמדה בערר X").
+```xml
+<basedOn val="a1"/>     <!-- יורש מ-Normal → cs="David" -->
+<rPr><rFonts asciiTheme="majorHAnsi" .../><sz val="40"/></rPr>  <!-- 20pt -->
+```
+Heading 1 **אינו** מציין cs fonts מפורשות, אבל יורש `cs="David"` מ-Normal.
+זה מבדיל אותו מ-`Title`, שמפנה ל-theme ריק.
+
+### `Heading 2` (styleId: `2`)
+לכותרות מקטעים ותת-מקטעים.
+```xml
+<basedOn val="a1"/>
+<pPr><keepNext/><spacing before="160"/><ind left="-567"/></pPr>
+<rPr><b/><bCs/><u val="single"/></rPr>   <!-- bold + underline -->
+```
+
+### `Title` (styleId: `a5`) — ⚠️ הימנע
+```xml
+<rPr><rFonts asciiTheme="majorHAnsi" cstheme="majorBidi" .../></rPr>
+```
+מפנה ל-theme. ב-`theme1.xml`: `majorFont.cs = ""` (ריק). → עברית נופלת
+ל-`majorFont.latin = "Aptos Display"`. **השתמש ב-Heading 1 במקום.**
+
+### `Subtitle` (styleId: `a7`) — ⚠️ אותה בעיה של Title
+לא בשימוש.
+
+## סגנונות תוכן
+
+### `Quote` (styleId: `a9`)
+```xml
+<basedOn val="a1"/>
+<pPr><spacing before="0" after="0" line="276"/>
+     <ind left="680" right="170"/></pPr>   <!-- הזחה דו-צדדית -->
+<rPr><b/><bCs/></rPr>                      <!-- bold -->
+```
+לציטוטי פסיקה. הזחה פנימה, bold.
+
+### `List Paragraph` (styleId: `a0`)
+```xml
+<basedOn val="a1"/>
+<pPr>
+  <numPr><numId val="1"/></numPr>          <!-- auto-numbering -->
+  <spacing after="0"/>
+  <ind left="-125" hanging="357"/>
+</pPr>
+<rPr><rFonts ascii="David" hAnsi="David"/><sz val="28"/></rPr>  <!-- 14pt -->
+```
+**numId=1 מפנה ל-abstractNumId=16**, שמוגדר כ-`decimal` עם `lvlText="%1."`.
+כלומר Word יוסיף "1.", "2.", "3." אוטומטית לפני הטקסט.
+
+**חשוב:** `List Paragraph` הוא היחיד בטמפלט עם numbering אוטומטי. אין
+bullet style מוכן. לרשימות עם (א)(ב), **הסר את ה-numPr** ברמת הפסקה:
+
+```python
+from docx.oxml.ns import qn
+
+def _strip_numpr(paragraph):
+    pPr = paragraph._p.get_or_add_pPr()
+    for numPr in pPr.findall(qn("w:numPr")):
+        pPr.remove(numPr)
+```
+
+## סגנונות נוספים בטמפלט (לא בשימוש כרגע)
+
+| styleId | שם | מה |
+|---------|----|----|
+| `P00`, `P11`, `P22` | תבניות מותאמות אישית | ישן, נראה שלא בשימוש פעיל |
+| `12`, `21`, `31` | פיסקת רשימה 1/2/3 | ללא numPr — שימוש ויזואלי בלבד |
+| `-` | פיסקת רשימה - ללא מספור | מיועד ל-bullets ללא מספור |
+| `14` | ציטוט1 | וריאציה ישנה של Quote |
+| `af2` / `af4` | header / footer | לכותרות עליונות/תחתונות |
+
+## theme (`word/theme/theme1.xml`)
+
+```xml
+<majorFont>
+  <latin typeface="Aptos Display"/>
+  <cs typeface=""/>                  <!-- ריק! -->
+</majorFont>
+<minorFont>
+  <latin typeface="Aptos"/>
+  <cs typeface=""/>                  <!-- ריק! -->
+</minorFont>
+```
+
+**ה-cs ריק ב-theme** — זו הסיבה ש-`Title` (שמפנה ל-theme) לא עובד
+לעברית. אל תסמוך על theme; השתמש ב-styles שמגדירים cs מפורש (Normal +
+כל מה שיורש ממנו).
+
+## numbering definitions
+
+`word/numbering.xml` כולל ~22 abstractNum מוגדרים. הרלוונטי לנו:
+
+```
+numId=1 → abstractNumId=16 → numFmt=decimal, lvlText="%1."
+```
+
+יש גם hebrew1 (`numFmt=hebrew1` = א., ב., ג.) ב-`abstractNumId=0, 1`.
+אף סגנון מוכן לא מפנה אליהם. אם תרצה בעתיד רשימה ממוספרת בעברית עם
+Word auto-numbering — יש להזריק `numPr` ידנית עם `numId=29` (שמפנה
+ל-abstractNumId=0).
+
+## גדלים — רפרנס מהיר
+
+| style | ascii | cs (עברית) |
+|-------|-------|-----------|
+| Normal | 13pt | 13pt |
+| Heading 1 | 20pt | 18pt |
+| Heading 2 | 13pt (ירושה) + bold + underline | אותו דבר |
+| Title | 28pt (Aptos Display — לא עברית!) | — |
+| List Paragraph | 14pt (David) | 14pt |
+| Quote | 13pt (ירושה) + bold | 13pt |
+
+## טיפ
+
+כדי לבדוק את כל הסגנונות שבמסמך:
+
+```python
+from docx import Document
+d = Document("skills/docx/decision_template.docx")
+for s in sorted(d.styles, key=lambda x: x.name):
+    print(s.type, s.name, s.style_id)
+```

skills/decision/references/block-schema.md

@@ -1,574 +0,0 @@
-# Block Schema — ארכיטקטורת מסמך החלטת ועדת ערר
-
-מסמך זה מגדיר את המבנה הפורמלי של החלטת ועדת ערר לתכנון ובניה. הוא משמש כמקור סמכותי להגדרת בלוקים, משקלות, פרמטרי עיבוד, וכללי ולידציה.
-
-**הפניה:** SKILL.md סעיפים 11-12 מכילים סיכום מהיר והנחיות תהליך. מסמך זה מכיל את ההגדרות המלאות.
-
----
-
-## 1. יסודות תיאורטיים
-
-ארכיטקטורת המסמך מבוססת על שילוב של ארבעה frameworks מוכרים:
-
-### CREAC — מתודולוגיית כתיבה משפטית
-Conclusion → Rule → Explanation → Application → Conclusion.
-מקור: Columbia Law School, Legal Writing methodology.
-**מיפוי:** חל על בלוק י (דיון) ובלוק יא (סיכום). בלוק י פותח במסקנה (C), מציג כלל משפטי (R), מסביר באמצעות פסיקה (E), מיישם על העובדות (A), וחוזר למסקנה (C). בלוק יא = C אחרון בלבד.
-
-### Federal Judicial Center — Judicial Writing Manual
-מגדיר תפקוד פונקציונלי לכל חלק בהחלטה שיפוטית:
-- **Orientation** (אוריינטציה) — מי, מה, איפה → בלוקים א-ה
-- **Framing** (מסגור) — הקשר עובדתי ותכנוני → בלוק ו
-- **Argumentation** (טיעון) — עמדות הצדדים → בלוק ז
-- **Procedural record** (תיעוד הליכי) — מה עשינו → בלוק ח
-- **Deliberation** (דיון) — ניתוח משפטי → בלוקים ט-י
-- **Disposition** (החלטה) — תוצאה אופרטיבית → בלוק יא
-
-### DITA — Darwin Information Typing Architecture
-סטנדרט OASIS להגדרת סוגי תוכן מובנים. מספק:
-- **Content model** — אילו אלמנטים מותרים בכל בלוק
-- **Constraints** — מה אסור (חשוב יותר ממה שמותר)
-- **Specialization** — ירושה מסוג בסיסי עם התאמות
-- **Relationships** — תלויות בין בלוקים
-
-### Akoma Ntoso / LegalDocumentML
-סטנדרט OASIS בינלאומי למסמכים משפטיים מובנים (UN/DESA). מספק:
-- **Semantic mapping** — כל בלוק ממופה לרכיב מוכר בסטנדרט
-- **Document class** — "judgment" (פסק דין / החלטה)
-
-
----
-
-## 2. הגדרות בלוקים
-
-### Block א: כותרת מוסדית / Institutional Header
-
-**ID:** `block-alef`
-**Akoma Ntoso:** `meta > identification`
-**CREAC role:** none
-**Functional purpose (JWM):** Orientation — מזהה את המוסד, התיק והגורם המחליט.
-
-**Content model:**
-- Types: template-field
-- Elements: טבלה 2 טורים (מוסד | מספרי תיק)
-- Sources: מערכת ניהול תיקים
-
-**Constraints:**
-- MUST: שם מוסד, מספר תיק, מספר תכנית/בקשה
-- MUST NOT: תוכן מהותי כלשהו
-- Dependencies: none
-
-**Weight:** 1% (קבוע, לא משתנה בין סוגי עררים)
-
-**Processing:**
-- Generation type: template-fill
-- Temperature: 0 | Thinking: off | Effort: min | Model: script
-
-
-### Block ב: הרכב הוועדה / Panel Composition
-
-**ID:** `block-bet`
-**Akoma Ntoso:** `meta > references > TLCPerson`
-**CREAC role:** none
-**Functional purpose (JWM):** Orientation — מזהה את ההרכב המחליט. חשוב לביקורת שיפוטית (הרכב כשיר).
-
-**Content model:**
-- Types: template-field
-- Elements: "בפני:" + יו"ר + חברים
-- Sources: מערכת ניהול
-
-**Constraints:**
-- MUST: יו"ר + לפחות חבר אחד
-- MUST NOT: תוכן מהותי
-- Dependencies: none
-
-**Weight:** 1% (קבוע)
-
-**Processing:**
-- Generation type: template-fill
-- Temperature: 0 | Thinking: off | Effort: min | Model: script
-
-
-### Block ג: צדדים / Parties
-
-**ID:** `block-gimel`
-**Akoma Ntoso:** `meta > references > TLCPerson` (appellants, respondents)
-**CREAC role:** none
-**Functional purpose (JWM):** Orientation — מזהה את הצדדים וב"כ. מגדיר את מסגרת הדיון.
-
-**Content model:**
-- Types: template-field
-- Elements: עוררים + "נגד" + משיבים + ב"כ
-- Sources: כתב ערר, כתב תשובה
-
-**Constraints:**
-- MUST: שם כל צד, "נגד" כמפריד
-- MUST NOT: תוכן מהותי, תיאור הערר
-- Dependencies: none
-
-**Weight:** 1% (קבוע)
-
-**Processing:**
-- Generation type: template-fill
-- Temperature: 0 | Thinking: off | Effort: min | Model: script
-
-
-### Block ד: כותרת "החלטה" / Decision Title
-
-**ID:** `block-dalet`
-**Akoma Ntoso:** `body > judgment > header`
-**CREAC role:** none
-**Functional purpose (JWM):** Orientation — סימון פורמלי של תחילת ההחלטה.
-
-**Content model:**
-- Types: template-field
-- Elements: מילה אחת: "החלטה"
-- Sources: none
-
-**Constraints:**
-- MUST: David 16pt, bold, מרכז
-- Dependencies: none
-
-**Weight:** 0% (שורה אחת)
-
-**Processing:**
-- Generation type: template-fill
-- Temperature: 0 | Thinking: off | Effort: min | Model: script
-
-
-### Block ה: פתיחה / Opening
-
-**ID:** `block-he`
-**Akoma Ntoso:** `body > judgment > introduction`
-**CREAC role:** C (מסקנה ראשונית — הצגת מה לפנינו)
-**Functional purpose (JWM):** Orientation — מכוון את הקורא למהות הערר במשפט אחד. מגדיר "להלן" מרכזיים.
-
-**Content model:**
-- Types: narrative (1-2 סעיפים)
-- Elements: numbered-para עם הגדרות "להלן"
-- Sources: כתב ערר, החלטת ועדה מקומית
-
-**Constraints:**
-- MUST: "לפנינו...", הגדרת הוועדה המקומית, הגדרת התכנית/הבקשה, הגדרת המגרש
-- MUST NOT: ניתוח, ערכי שיפוט, ציטוטים מצדדים
-- Dependencies: block-gimel (שמות צדדים להגדרות)
-
-**Weight:** 1% (קבוע — 1-2 סעיפים)
-
-**Processing:**
-- Generation type: paraphrase
-- Temperature: 0.2 | Thinking: low | Effort: low | Model: sonnet
-
-
-### Block ו: רקע עובדתי / Factual Background ("פתח דבר")
-
-**ID:** `block-vav`
-**Akoma Ntoso:** `body > judgment > background`
-**CREAC role:** none (עובדות בלבד, לא ניתוח)
-**Functional purpose (JWM):** Framing — מספק את התשתית העובדתית שעליה נבנה הדיון. השופט חייב להבין את המציאות בשטח לפני שקורא טענות.
-
-**Content model:**
-- Types: narrative, citation-block, image-placeholder
-- Elements: numbered-para, blockquote (ציטוט מפרוטוקול), image-box
-- Sources: כתבי טענות, תשריטים, פרוטוקולים, החלטות קודמות, GIS
-
-**סדר תוכן פנימי:**
-1. מקרקעין — מיקום, שטח, מאפיינים
-2. סביבת מקרקעין — בנייה סמוכה, אופי
-3. 📷 תמונה: מיקום GIS
-4. היסטוריה תכנונית — תכניות, החלטות (עובדות יבשות בלבד)
-5. מהות הבקשה/תכנית
-6. 📷 תמונה: תשריט
-7. ציטוט מפרוטוקול ועדה מקומית
-8. החלטת הוועדה + תנאים
-9. 📷 תמונה: צילום אוויר (אופציונלי)
-10. הגשת הערר
-
-**Constraints:**
-- MUST: מקרקעין, מהות הבקשה, החלטת הוועדה, הגשת הערר
-- MUST: לפחות 2 תמונות (מיקום + תשריט)
-- MUST: ציטוט מפרוטוקול הוועדה המקומית
-- ⚠️ **MUST NOT ("רקע ניטרלי"):** ציטוטים ישירים מצדדים, מילות ערך/שיפוט ("חריג", "חטא", "בעייתי"). החלטות קודמות = עובדה יבשה ("ביום X נדחתה תכנית Y"), ללא נימוקים וציטוטים מהן.
-- Dependencies: block-he (הגדרות "להלן")
-
-**Weight:**
-
-| סוג ערר | משקל | הערות |
-|---------|------|-------|
-| רישוי — דחייה | 15-25% | רקע מפורט עם הקשר תכנוני |
-| רישוי — קבלה | 30-40% | כולל ציטוט מפרוטוקול |
-| רישוי — קבלה חלקית | 25-35% | כולל ציטוט מפרוטוקול |
-| היטל השבחה | 6-18% | רקע מצומצם |
-
-**Weight methodology:**
-- Communicative weight (40%): גבוה — מספק את "התמונה" לשופט שלא מכיר את התיק
-- Reader attention (20%): בינוני-גבוה — primacy effect, הקורא קשוב בהתחלה
-- Judicial review (25%): גבוה — שופט בודק שהעובדות מלאות ומדויקות
-- Empirical (15%): מבוסס על מדידת החלטות דפנה (3.2 ב-SKILL.md)
-
-**Processing:**
-- Generation type: reproduction (העתקה נאמנה ממקורות)
-- Cognitive complexity: lookup (ארגון, לא ניתוח)
-- Accuracy: high-precision
-- Temperature: 0 | Thinking: off | Effort: low | Model: sonnet
-
-
-### Block ז: טענות הצדדים / Parties' Claims
-
-**ID:** `block-zayin`
-**Akoma Ntoso:** `body > judgment > arguments`
-**CREAC role:** none (הצגת טענות, לא ניתוח)
-**Functional purpose (JWM):** Argumentation — מציג את עמדות הצדדים בנאמנות, כך שהקורא יבין את המחלוקת לפני שקורא את ההכרעה.
-
-**Content model:**
-- Types: narrative
-- Elements: section-heading ("תמצית טענות הצדדים"), sub-headings (לכל צד), numbered-para
-- Sources: כתב ערר, כתב תשובה — **כתבי טענות מקוריים בלבד** (לא השלמות טיעון)
-
-**סדר קבוע:**
-1. כותרת: "תמצית טענות הצדדים"
-2. "טענות העוררים" (אם כמה עוררים — תתי-כותרות לכל אחד)
-3. "עמדת הוועדה המקומית"
-4. "עמדת מבקשי ההיתר" / "עמדת מגישי התכנית"
-
-**Constraints:**
-- MUST: כל טענה בסעיף נפרד, גוף שלישי ("העורר טוען כי...")
-- MUST: כל צד בפרק נפרד, סדר קבוע
-- MUST NOT: ניתוח, מסקנות, הערכת הוועדה ("טענה זו חלשה...")
-- MUST NOT: תוכן מהשלמות טיעון (→ block-chet)
-- Dependencies: block-vav (מספור רציף)
-
-**Weight:**
-
-| סוג ערר | משקל | הערות |
-|---------|------|-------|
-| רישוי — דחייה | 30-40% | טענות מפורטות |
-| רישוי — קבלה | 20-30% | כולל השלמות |
-| רישוי — קבלה חלקית | 25-30% | |
-| היטל השבחה | 13-25% | |
-
-**Weight methodology:**
-- Communicative weight (40%): בינוני — הצגה, לא הכרעה
-- Reader attention (20%): נמוך-בינוני — scanning attention, הקורא מחפש טענות ספציפיות
-- Judicial review (25%): גבוה — שופט בודק ש"נשמעו כל הצדדים"
-- Empirical (15%): מבוסס על מדידת החלטות דפנה
-
-**Processing:**
-- Generation type: paraphrase (סיכום נאמן בשפה של דפנה)
-- Cognitive complexity: medium-synthesis (קיבוץ וסידור טענות)
-- Accuracy: high-precision (לא לפספס טענה, לא לעוות)
-- Temperature: 0.1 | Thinking: low | Effort: medium | Model: sonnet
-
-
-### Block ח: הליכים בפני ועדת הערר / Proceedings
-
-**ID:** `block-chet`
-**Akoma Ntoso:** `body > judgment > proceedings` (custom extension)
-**CREAC role:** none (תיעוד, לא ניתוח)
-**Functional purpose (JWM):** Procedural record — מתעד שהוועדה פעלה כדין ונתנה מלוא יום בבית דין. קריטי ל"מבחן השופט" — שופט בעתמ"ם בודק שהצדדים קיבלו הזדמנות הוגנת.
-
-**Content model:**
-- Types: narrative, image-placeholder
-- Elements: section-heading ("ההליכים בפני ועדת הערר"), numbered-para, image-box
-- Sources: פרוטוקול דיון, תמונות סיור, החלטות ביניים, השלמות טיעון
-
-**סדר כרונולוגי:**
-1. דיון — תאריך, נוכחים
-2. סיור — תאריך, תיאור
-3. 📷 תמונה: צילומים מהסיור
-4. השלמות טיעון — עם תוכן מפורט (כל השלמה = סעיף נפרד)
-5. החלטות ביניים
-6. תגובות לתגובות — כרונולוגי
-7. 📷 תמונה: הדמיות/חתכים (אם צורפו)
-8. עררים מקבילים (אם יש)
-
-**Constraints:**
-- MUST: תאריכים מדויקים, כרונולוגיה ברורה
-- MUST: תוכן השלמות טיעון מפורט — כל השלמה בסעיף נפרד עם תמצית תוכן
-- MUST NOT: ניתוח או הערכה של ההשלמות ("טענה חזקה/חלשה")
-- Dependencies: block-zayin (מספור רציף)
-- References: block-zayin (הפניה לטענות מקוריות כשיש חפיפה)
-
-**Weight:**
-
-| סוג ערר | משקל | הערות |
-|---------|------|-------|
-| ערר פשוט (ללא השלמות) | 3-5% | דיון + סיור בלבד |
-| ערר מורכב (השלמות רבות) | 8-15% | כמו אריאלי: 31 סעיפים |
-| היטל השבחה | 2-4% | בדרך כלל מינימלי |
-
-**Weight methodology:**
-- Communicative weight (40%): נמוך-בינוני — תיעוד, לא הכרעה
-- Reader attention (20%): נמוך — scanning, אלא אם יש ממצאים חדשים מסיור/השלמות
-- Judicial review (25%): **גבוה מאוד** — שופט בודק שנתנו procedural fairness
-- Empirical (15%): מגוון רחב — תלוי בכמות ההשלמות
-
-**Processing:**
-- Generation type: reproduction + paraphrase (תאריכים מדויקים + תמצית תוכן)
-- Cognitive complexity: low (סידור כרונולוגי)
-- Accuracy: high-precision (תאריכים, שמות מסמכים)
-- Temperature: 0 | Thinking: off | Effort: low | Model: sonnet
-
-
-### Block ט: תכניות חלות / Applicable Plans (אופציונלי)
-
-**ID:** `block-tet`
-**Akoma Ntoso:** `body > judgment > motivation > background` (extended)
-**CREAC role:** R (Rule — הצגת הכללים המשפטיים/תכנוניים)
-**Functional purpose (JWM):** Deliberation (preliminary) — מציג את המסגרת הנורמטיבית שלאורה ייבחנו הטענות. בלוק גשר בין עובדות לניתוח.
-
-**Content model:**
-- Types: narrative, citation-block
-- Elements: section-heading, numbered-para, blockquote (ציטוט מהוראות תכנית)
-- Sources: הוראות תכנית (PDF), נספחי בינוי, החלטות מרכזות
-
-**Constraints:**
-- MUST: ציטוט ישיר מהוראות תכנית עם הדגשת (bold) מילים מכריעות
-- MUST NOT: ניתוח מעמיק (→ block-yod), הכרעה בין פרשנויות
-- Dependencies: block-chet (מספור), block-vav (הגדרות תכניות)
-- Condition: **אופציונלי** — רק כשיש מורכבות תכנונית (תכניות סותרות, תמ"א 38 + שימור, פרשנות)
-
-**Weight:**
-
-| מתי קיים | משקל |
-|----------|------|
-| תמ"א 38 + שימור | 8-12% |
-| פרשנות תכנית | 5-10% |
-| לא קיים | 0% |
-
-**Weight methodology:**
-- Communicative weight (40%): בינוני — הנחת תשתית נורמטיבית
-- Reader attention (20%): נמוך — טכני, אלא אם פרשנות שנויה במחלוקת
-- Judicial review (25%): בינוני — שופט בודק שהוועדה הבינה את הדין
-- Empirical (15%): אריאלי — 14 סעיפים; בית הכרם — משולב בדיון
-
-**Processing:**
-- Generation type: guided-synthesis (ציטוט + ניתוח ראשוני)
-- Cognitive complexity: medium (פרשנות טקסט משפטי)
-- Accuracy: precision + interpretation
-- Temperature: 0.2 | Thinking: medium | Effort: medium | Model: opus
-
-
-### Block י: דיון והכרעה / Discussion and Decision
-
-**ID:** `block-yod`
-**Akoma Ntoso:** `body > judgment > motivation`
-**CREAC role:** **full-CREAC** — C (מסקנה בפתיחה) → R (כלל משפטי) → E (ציטוט פסיקה) → A (יישום על העובדות) → C (מסקנת ביניים)
-**Functional purpose (JWM):** Deliberation — ליבת ההחלטה. כאן הוועדה מנתחת, מאזנת, ומכריעה. זהו ה-ratio decidendi.
-
-**Content model:**
-- Types: narrative, citation-block, image-placeholder
-- Elements: numbered-para (אסה רציפה ללא כותרות משנה), blockquote (ציטוטי פסיקה ותכנית), image-box
-- Sources: **כל** הבלוקים הקודמים + פסיקה + skill
-
-**מבנה פנימי (לפי סוג ערר — ראה SKILL.md סעיף 7.3):**
-- דחייה: שכבות הגנה (concentric circles)
-- קבלה: נימוק-נימוק
-- קבלה חלקית: מיפוי מתחים + ניתוח נושאי
-- היטל השבחה: פתיחה ישירה עם מסקנה
-
-**Constraints:**
-- MUST: מסקנה בפתיחת הדיון (לא בסוף)
-- MUST: מענה לכל טענה שהוצגה בבלוק ז
-- MUST: ציטוט פסיקה בבלוקים ארוכים (200-600 מילים)
-- ⚠️ **MUST NOT ("ללא כפילות"):** חזרה על עובדות/טענות מבלוקים קודמים. השתמש בהפניות: "כאמור בסעיף X לעיל", "כפי שפורט", "כפי שציינו"
-- MUST NOT: כותרות משנה (חריג: נושאים נפרדים לחלוטין)
-- Dependencies: **ALL** previous blocks (ה-ט)
-
-**Weight:**
-
-| סוג ערר | משקל | הערות |
-|---------|------|-------|
-| רישוי — דחייה | 37-50% | פתיחה רחבה + שכבות |
-| רישוי — קבלה | 35-45% | נימוק-נימוק |
-| רישוי — קבלה חלקית | 40-47% | מיפוי מתחים + ניתוח נושאי |
-| היטל השבחה | 32-48% | ציטוטי פסיקה מרובים |
-
-**Weight methodology:**
-- Communicative weight (40%): **מקסימלי** — זהו ה-ratio decidendi, תכלית ההחלטה
-- Reader attention (20%): **גבוה** — deep reading, הקורא מחפש את הנימוקים
-- Judicial review (25%): **מקסימלי** — שופט בוחן סבירות, מידתיות, התייחסות לטענות
-- Empirical (15%): 35-50% באופן עקבי בכל החלטות דפנה
-
-**Processing:**
-- Generation type: **rhetorical-construction** (בניית טיעון, איזון, רטוריקה)
-- Cognitive complexity: **high-reasoning** (CREAC מלא, שכבות, חידוד)
-- Accuracy: **precision + creativity** (ניתוח מדויק + ביטוי אלגנטי)
-- Temperature: **0.4** | Thinking: **max (budget 16K+)** | Effort: **max** | Model: **opus בלבד**
-
-
-### Block יא: סיכום / סוף דבר / Summary
-
-**ID:** `block-yod-alef`
-**Akoma Ntoso:** `body > judgment > decision`
-**CREAC role:** C (Conclusion אחרון — תמצית אופרטיבית)
-**Functional purpose (JWM):** Disposition — ההוראה האופרטיבית שמבצעים. זה מה שהצדדים צריכים לדעת "מה עכשיו."
-
-**Content model:**
-- Types: narrative
-- Elements: section-heading ("סיכום"/"סוף דבר"), numbered-para, sub-items (א. ב. ג.)
-- Sources: block-yod (מסקנות)
-
-**מבנה לפי תוצאה (ראה SKILL.md סעיף 8):**
-- דחייה: "הערר נדחה" + תתי-סעיפים + פסקה חמה (רישוי בלבד)
-- קבלה: "הערר מתקבל בכפוף ל..." + פרוזה
-- קבלה חלקית: "הערר מתקבל באופן חלקי" + 2-3 הוראות אופרטיביות
-- היטל השבחה: יבש
-
-**Constraints:**
-- MUST: תוצאה ברורה (נדחה/מתקבל/מתקבל חלקית)
-- MUST NOT (בקבלה חלקית): חזרה על נימוקים — ההנמקה כבר בדיון
-- Dependencies: block-yod (מסקנות)
-
-**Weight:**
-
-| סוג ערר | משקל |
-|---------|------|
-| דחייה | 2-9% |
-| קבלה | 3-5% |
-| קבלה חלקית | 2-3% |
-| היטל השבחה | 3-4% |
-
-**Processing:**
-- Generation type: paraphrase (עיבוד מסקנות בלוק י)
-- Cognitive complexity: low
-- Accuracy: high-precision (הוראות חייבות להיות חד-משמעיות)
-- Temperature: 0.1 | Thinking: low | Effort: low | Model: sonnet
-
-
-### Block יב: חתימות / Signatures
-
-**ID:** `block-yod-bet`
-**Akoma Ntoso:** `conclusions > signature`
-**CREAC role:** none
-**Functional purpose (JWM):** Authentication — אישור פורמלי של ההחלטה.
-
-**Content model:**
-- Types: template-field
-- Elements: "ניתנה פה אחד" + תאריך עברי/לועזי + טבלת חתימות
-- Sources: none
-
-**Constraints:**
-- MUST: "ניתנה פה אחד", תאריך, יו"ר + מזכיר/ה
-- Dependencies: none
-
-**Weight:** 1% (קבוע)
-
-**Processing:**
-- Generation type: template-fill
-- Temperature: 0 | Thinking: off | Effort: min | Model: script
-
-
----
-
-## 3. כללי גזירת פרמטרים
-
-פרמטרי העיבוד נגזרים ממאפייני התוכן, לא נקבעים שרירותית:
-
-### Temperature — נגזר מסוג הייצור
-
-| Generation type | Temperature | נימוק |
-|----------------|-------------|-------|
-| template-fill | 0 | אין צורך בשפה — מילוי שדות |
-| reproduction | 0 | נאמנות מוחלטת למקור. אפס יצירתיות |
-| paraphrase | 0.1 | מרווח מינימלי לניסוח בשפה של דפנה |
-| guided-synthesis | 0.2 | גמישות בארגון וחיבור מקורות, לא בתוכן |
-| analytical-reasoning | 0.3-0.4 | צריך ליצור קשרים בין עקרונות משפטיים |
-| rhetorical-construction | 0.4-0.5 | טווח ביטוי רחב לכתיבה משכנעת ואלגנטית |
-
-### Thinking budget — נגזר ממורכבות קוגניטיבית
-
-| Cognitive task | Budget | נימוק |
-|---------------|--------|-------|
-| template-fill / lookup | off | אין צורך בחשיבה |
-| sequential-extraction | low | חילוץ מידע חד-שלבי |
-| multi-source-integration | medium | צריך להצליב מקורות |
-| legal-analysis-with-CREAC | max (16K+) | חשיבה רב-שלבית: מסקנה → כלל → הסבר → יישום |
-
-### Model — נגזר מדרישת דיוק
-
-| Accuracy profile | Model | נימוק |
-|-----------------|-------|-------|
-| factual-precision | sonnet | מהיר, מדויק לחילוץ עובדות |
-| precision + interpretation | opus | נדרש לפרשנות תכנית / ציטוט מובנה |
-| precision + creativity | opus | נדרש לניתוח משפטי מורכב ורטוריקה |
-
-
----
-
-## 4. מתודולוגיית משקלות
-
-משקל כל בלוק נקבע על ידי שקלול 4 גורמים:
-
-### 4.1 Communicative Weight (40%)
-מה חלקו של הבלוק בתכלית ההחלטה? ההחלטה באה לעשות דבר אחד: להכריע במחלוקת ולנמק. בלוק י (דיון) הוא ליבת התכלית. בלוקים א-ד (כותרות) הם עטיפה.
-
-### 4.2 Reader Attention Distribution (20%)
-מבוסס על מחקרי F-pattern ו-primacy/recency:
-- **פתיחה** (בלוקים ה-ו): קשב גבוה (primacy effect)
-- **אמצע** (בלוקים ז-ח): scanning — הקורא מחפש טענות ספציפיות
-- **דיון** (בלוק י): deep reading — הקורא מחפש נימוקים
-- **סיום** (בלוק יא): קשב גבוה (recency effect)
-
-### 4.3 Judicial Review Requirement (25%)
-מה שופט בבית משפט לעניינים מנהליים יבדוק ("מבחן השופט"):
-- **תשתית עובדתית** (בלוק ו): מלאה ומדויקת?
-- **שמיעת צדדים** (בלוקים ז-ח): נתנו מלוא יום בבית דין?
-- **סבירות ומידתיות** (בלוק י): ההכרעה מנומקת ומאוזנת?
-- **התייחסות לטענות** (בלוק י): כל טענה קיבלה מענה?
-
-### 4.4 Empirical Basis (15%)
-מבוסס על מדידה מהחלטות שפורסמו:
-- הכט 1180-1181 (דחייה, 02.2026)
-- בית הכרם 1126/25 (קבלה חלקית, 03.2026)
-- אריאלי 1078+1083 (קבלה, 03.2026)
-
-המשקלות ב-SKILL.md סעיף 3.2 (יחסי הזהב) משמשים כבסיס אמפירי שאומת על ידי שלושת הגורמים האנליטיים.
-
-
----
-
-## 5. כללי ולידציה
-
-### 5.1 סדר בלוקים
-- בלוקים חייבים להופיע בסדר א עד יב
-- בלוקים א-ה ויב נדרשים בכל החלטה
-- בלוק ט אופציונלי (רק כשיש מורכבות תכנונית)
-
-### 5.2 Content Constraints
-- **רקע ניטרלי (בלוק ו):** אם סעיף מכיל ציטוט ישיר מצד או מילת שיפוט → לא שייך כאן
-- **טענות מקוריות בלבד (בלוק ז):** רק מכתבי ערר/תשובה. השלמות → בלוק ח
-- **ללא כפילות (בלוק י):** הפניה לבלוקים קודמים, לא חזרה. חריג: "נשוב על כך כי..." (חזרה מכוונת עם שכבה חדשה)
-- **הליכים ללא הערכה (בלוק ח):** תיעוד מה הוגש, לא הערכה של חוזק הטענות
-
-### 5.3 Weight Compliance
-- משקל כל בלוק (ספירת מילים / סה"כ) צריך להיות בטווח המוגדר **±10%**
-- אם בלוק י < 30% → flag: דיון לא מפותח מספיק
-- אם בלוק ו > 35% → flag: רקע מנופח, בדוק שאין תוכן טענתי
-
-### 5.4 Structural Integrity
-- מספור סעיפים רציף מ-1 עד הסוף, ללא איפוס בין בלוקים
-- כל הגדרת "להלן" חייבת להופיע לפני השימוש הראשון בה
-- כל טענה בבלוק ז חייבת לקבל מענה בבלוק י (ישיר או "למעלה מן הצורך")
-- כותרות פרקים: David 14pt, bold, קו תחתון, מרכז
-- כותרות משנה: David 12pt, bold, מרכז, ללא קו תחתון
-
-
----
-
-## 6. גרף תלויות בין בלוקים
-
-```
-א (כותרת)     → עצמאי
-ב (הרכב)      → עצמאי
-ג (צדדים)     → עצמאי
-ד (כותרת)     → עצמאי
-ה (פתיחה)     → תלוי ב: ג (שמות צדדים להגדרות "להלן")
-ו (רקע)       → תלוי ב: ה (הגדרות). מספור ממשיך מ-ה.
-ז (טענות)     → תלוי ב: ו (מספור). מפנה ל: ה, ו (הגדרות)
-ח (הליכים)    → תלוי ב: ז (מספור). מפנה ל: ז (טענות מקוריות)
-ט (תכניות)    → תלוי ב: ח (מספור). אופציונלי. מפנה ל: ו (הגדרות תכניות)
-י (דיון)      → תלוי ב: **כל** הבלוקים ה-ט. מפנה ל: כולם.
-יא (סיכום)    → תלוי ב: י (מסקנות). מפנה ל: י בלבד.
-יב (חתימות)   → עצמאי
-```

skills/decision/references/block-schema.md

@@ -0,0 +1 @@
+../../../docs/block-schema.md

web-ui/src/app/archive/page.tsx

@@ -0,0 +1,268 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import Link from "next/link";
+import {
+  flexRender,
+  getCoreRowModel,
+  getFilteredRowModel,
+  getSortedRowModel,
+  useReactTable,
+  type ColumnDef,
+  type SortingState,
+} from "@tanstack/react-table";
+import { toast } from "sonner";
+import { AppShell } from "@/components/app-shell";
+import { Card, CardContent } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import { useCases, useRestoreCase, type Case } from "@/lib/api/cases";
+import { APPEAL_SUBTYPE_LABELS } from "@/lib/practice-area";
+
+function formatDate(iso?: string | null) {
+  if (!iso) return "—";
+  try {
+    return new Date(iso).toLocaleDateString("he-IL", {
+      day: "2-digit",
+      month: "2-digit",
+      year: "numeric",
+    });
+  } catch {
+    return iso;
+  }
+}
+
+function RestoreButton({ caseNumber }: { caseNumber: string }) {
+  const restore = useRestoreCase(caseNumber);
+  return (
+    <Button
+      variant="outline"
+      size="sm"
+      disabled={restore.isPending}
+      onClick={() => {
+        restore.mutate(undefined, {
+          onSuccess: (res) => {
+            const pc = res.paperclip?.status;
+            if (pc === "restored") {
+              toast.success(`התיק שוחזר. גם הפרויקט ב-Paperclip שוחזר.`);
+            } else if (pc === "not_found") {
+              toast.success("התיק שוחזר. לא נמצא פרויקט מתאים ב-Paperclip.");
+            } else if (pc === "error") {
+              toast.warning(
+                `התיק שוחזר ב-legal-ai, אך סנכרון Paperclip נכשל: ${res.paperclip?.message ?? ""}`,
+              );
+            } else {
+              toast.success("התיק שוחזר.");
+            }
+          },
+          onError: (err) =>
+            toast.error(err instanceof Error ? err.message : "שגיאה בשחזור"),
+        });
+      }}
+    >
+      {restore.isPending ? "משחזר..." : "שחזר"}
+    </Button>
+  );
+}
+
+const columns: ColumnDef<Case>[] = [
+  {
+    accessorKey: "case_number",
+    header: "מס׳ ערר",
+    cell: ({ row }) => (
+      <Link
+        href={`/cases/${row.original.case_number}`}
+        className="text-navy font-semibold hover:text-gold-deep tabular-nums"
+      >
+        {row.original.case_number}
+      </Link>
+    ),
+  },
+  {
+    accessorKey: "title",
+    header: "כותרת",
+    cell: ({ row }) => (
+      <div className="text-ink max-w-[420px] truncate" title={row.original.title}>
+        {row.original.title}
+      </div>
+    ),
+  },
+  {
+    accessorKey: "appeal_subtype",
+    header: "תחום",
+    cell: ({ row }) => {
+      const s = row.original.appeal_subtype;
+      if (!s || s === "unknown")
+        return <span className="text-ink-muted">—</span>;
+      return (
+        <span className="text-ink-soft text-sm">{APPEAL_SUBTYPE_LABELS[s]}</span>
+      );
+    },
+  },
+  {
+    accessorKey: "archived_at",
+    header: "תאריך ארכוב",
+    cell: ({ row }) => (
+      <span className="text-ink-muted text-sm tabular-nums">
+        {formatDate(row.original.archived_at)}
+      </span>
+    ),
+  },
+  {
+    id: "actions",
+    header: "",
+    cell: ({ row }) => <RestoreButton caseNumber={row.original.case_number} />,
+  },
+];
+
+export default function ArchivePage() {
+  const { data, isPending, error } = useCases(true, "archived");
+  const [sorting, setSorting] = useState<SortingState>([
+    { id: "archived_at", desc: true },
+  ]);
+  const [globalFilter, setGlobalFilter] = useState("");
+
+  const rows = useMemo(() => data ?? [], [data]);
+
+  const table = useReactTable({
+    data: rows,
+    columns,
+    state: { sorting, globalFilter },
+    onSortingChange: setSorting,
+    onGlobalFilterChange: setGlobalFilter,
+    getCoreRowModel: getCoreRowModel(),
+    getSortedRowModel: getSortedRowModel(),
+    getFilteredRowModel: getFilteredRowModel(),
+    globalFilterFn: (row, _colId, filterValue: string) => {
+      if (!filterValue) return true;
+      const needle = filterValue.toLowerCase();
+      return (
+        row.original.case_number.toLowerCase().includes(needle) ||
+        row.original.title.toLowerCase().includes(needle)
+      );
+    },
+  });
+
+  return (
+    <AppShell>
+      <section className="space-y-8">
+        <header className="space-y-1.5">
+          <div className="text-[0.75rem] uppercase tracking-[0.12em] text-gold-deep">
+            ארכיון תיקי ערר
+          </div>
+          <h1 className="text-navy">תיקים סגורים</h1>
+          <p className="text-ink-muted text-base max-w-2xl leading-relaxed">
+            תיקים שסגרו את הטיפול בהם. שחזור מחזיר את התיק לרשימה הראשית
+            ופותח מחדש את הפרויקט המקביל ב-Paperclip.
+          </p>
+        </header>
+
+        <div className="h-[2px] bg-gradient-to-l from-transparent via-gold to-transparent" />
+
+        <Card className="bg-surface border-rule shadow-sm">
+          <CardContent className="px-6 py-5 space-y-4">
+            <div className="flex items-center gap-3">
+              <Input
+                value={globalFilter}
+                onChange={(e) => setGlobalFilter(e.target.value)}
+                placeholder="חיפוש לפי מס׳ ערר או כותרת…"
+                className="max-w-sm bg-surface"
+                dir="rtl"
+              />
+              <span className="text-sm text-ink-muted me-auto">
+                {table.getFilteredRowModel().rows.length} תיקים בארכיון
+              </span>
+            </div>
+
+            <div className="rounded-lg border border-rule bg-surface shadow-sm overflow-hidden">
+              <Table>
+                <TableHeader className="bg-rule-soft/60">
+                  {table.getHeaderGroups().map((hg) => (
+                    <TableRow key={hg.id} className="border-rule">
+                      {hg.headers.map((header) => (
+                        <TableHead
+                          key={header.id}
+                          onClick={header.column.getToggleSortingHandler()}
+                          className="text-navy font-semibold cursor-pointer select-none text-right"
+                        >
+                          {flexRender(
+                            header.column.columnDef.header,
+                            header.getContext(),
+                          )}
+                          {{ asc: " ▲", desc: " ▼" }[
+                            header.column.getIsSorted() as string
+                          ] ?? ""}
+                        </TableHead>
+                      ))}
+                    </TableRow>
+                  ))}
+                </TableHeader>
+                <TableBody>
+                  {isPending ? (
+                    Array.from({ length: 3 }).map((_, i) => (
+                      <TableRow key={i} className="border-rule">
+                        {columns.map((_c, j) => (
+                          <TableCell key={j}>
+                            <Skeleton className="h-4 w-24" />
+                          </TableCell>
+                        ))}
+                      </TableRow>
+                    ))
+                  ) : error ? (
+                    <TableRow>
+                      <TableCell
+                        colSpan={columns.length}
+                        className="text-center text-danger py-8"
+                      >
+                        שגיאה בטעינת ארכיון: {error.message}
+                      </TableCell>
+                    </TableRow>
+                  ) : table.getRowModel().rows.length === 0 ? (
+                    <TableRow>
+                      <TableCell
+                        colSpan={columns.length}
+                        className="text-center text-ink-muted py-12"
+                      >
+                        <div className="text-gold text-2xl mb-2" aria-hidden>
+                          ❦
+                        </div>
+                        {globalFilter
+                          ? "אין תיקים תואמים לחיפוש"
+                          : "אין תיקים בארכיון"}
+                      </TableCell>
+                    </TableRow>
+                  ) : (
+                    table.getRowModel().rows.map((row) => (
+                      <TableRow
+                        key={row.id}
+                        className="border-rule hover:bg-gold-wash/40 transition-colors"
+                      >
+                        {row.getVisibleCells().map((cell) => (
+                          <TableCell key={cell.id} className="py-3">
+                            {flexRender(
+                              cell.column.columnDef.cell,
+                              cell.getContext(),
+                            )}
+                          </TableCell>
+                        ))}
+                      </TableRow>
+                    ))
+                  )}
+                </TableBody>
+              </Table>
+            </div>
+          </CardContent>
+        </Card>
+      </section>
+    </AppShell>
+  );
+}

web-ui/src/app/cases/[caseNumber]/compose/page.tsx

@@ -1,6 +1,6 @@
 "use client";
 
-import { use } from "react";
+import { use, useRef, useState } from "react";
 import Link from "next/link";
 import { AppShell } from "@/components/app-shell";
 import { Card, CardContent } from "@/components/ui/card";
@@ -25,6 +25,103 @@ function ProseSection({ title, content }: { title: string; content?: string }) {
   );
 }
 
+function AnalysisActions({
+  caseNumber,
+  hasAnalysis,
+  onUploaded,
+}: {
+  caseNumber: string;
+  hasAnalysis: boolean;
+  onUploaded: () => void;
+}) {
+  const fileRef = useRef<HTMLInputElement>(null);
+  const [uploading, setUploading] = useState(false);
+  const [uploadMsg, setUploadMsg] = useState<{ ok: boolean; text: string } | null>(null);
+
+  async function handleUpload(file: File) {
+    setUploading(true);
+    setUploadMsg(null);
+    try {
+      const form = new FormData();
+      form.append("file", file);
+      const res = await fetch(`/api/cases/${caseNumber}/research/analysis/upload`, {
+        method: "PUT",
+        body: form,
+      });
+      const data = await res.json();
+      if (!res.ok) {
+        setUploadMsg({ ok: false, text: data.detail || "שגיאה בהעלאה" });
+        return;
+      }
+      setUploadMsg({
+        ok: true,
+        text: `הקובץ הועלה בהצלחה — ${data.sections.threshold_claims} טענות סף, ${data.sections.issues} סוגיות`,
+      });
+      onUploaded();
+    } catch {
+      setUploadMsg({ ok: false, text: "שגיאת רשת" });
+    } finally {
+      setUploading(false);
+      if (fileRef.current) fileRef.current.value = "";
+    }
+  }
+
+  return (
+    <div className="flex items-center gap-2 flex-wrap">
+      {uploadMsg && (
+        <span className={`text-xs ${uploadMsg.ok ? "text-green-700" : "text-red-600"}`}>
+          {uploadMsg.text}
+        </span>
+      )}
+      <input
+        ref={fileRef}
+        type="file"
+        accept=".md"
+        className="hidden"
+        onChange={(e) => {
+          const f = e.target.files?.[0];
+          if (f) handleUpload(f);
+        }}
+      />
+      <Button
+        variant="outline"
+        disabled={uploading}
+        onClick={() => fileRef.current?.click()}
+      >
+        {uploading ? "מעלה..." : "העלה ניתוח מעודכן"}
+      </Button>
+      {hasAnalysis && (
+        <Button
+          variant="outline"
+          onClick={() => {
+            const a = document.createElement("a");
+            a.href = `/api/cases/${caseNumber}/research/analysis/download`;
+            a.download = `analysis-${caseNumber}.md`;
+            a.click();
+          }}
+        >
+          הורד ניתוח
+        </Button>
+      )}
+      {hasAnalysis && (
+        <Button
+          variant="outline"
+          onClick={() => {
+            const a = document.createElement("a");
+            a.href = `/api/cases/${caseNumber}/research/analysis/export-docx`;
+            a.click();
+          }}
+        >
+          הורד כ-DOCX
+        </Button>
+      )}
+      <Button asChild variant="outline">
+        <Link href={`/cases/${caseNumber}`}>חזרה לתיק</Link>
+      </Button>
+    </div>
+  );
+}
+
 export default function ComposePage({
   params,
 }: {
@@ -78,24 +175,7 @@ export default function ComposePage({
               </p>
             )}
           </div>
-          <div className="flex items-center gap-2">
+          <AnalysisActions caseNumber={caseNumber} hasAnalysis={!!analysis.data} onUploaded={() => analysis.refetch()} />
-            {analysis.data && (
-              <Button
-                variant="outline"
-                onClick={() => {
-                  const a = document.createElement("a");
-                  a.href = `/api/cases/${caseNumber}/research/analysis/download`;
-                  a.download = `analysis-${caseNumber}.md`;
-                  a.click();
-                }}
-              >
-                הורד ניתוח
-              </Button>
-            )}
-            <Button asChild variant="outline">
-              <Link href={`/cases/${caseNumber}`}>חזרה לתיק</Link>
-            </Button>
-          </div>
         </div>
 
         <div className="h-[2px] bg-gradient-to-l from-transparent via-gold to-transparent" />

web-ui/src/app/cases/[caseNumber]/page.tsx

@@ -13,9 +13,14 @@ import { WorkflowTimeline } from "@/components/cases/workflow-timeline";
 import { StatusGuide } from "@/components/cases/status-guide";
 import { StatusChanger } from "@/components/cases/status-changer";
 import { DocumentsPanel } from "@/components/cases/documents-panel";
+import { DraftsPanel } from "@/components/cases/drafts-panel";
+import { AgentActivityFeed } from "@/components/cases/agent-activity-feed";
+import { AgentStatusWidget } from "@/components/cases/agent-status-widget";
 import { UploadSheet } from "@/components/documents/upload-sheet";
 import { expectedOutcomes } from "@/lib/schemas/case";
-import { useCase } from "@/lib/api/cases";
+import { useCase, useStartWorkflow } from "@/lib/api/cases";
+import { toast } from "sonner";
+import { Play, Loader2 } from "lucide-react";
 
 const EXPECTED_OUTCOME_LABELS: Record<string, string> = Object.fromEntries(
   expectedOutcomes.map((o) => [o.value, o.label]),
@@ -32,6 +37,8 @@ export default function CaseDetailPage({
 }) {
   const { caseNumber } = use(params);
   const { data, isPending, error } = useCase(caseNumber);
+  const startWorkflow = useStartWorkflow(caseNumber);
+  const canStartWorkflow = data?.status === "new" || data?.status === "documents_ready";
   const expectedOutcomeLabel = data?.expected_outcome
     ? EXPECTED_OUTCOME_LABELS[data.expected_outcome] ?? data.expected_outcome
     : null;
@@ -67,20 +74,26 @@ export default function CaseDetailPage({
               <Card className="bg-surface border-rule shadow-sm">
                 <CardContent className="px-6 py-5">
                   <Tabs defaultValue="overview" dir="rtl">
-                    <div className="flex items-center justify-between gap-3 mb-1">
+                    <div className="flex items-center justify-between gap-3 mb-1 flex-wrap">
                       <TabsList className="bg-rule-soft/60">
                         <TabsTrigger value="overview">סקירה</TabsTrigger>
-                        <TabsTrigger value="documents">
+                        <TabsTrigger value="drafts">
-                          מסמכים
+                          טיוטות והערות
-                          {data?.documents && (
+                        </TabsTrigger>
-                            <span className="ms-1.5 text-[0.7rem] text-ink-muted tabular-nums">
+                        <TabsTrigger value="agents">
-                              ({data.documents.length})
+                          סוכנים
-                            </span>
-                          )}
                         </TabsTrigger>
                       </TabsList>
+                      <div className="flex items-center gap-2 flex-wrap">
+                        <Button asChild className="bg-navy hover:bg-navy-soft text-parchment">
+                          <Link href={`/cases/${caseNumber}/compose`}>
+                            פתח בעורך ההחלטה
+                          </Link>
+                        </Button>
+                        {data && <CaseEditDialog data={data} />}
                         <UploadSheet caseNumber={caseNumber} />
                       </div>
+                    </div>
 
                     <TabsContent value="overview" className="mt-5 space-y-4">
                       <div>
@@ -92,35 +105,57 @@ export default function CaseDetailPage({
                       <div>
                         <h3 className="text-navy text-base mb-2">סיכום מהיר</h3>
                         <dl className="grid grid-cols-2 gap-y-2 gap-x-6 text-sm">
-                          <dt className="text-ink-muted">מסמכים בתיק</dt>
-                          <dd className="text-ink tabular-nums">
-                            {data?.documents?.length ?? 0}
-                          </dd>
                           <dt className="text-ink-muted">בעיבוד</dt>
                           <dd className="text-ink tabular-nums">
                             {data?.processing_count ?? 0}
                           </dd>
                         </dl>
                       </div>
-                      <div className="flex items-center gap-3 flex-wrap pt-2 border-t border-rule">
+                      {canStartWorkflow && (
-                        <Button asChild className="bg-navy hover:bg-navy-soft text-parchment">
+                        <div className="pt-2 border-t border-rule">
-                          <Link href={`/cases/${caseNumber}/compose`}>
+                          <Button
-                            פתח בעורך ההחלטה
+                            className="bg-gold-deep hover:bg-gold-deep/90 text-parchment"
-                          </Link>
+                            disabled={startWorkflow.isPending}
+                            onClick={() =>
+                              startWorkflow.mutate(undefined, {
+                                onSuccess: (res) =>
+                                  toast.success(
+                                    `תהליך הופעל — ${res.issue_identifier}`,
+                                  ),
+                                onError: (err) =>
+                                  toast.error(`שגיאה: ${err.message}`),
+                              })
+                            }
+                          >
+                            {startWorkflow.isPending ? (
+                              <Loader2 className="w-4 h-4 animate-spin me-1.5" />
+                            ) : (
+                              <Play className="w-4 h-4 me-1.5" />
+                            )}
+                            התחל תהליך
                           </Button>
-                        {data && <CaseEditDialog data={data} />}
                         </div>
+                      )}
+                      <DocumentsPanel data={data} />
                     </TabsContent>
 
-                    <TabsContent value="documents" className="mt-5">
+                    <TabsContent value="drafts" className="mt-5">
-                      <DocumentsPanel data={data} />
+                      <DraftsPanel
+                        caseNumber={caseNumber}
+                        status={data?.status}
+                      />
+                    </TabsContent>
+
+                    <TabsContent value="agents" className="mt-5">
+                      <AgentActivityFeed caseNumber={caseNumber} />
                     </TabsContent>
                   </Tabs>
                 </CardContent>
               </Card>
 
               <Card className="bg-surface border-rule shadow-sm h-fit">
-                <CardContent className="px-6 py-5">
+                <CardContent className="px-6 py-5 space-y-5">
+                  <AgentStatusWidget caseNumber={caseNumber} />
                   <h2 className="text-navy text-base mb-4">שלב בתהליך</h2>
                   <WorkflowTimeline status={data?.status} />
                   <StatusChanger caseNumber={caseNumber} currentStatus={data?.status} />

web-ui/src/app/feedback/page.tsx

@@ -1,329 +0,0 @@
-"use client";
-
-import { useState } from "react";
-import Link from "next/link";
-import { AppShell } from "@/components/app-shell";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { Badge } from "@/components/ui/badge";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { Label } from "@/components/ui/label";
-import { Textarea } from "@/components/ui/textarea";
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogTrigger,
-} from "@/components/ui/dialog";
-import {
-  useFeedbackList,
-  useCreateFeedback,
-  useResolveFeedback,
-  CATEGORY_LABELS,
-  BLOCK_LABELS,
-  type FeedbackCategory,
-} from "@/lib/api/feedback";
-import { toast } from "sonner";
-
-const CATEGORY_COLORS: Record<FeedbackCategory, string> = {
-  missing_content: "bg-amber-100 text-amber-800 border-amber-200",
-  wrong_tone: "bg-purple-100 text-purple-800 border-purple-200",
-  wrong_structure: "bg-blue-100 text-blue-800 border-blue-200",
-  factual_error: "bg-red-100 text-red-800 border-red-200",
-  style: "bg-emerald-100 text-emerald-800 border-emerald-200",
-  other: "bg-gray-100 text-gray-800 border-gray-200",
-};
-
-export default function FeedbackPage() {
-  const [showResolved, setShowResolved] = useState(false);
-  const [filterCategory, setFilterCategory] = useState<string>("");
-
-  const { data: feedbacks, isLoading } = useFeedbackList({
-    category: filterCategory || undefined,
-    unresolved_only: !showResolved,
-  });
-
-  const resolveMutation = useResolveFeedback();
-
-  function handleResolve(id: string) {
-    resolveMutation.mutate(
-      { feedbackId: id, applied_to: [] },
-      {
-        onSuccess: () => toast.success("ההערה סומנה כמטופלת"),
-        onError: () => toast.error("שגיאה בעדכון"),
-      },
-    );
-  }
-
-  return (
-    <AppShell>
-      <section className="space-y-6">
-        <header>
-          <nav className="text-[0.78rem] text-ink-muted mb-1">
-            <Link href="/" className="hover:text-gold-deep">
-              בית
-            </Link>
-            <span aria-hidden> &middot; </span>
-            <span className="text-navy">הערות יו״ר</span>
-          </nav>
-          <h1 className="text-navy mb-0">הערות יו״ר על טיוטות</h1>
-          <p className="text-ink-muted text-sm mt-1 max-w-2xl">
-            תיעוד הערות דפנה על טיוטות החלטות. כל הערה מנותחת ומשפיעה על שיפור
-            כתיבת ההחלטות העתידיות.
-          </p>
-        </header>
-
-        <div className="h-[2px] bg-gradient-to-l from-transparent via-gold to-transparent" />
-
-        {/* Toolbar */}
-        <div className="flex items-center gap-3 flex-wrap">
-          <NewFeedbackDialog />
-
-          <select
-            value={filterCategory}
-            onChange={(e) => setFilterCategory(e.target.value)}
-            className="rounded-md border border-rule bg-surface px-3 py-1.5 text-sm"
-          >
-            <option value="">כל הקטגוריות</option>
-            {Object.entries(CATEGORY_LABELS).map(([key, label]) => (
-              <option key={key} value={key}>
-                {label}
-              </option>
-            ))}
-          </select>
-
-          <label className="flex items-center gap-2 text-sm text-ink-muted cursor-pointer">
-            <input
-              type="checkbox"
-              checked={showResolved}
-              onChange={(e) => setShowResolved(e.target.checked)}
-              className="rounded border-rule"
-            />
-            הצג גם מטופלות
-          </label>
-
-          {feedbacks && (
-            <span className="text-sm text-ink-muted me-auto">
-              {feedbacks.length} הערות
-            </span>
-          )}
-        </div>
-
-        {/* Feedback list */}
-        {isLoading ? (
-          <Card className="bg-surface border-rule shadow-sm">
-            <CardContent className="px-6 py-8 text-center text-ink-muted">
-              טוען...
-            </CardContent>
-          </Card>
-        ) : !feedbacks?.length ? (
-          <Card className="bg-surface border-rule shadow-sm">
-            <CardContent className="px-6 py-8 text-center text-ink-muted">
-              אין הערות{!showResolved ? " פתוחות" : ""}
-              {filterCategory ? ` בקטגוריה ${CATEGORY_LABELS[filterCategory as FeedbackCategory]}` : ""}
-            </CardContent>
-          </Card>
-        ) : (
-          <div className="space-y-3">
-            {feedbacks.map((fb) => (
-              <Card
-                key={fb.id}
-                className={`bg-surface border-rule shadow-sm ${fb.resolved ? "opacity-60" : ""}`}
-              >
-                <CardHeader className="border-b pb-3">
-                  <div className="flex items-center gap-2 flex-wrap">
-                    <Badge
-                      className={`text-[0.7rem] border ${CATEGORY_COLORS[fb.category]}`}
-                    >
-                      {CATEGORY_LABELS[fb.category]}
-                    </Badge>
-                    <Badge variant="outline" className="text-[0.7rem]">
-                      {BLOCK_LABELS[fb.block_id] ?? fb.block_id}
-                    </Badge>
-                    {fb.case_number && (
-                      <Link
-                        href={`/cases/${fb.case_number}`}
-                        className="text-[0.7rem] text-gold-deep hover:underline"
-                      >
-                        תיק {fb.case_number}
-                      </Link>
-                    )}
-                    {fb.resolved && (
-                      <Badge className="bg-emerald-100 text-emerald-700 text-[0.7rem] border border-emerald-200">
-                        טופל
-                      </Badge>
-                    )}
-                    <span className="text-[0.7rem] text-ink-muted me-auto">
-                      {fb.created_at
-                        ? new Date(fb.created_at).toLocaleDateString("he-IL")
-                        : ""}
-                    </span>
-                  </div>
-                </CardHeader>
-                <CardContent className="px-6 py-4 space-y-3">
-                  <p className="text-sm leading-relaxed">{fb.feedback_text}</p>
-
-                  {fb.lesson_extracted && (
-                    <div className="bg-gold/5 border border-gold/20 rounded-md px-4 py-3">
-                      <p className="text-[0.7rem] font-semibold text-gold-deep mb-1">
-                        לקח שהופק:
-                      </p>
-                      <p className="text-sm text-ink-muted leading-relaxed">
-                        {fb.lesson_extracted}
-                      </p>
-                    </div>
-                  )}
-
-                  {!fb.resolved && (
-                    <div className="flex justify-end">
-                      <Button
-                        variant="outline"
-                        size="sm"
-                        onClick={() => handleResolve(fb.id)}
-                        disabled={resolveMutation.isPending}
-                      >
-                        סמן כמטופל
-                      </Button>
-                    </div>
-                  )}
-                </CardContent>
-              </Card>
-            ))}
-          </div>
-        )}
-      </section>
-    </AppShell>
-  );
-}
-
-/* ── New feedback dialog ─────────────────────────────────── */
-
-function NewFeedbackDialog() {
-  const [open, setOpen] = useState(false);
-  const createMutation = useCreateFeedback();
-
-  const [caseNumber, setCaseNumber] = useState("");
-  const [blockId, setBlockId] = useState("block-yod");
-  const [category, setCategory] = useState<FeedbackCategory>("missing_content");
-  const [feedbackText, setFeedbackText] = useState("");
-  const [lesson, setLesson] = useState("");
-
-  function handleSubmit(e: React.FormEvent) {
-    e.preventDefault();
-    if (!feedbackText.trim()) return;
-
-    createMutation.mutate(
-      {
-        case_number: caseNumber || undefined,
-        block_id: blockId,
-        feedback_text: feedbackText,
-        category,
-        lesson_extracted: lesson || undefined,
-      },
-      {
-        onSuccess: () => {
-          toast.success("ההערה נרשמה בהצלחה");
-          setOpen(false);
-          setCaseNumber("");
-          setFeedbackText("");
-          setLesson("");
-        },
-        onError: () => toast.error("שגיאה ברישום ההערה"),
-      },
-    );
-  }
-
-  return (
-    <Dialog open={open} onOpenChange={setOpen}>
-      <DialogTrigger asChild>
-        <Button>+ הערה חדשה</Button>
-      </DialogTrigger>
-      <DialogContent className="sm:max-w-lg" dir="rtl">
-        <DialogHeader>
-          <DialogTitle>רישום הערת יו״ר</DialogTitle>
-        </DialogHeader>
-        <form onSubmit={handleSubmit} className="space-y-4 mt-2">
-          <div className="grid grid-cols-2 gap-3">
-            <div>
-              <Label htmlFor="fb-case">מספר תיק (אופציונלי)</Label>
-              <Input
-                id="fb-case"
-                value={caseNumber}
-                onChange={(e) => setCaseNumber(e.target.value)}
-                placeholder="1130-25"
-              />
-            </div>
-            <div>
-              <Label htmlFor="fb-block">בלוק</Label>
-              <select
-                id="fb-block"
-                value={blockId}
-                onChange={(e) => setBlockId(e.target.value)}
-                className="w-full rounded-md border border-rule bg-surface px-3 py-2 text-sm"
-              >
-                {Object.entries(BLOCK_LABELS).map(([key, label]) => (
-                  <option key={key} value={key}>
-                    {label}
-                  </option>
-                ))}
-              </select>
-            </div>
-          </div>
-
-          <div>
-            <Label htmlFor="fb-category">קטגוריה</Label>
-            <select
-              id="fb-category"
-              value={category}
-              onChange={(e) => setCategory(e.target.value as FeedbackCategory)}
-              className="w-full rounded-md border border-rule bg-surface px-3 py-2 text-sm"
-            >
-              {Object.entries(CATEGORY_LABELS).map(([key, label]) => (
-                <option key={key} value={key}>
-                  {label}
-                </option>
-              ))}
-            </select>
-          </div>
-
-          <div>
-            <Label htmlFor="fb-text">ההערה</Label>
-            <Textarea
-              id="fb-text"
-              value={feedbackText}
-              onChange={(e) => setFeedbackText(e.target.value)}
-              placeholder="מה דפנה אמרה? מה חסר, מה לא נכון, מה צריך לשנות..."
-              rows={4}
-              required
-            />
-          </div>
-
-          <div>
-            <Label htmlFor="fb-lesson">לקח שהופק (אופציונלי)</Label>
-            <Textarea
-              id="fb-lesson"
-              value={lesson}
-              onChange={(e) => setLesson(e.target.value)}
-              placeholder="מה למדנו מההערה? מה צריך לשנות במערכת?"
-              rows={2}
-            />
-          </div>
-
-          <div className="flex justify-end gap-2 pt-2">
-            <Button
-              type="button"
-              variant="outline"
-              onClick={() => setOpen(false)}
-            >
-              ביטול
-            </Button>
-            <Button type="submit" disabled={createMutation.isPending}>
-              {createMutation.isPending ? "שומר..." : "שמור הערה"}
-            </Button>
-          </div>
-        </form>
-      </DialogContent>
-    </Dialog>
-  );
-}

web-ui/src/app/methodology/page.tsx

@@ -0,0 +1,47 @@
+"use client";
+
+import { AppShell } from "@/components/app-shell";
+import { Card, CardContent } from "@/components/ui/card";
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
+import { GoldenRatiosPanel } from "@/components/methodology/golden-ratios-panel";
+import { DiscussionRulesPanel } from "@/components/methodology/discussion-rules-panel";
+import { ContentChecklistsPanel } from "@/components/methodology/content-checklists-panel";
+
+export default function MethodologyPage() {
+  return (
+    <AppShell>
+      <section className="space-y-6">
+        <div>
+          <h1 className="text-xl font-bold text-navy">מתודולוגיה</h1>
+          <p className="text-sm text-ink-muted mt-1">
+            הגדרות ניסוח — יחסי אורך, כללי דיון, וצ׳קליסטים לפי סוג ערר
+          </p>
+        </div>
+
+        <Card className="bg-surface border-rule shadow-sm">
+          <CardContent className="px-6 py-5">
+            <Tabs defaultValue="ratios" dir="rtl">
+              <TabsList className="bg-rule-soft/60">
+                <TabsTrigger value="ratios">יחסי זהב</TabsTrigger>
+                <TabsTrigger value="rules">כללי דיון</TabsTrigger>
+                <TabsTrigger value="checklists">צ׳קליסטים</TabsTrigger>
+              </TabsList>
+
+              <TabsContent value="ratios" className="mt-5">
+                <GoldenRatiosPanel />
+              </TabsContent>
+
+              <TabsContent value="rules" className="mt-5">
+                <DiscussionRulesPanel />
+              </TabsContent>
+
+              <TabsContent value="checklists" className="mt-5">
+                <ContentChecklistsPanel />
+              </TabsContent>
+            </Tabs>
+          </CardContent>
+        </Card>
+      </section>
+    </AppShell>
+  );
+}

web-ui/src/app/settings/page.tsx

@@ -0,0 +1,252 @@
+"use client";
+
+import { useState } from "react";
+import Link from "next/link";
+import { Plus, Trash2, Tags, Building2 } from "lucide-react";
+import { AppShell } from "@/components/app-shell";
+import { Card, CardContent } from "@/components/ui/card";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Skeleton } from "@/components/ui/skeleton";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import {
+  useTagMappings,
+  usePaperclipCompanies,
+  useAddTagMapping,
+  useDeleteTagMapping,
+} from "@/lib/api/settings";
+import { APPEAL_SUBTYPES } from "@/lib/practice-area";
+import { toast } from "sonner";
+
+const TAG_SUGGESTIONS = APPEAL_SUBTYPES.filter((s) => s.value !== "unknown");
+
+export default function SettingsPage() {
+  const { data: mappings, isPending: loadingMappings } = useTagMappings();
+  const { data: companies, isPending: loadingCompanies } = usePaperclipCompanies();
+  const addMapping = useAddTagMapping();
+  const deleteMapping = useDeleteTagMapping();
+
+  const [tag, setTag] = useState("");
+  const [tagLabel, setTagLabel] = useState("");
+  const [companyId, setCompanyId] = useState("");
+
+  function handleTagInput(value: string) {
+    setTag(value);
+    const match = TAG_SUGGESTIONS.find((s) => s.value === value);
+    if (match) setTagLabel(match.label);
+  }
+
+  function handleAdd() {
+    if (!tag || !companyId) {
+      toast.error("יש לבחור תגית וחברה");
+      return;
+    }
+    const company = companies?.find((c) => c.id === companyId);
+    addMapping.mutate(
+      {
+        tag,
+        tag_label: tagLabel,
+        company_id: companyId,
+        company_name: company?.name ?? "",
+      },
+      {
+        onSuccess: () => {
+          toast.success("מיפוי נוסף בהצלחה");
+          setTag("");
+          setTagLabel("");
+          setCompanyId("");
+        },
+        onError: (err) => toast.error(`שגיאה: ${err.message}`),
+      },
+    );
+  }
+
+  function handleDelete(id: string, tag: string) {
+    deleteMapping.mutate(id, {
+      onSuccess: () => toast.success(`מיפוי "${tag}" נמחק`),
+      onError: (err) => toast.error(`שגיאה: ${err.message}`),
+    });
+  }
+
+  return (
+    <AppShell>
+      <section className="space-y-6">
+        <header>
+          <nav className="text-[0.78rem] text-ink-muted mb-1">
+            <Link href="/" className="hover:text-gold-deep">
+              בית
+            </Link>
+            <span aria-hidden> · </span>
+            <span className="text-navy">הגדרות</span>
+          </nav>
+          <h1 className="text-navy mb-0">הגדרות</h1>
+          <p className="text-ink-muted text-sm mt-1 max-w-2xl">
+            ניהול מיפוי תגיות ערר לחברות ב-Paperclip. כל תיק חדש ישויך
+            אוטומטית לפרויקט בחברה הנכונה לפי סוג הערר.
+          </p>
+        </header>
+
+        <div className="h-[2px] bg-gradient-to-l from-transparent via-gold to-transparent" />
+
+        {/* Companies overview */}
+        <Card className="bg-surface border-rule shadow-sm">
+          <CardContent className="px-6 py-5">
+            <h2 className="text-navy text-lg mb-3 flex items-center gap-2">
+              <Building2 className="w-4 h-4" />
+              חברות ב-Paperclip
+            </h2>
+            {loadingCompanies ? (
+              <Skeleton className="h-12 w-full" />
+            ) : !companies?.length ? (
+              <p className="text-ink-muted text-sm">לא נמצאו חברות</p>
+            ) : (
+              <div className="flex flex-wrap gap-3">
+                {companies.map((c) => (
+                  <div
+                    key={c.id}
+                    className="flex items-center gap-2 rounded-md bg-rule-soft/60 border border-rule px-4 py-2.5"
+                  >
+                    <span className="text-sm font-medium text-ink">{c.name}</span>
+                    <Badge variant="outline" className="text-[0.7rem] tabular-nums">
+                      {c.prefix}
+                    </Badge>
+                  </div>
+                ))}
+              </div>
+            )}
+          </CardContent>
+        </Card>
+
+        {/* Tag mappings */}
+        <Card className="bg-surface border-rule shadow-sm">
+          <CardContent className="px-6 py-5">
+            <h2 className="text-navy text-lg mb-4 flex items-center gap-2">
+              <Tags className="w-4 h-4" />
+              מיפוי תגיות
+              <Badge variant="outline" className="text-[0.7rem] tabular-nums">
+                {mappings?.length ?? 0}
+              </Badge>
+            </h2>
+
+            {/* Add form */}
+            <div className="flex flex-wrap items-end gap-3 mb-5 p-4 rounded-md bg-rule-soft/40 border border-rule">
+              <div className="flex flex-col gap-1.5 min-w-[180px]">
+                <label className="text-[0.72rem] text-ink-muted">
+                  תגית
+                </label>
+                <Input
+                  list="tag-suggestions"
+                  value={tag}
+                  onChange={(e) => handleTagInput(e.target.value)}
+                  placeholder="סוג ערר או תגית חופשית"
+                  className="w-[220px]"
+                />
+                <datalist id="tag-suggestions">
+                  {TAG_SUGGESTIONS.map((s) => (
+                    <option key={s.value} value={s.value}>
+                      {s.label}
+                    </option>
+                  ))}
+                </datalist>
+              </div>
+
+              <div className="flex flex-col gap-1.5 min-w-[140px]">
+                <label className="text-[0.72rem] text-ink-muted">תווית</label>
+                <Input
+                  value={tagLabel}
+                  onChange={(e) => setTagLabel(e.target.value)}
+                  placeholder="שם לתצוגה"
+                  className="w-[160px]"
+                />
+              </div>
+
+              <div className="flex flex-col gap-1.5 min-w-[200px]">
+                <label className="text-[0.72rem] text-ink-muted">
+                  חברה ב-Paperclip
+                </label>
+                <Select value={companyId} onValueChange={setCompanyId}>
+                  <SelectTrigger className="w-[240px]">
+                    <SelectValue placeholder="בחר חברה" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {companies?.map((c) => (
+                      <SelectItem key={c.id} value={c.id}>
+                        {c.name} ({c.prefix})
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              </div>
+
+              <Button
+                onClick={handleAdd}
+                disabled={addMapping.isPending || !tag || !companyId}
+                size="default"
+              >
+                <Plus className="w-4 h-4" data-icon="inline-start" />
+                {addMapping.isPending ? "שומר..." : "הוסף מיפוי"}
+              </Button>
+            </div>
+
+            {/* Table */}
+            {loadingMappings ? (
+              <Skeleton className="h-32 w-full" />
+            ) : !mappings?.length ? (
+              <p className="text-ink-muted text-sm">
+                אין מיפויים. הוסף מיפוי כדי שתיקים חדשים ישויכו אוטומטית
+                לפרויקט בחברה הנכונה.
+              </p>
+            ) : (
+              <div className="overflow-x-auto">
+                <table className="w-full text-sm">
+                  <thead>
+                    <tr className="border-b border-rule text-ink-muted text-[0.72rem] uppercase tracking-wider">
+                      <th className="text-start py-2 px-3 font-medium">Tag</th>
+                      <th className="text-start py-2 px-3 font-medium">Label</th>
+                      <th className="text-start py-2 px-3 font-medium">Company</th>
+                      <th className="py-2 px-3 w-12" />
+                    </tr>
+                  </thead>
+                  <tbody>
+                    {mappings.map((m) => (
+                      <tr
+                        key={m.id}
+                        className="border-b border-rule/60 hover:bg-rule-soft/40 transition-colors"
+                      >
+                        <td className="py-2.5 px-3">
+                          <Badge variant="outline" className="text-[0.75rem] font-mono">
+                            {m.tag}
+                          </Badge>
+                        </td>
+                        <td className="py-2.5 px-3 text-ink">{m.tag_label}</td>
+                        <td className="py-2.5 px-3 text-ink">{m.company_name}</td>
+                        <td className="py-2.5 px-3">
+                          <Button
+                            variant="ghost"
+                            size="icon-xs"
+                            onClick={() => handleDelete(m.id, m.tag)}
+                            disabled={deleteMapping.isPending}
+                            title="מחק מיפוי"
+                          >
+                            <Trash2 className="w-3.5 h-3.5 text-danger" />
+                          </Button>
+                        </td>
+                      </tr>
+                    ))}
+                  </tbody>
+                </table>
+              </div>
+            )}
+          </CardContent>
+        </Card>
+      </section>
+    </AppShell>
+  );
+}

web-ui/src/components/app-shell.tsx

@@ -24,11 +24,12 @@ type NavItem = {
 
 const NAV_ITEMS: NavItem[] = [
   { href: "/",            label: "בית"         },
-  { href: "/cases/new",   label: "תיק חדש"     },
+  { href: "/archive",     label: "ארכיון"      },
   { href: "/training",    label: "אימון סגנון" },
-  { href: "/feedback",    label: "הערות יו״ר"  },
+  { href: "/methodology", label: "מתודולוגיה" },
   { href: "/skills",      label: "מיומנויות"  },
   { href: "/diagnostics", label: "אבחון"       },
+  { href: "/settings",    label: "הגדרות"      },
 ];
 
 function isActive(pathname: string, href: string): boolean {

web-ui/src/components/cases/agent-activity-feed.tsx

@@ -0,0 +1,306 @@
+"use client";
+
+import { useRef, useState, useEffect } from "react";
+import { Button } from "@/components/ui/button";
+import { Textarea } from "@/components/ui/textarea";
+import { Badge } from "@/components/ui/badge";
+import { Markdown } from "@/components/ui/markdown";
+import { useAgentActivity, useSendComment } from "@/lib/api/agents";
+import type { PaperclipComment } from "@/lib/api/agents";
+import { toast } from "sonner";
+import {
+  Bot,
+  User,
+  Send,
+  Loader2,
+  MessageSquare,
+  Clock,
+} from "lucide-react";
+
+/* ── Role → color mapping ────────────────────────────────────── */
+
+const ROLE_COLORS: Record<string, string> = {
+  ceo: "bg-blue-100 text-blue-800 border-blue-200",
+  researcher: "bg-purple-100 text-purple-800 border-purple-200",
+  engineer: "bg-emerald-100 text-emerald-800 border-emerald-200",
+  qa: "bg-amber-100 text-amber-800 border-amber-200",
+};
+
+const ROLE_DOT: Record<string, string> = {
+  ceo: "bg-blue-500",
+  researcher: "bg-purple-500",
+  engineer: "bg-emerald-500",
+  qa: "bg-amber-500",
+};
+
+const ROLE_LABELS: Record<string, string> = {
+  ceo: "מנהל",
+  researcher: "חוקר",
+  engineer: "מהנדס",
+  qa: "בודק איכות",
+  general: "כללי",
+};
+
+const ISSUE_STATUS_LABELS: Record<string, string> = {
+  backlog: "ממתין",
+  todo: "לביצוע",
+  in_progress: "בביצוע",
+  in_review: "בבדיקה",
+  done: "הושלם",
+  cancelled: "בוטל",
+  blocked: "חסום",
+};
+
+function roleColor(role: string | null) {
+  return ROLE_COLORS[role ?? ""] ?? "bg-gray-100 text-gray-700 border-gray-200";
+}
+
+function roleDot(role: string | null) {
+  return ROLE_DOT[role ?? ""] ?? "bg-gray-400";
+}
+
+function roleLabel(role: string | null) {
+  return ROLE_LABELS[role ?? ""] ?? role ?? "";
+}
+
+function issueStatusLabel(status: string) {
+  return ISSUE_STATUS_LABELS[status] ?? status;
+}
+
+/* ── Time formatting ─────────────────────────────────────────── */
+
+function timeAgo(iso: string | null): string {
+  if (!iso) return "";
+  const diff = Date.now() - new Date(iso).getTime();
+  const mins = Math.floor(diff / 60_000);
+  if (mins < 1) return "עכשיו";
+  if (mins < 60) return `לפני ${mins} דק׳`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 24) return `לפני ${hours} שע׳`;
+  const days = Math.floor(hours / 24);
+  return `לפני ${days} ימים`;
+}
+
+/* ── Issue identifier → find matching identifier ─────────────── */
+
+function issueIdentifier(
+  comment: PaperclipComment,
+  issueMap: Map<string, string>,
+): string {
+  return issueMap.get(comment.issue_id) ?? "";
+}
+
+/* ── Comment card ────────────────────────────────────────────── */
+
+function CommentCard({
+  comment,
+  issueMap,
+}: {
+  comment: PaperclipComment;
+  issueMap: Map<string, string>;
+}) {
+  const isAgent = !!comment.author_agent_id;
+  const label = isAgent ? comment.agent_name ?? "סוכן" : "חיים";
+  const identifier = issueIdentifier(comment, issueMap);
+
+  return (
+    <div className="group relative flex gap-3 py-3 px-2 rounded-lg hover:bg-sand-soft/50 transition-colors">
+      {/* Avatar */}
+      <div className="flex-shrink-0 pt-0.5">
+        {isAgent ? (
+          <div
+            className={`w-8 h-8 rounded-full flex items-center justify-center ${roleColor(comment.agent_role)}`}
+          >
+            <Bot className="w-4 h-4" />
+          </div>
+        ) : (
+          <div className="w-8 h-8 rounded-full flex items-center justify-center bg-gold-soft text-gold-deep border border-gold">
+            <User className="w-4 h-4" />
+          </div>
+        )}
+      </div>
+
+      {/* Content */}
+      <div className="flex-1 min-w-0">
+        {/* Header */}
+        <div className="flex items-center gap-2 mb-1 flex-wrap">
+          <span className="text-sm font-semibold text-navy">{label}</span>
+          {isAgent && comment.agent_role && (
+            <span
+              className={`inline-flex items-center gap-1 text-[11px] px-1.5 py-0.5 rounded-full border ${roleColor(comment.agent_role)}`}
+            >
+              <span className={`w-1.5 h-1.5 rounded-full ${roleDot(comment.agent_role)}`} />
+              {roleLabel(comment.agent_role)}
+            </span>
+          )}
+          {identifier && (
+            <Badge variant="outline" className="text-[10px] font-mono">
+              {identifier}
+            </Badge>
+          )}
+          <span className="text-[11px] text-ink-faint mr-auto flex items-center gap-1">
+            <Clock className="w-3 h-3" />
+            {timeAgo(comment.created_at)}
+          </span>
+        </div>
+
+        {/* Body */}
+        <div className="text-sm">
+          <Markdown content={comment.body} />
+        </div>
+      </div>
+    </div>
+  );
+}
+
+/* ── Main Feed ───────────────────────────────────────────────── */
+
+export function AgentActivityFeed({
+  caseNumber,
+}: {
+  caseNumber: string;
+}) {
+  const { data, isLoading, error } = useAgentActivity(caseNumber);
+  const sendComment = useSendComment(caseNumber);
+  const [body, setBody] = useState("");
+  const endRef = useRef<HTMLDivElement>(null);
+
+  // Build issue_id → identifier map
+  const issueMap = new Map<string, string>();
+  if (data?.issues) {
+    for (const iss of data.issues) {
+      issueMap.set(iss.id, iss.identifier);
+    }
+  }
+
+  // Auto-scroll on new comments
+  const commentCount = data?.comments?.length ?? 0;
+  useEffect(() => {
+    endRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [commentCount]);
+
+  const handleSend = () => {
+    if (!body.trim()) return;
+    sendComment.mutate(
+      { body: body.trim() },
+      {
+        onSuccess: (res) => {
+          setBody("");
+          toast.success(`נשלח ל-${res.issue_identifier}`);
+        },
+        onError: () => toast.error("שגיאה בשליחת ההודעה"),
+      },
+    );
+  };
+
+  // ── Empty / loading states ──
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center py-12 text-ink-faint">
+        <Loader2 className="w-5 h-5 animate-spin ml-2" />
+        <span>טוען פעילות סוכנים...</span>
+      </div>
+    );
+  }
+
+  if (error) {
+    return (
+      <div className="text-center py-12 text-red-500 text-sm">
+        שגיאה בטעינת פעילות סוכנים
+      </div>
+    );
+  }
+
+  if (!data?.issues?.length) {
+    return (
+      <div className="text-center py-12 space-y-2">
+        <MessageSquare className="w-10 h-10 mx-auto text-ink-faint/40" />
+        <p className="text-sm text-ink-faint">
+          התהליך טרם הופעל. לחץ &quot;התחל תהליך&quot; בלשונית סקירה.
+        </p>
+      </div>
+    );
+  }
+
+  const comments = data.comments ?? [];
+
+  // An issue is "active" if it's not done/cancelled. When everything is closed
+  // we should NOT show the "agents are working, waiting for report" spinner.
+  const hasActiveIssue = data.issues.some(
+    (iss) => iss.status !== "done" && iss.status !== "cancelled",
+  );
+
+  return (
+    <div className="flex flex-col h-full">
+      {/* Issue summary bar */}
+      <div className="flex items-center gap-2 px-2 py-2 border-b border-rule mb-2 flex-wrap">
+        {data.issues.map((iss) => (
+          <Badge
+            key={iss.id}
+            variant={iss.status === "done" ? "secondary" : "default"}
+            className="text-[11px] font-mono"
+          >
+            {iss.identifier} — {issueStatusLabel(iss.status)}
+          </Badge>
+        ))}
+      </div>
+
+      {/* Comments stream */}
+      <div className="flex-1 overflow-y-auto max-h-[500px] space-y-1 px-1">
+        {comments.length === 0 ? (
+          hasActiveIssue ? (
+            <div className="text-center py-8 text-ink-faint text-sm">
+              <Loader2 className="w-5 h-5 animate-spin mx-auto mb-2" />
+              הסוכנים התחילו לעבוד, ממתין לדיווח ראשון...
+            </div>
+          ) : (
+            <div className="text-center py-8 text-ink-faint text-sm">
+              <MessageSquare className="w-5 h-5 mx-auto mb-2 opacity-50" />
+              אין משימות פעילות בתיק. כל המשימות הסתיימו או בוטלו.
+            </div>
+          )
+        ) : (
+          comments.map((c) => (
+            <CommentCard key={c.id} comment={c} issueMap={issueMap} />
+          ))
+        )}
+        <div ref={endRef} />
+      </div>
+
+      {/* Comment input */}
+      <div className="border-t border-rule pt-3 mt-3 space-y-2">
+        <Textarea
+          value={body}
+          onChange={(e) => setBody(e.target.value)}
+          placeholder="כתוב הוראה לסוכנים..."
+          className="min-h-[60px] resize-none text-sm"
+          dir="rtl"
+          onKeyDown={(e) => {
+            if (e.key === "Enter" && (e.ctrlKey || e.metaKey)) {
+              e.preventDefault();
+              handleSend();
+            }
+          }}
+        />
+        <div className="flex items-center justify-between">
+          <span className="text-[11px] text-ink-faint">
+            ההודעה תנותב דרך סוכן ה-CEO &middot; Ctrl+Enter לשליחה
+          </span>
+          <Button
+            size="sm"
+            onClick={handleSend}
+            disabled={!body.trim() || sendComment.isPending}
+          >
+            {sendComment.isPending ? (
+              <Loader2 className="w-4 h-4 animate-spin" />
+            ) : (
+              <Send className="w-4 h-4 ml-1" />
+            )}
+            שלח
+          </Button>
+        </div>
+      </div>
+    </div>
+  );
+}

web-ui/src/components/cases/agent-status-widget.tsx

@@ -0,0 +1,79 @@
+"use client";
+
+import { useAgentActivity } from "@/lib/api/agents";
+import type { PaperclipAgent } from "@/lib/api/agents";
+import { Bot } from "lucide-react";
+
+/* ── Status dot colors ───────────────────────────────────────── */
+
+const STATUS_DOT: Record<string, string> = {
+  active: "bg-emerald-500 shadow-[0_0_6px_rgba(16,185,129,0.6)]",
+  running: "bg-emerald-500 shadow-[0_0_6px_rgba(16,185,129,0.6)]",
+  idle: "bg-gray-300",
+  error: "bg-red-500",
+};
+
+const STATUS_LABEL: Record<string, string> = {
+  active: "פעיל",
+  running: "פעיל",
+  idle: "ממתין",
+  error: "שגיאה",
+};
+
+function statusDot(status: string) {
+  return STATUS_DOT[status] ?? STATUS_DOT.idle;
+}
+
+/* ── Agent row ───────────────────────────────────────────────── */
+
+function AgentRow({ agent }: { agent: PaperclipAgent }) {
+  return (
+    <div className="flex items-center gap-2 py-1">
+      <span
+        className={`w-2 h-2 rounded-full flex-shrink-0 ${statusDot(agent.status)}`}
+      />
+      <span className="text-xs text-ink truncate">{agent.name}</span>
+      <span className="text-[10px] text-ink-faint mr-auto">
+        {STATUS_LABEL[agent.status] ?? agent.status}
+      </span>
+    </div>
+  );
+}
+
+/* ── Widget ───────────────────────────────────────────────────── */
+
+export function AgentStatusWidget({
+  caseNumber,
+}: {
+  caseNumber: string;
+}) {
+  const { data } = useAgentActivity(caseNumber);
+
+  // Don't render if no Paperclip project yet
+  if (!data?.issues?.length) return null;
+
+  const agents = data.agents ?? [];
+  const activeCount = agents.filter((a) => a.status === "active" || a.status === "running").length;
+
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-1.5 text-xs font-medium text-navy">
+          <Bot className="w-3.5 h-3.5" />
+          <span>סוכנים</span>
+        </div>
+        {agents.length > 0 && (
+          <span className="text-[10px] text-ink-faint">
+            {activeCount} פעילים מתוך {agents.length}
+          </span>
+        )}
+      </div>
+
+      <div className="space-y-0.5">
+        {agents.map((agent) => (
+          <AgentRow key={agent.id} agent={agent} />
+        ))}
+      </div>
+    </div>
+  );
+}

web-ui/src/components/cases/case-archive-action.tsx

@@ -0,0 +1,124 @@
+"use client";
+
+import { useState } from "react";
+import { toast } from "sonner";
+import { Archive, RotateCcw, Loader2 } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogClose,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import { useArchiveCase, useRestoreCase, type ArchiveResult } from "@/lib/api/cases";
+
+function paperclipMessage(res: ArchiveResult, action: "archive" | "restore"): string {
+  const verb = action === "archive" ? "אורכן" : "שוחזר";
+  switch (res.paperclip?.status) {
+    case "archived": {
+      const cancelled = res.paperclip.issues_cancelled?.length ?? 0;
+      const issuesNote = cancelled > 0 ? ` (${cancelled} משימות פתוחות בוטלו)` : "";
+      return `התיק ${verb}. גם הפרויקט ב-Paperclip${issuesNote}.`;
+    }
+    case "restored":
+      return `התיק ${verb}. גם הפרויקט ב-Paperclip ${verb}.`;
+    case "not_found":
+      return `התיק ${verb}. לא נמצא פרויקט מקביל ב-Paperclip.`;
+    case "error":
+      return `התיק ${verb} ב-legal-ai, אך סנכרון Paperclip נכשל${
+        res.paperclip?.message ? `: ${res.paperclip.message}` : "."
+      }`;
+    default:
+      return `התיק ${verb}.`;
+  }
+}
+
+export function CaseArchiveAction({
+  caseNumber,
+  archivedAt,
+}: {
+  caseNumber: string;
+  archivedAt?: string | null;
+}) {
+  const [open, setOpen] = useState(false);
+  const archive = useArchiveCase(caseNumber);
+  const restore = useRestoreCase(caseNumber);
+
+  const isArchived = Boolean(archivedAt);
+  const pending = archive.isPending || restore.isPending;
+
+  function handleArchive() {
+    archive.mutate(undefined, {
+      onSuccess: (res) => {
+        setOpen(false);
+        toast.success(paperclipMessage(res, "archive"));
+      },
+      onError: (err) =>
+        toast.error(err instanceof Error ? err.message : "שגיאה בארכוב"),
+    });
+  }
+
+  function handleRestore() {
+    restore.mutate(undefined, {
+      onSuccess: (res) => {
+        toast.success(paperclipMessage(res, "restore"));
+      },
+      onError: (err) =>
+        toast.error(err instanceof Error ? err.message : "שגיאה בשחזור"),
+    });
+  }
+
+  if (isArchived) {
+    return (
+      <Button
+        variant="outline"
+        size="sm"
+        disabled={pending}
+        onClick={handleRestore}
+      >
+        {pending ? (
+          <Loader2 className="me-1 h-3.5 w-3.5 animate-spin" />
+        ) : (
+          <RotateCcw className="me-1 h-3.5 w-3.5" />
+        )}
+        שחזר מהארכיון
+      </Button>
+    );
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button variant="outline" size="sm" disabled={pending}>
+          {pending ? (
+            <Loader2 className="me-1 h-3.5 w-3.5 animate-spin" />
+          ) : (
+            <Archive className="me-1 h-3.5 w-3.5" />
+          )}
+          ארכן תיק
+        </Button>
+      </DialogTrigger>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>ארכון תיק {caseNumber}</DialogTitle>
+          <DialogDescription>
+            התיק יוסר מרשימת התיקים הראשית ויעבור לעמוד הארכיון. הפרויקט
+            המקביל ב-Paperclip יסומן גם הוא כארכוב. ניתן לשחזר בכל עת.
+          </DialogDescription>
+        </DialogHeader>
+        <DialogFooter>
+          <DialogClose asChild>
+            <Button variant="outline">בטל</Button>
+          </DialogClose>
+          <Button onClick={handleArchive} disabled={pending}>
+            {pending ? "מארכן..." : "ארכן"}
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  );
+}

web-ui/src/components/cases/case-header.tsx

@@ -2,6 +2,8 @@ import Link from "next/link";
 import { Card, CardContent } from "@/components/ui/card";
 import { Badge } from "@/components/ui/badge";
 import { StatusBadge } from "@/components/cases/status-badge";
+import { SyncIndicator } from "@/components/cases/sync-indicator";
+import { CaseArchiveAction } from "@/components/cases/case-archive-action";
 import {
   PRACTICE_AREA_LABELS,
   APPEAL_SUBTYPE_LABELS,
@@ -40,6 +42,14 @@ export function CaseHeader({ data }: { data?: CaseDetail }) {
                 ערר {data?.case_number ?? "—"}
               </span>
               {data?.status && <StatusBadge status={data.status} />}
+              {data?.archived_at && (
+                <Badge
+                  variant="outline"
+                  className="rounded-full px-2.5 py-0.5 text-[0.72rem] font-medium bg-ink-muted/10 text-ink-muted border-ink-muted/30"
+                >
+                  בארכיון
+                </Badge>
+              )}
               {data?.practice_area && (
                 <Badge
                   variant="outline"
@@ -51,6 +61,12 @@ export function CaseHeader({ data }: { data?: CaseDetail }) {
                   )}
                 </Badge>
               )}
+              {data?.case_number && (
+                <CaseArchiveAction
+                  caseNumber={data.case_number}
+                  archivedAt={data.archived_at}
+                />
+              )}
             </div>
             <h1 className="text-navy text-xl font-bold leading-snug max-w-2xl mb-0">
               {data?.title ?? "טוען…"}
@@ -71,6 +87,10 @@ export function CaseHeader({ data }: { data?: CaseDetail }) {
               עודכן
             </dt>
             <dd className="text-ink-soft tabular-nums">{formatDate(data?.updated_at)}</dd>
+            <dt className="text-ink-muted text-[0.72rem] uppercase tracking-wider">
+              סנכרון
+            </dt>
+            <dd><SyncIndicator caseNumber={data?.case_number} /></dd>
           </dl>
         </div>
       </CardContent>

web-ui/src/components/cases/document-type-editor.tsx

@@ -0,0 +1,329 @@
+"use client";
+
+import { useState } from "react";
+import { CheckCircle2, Loader2, Sparkles } from "lucide-react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import {
+  APPRAISER_SIDE_LABELS,
+  APPRAISER_SIDE_OPTIONS,
+  DOC_TYPE_OPTIONS,
+  appraiserSideLabel,
+  doctypeLabel,
+  doctypeTone,
+  type AppraiserSide,
+  type DocType,
+} from "@/lib/doc-types";
+import {
+  useExtractAppraiserFacts,
+  usePatchDocument,
+  type ExtractAppraiserFactsResponse,
+} from "@/lib/api/documents";
+
+/*
+ * Inline editor for a document's tags. Renders a colored Badge that opens a
+ * Popover with two Selects:
+ *   1. doc_type (always shown)
+ *   2. appraiser_side (only when doc_type === "appraisal")
+ *
+ * After a successful save we swap the Popover body to a confirmation view
+ * with a "חלץ עובדות שמאיות עכשיו" button — extraction is expensive so we
+ * never run it silently on save; the chair clicks this when they're done
+ * tagging all appraisals in the case.
+ */
+
+export function DocumentTypeEditor({
+  caseNumber,
+  docId,
+  docType,
+  appraiserSide,
+}: {
+  caseNumber: string;
+  docId: string;
+  docType: string;
+  appraiserSide?: string;
+}) {
+  const [open, setOpen] = useState(false);
+  const [draftType, setDraftType] = useState<string>(docType || "");
+  const [draftSide, setDraftSide] = useState<string>(appraiserSide || "");
+  const [saved, setSaved] = useState(false);
+  const [extractResult, setExtractResult] =
+    useState<ExtractAppraiserFactsResponse | null>(null);
+  const patch = usePatchDocument(caseNumber);
+  const extract = useExtractAppraiserFacts(caseNumber);
+
+  function reset() {
+    setDraftType(docType || "");
+    setDraftSide(appraiserSide || "");
+    setSaved(false);
+    setExtractResult(null);
+    patch.reset();
+    extract.reset();
+  }
+
+  const isAppraisal = draftType === "appraisal";
+  const sideMissing = isAppraisal && !draftSide;
+  const dirty =
+    draftType !== docType ||
+    (isAppraisal && draftSide !== (appraiserSide || ""));
+
+  async function handleSave() {
+    if (sideMissing || !dirty) return;
+    const body: { doc_type?: string; appraiser_side?: string } = {};
+    if (draftType !== docType) body.doc_type = draftType;
+    if (isAppraisal && draftSide !== (appraiserSide || "")) {
+      body.appraiser_side = draftSide;
+    }
+    // If the new type is NOT appraisal but the doc previously had a side,
+    // clear it so it doesn't dangle confusingly in metadata.
+    if (!isAppraisal && appraiserSide) body.appraiser_side = "";
+
+    await patch.mutateAsync({ docId, patch: body });
+    setSaved(true);
+  }
+
+  async function handleExtract() {
+    const result = await extract.mutateAsync();
+    setExtractResult(result);
+  }
+
+  // Build the on-badge label: "שומה · שמאי הוועדה" when both present.
+  const badgeText =
+    docType === "appraisal" && appraiserSide
+      ? `${doctypeLabel(docType)} · ${appraiserSideLabel(appraiserSide)}`
+      : doctypeLabel(docType);
+
+  return (
+    <Popover
+      open={open}
+      onOpenChange={(next) => {
+        setOpen(next);
+        if (next) reset();
+      }}
+    >
+      <PopoverTrigger asChild>
+        <button
+          type="button"
+          className="shrink-0 cursor-pointer outline-none focus-visible:ring-2 focus-visible:ring-gold/50 rounded-full"
+          title="לחץ לשינוי תיוג"
+        >
+          <Badge
+            variant="outline"
+            className={`rounded-full px-2 py-0.5 text-[0.7rem] ${doctypeTone(docType)} hover:opacity-80`}
+          >
+            {badgeText}
+          </Badge>
+        </button>
+      </PopoverTrigger>
+      <PopoverContent className="w-80 space-y-3" align="end" dir="rtl">
+        {saved ? (
+          <PostSaveView
+            isAppraisal={isAppraisal}
+            extract={extract}
+            extractResult={extractResult}
+            onExtract={handleExtract}
+            onClose={() => setOpen(false)}
+          />
+        ) : (
+          <>
+            <div className="space-y-1.5">
+              <label className="text-xs text-ink-muted">סוג מסמך</label>
+              <Select value={draftType} onValueChange={setDraftType} dir="rtl">
+                <SelectTrigger className="w-full">
+                  <SelectValue placeholder="בחר סוג" />
+                </SelectTrigger>
+                <SelectContent>
+                  {DOC_TYPE_OPTIONS.map((opt) => (
+                    <SelectItem key={opt.value} value={opt.value}>
+                      {opt.label}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+
+            {isAppraisal && (
+              <div className="space-y-1.5">
+                <label className="text-xs text-ink-muted">צד השמאי</label>
+                <Select value={draftSide} onValueChange={setDraftSide} dir="rtl">
+                  <SelectTrigger className="w-full">
+                    <SelectValue placeholder="בחר צד" />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {APPRAISER_SIDE_OPTIONS.map((opt) => (
+                      <SelectItem key={opt.value} value={opt.value}>
+                        {opt.label}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+                {sideMissing && (
+                  <p className="text-[0.7rem] text-warn">
+                    נדרש לציין את הצד לפני חילוץ עובדות שמאיות.
+                  </p>
+                )}
+                <p className="text-[0.65rem] text-ink-muted leading-tight">
+                  ערכים: {Object.values(APPRAISER_SIDE_LABELS).join(" · ")}
+                </p>
+              </div>
+            )}
+
+            {patch.isError && (
+              <p className="text-[0.7rem] text-danger">
+                שמירה נכשלה. נסה שוב.
+              </p>
+            )}
+
+            <div className="flex justify-end gap-2 pt-1">
+              <Button
+                type="button"
+                variant="ghost"
+                size="sm"
+                onClick={() => setOpen(false)}
+                disabled={patch.isPending}
+              >
+                ביטול
+              </Button>
+              <Button
+                type="button"
+                size="sm"
+                onClick={handleSave}
+                disabled={!dirty || sideMissing || patch.isPending}
+              >
+                {patch.isPending && (
+                  <Loader2 className="w-3.5 h-3.5 animate-spin" />
+                )}
+                שמור
+              </Button>
+            </div>
+          </>
+        )}
+      </PopoverContent>
+    </Popover>
+  );
+}
+
+// Re-export types so callers don't need to dual-import.
+export type { AppraiserSide, DocType };
+
+
+/* ── Post-save view: saved confirmation + extract action ─────────────
+ *
+ * Extraction is case-scoped (runs across every appraisal tagged in the
+ * case), so the button sits here rather than per-doc. If the chair is
+ * mid-tagging, clicking extract may return sides_missing with the list
+ * of still-untagged appraisals — we surface that list instead of a
+ * generic error.
+ */
+
+function PostSaveView({
+  isAppraisal,
+  extract,
+  extractResult,
+  onExtract,
+  onClose,
+}: {
+  isAppraisal: boolean;
+  extract: ReturnType<typeof useExtractAppraiserFacts>;
+  extractResult: ExtractAppraiserFactsResponse | null;
+  onExtract: () => void;
+  onClose: () => void;
+}) {
+  const pending = extract.isPending;
+
+  return (
+    <div className="space-y-3">
+      <div className="flex items-center gap-2 text-success">
+        <CheckCircle2 className="w-4 h-4" />
+        <span className="text-sm font-medium">התיוג נשמר</span>
+      </div>
+
+      {isAppraisal && !extractResult && (
+        <p className="text-[0.72rem] text-ink-muted leading-relaxed">
+          ההתגיה עודכנה. אם סיימת לתייג את כל השומות בתיק, הפעל חילוץ
+          עובדות שמאיות (תכניות + היתרים + סתירות בין שמאים).
+        </p>
+      )}
+
+      {extractResult?.status === "completed" && (
+        <div className="rounded-md border border-success/30 bg-success-bg px-2.5 py-2 text-[0.72rem] text-ink space-y-0.5">
+          <p>
+            <strong>הושלם.</strong> חולצו {extractResult.total_facts} עובדות
+            מ-{extractResult.appraisal_count} שומות.
+          </p>
+          {extractResult.conflicts.length > 0 && (
+            <p>זוהו {extractResult.conflicts.length} סתירות בין שמאים.</p>
+          )}
+        </div>
+      )}
+
+      {extractResult?.status === "no_appraisals" && (
+        <p className="text-[0.72rem] text-ink-muted">
+          אין בתיק מסמכים מתויגים כ-שומה.
+        </p>
+      )}
+
+      {extractResult?.status === "sides_missing" && (
+        <div className="rounded-md border border-warn/40 bg-warn-bg px-2.5 py-2 text-[0.72rem] text-ink space-y-1">
+          <p>
+            נותרו {extractResult.missing.length} שומות ללא תיוג צד. תייג אותן
+            לפני הפעלת החילוץ:
+          </p>
+          <ul className="list-disc pr-4 space-y-0.5">
+            {extractResult.missing.map((m) => (
+              <li key={m.document_id} className="truncate">
+                {m.title}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      {extract.isError && !extractResult && (
+        <p className="text-[0.72rem] text-danger">
+          החילוץ נכשל. נסה שוב.
+        </p>
+      )}
+
+      <div className="flex justify-end gap-2 pt-1">
+        <Button type="button" variant="ghost" size="sm" onClick={onClose}>
+          סגור
+        </Button>
+        {isAppraisal && (
+          <Button
+            type="button"
+            size="sm"
+            onClick={onExtract}
+            disabled={pending}
+          >
+            {pending ? (
+              <Loader2 className="w-3.5 h-3.5 animate-spin" />
+            ) : (
+              <Sparkles className="w-3.5 h-3.5" />
+            )}
+            {extractResult ? "הפעל שוב" : "חלץ עובדות שמאיות עכשיו"}
+          </Button>
+        )}
+      </div>
+
+      {pending && (
+        <p className="text-[0.68rem] text-ink-muted leading-tight">
+          החילוץ יכול להימשך כמה דקות — שומות ארוכות עוברות ניתוח פסקה אחר
+          פסקה ע"י המודל.
+        </p>
+      )}
+    </div>
+  );
+}

web-ui/src/components/cases/documents-panel.tsx

@@ -1,7 +1,6 @@
 "use client";
 
 import { useEffect, useState } from "react";
-import { Badge } from "@/components/ui/badge";
 import { Button } from "@/components/ui/button";
 import { Progress } from "@/components/ui/progress";
 import {
@@ -23,39 +22,19 @@ import { useMutation, useQueryClient } from "@tanstack/react-query";
 import { apiRequest } from "@/lib/api/client";
 import { casesKeys } from "@/lib/api/cases";
 import type { CaseDetail, CaseDocument } from "@/lib/api/cases";
+import { DocumentTypeEditor } from "@/components/cases/document-type-editor";
 
 /*
  * Document list for the case detail "מסמכים" tab. Uses the real document
  * row shape returned by the FastAPI case_get endpoint — see db.list_documents
  * and the `documents` schema in legal_mcp/services/db.py:
  *   id · case_id · doc_type · title · file_path · extraction_status ·
- *   page_count · created_at · practice_area · appeal_subtype
+ *   page_count · created_at · practice_area · appeal_subtype · metadata
+ *
+ * Doc-type labels and tone classes live in @/lib/doc-types so the upload
+ * sheet, the inline editor, and this panel all stay in sync.
  */
 
-const DOC_TYPE_LABELS: Record<string, string> = {
-  appeal:    "כתב ערר",
-  response:  "כתב תשובה",
-  protocol:  "פרוטוקול",
-  decision:  "החלטת ועדה מקומית",
-  plan:      "תכנית",
-  reference: "חומר רקע",
-  auto:      "—",
-};
-
-function doctypeLabel(t: string): string {
-  return DOC_TYPE_LABELS[t] ?? t;
-}
-
-function doctypeTone(t: string): string {
-  switch (t) {
-    case "appeal":    return "bg-info-bg text-info border-info/40";
-    case "response":  return "bg-gold-wash text-gold-deep border-gold/40";
-    case "decision":  return "bg-success-bg text-success border-success/40";
-    case "protocol":  return "bg-warn-bg text-warn border-warn/40";
-    default:          return "bg-rule-soft text-ink-muted border-rule";
-  }
-}
-
 const STATUS_LABELS: Record<string, string> = {
   pending:    "בהמתנה",
   processing: "בעיבוד",
@@ -271,12 +250,15 @@ function DocumentRow({
           </div>
         </button>
         {doc.doc_type && (
-          <Badge
+          <DocumentTypeEditor
-            variant="outline"
+            caseNumber={caseNumber}
-            className={`rounded-full px-2 py-0.5 text-[0.7rem] shrink-0 ${doctypeTone(doc.doc_type)}`}
+            docId={doc.id}
-          >
+            docType={doc.doc_type}
-            {doctypeLabel(doc.doc_type)}
+            appraiserSide={
-          </Badge>
+              (doc.metadata as { appraiser_side?: string } | undefined)
+                ?.appraiser_side
+            }
+          />
         )}
         <button
           type="button"

web-ui/src/components/cases/drafts-panel.tsx

@@ -0,0 +1,572 @@
+"use client";
+
+import { useRef, useState } from "react";
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Label } from "@/components/ui/label";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import {
+  useExports,
+  useExportDocx,
+  useUploadDraft,
+  useMarkFinal,
+  useDeleteDraft,
+  useActiveDraft,
+} from "@/lib/api/exports";
+import {
+  useCaseFeedback,
+  useCreateFeedback,
+  useResolveFeedback,
+  CATEGORY_LABELS,
+  CATEGORY_COLORS,
+  BLOCK_LABELS,
+  type FeedbackCategory,
+} from "@/lib/api/feedback";
+import type { CaseStatus } from "@/lib/api/cases";
+import { toast } from "sonner";
+import {
+  FileText,
+  Download,
+  Upload,
+  Award,
+  Loader2,
+  FileOutput,
+  Plus,
+  Trash2,
+} from "lucide-react";
+
+/* Statuses at which a draft is considered ready */
+const DRAFT_READY: CaseStatus[] = [
+  "drafted",
+  "exported",
+  "reviewed",
+  "final",
+];
+
+function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(0)} KB`;
+  return `${(kb / 1024).toFixed(1)} MB`;
+}
+
+function formatDate(epoch: number): string {
+  return new Date(epoch * 1000).toLocaleDateString("he-IL", {
+    day: "numeric",
+    month: "short",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+}
+
+/* ── Main component ─────────────────────────────────── */
+
+export function DraftsPanel({
+  caseNumber,
+  status,
+}: {
+  caseNumber: string;
+  status?: CaseStatus;
+}) {
+  const { data: exports, isLoading: exportsLoading } = useExports(caseNumber);
+  const { data: feedbacks, isLoading: feedbackLoading } =
+    useCaseFeedback(caseNumber);
+  const { data: activeDraft } = useActiveDraft(caseNumber);
+  const exportDocx = useExportDocx(caseNumber);
+  const uploadDraft = useUploadDraft(caseNumber);
+  const markFinal = useMarkFinal(caseNumber);
+  const deleteDraft = useDeleteDraft(caseNumber);
+  const resolveMutation = useResolveFeedback();
+
+  const fileRef = useRef<HTMLInputElement>(null);
+  const [deleteTarget, setDeleteTarget] = useState<string | null>(null);
+
+  const isDraftReady = status && DRAFT_READY.includes(status);
+  const openFeedbacks = feedbacks?.filter((f) => !f.resolved) ?? [];
+
+  // Determine draft label based on *actual* v-numbers in filenames (not counts).
+  // "(מתוקנת)" suffix appears when there's at least one עריכה-* file.
+  const draftLabel = (() => {
+    if (!exports?.length) return "טיוטה מוכנה לעיון";
+    const drafts = exports.filter((f) => f.filename.startsWith("טיוטה-"));
+    const revisions = exports.filter((f) => f.filename.startsWith("עריכה-"));
+    if (!drafts.length) return "טיוטה מוכנה לעיון";
+    const versions = drafts
+      .map((f) => {
+        const m = f.filename.match(/v(\d+)/);
+        return m ? parseInt(m[1], 10) : 0;
+      })
+      .filter((n) => n > 0);
+    const maxVer = versions.length ? Math.max(...versions) : drafts.length;
+    const suffix = revisions.length > 0 ? " (מתוקנת)" : "";
+    return `טיוטה v${maxVer}${suffix} מוכנה לעיון`;
+  })();
+
+  function handleUpload(file: File) {
+    uploadDraft.mutate(file, {
+      onSuccess: (data) => {
+        const added = data.bookmarks_added?.length ?? 0;
+        const missing = data.missing_blocks?.length ?? 0;
+        const fallback = data.structural_fallback?.length ?? 0;
+        const realDetected = added - fallback;
+        if (data.apply_status === "completed" || data.apply_status === "ok") {
+          if (realDetected > 0) {
+            toast.success(`הועלה: ${data.filename} — זוהו ${realDetected} בלוקי תוכן`);
+          } else {
+            toast.success(`הועלה: ${data.filename}`);
+          }
+          if (missing > 0) {
+            toast.warning(
+              `שימו לב: ${missing} בלוקי תוכן לא זוהו — בדוק את הכותרות`,
+            );
+          }
+        } else {
+          toast.error(`הועלה אך השילוב נכשל: ${data.apply_status ?? "שגיאה"}`);
+        }
+      },
+      onError: (err) =>
+        toast.error(err instanceof Error ? err.message : "שגיאה בהעלאה"),
+    });
+  }
+
+  function handleExport() {
+    exportDocx.mutate(undefined, {
+      onSuccess: () => toast.success("הטיוטה יוצאה בהצלחה"),
+      onError: () => toast.error("שגיאה בייצוא"),
+    });
+  }
+
+  function handleMarkFinal(filename: string) {
+    markFinal.mutate(filename, {
+      onSuccess: () => toast.success("סומן כסופי"),
+      onError: () => toast.error("שגיאה בסימון"),
+    });
+  }
+
+  function handleResolve(id: string) {
+    resolveMutation.mutate(
+      { feedbackId: id, applied_to: [] },
+      {
+        onSuccess: () => toast.success("ההערה סומנה כמטופלת"),
+        onError: () => toast.error("שגיאה בעדכון"),
+      },
+    );
+  }
+
+  return (
+    <div className="space-y-6">
+      {/* ── Banner ── */}
+      {isDraftReady && (
+        <div className="flex items-center gap-3 rounded-lg border border-gold/40 bg-gold-wash px-4 py-3">
+          <FileText className="w-5 h-5 text-gold-deep shrink-0" />
+          <span className="text-sm font-medium text-gold-deep">
+            {draftLabel}
+          </span>
+          <div className="me-auto" />
+          <Button
+            size="sm"
+            onClick={handleExport}
+            disabled={exportDocx.isPending}
+            className="bg-navy hover:bg-navy-soft text-parchment"
+          >
+            {exportDocx.isPending ? (
+              <Loader2 className="w-4 h-4 animate-spin me-1.5" />
+            ) : (
+              <FileOutput className="w-4 h-4 me-1.5" />
+            )}
+            הפק DOCX
+          </Button>
+        </div>
+      )}
+
+      {/* ── Active-draft badge — the DOCX that is the current source of truth ── */}
+      {activeDraft?.filename && (
+        <div className="flex items-center gap-2 text-xs text-ink-muted">
+          <span>מקור האמת:</span>
+          <Badge variant="outline" className="bg-surface">
+            {activeDraft.filename}
+          </Badge>
+        </div>
+      )}
+
+      {/* ── Exports list ── */}
+      <section>
+        <div className="flex items-center justify-between mb-3">
+          <h3 className="text-navy text-base">קבצי טיוטה</h3>
+          <div className="flex items-center gap-2">
+            <input
+              ref={fileRef}
+              type="file"
+              accept=".docx"
+              className="hidden"
+              onChange={(e) => {
+                const f = e.target.files?.[0];
+                if (f) handleUpload(f);
+                if (fileRef.current) fileRef.current.value = "";
+              }}
+            />
+            <Button
+              variant="outline"
+              size="sm"
+              onClick={() => fileRef.current?.click()}
+              disabled={uploadDraft.isPending}
+            >
+              {uploadDraft.isPending ? (
+                <Loader2 className="w-4 h-4 animate-spin me-1.5" />
+              ) : (
+                <Upload className="w-4 h-4 me-1.5" />
+              )}
+              העלה גרסה מתוקנת
+            </Button>
+          </div>
+        </div>
+
+        {exportsLoading ? (
+          <p className="text-sm text-ink-muted">טוען...</p>
+        ) : !exports?.length ? (
+          <p className="text-sm text-ink-muted">
+            אין טיוטות עדיין.{" "}
+            {!isDraftReady && "הטיוטה תופיע כאן כשתהיה מוכנה."}
+          </p>
+        ) : (
+          <div className="rounded-lg border border-rule overflow-hidden">
+            <table className="w-full text-sm">
+              <thead>
+                <tr className="bg-rule-soft/40 text-ink-muted text-[0.75rem]">
+                  <th className="text-start px-4 py-2 font-medium">File</th>
+                  <th className="text-start px-4 py-2 font-medium">Size</th>
+                  <th className="text-start px-4 py-2 font-medium">Date</th>
+                  <th className="px-4 py-2" />
+                </tr>
+              </thead>
+              <tbody>
+                {exports.map((file) => (
+                  <tr
+                    key={file.filename}
+                    className="border-t border-rule hover:bg-rule-soft/20"
+                  >
+                    <td className="px-4 py-2.5 flex items-center gap-2">
+                      <span>{file.filename}</span>
+                      {file.is_final && (
+                        <Badge className="bg-success-bg text-success border-success/40 text-[0.65rem]">
+                          <Award className="w-3 h-3 me-0.5" />
+                          סופי
+                        </Badge>
+                      )}
+                    </td>
+                    <td className="px-4 py-2.5 text-ink-muted tabular-nums">
+                      {formatSize(file.size)}
+                    </td>
+                    <td className="px-4 py-2.5 text-ink-muted tabular-nums">
+                      {formatDate(file.created_at)}
+                    </td>
+                    <td className="px-4 py-2.5">
+                      <div className="flex items-center gap-1 justify-end">
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          className="h-7 px-2"
+                          onClick={() =>
+                            window.open(
+                              `/api/cases/${caseNumber}/exports/${file.filename}/download`,
+                              "_blank",
+                            )
+                          }
+                        >
+                          <Download className="w-3.5 h-3.5 me-1" />
+                          הורד
+                        </Button>
+                        {!file.is_final && (
+                          <>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              className="h-7 px-2 text-ink-muted"
+                              onClick={() => handleMarkFinal(file.filename)}
+                              disabled={markFinal.isPending}
+                            >
+                              <Award className="w-3.5 h-3.5 me-1" />
+                              סמן כסופי
+                            </Button>
+                            <Button
+                              variant="ghost"
+                              size="sm"
+                              className="h-7 px-2 text-red-500 hover:text-red-700 hover:bg-red-50"
+                              onClick={() => setDeleteTarget(file.filename)}
+                            >
+                              <Trash2 className="w-3.5 h-3.5" />
+                            </Button>
+                          </>
+                        )}
+                      </div>
+                    </td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        )}
+
+        {/* Delete confirmation dialog */}
+        <Dialog
+          open={deleteTarget !== null}
+          onOpenChange={(open) => !open && setDeleteTarget(null)}
+        >
+          <DialogContent className="sm:max-w-sm" dir="rtl">
+            <DialogHeader>
+              <DialogTitle>מחיקת טיוטה</DialogTitle>
+            </DialogHeader>
+            <p className="text-sm text-ink-muted">
+              למחוק את הקובץ{" "}
+              <span className="font-medium text-ink">{deleteTarget}</span>?
+              <br />
+              פעולה זו לא ניתנת לביטול.
+            </p>
+            <div className="flex justify-end gap-2 pt-2">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => setDeleteTarget(null)}
+              >
+                ביטול
+              </Button>
+              <Button
+                variant="destructive"
+                size="sm"
+                disabled={deleteDraft.isPending}
+                onClick={() => {
+                  if (!deleteTarget) return;
+                  deleteDraft.mutate(deleteTarget, {
+                    onSuccess: () => {
+                      toast.success("הקובץ נמחק");
+                      setDeleteTarget(null);
+                    },
+                    onError: () => toast.error("שגיאה במחיקה"),
+                  });
+                }}
+              >
+                {deleteDraft.isPending ? (
+                  <Loader2 className="w-4 h-4 animate-spin me-1" />
+                ) : (
+                  <Trash2 className="w-4 h-4 me-1" />
+                )}
+                מחק
+              </Button>
+            </div>
+          </DialogContent>
+        </Dialog>
+      </section>
+
+      {/* ── Chair feedback ── */}
+      <section>
+        <div className="flex items-center justify-between mb-3">
+          <h3 className="text-navy text-base">
+            הערות יו״ר
+            {openFeedbacks.length > 0 && (
+              <Badge className="ms-2 bg-red-100 text-red-700 border-red-200 text-[0.65rem]">
+                {openFeedbacks.length} פתוחות
+              </Badge>
+            )}
+          </h3>
+          <NewCaseFeedbackDialog caseNumber={caseNumber} />
+        </div>
+
+        {feedbackLoading ? (
+          <p className="text-sm text-ink-muted">טוען...</p>
+        ) : !feedbacks?.length ? (
+          <p className="text-sm text-ink-muted">אין הערות לתיק זה.</p>
+        ) : (
+          <div className="space-y-2">
+            {feedbacks.map((fb) => (
+              <div
+                key={fb.id}
+                className={`rounded-lg border border-rule bg-surface px-4 py-3 space-y-2 ${
+                  fb.resolved ? "opacity-50" : ""
+                }`}
+              >
+                <div className="flex items-center gap-2 flex-wrap">
+                  <Badge
+                    className={`text-[0.65rem] border ${CATEGORY_COLORS[fb.category]}`}
+                  >
+                    {CATEGORY_LABELS[fb.category]}
+                  </Badge>
+                  <Badge variant="outline" className="text-[0.65rem]">
+                    {BLOCK_LABELS[fb.block_id] ?? fb.block_id}
+                  </Badge>
+                  {fb.resolved && (
+                    <Badge className="bg-emerald-100 text-emerald-700 text-[0.65rem] border border-emerald-200">
+                      טופל
+                    </Badge>
+                  )}
+                  <span className="text-[0.65rem] text-ink-muted me-auto">
+                    {fb.created_at
+                      ? new Date(fb.created_at).toLocaleDateString("he-IL")
+                      : ""}
+                  </span>
+                </div>
+                <p className="text-sm leading-relaxed">{fb.feedback_text}</p>
+
+                {fb.lesson_extracted && (
+                  <div className="bg-gold/5 border border-gold/20 rounded-md px-3 py-2">
+                    <p className="text-[0.65rem] font-semibold text-gold-deep mb-0.5">
+                      לקח שהופק:
+                    </p>
+                    <p className="text-sm text-ink-muted leading-relaxed">
+                      {fb.lesson_extracted}
+                    </p>
+                  </div>
+                )}
+
+                {!fb.resolved && (
+                  <div className="flex justify-end">
+                    <Button
+                      variant="outline"
+                      size="sm"
+                      className="h-7 text-[0.75rem]"
+                      onClick={() => handleResolve(fb.id)}
+                      disabled={resolveMutation.isPending}
+                    >
+                      סמן כמטופל
+                    </Button>
+                  </div>
+                )}
+              </div>
+            ))}
+          </div>
+        )}
+      </section>
+    </div>
+  );
+}
+
+/* ── New feedback dialog (case-scoped) ─────────────── */
+
+function NewCaseFeedbackDialog({ caseNumber }: { caseNumber: string }) {
+  const [open, setOpen] = useState(false);
+  const createMutation = useCreateFeedback();
+
+  const [blockId, setBlockId] = useState("block-yod");
+  const [category, setCategory] = useState<FeedbackCategory>("missing_content");
+  const [feedbackText, setFeedbackText] = useState("");
+  const [lesson, setLesson] = useState("");
+
+  function handleSubmit(e: React.FormEvent) {
+    e.preventDefault();
+    if (!feedbackText.trim()) return;
+
+    createMutation.mutate(
+      {
+        case_number: caseNumber,
+        block_id: blockId,
+        feedback_text: feedbackText,
+        category,
+        lesson_extracted: lesson || undefined,
+      },
+      {
+        onSuccess: () => {
+          toast.success("ההערה נרשמה בהצלחה");
+          setOpen(false);
+          setFeedbackText("");
+          setLesson("");
+        },
+        onError: () => toast.error("שגיאה ברישום ההערה"),
+      },
+    );
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={setOpen}>
+      <DialogTrigger asChild>
+        <Button variant="outline" size="sm">
+          <Plus className="w-3.5 h-3.5 me-1" />
+          הערה חדשה
+        </Button>
+      </DialogTrigger>
+      <DialogContent className="sm:max-w-lg" dir="rtl">
+        <DialogHeader>
+          <DialogTitle>הערת יו״ר — תיק {caseNumber}</DialogTitle>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className="space-y-4 mt-2">
+          <div className="grid grid-cols-2 gap-3">
+            <div>
+              <Label htmlFor="fb-block">בלוק</Label>
+              <select
+                id="fb-block"
+                value={blockId}
+                onChange={(e) => setBlockId(e.target.value)}
+                className="w-full rounded-md border border-rule bg-surface px-3 py-2 text-sm"
+              >
+                {Object.entries(BLOCK_LABELS).map(([key, label]) => (
+                  <option key={key} value={key}>
+                    {label}
+                  </option>
+                ))}
+              </select>
+            </div>
+            <div>
+              <Label htmlFor="fb-category">קטגוריה</Label>
+              <select
+                id="fb-category"
+                value={category}
+                onChange={(e) =>
+                  setCategory(e.target.value as FeedbackCategory)
+                }
+                className="w-full rounded-md border border-rule bg-surface px-3 py-2 text-sm"
+              >
+                {Object.entries(CATEGORY_LABELS).map(([key, label]) => (
+                  <option key={key} value={key}>
+                    {label}
+                  </option>
+                ))}
+              </select>
+            </div>
+          </div>
+
+          <div>
+            <Label htmlFor="fb-text">ההערה</Label>
+            <Textarea
+              id="fb-text"
+              value={feedbackText}
+              onChange={(e) => setFeedbackText(e.target.value)}
+              placeholder="מה דפנה אמרה? מה חסר, מה לא נכון, מה צריך לשנות..."
+              rows={4}
+              required
+            />
+          </div>
+
+          <div>
+            <Label htmlFor="fb-lesson">לקח שהופק (אופציונלי)</Label>
+            <Textarea
+              id="fb-lesson"
+              value={lesson}
+              onChange={(e) => setLesson(e.target.value)}
+              placeholder="מה למדנו מההערה? מה צריך לשנות במערכת?"
+              rows={2}
+            />
+          </div>
+
+          <div className="flex justify-end gap-2 pt-2">
+            <Button
+              type="button"
+              variant="outline"
+              onClick={() => setOpen(false)}
+            >
+              ביטול
+            </Button>
+            <Button type="submit" disabled={createMutation.isPending}>
+              {createMutation.isPending ? "שומר..." : "שמור הערה"}
+            </Button>
+          </div>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}

web-ui/src/components/cases/kpi-cards.tsx

@@ -18,7 +18,7 @@ const TONE_STYLES: Record<Bucket["tone"], string> = {
 function bucketize(cases: Case[] | undefined): Bucket[] {
   const c = cases ?? [];
   const inProgress = c.filter((x) =>
-    ["processing", "documents_ready", "outcome_set", "brainstorming", "direction_approved"].includes(x.status),
+    ["processing", "documents_ready", "analyst_verified", "research_complete", "outcome_set", "brainstorming", "direction_approved", "analysis_enriched", "ready_for_writing"].includes(x.status),
   ).length;
   const drafting = c.filter((x) =>
     ["drafting", "qa_review", "drafted"].includes(x.status),