Merge remote-tracking branch 'origin/main' into worktree-anti-pattern-directive-position

`block_distance_to_final` החזיר `anti_pattern_total` בלבד. ריצת-כיול שמדווחת
"anti=4" אינה יכולה לומר מה לתקן — באבחון ה-A/B של 2026-07-28 נאלצנו להסיק
את הדפוס האשם מהקשר במקום למדוד אותו.

- `anti_by_pattern` (שם-דפוס → מספר-פגיעות) נוסף לתא-המדידה, מ-
  `count_anti_patterns` הקיים — אין ספירה מקבילה.
- `_mean_by_pattern` ממצע על **כל** הריצות: דפוס שלא נורה בריצה נספר כ-0
  ולא מושמט, אחרת הממוצע היה מוטה כלפי מעלה.
- הדוח מקבל טבלת "פילוח אנטי-דפוסים (איזה כלל הופר)" per block×effort×model.

invariants: INV-G8 (eval-harness) · G2 (מרונדר מ-count_anti_patterns/
ANTI_PATTERNS הקנוניים — מקור אחד).

אימות: self-test ALL PASS · 470 passed · בדיקת-שפיות ישירה —
טקסט עם 1 כותרת + 2 תבליטים + 1 פיצול-מיני מפולח נכון ל-
{markdown_headers:1, bullet_lists:2, inline_numbered_fragments:1}.

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

.claude/agents/legal-analyst.md

@@ -234,7 +234,7 @@ search_precedent_library(
 
 ### 5ד. תיעוד מחייב — סעיף "שאילתות לקורפוסים" ב-`analysis-and-research.md`
 
-ב-artifact הסופי, חובה להופיע סעיף חדש בשם **"7א. שאילתות לקורפוסים — log מלא"**, עם הפורמט הבא:
+ב-artifact הסופי, חובה להופיע סעיף חדש בשם **"7א. שאילתות לקורפוסים — log מלא"**, עם הפורמט הבא. (זהו סעיף 7א שמופיע גם בתבנית-הפלט המלאה שבהמשך — **אותו סעיף אחד**, לא תבנית נפרדת.)
 
 ```markdown
 ## 7א. שאילתות לקורפוסים — log מלא
@@ -323,7 +323,7 @@ FROM documents d WHERE d.case_id = '{case_id}' AND d.doc_type IN ('appeal', 'res
 
 ### העֵר את העוזר המשפטי (CEO) — חובה!
 
-wakeup ל-CEO עם `payload.issueId=$PAPERCLIP_TASK_ID` ו-`reason="מנתח משפטי סיים $PAPERCLIP_TASK_ID בסטטוס done/blocked"` — הפרוטוקול המלא (CEO לפי חברה, אזהרות) במקור היחיד [HEARTBEAT.md](HEARTBEAT.md) §4ג. **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+wakeup ל-CEO עם `payload.issueId=$PAPERCLIP_TASK_ID` ו-`reason="מנתח משפטי סיים $PAPERCLIP_TASK_ID בסטטוס done/blocked"` — הפרוטוקול המלא (CEO לפי חברה, אזהרות) במקור היחיד [HEARTBEAT.md](HEARTBEAT.md) §4ג.
 **⚠️ `$PAPERCLIP_TASK_ID` — זה UUID, לא CMP-XX.** מוגדר אוטומטית ע"י Paperclip; ב-double-quotes bash מרחיב לערך האמיתי. שגיאת `invalid input syntax for type uuid` = שלחת CMP-XX במקום UUID.
 
 ## מבנה הפלט המלא — analysis-and-research.md

.claude/agents/legal-ceo.md

@@ -820,44 +820,38 @@ ls data/cases/$CASE_NUMBER/documents/research/analysis-and-research.md
 
 ---
 
-**תבנית issue לכותב ההחלטה — חובה בכל issue שמוקצה לכותב:**
+**מסמך-ההכוונה לכותב — הפק את התדריך שהיית רוצה לקבל, לא טופס למילוי:**
 
-כל issue לכותב חייב לכלול את **כל** הסעיפים הבאים. אסור לשלוח issue עם משפט כמו "הועבר לכתיבה" — זה חסר תועלת. הכותב צריך הכל מוכן מראש.
+כשאתה מעביר תיק לכותב אתה מבצע את **פעולת-ההיסק המרכזית שלך**: להמיר את ניתוח-המנתח + הכרעות-היו"ר למסמך שמאפשר לכותב לנסח החלטה חדה בסגנון דפנה **בלי לחזור אליך**. אל תמלא טופס — הפעל שיפוט משפטי. תדריך טוב:
+
+- **מוביל בהכרעה ובסוגיה המכריעה** — קבע איזו סוגיה נושאת את התוצאה ומה מייתר את מה, והצב אותה ראשונה.
+- **בונה כל סוגיה כסילוגיזם** (כלל → עובדות → מסקנה) עם התקדים והמסמך הספציפיים.
+- **מזהה אדנים עצמאיים** — אם יותר מנימוק אחד מספיק לבדו לתוצאה, אמור זאת מפורשות, כך שנפילת אדן בערעור לא תפיל את ההחלטה.
+- **בודק עקביות פנימית** — אם שתי הכרעות עלולות להיראות סותרות (למשל דחיית טענה פרשנית אחת וקבלת אחרת), סמן את המתח והסבר את האבחנה לפני שעורך-דין יטען לו.
+- **עונה לנקודה החזקה של הצד המפסיד** — לא מתעלם ממנה.
+- **משקלל את הכרעות-היו"ר** ומעביר אותן מילולית.
+
+**מה התדריך חייב להכיל** (החוזה מול הכותב — אל תשמיט אף רכיב; אל תשלח issue עם "הועבר לכתיבה"):
 
 ```markdown
 ## הנחיות כתיבה — ערר {case_number}
 
 ### 1. תוצאה ומצב
-- **תוצאה:** {דחייה / קבלה חלקית / קבלה מלאה}
-- **טיוטה קיימת:** {כן/לא}. אם כן: נתיב מלא לקובץ + הנחיה "קרא את הטיוטה, השתמש בה כבסיס, אל תכתוב מאפס"
-- **הוראות עריכה מתוך הטיוטה:** {רשימה מדויקת של מה חיים ביקש לשנות — פסקאות, תוכן, placeholders}
+- **תוצאה:** {דחייה / קבלה חלקית / קבלה מלאה} — עם נימוק קצר ומהי הראיה הניצחת.
+- **טיוטה קיימת:** {כן/לא}. אם כן: נתיב מלא + "קרא, השתמש כבסיס, אל תכתוב מאפס".
+- **הוראות עריכה מהטיוטה:** {מה חיים ביקש לשנות — פסקאות, תוכן, placeholders}.
 
-### 2. סדר סוגיות + מבנה סילוגיסטי
-לכל סוגיה שצריך לכתוב/לערוך — מבנה סילוגיסטי מלא:
-
-**סוגיה N: {כותרת}**
-- סוג ניתוח: {כלל ברור / איזון אינטרסים / מידתיות / שיקול דעת}
-- כלל (הנחה עליונה): {הוראת תכנית / סעיף חוק / הלכה — ציטוט מדויק}
-- עובדות (הנחה תחתונה): {העובדות הספציפיות שצריך להחיל — הפנייה למסמך מקור ספציפי}
-- מסקנה: {מה נובע מהחלת הכלל על העובדות}
-- תקדימים: {שם פסק דין + מה הוא קובע + למה רלוונטי}
-- מסמכי מקור: {שמות קבצים ספציפיים ב-data/cases/{case_number}/documents/originals/}
+### 2. סוגיות — סדר סילוגיסטי, המכריעה מובילה
+לכל סוגיה: סוג-ניתוח (כלל ברור / איזון / מידתיות / שיקול-דעת) · כלל (ציטוט מדויק של הוראת-תכנית/חוק/הלכה) · עובדות (בהפניה למסמך-מקור ספציפי) · מסקנה · תקדימים (שם + מה קובע + רלוונטיות) · מסמכי-מקור (ב-data/cases/{case_number}/documents/originals/). סמן אדנים עצמאיים, מוקשי-עקביות ומענה לצד המפסיד היכן שהם קיימים.
 
 ### 3. טיפול בטענות
-| # | טענה | טיפול | סוגיה |
-|---|------|-------|-------|
-| 1 | {טענה} | דיון מלא / קיבוץ / דילוג | {באיזו סוגיה} |
-...
+טבלה: # | טענה | טיפול (דיון מלא / קיבוץ / דילוג) | סוגיה.
 
-### 4. chair directions
-- העתק מלא של עמדות הוועדה מ-analysis-and-research.md (או הפנייה: "קרא get_chair_directions")
+### 4. הנחיות-היו"ר
+העתק מילולי של עמדות-הוועדה מ-analysis-and-research.md (או "קרא get_chair_directions"), **עטוף ב-`<chair_directions>…</chair_directions>`** — טקסט מילולי בלבד בלי פרפרזה, כדי שהכותב לא ידרוס אותן.
 
 ### 5. הנחיות סגנון
-- ניטרליות: בלוק ו = עובדות בלבד, בלי ציטוטים מצדדים
-- ללא כפילות: בלוק י מפנה לבלוקים קודמים
-- טענות מקוריות: בלוק ז = כתבי טענות מקוריים
-- אורך מינימלי לדיון: 1,500 מילים לבלוק י
-- פסיקה: חובה לצטט לפחות 3 תקדימים בדיון
+ניטרליות (בלוק ו = עובדות בלבד, בלי ציטוטי-צדדים) · ללא כפילות (בלוק י מפנה לקודמים) · טענות מקוריות (בלוק ז) · דיון ≥ 1,500 מילים · ≥ 3 תקדימים בדיון.
 ```
 
 ---

.claude/agents/legal-exporter.md

@@ -96,7 +96,7 @@ tools:
      "id": "r1",
      "type": "insert_after",  // או insert_before, replace, delete
      "anchor_bookmark": "block-yod",  // מ-list_bookmarks
-     "content": "וכך נפסק בעניין פלוני. בבג\"ץ 1234/21 קבע השופט...",
+     "content": "<תוכן ההוספה — טקסט עברי נקי, בלי ציטוט מומצא>",
      "style": "body",  // או heading, quote
      "reason": "הוספת פסק הלכה שחסר לפי בקשת יו\"ר"
    }
@@ -128,7 +128,7 @@ tools:
 
 בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מייצא טיוטה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO).** בקצרה: PATCH סטטוס `done`/`blocked`, ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מייצא טיוטה סיים [issue-id] בסטטוס [done/blocked]"`.
 
 ## כללים קריטיים
 

.claude/agents/legal-proofreader.md

@@ -96,5 +96,4 @@ tools:
 
 בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל / markers `[?]` רבים), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מגיה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
-**⚠️ אסור לקבע UUID של CEO** — UUID שונה לכל חברה. תמיד דרך `$PAPERCLIP_COMPANY_ID`. wakeup לחברה אחרת נדחה: `Agent key cannot access another company`.
+**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO).** בקצרה: PATCH סטטוס `done`/`blocked` (`blocked` אם markers `[?]` רבים), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="מגיה סיים [issue-id] בסטטוס [done/blocked]"`.

.claude/agents/legal-qa.md

@@ -56,6 +56,8 @@ tools:
 
 ## 7 בדיקות
 
+> **סף-הקבלה המשותף — `docs/qa-acceptance-rubric.md`:** 7 הבדיקות למטה הן האכיפה המפורטת שלו (מקור-אמת אחד; הכותב מכוון לאותו rubric). בדיווח — מפה כל `fail` לחוסם/אזהרה שם.
+
 ### 1. שלמות מבנית (structural_integrity)
 - כל בלוקי חובה קיימים (ה עד יא)
 - מספור רציף ללא קפיצות
@@ -232,14 +234,24 @@ new → processing → documents_ready → analyst_verified → research_complet
 6. האם יש אנלוגיה לתקדים ללא הסבר מדיניות (למה הדמיון רלוונטי)?
 
 ### שלב 3: דיווח — חובה!
-פרסם comment ב-Paperclip עם:
-- תוצאת כל בדיקה (pass/fail)
-- רשימת שגיאות מפורטת (אם יש)
-- האם מותר לייצא (כל הקריטיים pass?)
-- עדכן סטטוס ל-qa_review (אם נכשל) או drafted (אם עבר)
+פרסם comment ב-Paperclip **במבנה קבוע** (markdown — נקרא ע"י היו"ר וע"י ה-CEO), כדי שהפסיקה תהיה עקבית וניתנת-לפרסינג. מלא שורה לכל אחת מ-7 הבדיקות:
+
+```markdown
+## דוח בדיקת איכות — ערר {case_number}
+
+| בדיקה | תוצאה | חומרה | ממצא (אם fail) |
+|-------|:-----:|:-----:|-----------------|
+| {שם הבדיקה} | pass / fail | critical / major / minor | {פירוט קצר} |
+| ... שורה לכל 7 הבדיקות ... | | | |
+
+**מותר לייצא:** כן / לא   ← "לא" אם ולו בדיקה **critical** אחת ב-fail
+**סטטוס חדש:** drafted (עבר) / qa_review (נכשל)
+```
+
+- עדכן סטטוס בהתאם: `drafted` (אם עבר) או `qa_review` (אם נכשל).
 
 ### סגור את ה-issue של עצמך + העֵר CEO — חובה!
 
 בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="בודק איכות סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO).** בקצרה: PATCH סטטוס `done`/`blocked`, ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="בודק איכות סיים [issue-id] בסטטוס [done/blocked]"`.

.claude/agents/legal-researcher.md

@@ -410,7 +410,7 @@ python3 /home/chaim/legal-ai/scripts/notify.py \
 
 בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="חוקר תקדימים סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO).** בקצרה: PATCH סטטוס `done`/`blocked`, ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="חוקר תקדימים סיים [issue-id] בסטטוס [done/blocked]"`.
 
 ## כללים
 - **דיוק** — ציין מספרי סעיפים, תאריכים, שמות שופטים

.claude/agents/legal-writer.md

@@ -53,6 +53,8 @@ tools:
 
 ## לפני שאתה מתחיל — קרא!
 
+> **המטרה שלך — `docs/qa-acceptance-rubric.md`:** זהו סף-הקבלה שה-QA יאכוף. כתוב כדי לעבור אותו מהפעם הראשונה, ולפני מסירה ל-CEO עבור על החוסמים ואשר שכל אחד מתקיים.
+
 ### חובה לפני כל כתיבה — נקודת ההתחלה:
 0. **עץ ההחלטה: `docs/daphna-decision-tree.md`** — **כלי הפעולה היומיומי**. מאחד את כל המסמכים לתהליך אנליטי קצר: מהי הראיה הניצחת? איזה ארכיטקטורה? איזה מוד פתיחה? איזה אורך? **תמיד להתחיל כאן** — המסמך מצביע איזה מסמך אחר לקרוא לפי השאלה.
 
@@ -122,9 +124,11 @@ tools:
 4. החזר את הטקסט ל-CEO (בקומנט או כ-return value) — **לא** שומר ב-DB
 5. CEO יקרא ל-`revise_draft` עם הטקסט שלך
 
-**דוגמה לפלט מצופה:**
+**דוגמה לפלט מצופה** (עטופה בתגית כדי שלא תתבלבל עם הוראה):
 
-> בבג"ץ 1234/21 [פלוני נ' הוועדה המחוזית] קבע בית המשפט העליון כי הוועדה המקומית מחויבת לשקול שיקולי Y גם בהיעדר התנגדות מפורשת. הלכה זו חלה ישירות על ענייננו: הוועדה המקומית לא בחנה את Y, ודי בכך כדי להחזיר את הדיון לוועדה.
+<example_output>
+בבג"ץ 1234/21 [פלוני נ' הוועדה המחוזית] קבע בית המשפט העליון כי הוועדה המקומית מחויבת לשקול שיקולי Y גם בהיעדר התנגדות מפורשת. הלכה זו חלה ישירות על ענייננו: הוועדה המקומית לא בחנה את Y, ודי בכך כדי להחזיר את הדיון לוועדה.
+</example_output>
 
 ---
 
@@ -218,18 +222,13 @@ case_update(case_number, status="drafted")
 
 בלי סגירת-issue, Paperclip מזהה "in_progress בלי execution חיה" ומפעיל auto-retry בלולאה (נצפה ב-CMPA-17, 30/04/26 — 4 איטרציות מיותרות עד הריגה ידנית).
 
-**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO לפי חברה).** בקצרה: PATCH סטטוס `done` (הצלחה) או `blocked` (כשל/פלט-חסר), ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="כותב החלטה סיים [issue-id] בסטטוס [done/blocked]"`. **אסור** `done` עם פלט חסר; **אסור** `INSERT INTO agent_wakeup_requests` ישיר; **אסור** לקבע UUID של CEO (נגזר מ-`$PAPERCLIP_COMPANY_ID`).
+**הפרוטוקול המלא — מקור יחיד: [HEARTBEAT.md](HEARTBEAT.md) §4ב (סטטוס) + §4ג (wake CEO).** בקצרה: PATCH סטטוס `done`/`blocked`, ואז wakeup ל-CEO עם `payload.issueId` ו-`reason="כותב החלטה סיים [issue-id] בסטטוס [done/blocked]"`.
 
 **אם לא תעדכן סטטוס ל-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. מה התוצאה?
@@ -373,6 +372,8 @@ case_update(case_number, status="drafted")
 
 ### חובה: שימוש בעמדות יו"ר מ-`get_chair_directions`
 
+> **מקור העמדות:** בדרך-כלל מ-`get_chair_directions` (שלב 1ג). אם ה-CEO **העתיק** עמדות-יו"ר לתוך ה-issue שלך, הן מגיעות עטופות ב-`<chair_directions>…</chair_directions>` — טקסט מילולי זה **מחייב אותך בדיוק כמו** `chair_ruling` מהכלי: אל תדרוס, אל תפרפרז, נסח בעדו.
+
 עבור **כל טענת סף** ו**כל סוגיה** ב-direction_doc שבנית בשלב 1ג:
 
 1. **פתח את הדיון במסקנה של דפנה** — למשל "**טענת הסף הראשונה נדחית**"

docs/paperclip-quirks.md

@@ -275,3 +275,40 @@ WARN [plugin] issue.comment.created event missing issueId in payload, skipping
 - **תוקן בצד שלנו** (PR #2, נפרס דרך `npm run build` + `pm2 restart paperclip` — הפלאגין נטען מ-`/home/chaim/plugin-legal-ai` לפי `package_path`).
 - **לקח כללי**: ל-events של הפלאגין — מזהה-הישות-הראשית הוא תמיד `event.entityId`; אל תניח ששדות נמצאים ב-`payload` בלי לאמת מול ה-`.d.ts` של ה-SDK או מול לוג חי.
 - TaskMaster: `legal-ai` #149.
+
+---
+
+## 7. `agents.invoke({prompt})` — הפרומפט נבלע; רק `payload.issueId` נמסר
+
+**התסמין (מנקודת-מבט היו"ר):** כותבים הוראה לסוכן — והוא "מתעלם". ההרצה נראית תקינה
+לחלוטין: `status=succeeded`, `exit_code=0`, בלי שגיאה, ואפילו עולה כסף. הסוכן מדווח
+"כל התורים ריקים — אין עבודה".
+
+**הסיבה:** `ctx.agents.invoke(agentId, companyId, {prompt, reason})` הוא ה-API **המתועד**
+של ה-Plugin SDK ("*Invoke an agent with a prompt payload*"), ו-`prompt` הוא שדה חובה.
+Paperclip מקבל אותו, שומר אותו ב-`agent_wakeup_requests.payload.prompt` — **וה-runner קורא
+רק `payload.issueId`**. הפרומפט לא מגיע למודל. ה-`reason` כן שורד (ל-`context_snapshot.wakeReason`),
+ולכן זה נראה כאילו משהו נמסר.
+
+מדידה ב-DB (2026-07-16): **18 מתוך 18** ה-wakeups שאי-פעם נשאו `payload.prompt` לא הגיעו
+לאף הרצה — 0% מסירה. מול 107,172 wakeups עם `issueId` שעובדים. אימות ישיר: בלוג-ההרצה
+שנבלעה אין ולו אזכור אחד של מספר-התיק, והמודל פותח ב-*"This heartbeat has no scoped wake payload"*.
+
+**מה עושים במקום:** נושאים את ההוראה על **issue**, לא ב-payload — issue-ילד שכבר משויך
+ל-CEO, עם ההוראה ב-`description`, ואז wakeup עם `payload.issueId`. זה בדיוק
+`open_ceo_run` ב-[`web/paperclip_client.py`](../web/paperclip_client.py), והמסלול היחיד
+שאומת כמגיע לסוכן.
+
+**מלכודות שנלוות לזה — אל תיפול בהן שוב:**
+- **`issues.create` של ה-SDK עם `assigneeAgentId` *לא* מעיר את הסוכן.** ה-REST המקביל
+  (`POST /api/issues/:id/children`) *כן* — הוא פולט wakeup `issue_assigned`. אל תכליל
+  מהתנהגות REST על ה-SDK; זה נבדק ונמצא שונה.
+- **`ctx.issues.requestWakeup` (ה-primitive הנכון ב-SDK) נכשל מתוך scheduled job** עם
+  `missing, expired, or unknown invocation scope` — למרות ש-capability `issues.wakeup`
+  מוצהר ומותקן. אותה שגיאה מפילה גם `companies.list` / `issues.list` / `issues.listComments`
+  בתוך ה-sweep, ולכן **רשת-הביטחון `route-pending-comments` אינה אמינה**. לא נחקר לעומק —
+  לכן ניתוב-ההערות הועבר ל-backend של legal-ai (REST), שאינו חשוף לבעיה.
+
+**סטטוס:** נעקף — `POST /api/cases/{case}/agents/comment` ו-`/agents/interaction-response`
+פותחים הרצת-CEO ישירות (REST) ומסמנים את ההערה כמנותבת, כדי שה-sweep השבור לא יירה
+הרצת-סרק. TaskMaster `legal-ai` #228.

docs/qa-acceptance-rubric.md

@@ -0,0 +1,57 @@
+# Rubric קבלה של החלטה — מקור-אמת אחד
+
+מסמך זה הוא **הגדרת ה"מוכן"** של טיוטת החלטה: סף-הקבלה שהכותב **מכוון אליו מראש**
+וה-QA **אוכף** כשער. שני הסוכנים מפנים לכאן — אין לשכפל את הקריטריונים בקבצי-הסוכן.
+
+**זהו סף-הקבלה, לא הוראת-הכתיבה.** ה"איך" המלא חי במסמכי-הקול המופנים בכל שורה
+(`daphna-voice-fingerprint.md`, `daphna-block-zayin-claims.md`,
+`daphna-architecture-by-outcome.md`, `daphna-acceptance-architecture.md`,
+`decision-methodology.md`, `anti-hallucination-gate.md`). כאן — רק המבחן.
+
+> **לכותב:** לפני מסירה ל-CEO, עבור על החוסמים למטה ואשר שכל אחד מתקיים. טיוטה
+> שלא עוברת חוסם אחד — תוחזר ב-`needs_revision`. כתוב כדי לעבור מהפעם הראשונה.
+>
+> **ל-QA:** אלה הקריטריונים ש-7 הבדיקות שלך אוכפות. `fail` על חוסם = `qa_review`;
+> `fail` על אזהרה = דיווח לחיים, לא חוסם.
+
+---
+
+## חוסמי ייצוא (critical — כל אחד מכשיל את הטיוטה)
+
+1. **שלמות מבנית** — בלוקים ה–יא קיימים; מספור רציף ללא קפיצות/כפילות; "להלן" בשימוש ראשון.
+2. **רקע ניטרלי (בלוק ו)** — עובדות בלבד; **אפס** ציטוטים מצדדים; **אפס** מילות-שיפוט
+   ("חריג", "בעייתי", "מגוחך", "פגום", "שערורייתי").
+3. **כיסוי טענות** — כל טענה מהותית מבלוק ז קיבלה מענה בבלוק י (ישיר / קיבוץ / ציון שנבחנה).
+   טענות `[skip]` לא נספרות; `[bundle]` נבדקות כקבוצה. טענה מהותית לא-מסומנת שלא נענתה = כשל.
+4. **מתודולוגיה** — לכל סוגיה מבנה סילוגיסטי (כלל+עובדות+מסקנה); ממצא עובדתי מופרד ממסקנה
+   משפטית; טענת הצד המפסיד הוצגה בחוזקתה (Steel-Man); איזון מפורש כשנדרש; בלי "נוסחאות ריקות";
+   ציטוטים בסנדוויץ' (הקדמה→ציטוט→ניתוח).
+5. **קול דפנה** —
+   - בלוק ז: כותרת **"תמצית טענות הצדדים"**; כותרת-משנה לכל צד; בלי רשימה ממוספרת בפסקה;
+     בלי מילות-הערכה; בלי גילוי-מסקנה; קול פעיל ("העורר טוען").
+   - בלוק י: כותרת **"דיון והכרעה"**; קול "אנחנו" תפקידי ("מצאנו", לא "הוועדה מוצאת");
+     דפוס **"אכן... אולם"** לטענות שנדחות; בלי מספור-פסקאות סדרתי; ציטוטי פסיקה במלואם (4–15 שורות);
+     "למעלה מן הצורך" לטיעונים מרכזיים; בלי תוצאת הכל-או-לא-כלום כשיש טענות מהותיות משני הצדדים.
+   - 8xxx עם הכרעה שמאית → ציטוט **בר"מ 3644/13** קיים.
+6. **עיגון-מקור (INV-AH)** — כל אזכור פסיקה/חוק/הלכה/מספר מעוגן-מקור עם ציטוט; ציטוט חיצוני
+   תואם להלכה מאושרת בקורפוס (`search_precedent_library`). אזכור לא-מעוגן = הסר או הורד ל-`[ספקולציה]`.
+7. **צירוף פסיקה ל-DB** — כל ציטוט בבלוק י (חיצוני/internal) רשום ב-`case_precedents` דרך
+   `precedent_attach`. ציטוט שקיים רק בטקסט ולא ב-DB = חוסם (ה-exporter ו-Hermes קוראים מה-DB).
+8. **log שאילתות-קורפוס** — `analysis-and-research.md` §7א ו-`precedent-research.md` §ז קיימים,
+   עם מינימום queries לקורפוס הסמכותי (`analyst ≥ טענות-סף + סוגיות`; `researcher ≥ סוגיות`)
+   ותיעוד negative-evidence (גם 0-results).
+
+## אזהרות (warning — מדווח לחיים, לא חוסם)
+- **משקלות בטווח:** ו 15–40% · ז 20–40% · י 32–50% · יא 2–9%.
+- **בלי כפילות:** בלוק י מפנה לבלוקים קודמים ("כאמור"), לא חוזר על עובדות/טענות.
+- **מראה-מקום מלא בציטוטים:** מספר-תיק מלא + ערכאה + תאריך/`פורסם בנבו` (+ `page_reference` לציטוט ארוך).
+
+## אם תוצאה = קבלה (מ-`daphna-acceptance-architecture.md`)
+- התבנית הנבחרת (A/B/C/D/E) מתאימה לסיבת-הקבלה, ופורמט-הסיום תואם לתבנית
+  (A: "מתבטלת" + הודאת-צד-נגדי; B: "תיקבע לדיון"; C: "בכפוף לתיקונים" + הכרה בוועדה;
+  D: "דרישת התשלום בטלה"; E: "השומה תושב לתיקון").
+
+---
+
+> **מקור-אמת:** חומרת-הבדיקות המחייבת חיה ב-`.claude/agents/legal-qa.md` ("7 בדיקות" + טבלת-חומרה)
+> וב-`docs/spec/05-qa-review.md`. Rubric זה הוא התמצית המשותפת — כשמשתנה שער QA, עדכן שם ואת התמצית כאן.

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

@@ -23,8 +23,10 @@ from pathlib import Path
 from legal_mcp import config
 from legal_mcp.services import db, embeddings, claude_session, audit, storage
 from legal_mcp.services.lessons import (
+    ANTI_PATTERNS as _ANTI_PATTERNS,
     OUTCOME_LABELS_HE,
     PRACTICE_AREA_OVERRIDES,
+    anti_pattern_directive,
     canonical_outcome,
     get_content_checklist,
     get_methodology_summary,
@@ -369,6 +371,7 @@ async def write_block(
     block_id: str,
     instructions: str = "",
     effort_override: str | None = None,
+    model_override: str | None = None,
 ) -> dict:
     """כתיבת בלוק יחיד בהחלטה.
 
@@ -381,6 +384,12 @@ async def write_block(
             THIS call only — used by the #208 model/effort calibration harness
             to A/B efforts without mutating the pinned defaults. Production
             callers leave it None and get the deterministic per-block effort.
+        model_override: optional per-call generation model id (e.g.
+            "claude-opus-5"). Same contract as effort_override — the #208
+            harness A/Bs MODELS without mutating the pinned GENERATION_MODEL.
+            Pass the BASE id only: the 1M-context escalation (#216) is applied
+            on top automatically for large prompts, so an override never
+            silently loses the 1M window. Production callers leave it None.
 
     Returns:
         dict עם content, word_count, block_id, generation_type
@@ -468,6 +477,12 @@ async def write_block(
     if instructions:
         prompt += f"\n\n## הנחיות נוספות:\n{instructions}"
 
+    # LAST in the prompt, deliberately (see lessons.anti_pattern_directive): the
+    # same canonical rule already appears inside style_context, but ~47K chars
+    # deep, where it measurably fails to bind. Restating it here is the only
+    # change the A/B isolated as effective — so nothing may be appended after it.
+    prompt += "\n\n" + anti_pattern_directive()
+
     # Block י requires approved direction
     if block_id == "block-yod":
         dir_doc = (decision or {}).get("direction_doc") or {}
@@ -478,7 +493,12 @@ async def write_block(
     # escalate to the 1M-context build (`[1m]`) instead of failing the block —
     # block-yod legitimately carries the whole case as source-context. The 400K
     # ceiling was an artifact of the old 200K-only build, NOT a model limit.
-    gen_model = GENERATION_MODEL_1M if len(prompt) > _CTX_1M_THRESHOLD_CHARS else GENERATION_MODEL
+    # model_override (#208 harness) swaps the BASE id only — the 1M decision below
+    # still applies, so an A/B'd model keeps the same context-window behaviour as
+    # the pinned default instead of silently falling back to the 200K build.
+    _base_model = model_override or GENERATION_MODEL
+    _model_1m = GENERATION_MODEL_1M if _base_model == GENERATION_MODEL else f"{_base_model}[1m]"
+    gen_model = _model_1m if len(prompt) > _CTX_1M_THRESHOLD_CHARS else _base_model
 
     # Final guard: even the 1M build is finite (~2M Hebrew chars of input). Cap at
     # 1.5M chars (~750K tokens) to leave room for output + a safety margin under 1M.
@@ -1107,6 +1127,16 @@ async def _build_style_context(practice_area: str = "") -> str:
     # ── למידה מצטברת (T15) — עריכות היו"ר ב-/methodology + לקחי /training ──
     # גובר על ברירות-המחדל לעיל. כך כל מה שלמדנו עד היום מגיע לכותב.
     learned: list[str] = []
+    # The canonical anti-patterns are rendered UNCONDITIONALLY, before any DB
+    # call. They used to be produced inside the overrides loop below — so a
+    # failure on an EARLIER category (e.g. golden_ratios) aborted the loop and
+    # dropped the style invariants from the prompt silently, with only a generic
+    # "overrides not loaded" warning to show for it (§6). A chair-override
+    # outage must not be able to un-teach Dafna's structural style.
+    learned.append("\n**אנטי-דפוסים (להימנע) — כתוב נרטיב משפטי רציף; הימנע מ:**")
+    for ap in _ANTI_PATTERNS:
+        learned.append(f"- {ap['note']}")
+
     try:
         for cat, label in (
             ("golden_ratios", "יחסי-זהב (אחוזי-סעיפים)"),
@@ -1125,10 +1155,8 @@ async def _build_style_context(practice_area: str = "") -> str:
                 # corrects them, and drafts keep emitting them (the gap that left
                 # 8137 with 28 hits). Chair additions layer on top; they never
                 # remove the canonical ones.
-                from legal_mcp.services.lessons import ANTI_PATTERNS as _ANTI
-                learned.append(f"\n**{label} — כתוב נרטיב משפטי רציף; הימנע מ:**")
-                for ap in _ANTI:
-                    learned.append(f"- {ap['note']}")
+                # The canonical list is already rendered above, outside this try —
+                # here we only layer the chair's ADDITIONS on top of it.
                 for k, v in (ov or {}).items():
                     learned.append(f"- (יו\"ר) {k}: {json.dumps(v, ensure_ascii=False)}")
                 continue
@@ -1264,6 +1292,12 @@ async def get_block_context(case_id: UUID, block_id: str, instructions: str = ""
     if instructions:
         formatted_prompt += f"\n\n## הנחיות נוספות:\n{instructions}"
 
+    # Same closing directive, same position, same canonical source as write_block.
+    # This is the EXTERNAL-writer path (legal-writer agent) — if the rule were
+    # applied only in write_block, agent-written blocks would keep emitting the
+    # anti-patterns and the two writers would drift apart (G2).
+    formatted_prompt += "\n\n" + anti_pattern_directive()
+
     # Block י requires approved direction
     if block_id == "block-yod":
         dir_doc = (decision or {}).get("direction_doc") or {}

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

@@ -59,6 +59,28 @@ ANTI_PATTERNS: list[dict] = [
      "note": "רשימות תבליטים באנליזה — דפנה כותבת נרטיב רציף"},
 ]
 
+
+def anti_pattern_directive() -> str:
+    """The closing style directive, rendered from ANTI_PATTERNS (the same list
+    style_distance scores against — one source, two renderings, not two rules).
+
+    WHY THIS EXISTS SEPARATELY FROM the style-context rendering: the rule was
+    already reaching the writer, buried ~47K chars deep inside style_context,
+    and drafts kept emitting the very patterns it forbids. A measured A/B over
+    the signed finals (9 cases, 60 generations, 2026-07-28) showed that the SAME
+    rule restated at the END of the assembled prompt cuts anti-pattern hits by
+    72–93% on both blocks and both models:
+
+        block-vav  opus-4-8 1.75 → 0.12 | opus-5 2.25 → 0.62
+        block-zayin opus-4-8 4.57 → 0.43 | opus-5 4.43 → 0.43
+
+    So this is a POSITION fix, not a new instruction. Keep it last in the prompt.
+    """
+    lines = ["## כלל-סגנון מחייב (גובר על כל דוגמה בהקשר שלמעלה)",
+             "כתוב נרטיב משפטי רציף בלבד — פסקאות שלמות. אסור:"]
+    lines += [f"- {ap['note']}" for ap in ANTI_PATTERNS]
+    return "\n".join(lines)
+
 # ── Paragraph length guidance (word counts) ────────────────────────
 
 PARAGRAPH_LENGTHS = {

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

@@ -176,7 +176,13 @@ def block_distance_to_final(
     outcome = canonical_outcome(outcome)
     diff = compute_diff_stats(regenerated_text or "", final_section_text or "")
     change_percent = diff["change_percent"]
-    anti_total = count_anti_patterns(regenerated_text or "")["total"]
+    anti = count_anti_patterns(regenerated_text or "")
+    anti_total = anti["total"]
+    # Per-pattern breakdown, not just the total: a calibration run that only
+    # reports "anti=4" cannot tell you WHICH rule was broken, so it cannot say
+    # what to fix. (Diagnosing the 2026-07-28 model A/B needed exactly this and
+    # had to fall back on inference.)
+    anti_by_pattern = {name: h["count"] for name, h in anti["by_pattern"].items()}
 
     section = _BLOCK_TO_SECTION.get(block_id)
     regen_words = len((regenerated_text or "").split())
@@ -205,6 +211,7 @@ def block_distance_to_final(
         "final_words": final_words,
         "change_percent": change_percent,
         "anti_pattern_total": anti_total,
+        "anti_by_pattern": anti_by_pattern,
         "golden_ratio_deviation_pp": ratio_dev,
         "distance": distance,
     }

mcp-server/tests/test_anti_pattern_directive.py

@@ -0,0 +1,60 @@
+"""The style invariants must actually REACH the writer.
+
+Both tests here cover defects found by the 2026-07-28 model×prompt A/B over the
+signed finals: the canonical anti-patterns were present in the prompt but buried
+~47K chars into style_context (where they measurably failed to bind), and they
+were rendered inside a try/except that an unrelated DB failure could abort.
+"""
+import pytest
+
+from legal_mcp.services import block_writer
+from legal_mcp.services.lessons import ANTI_PATTERNS, anti_pattern_directive
+
+
+def test_directive_renders_every_canonical_anti_pattern():
+    """One source, two renderings — the directive may not drift from the list
+    style_distance scores against."""
+    text = anti_pattern_directive()
+    for ap in ANTI_PATTERNS:
+        assert ap["note"] in text, f"missing anti-pattern in directive: {ap['name']}"
+
+
+def test_both_writer_paths_append_the_directive_last():
+    """write_block (in-process) and get_block_context (legal-writer agent) must
+    both close with the directive — otherwise the two writers drift (G2)."""
+    import inspect
+    src = inspect.getsource(block_writer)
+    for fn in ("async def write_block(", "async def get_block_context("):
+        start = src.index(fn)
+        # bound the search to this function: up to the next top-level def
+        rest = src[start + len(fn):]
+        nxt = rest.find("\nasync def ")
+        body = rest[: nxt if nxt != -1 else len(rest)]
+        assert "anti_pattern_directive()" in body, f"{fn} does not append the style directive"
+
+
+@pytest.mark.asyncio
+async def test_style_context_keeps_anti_patterns_when_overrides_fail(monkeypatch):
+    """A chair-override outage must not silently un-teach the structural style.
+
+    Regression: the canonical list used to be emitted inside the overrides loop,
+    so a throw on an EARLIER category (golden_ratios) dropped it entirely.
+    """
+    async def _boom(*a, **k):
+        raise RuntimeError("methodology table unavailable")
+
+    async def _empty(*a, **k):
+        return []
+
+    # Every DB accessor this function touches is stubbed — the test must not open
+    # a real connection (a live pool here leaks across the shared event loop and
+    # breaks unrelated tests later in the run).
+    monkeypatch.setattr(block_writer.db, "get_style_patterns", _empty)
+    monkeypatch.setattr(block_writer.db, "get_methodology_overrides", _boom)
+    monkeypatch.setattr(block_writer.db, "get_recent_decision_lessons", _empty)
+
+    ctx = await block_writer._build_style_context("היטל השבחה")
+
+    assert "נרטיב משפטי רציף" in ctx
+    for ap in ANTI_PATTERNS:
+        assert ap["note"] in ctx, f"anti-pattern dropped on override failure: {ap['name']}"

scripts/calibrate_effort.py

@@ -166,17 +166,33 @@ def aggregate_cell(per_run: list[dict]) -> dict:
     """Mean each metric across repeated generations of the same (case, block, effort)."""
     if not per_run:
         return {"distance": 1.0, "anti_pattern_total": 0.0, "change_percent": 100.0,
-                "golden_ratio_deviation_pp": None, "n": 0}
+                "golden_ratio_deviation_pp": None, "anti_by_pattern": {}, "n": 0}
     ratios = [r["golden_ratio_deviation_pp"] for r in per_run if r.get("golden_ratio_deviation_pp") is not None]
     return {
         "distance": round(mean(r["distance"] for r in per_run), 4),
         "anti_pattern_total": round(mean(r["anti_pattern_total"] for r in per_run), 2),
         "change_percent": round(mean(r["change_percent"] for r in per_run), 2),
         "golden_ratio_deviation_pp": round(mean(ratios), 2) if ratios else None,
+        "anti_by_pattern": _mean_by_pattern(per_run),
         "n": len(per_run),
     }
 
 
+def _mean_by_pattern(per_run: list[dict]) -> dict:
+    """Mean hits PER anti-pattern name across runs — the 'which rule broke' view.
+
+    A pattern absent from a run counts as 0 (count_anti_patterns omits zero-hit
+    keys), so the mean is over ALL runs, not only the ones that tripped it.
+    """
+    names: set[str] = set()
+    for r in per_run:
+        names |= set((r.get("anti_by_pattern") or {}).keys())
+    return {
+        name: round(mean((r.get("anti_by_pattern") or {}).get(name, 0) for r in per_run), 2)
+        for name in sorted(names)
+    }
+
+
 def _current_default(block_id: str) -> str | None:
     from legal_mcp.services.block_writer import BLOCK_CONFIG, DEFAULT_EFFORT
     cfg = BLOCK_CONFIG.get(block_id, {})
@@ -420,13 +436,30 @@ async def _finals_for_calibration(case_filter: str | None) -> list[dict]:
 
 
 async def _score_cell(case_id, block_id: str, effort: str, final_section: str,
-                      final_total_words: int, outcome: str, repeats: int) -> dict:
-    """Generate `block_id` at `effort` `repeats` times; score each vs the final section."""
+                      final_total_words: int, outcome: str, repeats: int,
+                      model: str | None = None, instructions: str = "") -> dict:
+    """Generate `block_id` at `effort` `repeats` times; score each vs the final section.
+
+    `model` (optional) A/Bs the generation model via write_block(model_override=…).
+    None ⇒ the pinned GENERATION_MODEL, i.e. the production path unchanged.
+
+    `instructions` (optional) is appended to the block prompt for EVERY cell in
+    the run — a prompt-variant A/B (e.g. an explicit formatting rule). It is
+    applied to all models so the comparison stays a model comparison rather
+    than silently becoming a prompt comparison.
+    """
     from legal_mcp.services import block_writer
     from legal_mcp.services.style_distance import block_distance_to_final
     runs: list[dict] = []
+    models_used: list[str] = []
     for _ in range(repeats):
-        res = await block_writer.write_block(case_id, block_id, effort_override=effort)
+        res = await block_writer.write_block(
+            case_id, block_id, instructions=instructions,
+            effort_override=effort, model_override=model,
+        )
+        # Record what the CLI was actually asked to run, so a silent fallback to
+        # a different build is visible in the report rather than mis-attributed.
+        models_used.append(res.get("model_used") or "?")
         scored = block_distance_to_final(
             block_id, res.get("content", ""), final_section, outcome,
             section_target_total_words=final_total_words,
@@ -434,6 +467,8 @@ async def _score_cell(case_id, block_id: str, effort: str, final_section: str,
         runs.append(scored)
     agg = aggregate_cell(runs)
     agg["effort"] = effort
+    agg["model"] = model
+    agg["models_used"] = sorted(set(models_used))
     agg["runs"] = runs
     return agg
 
@@ -446,6 +481,7 @@ async def _run(args, ts: str) -> dict:
 
     efforts = args.efforts
     blocks = args.blocks
+    models = args.models
     finals = await _finals_for_calibration(args.case)
 
     cases_meta = []
@@ -468,11 +504,15 @@ async def _run(args, ts: str) -> dict:
         section = _BLOCK_TO_SECTION.get(block_id)
         plan[block_id] = [c for c in cases_meta if section and c["sections"].get(section)]
 
-    total_cells = sum(len(plan[b]) for b in blocks) * len(efforts) * args.repeats
+    total_cells = sum(len(plan[b]) for b in blocks) * len(efforts) * args.repeats * len(models)
     grid_summary = {
         "n_finals": len(cases_meta),
         "finals": [c["case_number"] for c in cases_meta],
         "blocks": blocks, "efforts": efforts, "repeats": args.repeats,
+        "models": models,
+        # Provenance: a prompt-variant run is NOT comparable to a baseline run,
+        # so the instruction text is recorded in the report, not just the shell.
+        "instructions": getattr(args, "instructions", "") or "",
         "total_generations": total_cells,
         "per_block_n": {b: len(plan[b]) for b in blocks},
     }
@@ -480,6 +520,27 @@ async def _run(args, ts: str) -> dict:
     if args.dry_run:
         return {"dry_run": True, "grid": grid_summary, "by_block": {}}
 
+    by_model: dict[str, dict] = {}
+    for model in models:
+        by_block = await _run_blocks_for_model(
+            model, blocks, efforts, plan, args, ts, grid_summary, by_model, _BLOCK_TO_SECTION,
+        )
+        by_model[model] = by_block
+
+    # `by_block` stays the single-model shape (first model) so --rerank and the
+    # existing per-block report path keep working unchanged (G2 — no second
+    # result schema); multi-model runs additionally carry by_model.
+    out = {"dry_run": False, "grid": grid_summary, "by_block": by_model[models[0]]}
+    if len(models) > 1:
+        out["by_model"] = by_model
+    return out
+
+
+async def _run_blocks_for_model(model, blocks, efforts, plan, args, ts, grid_summary,
+                                by_model_so_far, _BLOCK_TO_SECTION) -> dict:
+    """The per-block × per-effort grid for ONE generation model."""
+    from uuid import UUID
+
     by_block: dict[str, dict] = {}
     for block_id in blocks:
         section = _BLOCK_TO_SECTION.get(block_id)
@@ -497,11 +558,12 @@ async def _run(args, ts: str) -> dict:
                     cell = await _score_cell(
                         UUID(c["case_id"]), block_id, effort, final_section,
                         c["final_total_words"], c["outcome"], args.repeats,
+                        model=model, instructions=getattr(args, "instructions", "") or "",
                     )
                 except Exception as exc:  # noqa: BLE001 — harness must survive any cell failure
                     logger.warning(
-                        "calibration cell skipped: case=%s block=%s effort=%s — %s",
-                        c["case_number"], block_id, effort, exc,
+                        "calibration cell skipped: case=%s block=%s effort=%s model=%s — %s",
+                        c["case_number"], block_id, effort, model, exc,
                     )
                     continue
                 per_effort_runs[effort].append(cell)
@@ -523,6 +585,7 @@ async def _run(args, ts: str) -> dict:
                 "anti_pattern_total": round(mean(r["anti_pattern_total"] for r in rows), 2),
                 "change_percent": round(mean(r["change_percent"] for r in rows), 2),
                 "golden_ratio_deviation_pp": round(mean(ratios), 2) if ratios else None,
+                "anti_by_pattern": _mean_by_pattern(rows),
                 "n": len(rows),
             })
         rec = recommend_effort(effort_rows)
@@ -532,6 +595,11 @@ async def _run(args, ts: str) -> dict:
             "recommended": rec["effort"] if rec else None,
             "confidence": rec["confidence"] if rec else None,
             "confidence_margin": rec.get("confidence_margin") if rec else None,
+            "model": model,
+            # Model builds the CLI actually reported across this block's cells —
+            # a mismatch vs `model` means a silent fallback, not a real A/B.
+            "models_used": sorted({m for e in per_effort_runs.values()
+                                   for cell in e for m in cell.get("models_used", [])}),
             "efforts": effort_rows,
             "per_case": per_case,
         }
@@ -541,11 +609,15 @@ async def _run(args, ts: str) -> dict:
         # Blocks not yet done are simply absent from by_block; _write_report tolerates
         # partial results. main() does the final flush once the loop finishes.
         try:
-            _write_report({"dry_run": False, "grid": grid_summary, "by_block": by_block}, ts)
+            snap = {"dry_run": False, "grid": grid_summary, "by_block": by_block}
+            if by_model_so_far or len(grid_summary.get("models", [])) > 1:
+                snap["by_model"] = {**by_model_so_far, model: by_block}
+            _write_report(snap, ts)
         except Exception as exc:  # noqa: BLE001 — a write hiccup must not abort the run
-            logger.warning("incremental report write failed after block=%s — %s", block_id, exc)
+            logger.warning("incremental report write failed after block=%s model=%s — %s",
+                           block_id, model, exc)
 
-    return {"dry_run": False, "grid": grid_summary, "by_block": by_block}
+    return by_block
 
 
 IL_TZ = ZoneInfo("Asia/Jerusalem")
@@ -578,7 +650,10 @@ def _write_report(result: dict, ts: str) -> tuple[Path, Path]:
         "ההמלצה אדוויזורית; ההכרעה בידי היו\"ר/המפעיל.\n",
         f"- בלוקים: {', '.join(g['blocks'])}",
         f"- efforts: {', '.join(g['efforts'])} · repeats/cell: {g['repeats']}",
+        f"- models: {', '.join(m or 'pinned-default' for m in g.get('models', [None]))}",
         f"- סך ייצורי-מודל: {g['total_generations']}",
+        (f"- ⚠️ **וריאנט-פרומפט** (לא בר-השוואה לריצת-בסיס): `{g['instructions']}`"
+         if g.get("instructions") else "- וריאנט-פרומפט: — (פרומפט ייצור כפי-שהוא)"),
         "",
     ]
     if result.get("dry_run"):
@@ -613,6 +688,54 @@ def _write_report(result: dict, ts: str) -> tuple[Path, Path]:
                 f"| {r['effort']}{star} | {r['distance']:.4f} | {r['anti_pattern_total']} | "
                 f"{r['change_percent']} | {ratio if ratio is not None else '—'} | {r['n']} |")
         lines.append("")
+    by_model = result.get("by_model") or {}
+    if len(by_model) > 1:
+        lines += ["## השוואת-מודלים (אותו block, אותו effort, אותם סופיים)\n",
+                  "| block | effort | model | anti_total | change% | ratioΔpp | distance | n |",
+                  "|---|---|---|---|---|---|---|---|"]
+        for b in g["blocks"]:
+            for eff in g["efforts"]:
+                rows = []
+                for m, bb in by_model.items():
+                    for r in (bb.get(b) or {}).get("efforts", []):
+                        if r["effort"] == eff:
+                            rows.append((m, r))
+                if len(rows) < 2:
+                    continue  # nothing to compare for this cell — don't fake a row
+                best = min(rows, key=lambda mr: (mr[1]["anti_pattern_total"],
+                                                 mr[1]["golden_ratio_deviation_pp"] or 0,
+                                                 mr[1]["distance"]))[0]
+                for m, r in rows:
+                    ratio = r["golden_ratio_deviation_pp"]
+                    star = " ⭐" if m == best else ""
+                    lines.append(
+                        f"| {b} | {eff} | {m}{star} | {r['anti_pattern_total']} | "
+                        f"{r['change_percent']} | {ratio if ratio is not None else '—'} | "
+                        f"{r['distance']:.4f} | {r['n']} |")
+        lines.append("")
+
+        # WHICH rule broke — a total alone can't tell you what to fix.
+        bd_rows = [(b, eff, m, r) for b in g["blocks"] for eff in g["efforts"]
+                   for m, bb in by_model.items()
+                   for r in (bb.get(b) or {}).get("efforts", []) if r["effort"] == eff]
+        if any(r.get("anti_by_pattern") for *_, r in bd_rows):
+            names = sorted({n for *_, r in bd_rows for n in (r.get("anti_by_pattern") or {})})
+            lines += ["### פילוח אנטי-דפוסים (איזה כלל הופר)\n",
+                      "| block | effort | model | " + " | ".join(names) + " |",
+                      "|---|---|---|" + "---|" * len(names)]
+            for b, eff, m, r in bd_rows:
+                cells = " | ".join(str((r.get("anti_by_pattern") or {}).get(n, 0)) for n in names)
+                lines.append(f"| {b} | {eff} | {m} | {cells} |")
+            lines.append("")
+        # A silent CLI fallback would make the whole comparison meaningless — surface it.
+        for m, bb in by_model.items():
+            for b, bd in bb.items():
+                used = bd.get("models_used") or []
+                if used and any(not u.startswith(str(m)) for u in used):
+                    lines.append(f"> ⚠️ **{b} / {m}**: ה-CLI דיווח `{', '.join(used)}` — "
+                                 "ייתכן fallback שקט; ההשוואה לתא זה אינה תקפה.\n")
+        lines.append("")
+
     lines.append("> דירוג-ההמלצה **style-clean** (#213): anti_total ראשי → ratioΔ → distance (tiebreak). "
                  "**change% מדווח-לא-מדורג** — מערבב סגנון עם שלמות-תוכן (07-learning §0.7), "
                  "anti_total הוא הסיגנל הנקי-לסגנון. confidence=⚠️weak ⇒ הבחירה בתוך-הרעש "
@@ -633,6 +756,12 @@ async def main() -> int:
                     help="comma block ids to calibrate")
     ap.add_argument("--case", default=None, help="restrict to a single case_number")
     ap.add_argument("--repeats", type=int, default=1, help="generations per cell (avg out gen noise)")
+    ap.add_argument("--models", default="",
+                    help="comma generation-model ids to A/B (e.g. claude-opus-4-8,claude-opus-5). "
+                         "Empty (default) = the pinned GENERATION_MODEL, i.e. production unchanged.")
+    ap.add_argument("--instructions", default="",
+                    help="extra prompt instruction appended to EVERY cell (prompt-variant A/B). "
+                         "Applied to all models — the run stays a model comparison. Recorded in the report.")
     args = ap.parse_args()
 
     logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
@@ -653,6 +782,9 @@ async def main() -> int:
     if bad_b:
         print(f"non-calibratable block(s): {bad_b}. valid: {VALID_BLOCKS}", file=sys.stderr)
         return 2
+    # [None] = "use the pinned GENERATION_MODEL" — keeps the default run byte-identical
+    # to the pre-#models behaviour instead of hard-coding the id in a second place (G2).
+    args.models = [m.strip() for m in args.models.split(",") if m.strip()] or [None]
 
     ts = _ts()
     result = await _run(args, ts)

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

@@ -10,6 +10,7 @@ import {
   useSendComment,
   useSubmitInteraction,
   useDismissInteraction,
+  useSetIssueStatus,
 } from "@/lib/api/agents";
 import type {
   Interaction,
@@ -772,31 +773,96 @@ function IssueGroup({
   defaultOpen: boolean;
 }) {
   const [open, setOpen] = useState(defaultOpen);
+  const setStatus = useSetIssueStatus(caseNumber);
   const closed = issue.status === "done" || issue.status === "cancelled";
+  // Show the parent run this issue hangs under (e.g. a "הרצה חדשה" nested under
+  // the live CEO root) so the hierarchy is visible, not flattened.
+  const parentIdentifier = issue.parent_id
+    ? issueMap.get(issue.parent_id)
+    : undefined;
+
+  const close = (status: "done" | "cancelled") =>
+    setStatus.mutate(
+      { issue_id: issue.id, status },
+      {
+        onSuccess: () =>
+          toast.success(
+            status === "done" ? "המשימה סומנה כהושלמה" : "המשימה בוטלה",
+          ),
+        onError: () => toast.error("שגיאה בעדכון סטטוס המשימה"),
+      },
+    );
+
   return (
-    <div className="border-b border-rule-soft last:border-b-0">
-      <button
-        type="button"
-        onClick={() => setOpen((o) => !o)}
-        aria-expanded={open}
-        className="w-full flex items-center gap-2 px-2 py-2.5 hover:bg-sand-soft/50 text-start"
-      >
-        <Badge
-          variant={closed ? "secondary" : "default"}
-          className="text-[10px] font-mono shrink-0"
+    <div className="border-b-2 border-rule last:border-b-0">
+      <div className="w-full flex items-center gap-2 px-2 py-2.5 hover:bg-sand-soft/50">
+        <button
+          type="button"
+          onClick={() => setOpen((o) => !o)}
+          aria-expanded={open}
+          className="flex-1 flex items-center gap-2 text-start min-w-0"
         >
-          {issue.identifier}
-        </Badge>
-        <span className="text-[0.78rem] font-semibold text-navy truncate">
-          {shortIssueTitle(issue.title)}
-        </span>
-        <span className="text-[0.7rem] text-ink-muted whitespace-nowrap">
-          {issueStatusLabel(issue.status)} · {items.length}
-        </span>
-        <ChevronDown
-          className={`w-4 h-4 ms-auto text-ink-faint shrink-0 transition-transform ${open ? "rotate-180" : ""}`}
-        />
-      </button>
+          <Badge
+            variant={closed ? "secondary" : "default"}
+            className="text-[10px] font-mono shrink-0"
+          >
+            {issue.identifier}
+          </Badge>
+          <span className="text-[0.78rem] font-semibold text-navy truncate">
+            {shortIssueTitle(issue.title)}
+          </span>
+          {parentIdentifier && (
+            <span
+              className="inline-flex items-center gap-0.5 text-[0.6rem] font-bold text-gold-deep bg-gold/10 border border-rule rounded-full px-1.5 py-0.5 shrink-0 whitespace-nowrap"
+              title={`תת-משימה של ${parentIdentifier}`}
+            >
+              ↳ {parentIdentifier}
+            </span>
+          )}
+          <span className="text-[0.7rem] text-ink-muted whitespace-nowrap">
+            {issueStatusLabel(issue.status)} · {items.length}
+          </span>
+        </button>
+        {!closed && (
+          <div className="flex items-center gap-1 shrink-0">
+            <Button
+              size="sm"
+              variant="outline"
+              onClick={() => close("done")}
+              disabled={setStatus.isPending}
+              className="h-7 px-2 text-[0.7rem] text-success border-success/40 hover:bg-success-bg"
+              title="סמן את המשימה כהושלמה"
+            >
+              {setStatus.isPending ? (
+                <Loader2 className="w-3 h-3 animate-spin" />
+              ) : (
+                <CheckCircle2 className="w-3.5 h-3.5 me-1" />
+              )}
+              הושלם
+            </Button>
+            <Button
+              size="sm"
+              variant="ghost"
+              onClick={() => close("cancelled")}
+              disabled={setStatus.isPending}
+              className="h-7 px-2 text-[0.7rem] text-ink-muted hover:text-danger"
+              title="בטל את המשימה"
+            >
+              בטל
+            </Button>
+          </div>
+        )}
+        <button
+          type="button"
+          onClick={() => setOpen((o) => !o)}
+          aria-label={open ? "כווץ" : "הרחב"}
+          className="shrink-0"
+        >
+          <ChevronDown
+            className={`w-4 h-4 text-ink-faint transition-transform ${open ? "rotate-180" : ""}`}
+          />
+        </button>
+      </div>
       {open && (
         <div className="pb-1">
           {items.map((item) =>
@@ -878,6 +944,13 @@ function TargetSelector({
   const defaultIssue = useMemo(() => pickDefaultTarget(issues), [issues]);
   const activeIssues = issues.filter((i) => isOpenStatus(i.status));
   const closedIssues = issues.filter((i) => !isOpenStatus(i.status));
+  // id → identifier, to label a run with the parent it hangs under (↳ CMP-189).
+  const idToIdentifier = useMemo(
+    () => new Map(issues.map((i) => [i.id, i.identifier])),
+    [issues],
+  );
+  const parentTag = (i: PaperclipIssue) =>
+    i.parent_id ? idToIdentifier.get(i.parent_id) : undefined;
 
   // The issue the pill currently represents (explicit pick, or the auto default).
   const effectiveIssue =
@@ -925,7 +998,31 @@ function TargetSelector({
             onClick={() => setOpen(false)}
             aria-hidden
           />
-          <div className="absolute z-20 top-full mt-1 start-0 w-[360px] max-w-[88vw] bg-white border border-rule rounded-xl shadow-lg p-1.5">
+          <div className="absolute z-20 top-full mt-1 start-0 w-[360px] max-w-[88vw] max-h-[62vh] overflow-y-auto overscroll-contain bg-white border border-rule rounded-xl shadow-lg p-1.5">
+            {/* "פתח הרצה חדשה" is the FIRST, most-prominent option so it's always
+                visible without scrolling to the bottom of a long task list. */}
+            <button
+              type="button"
+              onClick={() => {
+                onChange({ kind: "new_run" });
+                setOpen(false);
+              }}
+              className="w-full flex items-center gap-2.5 px-2 py-2 rounded-lg text-start bg-gold/10 border border-rule hover:border-gold/60"
+            >
+              <span className="w-6 h-6 rounded-md bg-navy text-white flex items-center justify-center shrink-0">
+                <Plus className="w-4 h-4" />
+              </span>
+              <span className="min-w-0">
+                <span className="block text-xs font-semibold text-navy">
+                  פתח הרצה חדשה
+                </span>
+                <span className="block text-[10px] text-ink-muted">
+                  ה-CEO ייצור משימה חדשה ויטפל בהוראה מאפס
+                </span>
+              </span>
+            </button>
+            <div className="h-px bg-rule-soft my-1.5 mx-1" />
+
             <div className="px-2 py-1 text-[10px] font-bold text-ink-faint uppercase tracking-wide">
               משימות פעילות
             </div>
@@ -933,6 +1030,7 @@ function TargetSelector({
               const selected =
                 (target.kind === "issue" && target.id === i.id) ||
                 (target.kind === "auto" && defaultIssue?.id === i.id);
+              const parent = parentTag(i);
               return (
                 <button
                   key={i.id}
@@ -941,12 +1039,20 @@ function TargetSelector({
                     onChange({ kind: "issue", id: i.id });
                     setOpen(false);
                   }}
-                  className={`w-full flex items-center gap-2 px-2 py-2 rounded-lg text-start hover:bg-sand-soft ${selected ? "bg-gold/10" : ""}`}
+                  className={`w-full flex items-center gap-2 px-2 py-2 rounded-lg text-start hover:bg-sand-soft ${parent ? "ps-6" : ""} ${selected ? "bg-gold/10" : ""}`}
                 >
                   <span className="w-1.5 h-1.5 rounded-full bg-emerald-500 shrink-0" />
                   <Badge variant="outline" className="text-[10px] font-mono shrink-0">
                     {i.identifier}
                   </Badge>
+                  {parent && (
+                    <span
+                      className="text-[9px] font-bold text-gold-deep bg-gold/10 border border-rule rounded-full px-1.5 py-0.5 shrink-0 whitespace-nowrap"
+                      title={`תת-משימה של ${parent}`}
+                    >
+                      ↳ {parent}
+                    </span>
+                  )}
                   <span className="text-xs text-ink-soft truncate flex-1">
                     {shortIssueTitle(i.title)}
                   </span>
@@ -968,50 +1074,39 @@ function TargetSelector({
                 <div className="px-2 py-1 text-[10px] font-bold text-ink-faint uppercase tracking-wide">
                   משימות סגורות · שליחה אליהן לא תעיר סוכן
                 </div>
-                {closedIssues.map((i) => (
-                  <div
-                    key={i.id}
-                    className="w-full flex items-center gap-2 px-2 py-2 rounded-lg opacity-60 cursor-not-allowed"
-                    title="משימה סגורה — שליחה אליה לא תעיר סוכן"
-                  >
-                    <span className="w-1.5 h-1.5 rounded-full bg-ink-faint shrink-0" />
-                    <Badge variant="outline" className="text-[10px] font-mono shrink-0">
-                      {i.identifier}
-                    </Badge>
-                    <span className="text-xs text-ink-faint truncate flex-1">
-                      {shortIssueTitle(i.title)}
-                    </span>
-                    <span
-                      className={`text-[10px] font-semibold rounded-full px-2 py-0.5 shrink-0 ${statusTone(i.status)}`}
+                {closedIssues.map((i) => {
+                  const parent = parentTag(i);
+                  return (
+                    <div
+                      key={i.id}
+                      className={`w-full flex items-center gap-2 px-2 py-2 rounded-lg opacity-60 cursor-not-allowed ${parent ? "ps-6" : ""}`}
+                      title="משימה סגורה — שליחה אליה לא תעיר סוכן"
                     >
-                      {issueStatusLabel(i.status)}
-                    </span>
-                  </div>
-                ))}
+                      <span className="w-1.5 h-1.5 rounded-full bg-ink-faint shrink-0" />
+                      <Badge variant="outline" className="text-[10px] font-mono shrink-0">
+                        {i.identifier}
+                      </Badge>
+                      {parent && (
+                        <span
+                          className="text-[9px] font-bold text-gold-deep bg-gold/10 border border-rule rounded-full px-1.5 py-0.5 shrink-0 whitespace-nowrap"
+                          title={`תת-משימה של ${parent}`}
+                        >
+                          ↳ {parent}
+                        </span>
+                      )}
+                      <span className="text-xs text-ink-faint truncate flex-1">
+                        {shortIssueTitle(i.title)}
+                      </span>
+                      <span
+                        className={`text-[10px] font-semibold rounded-full px-2 py-0.5 shrink-0 ${statusTone(i.status)}`}
+                      >
+                        {issueStatusLabel(i.status)}
+                      </span>
+                    </div>
+                  );
+                })}
               </>
             )}
-
-            <div className="h-px bg-rule-soft my-1.5 mx-1" />
-            <button
-              type="button"
-              onClick={() => {
-                onChange({ kind: "new_run" });
-                setOpen(false);
-              }}
-              className="w-full flex items-center gap-2.5 px-2 py-2 rounded-lg text-start hover:bg-sand-soft"
-            >
-              <span className="w-6 h-6 rounded-md bg-navy text-white flex items-center justify-center shrink-0">
-                <Plus className="w-4 h-4" />
-              </span>
-              <span className="min-w-0">
-                <span className="block text-xs font-semibold text-navy">
-                  פתח הרצה חדשה
-                </span>
-                <span className="block text-[10px] text-ink-muted">
-                  ה-CEO ייצור משימה חדשה ויטפל בהוראה מאפס
-                </span>
-              </span>
-            </button>
           </div>
         </>
       )}

web-ui/src/lib/api/agents.ts

@@ -208,6 +208,25 @@ export function useDismissInteraction(caseNumber: string | undefined) {
   });
 }
 
+/** Manually close a board issue to done/cancelled — the chair tidying the agents
+ * board (e.g. superseded runs left in in_review). Backend does a loop-safe
+ * direct close and issues no wakeup; only the two terminal statuses are allowed. */
+export function useSetIssueStatus(caseNumber: string | undefined) {
+  const qc = useQueryClient();
+  return useMutation({
+    mutationFn: (vars: { issue_id: string; status: "done" | "cancelled" }) =>
+      apiRequest<{ ok: boolean; id: string; identifier: string; status: string }>(
+        `/api/cases/${caseNumber}/agents/issue-status`,
+        { method: "POST", body: vars },
+      ),
+    onSuccess: () => {
+      if (caseNumber) {
+        qc.invalidateQueries({ queryKey: agentKeys.activity(caseNumber) });
+      }
+    },
+  });
+}
+
 export type AgentResetResult = {
   ok: boolean;
   reassigned_issues: { id: string; identifier: string }[];

web/agent_platform_port.py

@@ -63,10 +63,12 @@ from web.paperclip_client import (
     cancel_interaction as _cancel_interaction,
     cancel_run as _cancel_run,
     escalate_issue as _escalate_issue,
+    mark_comment_routed as _mark_comment_routed,
     post_comment as _post_comment,
     reap_stale_interactions as _reap_stale_interactions,
     reset_agent_session as _reset_agent_session,
     reset_case_agents as _reset_case_agents,
+    set_issue_status as _set_issue_status,
     wake_analyst_for_appraiser_facts as _wake_analyst_for_appraiser_facts,
     wake_analyst_for_argument_aggregation as _wake_analyst_for_argument_aggregation,
     wake_analyst_for_protocol_analysis as _wake_analyst_for_protocol_analysis,
@@ -114,6 +116,9 @@ pc_wake_analyst_for_protocol_analysis = instrument(
 pc_post_comment = instrument(
     "agent.comment", keys=("issue_id", "company_id"),
 )(_post_comment)
+pc_mark_comment_routed = instrument(
+    "agent.comment", keys=("issue_id", "comment_id"),
+)(_mark_comment_routed)
 pc_cancel_interaction = instrument(
     "interaction.cancelled", keys=("issue_id", "interaction_id"),
 )(_cancel_interaction)
@@ -123,6 +128,12 @@ pc_cancel_interaction = instrument(
 pc_escalate_issue = instrument(
     "agent.escalated", keys=("issue_id", "severity", "company_id", "reason"),
 )(_escalate_issue)
+# Manual chair close of a board issue (done/cancelled) — the loop-safe primitive
+# behind the agents-board "סמן כהושלם / בטל" actions. Countable per case in the
+# same telemetry stream as the escalations/wakeups it sits beside.
+pc_set_issue_status = instrument(
+    "issue.status_set", keys=("issue_id", "status", "company_id"),
+)(_set_issue_status)
 pc_reap_stale_interactions = instrument(
     "interaction.reaped", result_keys=("cancelled",),
 )(_reap_stale_interactions)
@@ -179,6 +190,7 @@ __all__ = [
     "pc_get_generation_run_status",
     # comments / interactions
     "pc_post_comment",
+    "pc_mark_comment_routed",
     "pc_get_issue_comments",
     "pc_get_issue_interactions",
     "pc_accept_interaction",
@@ -187,6 +199,7 @@ __all__ = [
     "pc_cancel_interaction",
     "pc_reap_stale_interactions",
     "pc_escalate_issue",
+    "pc_set_issue_status",
     # agent-run observability + control (live view + smart management)
     "pc_get_agent_health",
     "pc_get_recent_escalations",

web/app.py

@@ -82,6 +82,7 @@ from web.agent_platform_port import (
     pc_reset_agent_session,
     pc_reset_case_agents,
     pc_respond_to_interaction,
+    pc_set_issue_status,
     pc_restore_project,
     pc_wake_analyst_for_appraiser_facts,
     pc_wake_analyst_for_argument_aggregation,
@@ -91,6 +92,7 @@ from web.agent_platform_port import (
     pc_wake_ceo,
     pc_wake_ceo_for_action,
     pc_open_ceo_run,
+    pc_mark_comment_routed,
     pc_wake_ceo_for_feedback_fold,
     pc_wake_curator_for_final,
     pc_wake_for_precedent_extraction,
@@ -4660,8 +4662,9 @@ async def api_case_agents(case_number: str):
 class AgentCommentRequest(BaseModel):
     body: str
     issue_id: str | None = None
-    # "פתח הרצה חדשה" — open a fresh CEO-owned run for this instruction instead of
-    # appending to an existing issue (agents-tab target selector). Overrides issue_id.
+    # "פתח הרצה חדשה" — skip the comment entirely and only open a CEO run. Kept for
+    # the agents-tab target selector; the default path below now opens a run too, so
+    # this only differs in *not* recording the instruction on the parent thread.
     new_run: bool = False
 
 
@@ -4705,10 +4708,31 @@ async def api_post_agent_comment(case_number: str, req: AgentCommentRequest):
 
     result = await pc_post_comment(target["id"], target["company_id"], req.body)
 
+    # The comment alone reaches nobody: a case issue awaiting the chair is
+    # `in_review` and owned by a human, so Paperclip cancels any wakeup on it
+    # (`issue_assignee_changed` → "wake the new owner" → the owner is a person).
+    # The plugin sweep that was meant to catch this delivers the instruction as
+    # `payload.prompt`, which the runner drops. So the comment is recorded for the
+    # thread, and the instruction is carried by a CEO-owned child run — the one
+    # path verified to reach the agent (TaskMaster #228; see paperclip-quirks.md).
+    run = await pc_open_ceo_run(case_number, req.body)
+    if run.get("status") != "ok":
+        raise HTTPException(
+            502,
+            f"ההערה נשמרה אך פתיחת ההרצה נכשלה — הסוכן לא יטפל בה: "
+            f"{run.get('reason', 'unknown')}",
+        )
+    # Claim the comment so the sweep does not re-route it: the CEO answers on the
+    # child issue, leaving the parent with no agent reply, which the sweep reads
+    # as "still pending" forever.
+    await pc_mark_comment_routed(target["id"], result.get("comment_id", ""))
+
     # Echo the resolved target so the UI can show where it landed and flag it
     # when the chair explicitly targeted a closed issue (whose wakeup is skipped).
     result["issue_identifier"] = target.get("identifier", "")
     result["issue_status"] = target.get("status", "")
+    result["run_issue_id"] = run["issue_id"]
+    result["run_issue_identifier"] = run.get("identifier", "")
     return result
 
 
@@ -4725,8 +4749,10 @@ async def api_post_interaction_response(
 ):
     """Submit a user's answer to a Paperclip issue-thread interaction.
 
-    Routes to /respond | /accept | /reject based on `action`. Paperclip
-    auto-wakes the issue assignee after a successful submission.
+    Routes to /respond | /accept | /reject based on `action`, then opens a CEO run
+    carrying the answer. Paperclip's own `wake_assignee` cannot deliver it: the
+    issue is owned by the chair while it waits for her, so the "assignee" it wakes
+    is a person and no agent ever runs (TaskMaster #228).
     """
     issues = await pc_get_case_issues(case_number)
     if not any(i["id"] == req.issue_id for i in issues):
@@ -4738,7 +4764,7 @@ async def api_post_interaction_response(
         "reject": pc_reject_interaction,
     }
     try:
-        return await handlers[req.action](
+        result = await handlers[req.action](
             req.issue_id, req.interaction_id, req.payload,
         )
     except httpx.HTTPStatusError as e:
@@ -4747,6 +4773,23 @@ async def api_post_interaction_response(
     except Exception as e:
         raise HTTPException(502, f"שגיאת Paperclip: {e}")
 
+    answer = json.dumps(req.payload, ensure_ascii=False)
+    run = await pc_open_ceo_run(
+        case_number,
+        f'תשובת היו"ר לשאלה שהוצגה לה ({req.action}):\n\n{answer}\n\n'
+        f"קרא את ה-interaction המקורי על ה-issue והמשך משם.",
+    )
+    if run.get("status") != "ok":
+        raise HTTPException(
+            502,
+            f"התשובה נשמרה אך פתיחת ההרצה נכשלה — הסוכן לא ימשיך: "
+            f"{run.get('reason', 'unknown')}",
+        )
+    if isinstance(result, dict):
+        result["run_issue_id"] = run["issue_id"]
+        result["run_issue_identifier"] = run.get("identifier", "")
+    return result
+
 
 class InteractionDismissRequest(BaseModel):
     issue_id: str
@@ -4809,6 +4852,29 @@ async def api_escalate_issue(case_number: str, req: EscalateRequest):
     return result
 
 
+class IssueStatusRequest(BaseModel):
+    issue_id: str
+    status: Literal["done", "cancelled"]
+
+
+@app.post("/api/cases/{case_number}/agents/issue-status")
+async def api_set_issue_status(case_number: str, req: IssueStatusRequest):
+    """Manually close a board issue to done/cancelled from the chair UI.
+
+    Lets the chair tidy the agents board by hand — superseded "הרצה חדשה" runs
+    left in ``in_review`` had no manual close control and piled up. Only the two
+    terminal statuses are accepted; the loop-safe direct-DB close lives behind the
+    Port (``pc_set_issue_status``) and issues no wakeup.
+    """
+    issues = await pc_get_case_issues(case_number)
+    if not any(i["id"] == req.issue_id for i in issues):
+        raise HTTPException(404, f"Issue {req.issue_id} לא שייך לתיק {case_number}")
+    result = await pc_set_issue_status(req.issue_id, req.status)
+    if not result.get("ok"):
+        raise HTTPException(400, result.get("error", "עדכון הסטטוס נכשל"))
+    return result
+
+
 # ── Settings: MCP Server Configuration ────────────────────────────
 #
 # Source of truth for legal-ai env vars is Coolify (see memory:

web/paperclip_client.py

@@ -327,6 +327,40 @@ async def _create_issue(
     return issue_id, identifier
 
 
+async def mark_comment_routed(issue_id: str, comment_id: str) -> dict:
+    """Claim a chair comment as already routed, so the plugin sweep skips it.
+
+    The plugin's `route-pending-comments` sweep re-routes any user comment newer
+    than the newest agent comment on the same issue. A chair instruction answered
+    on a CEO **child** issue leaves the parent with no agent reply, so the sweep
+    would keep re-routing it forever. Writing the sweep's own marker
+    (`last-routed-comment-id`, plugin state, issue scope) is what tells it the
+    comment is handled — this is the same key `markCommentRouted` sets in
+    `plugin-legal-ai/src/worker.ts`.
+    """
+    if not comment_id:
+        return {"ok": False, "error": "no_comment_id"}
+    try:
+        conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+        try:
+            await conn.execute(
+                """INSERT INTO plugin_state (plugin_id, scope_kind, scope_id, namespace, state_key, value_json)
+                   VALUES ($1::uuid, 'issue', $2, 'default', 'last-routed-comment-id', $3::jsonb)
+                   ON CONFLICT (plugin_id, scope_kind, scope_id, namespace, state_key)
+                   DO UPDATE SET value_json = $3::jsonb""",
+                PLUGIN_ID, issue_id, json.dumps(comment_id),
+            )
+        finally:
+            await conn.close()
+        return {"ok": True, "issue_id": issue_id, "comment_id": comment_id}
+    except Exception as e:
+        logger.warning(
+            "mark_comment_routed failed for issue %s comment %s: %s",
+            issue_id, comment_id, e,
+        )
+        return {"ok": False, "error": str(e)}
+
+
 async def _link_case_to_issue(conn: asyncpg.Connection, issue_id: str, case_number: str) -> None:
     """Store the legal-ai case number in plugin state, linked to the issue."""
     await conn.execute(
@@ -655,10 +689,14 @@ async def get_agents_for_case(company_id: str, issue_ids: list[str]) -> list[dic
 
 
 async def post_comment(issue_id: str, company_id: str, body: str) -> dict:
-    """Post a comment on a Paperclip issue.
+    """Post a comment on a Paperclip issue. Records only — wakes nobody.
 
-    Tries the Board API first (triggers plugin events for CEO routing).
-    Falls back to direct DB insert + CEO wakeup if API fails.
+    Delivering the instruction is the caller's job, via :func:`open_ceo_run`. This
+    function used to also wake the CEO on ``issue_id``, but that wakeup is dead on
+    arrival for the case issues the chair actually comments on: they are
+    `in_review` and owned by her, so Paperclip cancels the run with
+    `issue_assignee_changed` before it starts. Keeping it would leave two parallel
+    delivery paths — one that works and one that silently doesn't (INV-G2).
     """
     # Try Board API first — this triggers the event bus
     if PAPERCLIP_BOARD_API_KEY:
@@ -675,7 +713,6 @@ async def post_comment(issue_id: str, company_id: str, body: str) -> dict:
         except Exception:
             logger.debug("Board API comment failed for issue %s, falling back to DB", issue_id)
 
-    # Fallback: direct DB insert + explicit CEO wakeup
     comment_id = str(uuid.uuid4())
     conn = await asyncpg.connect(PAPERCLIP_DB_URL)
     try:
@@ -688,23 +725,6 @@ async def post_comment(issue_id: str, company_id: str, body: str) -> dict:
     finally:
         await conn.close()
 
-    # Wake the correct CEO for this company
-    ceo_id = CEO_AGENTS.get(company_id, CEO_AGENT_ID)
-    try:
-        await pc_request(
-            "POST",
-            f"/api/agents/{ceo_id}/wakeup",
-            json={
-                "source": "on_demand",
-                "triggerDetail": "manual",
-                "reason": f"user_comment_{issue_id}",
-                "payload": {"issueId": issue_id, "mutation": "comment"},
-            },
-            raise_on_error=True,
-        )
-    except Exception:
-        logger.warning("Failed to wake CEO after DB comment on issue %s", issue_id)
-
     return {"comment_id": comment_id, "issue_id": issue_id, "method": "db_fallback"}
 
 
@@ -968,6 +988,70 @@ async def escalate_issue(
     }
 
 
+async def set_issue_status(
+    issue_id: str, status: str, company_id: str = "",
+) -> dict:
+    """Manually close a case issue to ``done`` or ``cancelled`` from the chair UI.
+
+    The chair needs to tidy the agents board by hand: superseded "הרצה חדשה" runs
+    that were replaced by a later run pile up in ``in_review`` with no way to close
+    them — there was no manual control, so they had to be closed out-of-band. This
+    is the loop-safe primitive behind the board's "סמן כהושלם / בטל" actions.
+
+    Only the two **terminal** statuses are accepted (``CLOSED_ISSUE_STATUSES``) —
+    this tidies the board, it does not drive the workflow (agents own the
+    todo/in_progress/in_review transitions). Direct-DB in one transaction,
+    mirroring :func:`escalate_issue`: bypasses Paperclip's disposition resolver
+    (whose multi-PATCH/``issue.released`` behaviour *causes* the recovery loops),
+    sets the matching close timestamp, clears any agent assignee so no recovery
+    sweep re-acts on it, and records an ``author_type='system'`` audit note (inert
+    w.r.t. the user-comment routing sweep, so it will not wake an agent). No wakeup.
+    """
+    if status not in CLOSED_ISSUE_STATUSES:
+        return {
+            "ok": False,
+            "error": f"invalid status {status!r}; expected one of {tuple(CLOSED_ISSUE_STATUSES)}",
+        }
+
+    # status is validated against the frozenset above, so the interpolated column
+    # name is one of exactly two literals — no injection surface.
+    ts_col = "completed_at" if status == "done" else "cancelled_at"
+    note = (
+        "✓ סומן ידנית כהושלם ע\"י היו\"ר"
+        if status == "done"
+        else "✕ בוטל ידנית ע\"י היו\"ר"
+    )
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        async with conn.transaction():
+            row = await conn.fetchrow(
+                f"""UPDATE issues
+                       SET status=$1, {ts_col}=now(),
+                           assignee_agent_id=null, updated_at=now()
+                     WHERE id=$2::uuid
+                 RETURNING id, identifier, company_id""",
+                status, issue_id,
+            )
+            if not row:
+                return {"ok": False, "error": f"issue {issue_id} not found"}
+            cid = company_id or str(row["company_id"])
+            await conn.execute(
+                """INSERT INTO issue_comments (id, company_id, issue_id, body, author_type)
+                   VALUES ($1::uuid, $2::uuid, $3::uuid, $4, 'system')""",
+                str(uuid.uuid4()), cid, issue_id, note,
+            )
+    finally:
+        await conn.close()
+
+    logger.info("Chair set issue %s → %s", issue_id, status)
+    return {
+        "ok": True,
+        "id": str(row["id"]),
+        "identifier": row["identifier"],
+        "status": status,
+    }
+
+
 async def respond_to_interaction(
     issue_id: str, interaction_id: str, payload: dict,
 ) -> dict: