feat(halacha): drain לילי (23:00–05:00) + per-upload חילוץ תיק-בודד דרך ה-CEO (#120)

מפריד בין ריקון-באקלוג המוני לבין חילוץ per-upload, ומסיר את ה"פקק" שגרם
timeout/process_lost ב-heartbeat של ה-CEO.

הבעיה (אבחנה 2026-06-11): לחיצת "חלץ הלכות" על תיק בודד יצרה issue (CMP-165)
שהורה ל-CEO להריץ precedent_process_pending(halacha) — בולען סינכרוני שמרוקן את
כל התור ההיסטורי (147 ממתינים, שעות) בתוך heartbeat שחסום לשעה. תוצאה: timeout
כל שעה → process_lost בפירוק קבוצת-התהליכים → retry → סטורם, והתיק הבודד (FIFO
אחרון) לא טופל. לא OOM, לא קוד שבור — אי-התאמה ארכיטקטונית.

התיקון:
1. per-upload (web/paperclip_client.py, wake_for_precedent_extraction): גוף ה-issue
   + תיאור-הפרויקט מורים כעת להריץ precedent_extract_metadata +
   precedent_extract_halachot ל-case_law_id של ה-issue **בלבד** — עם אזהרה
   מפורשת לא להריץ process_pending. reextract_halachot כבר מנקה requested_at
   ומסמן completed → התיק לא יחזור לתור הלילי.
2. הוראות ה-CEO (.claude/agents/legal-ceo.md): אותו שינוי — חילוץ תיק-בודד, לא
   ריקון-תור. (צריך sync_agents_across_companies.py --apply אחרי מיזוג.)
3. ריקון-באקלוג (scripts/drain_halacha_queue.py): שער חלון-לילה 23:00–05:00 שעון
   ישראל (zoneinfo, DST-safe — המכונה UTC). מחוץ לחלון ===SKIP===; נעצר ===STOP===
   כשהחלון נסגר, השאר ממשיך בלילה הבא (FIFO + per-chunk checkpoint). env:
   HALACHA_DRAIN_WINDOW_START/_END/_TZ.
4. cron (scripts/legal-halacha-drain.config.cjs): UTC band 20:00–03:00 שמכסה את
   חלון-ישראל בשני מצבי-DST; הסקריפט גוזם לחלון המדויק. ירייה שעתית מחדשת
   one-shot שמת (advisory-lock → חפיפה בטוחה).

רשת-ביטחון: request_halacha_extraction עדיין מסמן requested_at, כך שאם wakeup
ל-CEO נכשל — הדריינר הלילי יתפוס את התיק (בלילה, חסום), אך שום נתיב יומי לא
מרוקן את כל התור.

Invariants: מקיים G12/INV-PORT1 (paperclip_client = shell; leak_guard עובר).
נוגע X16 (durability — מתקציב-זמן heartbeat ל-job ייעודי).

בדיקות: py_compile ✓ · window-logic + zoneinfo ✓ (17:00 IDT→False) · leak_guard ✓.

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

scripts/SCRIPTS.md

@@ -101,8 +101,8 @@
 | `run_curator_deepseek_test_v2.sh` | A/B test #2 (2026-05-05) — אותו run אבל עם interaction. תוצאה: 9:08 דק׳, 5 ממצאים, היחיד מ-4 הריצות שזיהה תוצאה עובדתית נכונה (קבלה חלקית). interaction נכשל ב-API ("Agent run id required" בריצה ידנית). | החלפת Curator לאדפטר DeepSeek מקומי |
 | `run_curator_sonnet_rerun.sh` | A/B test #3 (2026-05-05) — ריצה חוזרת של Sonnet 4.5 על אותו CMP-78. תוצאה: 12:52 דק׳ (לעומת 20:13 בריצה המקורית — כי בלי לולאת interaction.json). זיהה תוצאה שגויה ("דחייה") **בעקביות עם הריצה המקורית** — Sonnet עקבי-בטעות, DeepSeek אקראי. | בדיקה חד-פעמית — לא להריץ שוב |
 | `ingest_incoming_batch.py` | python | קליטת batch של החלטות ועדת ערר מ-`data/precedents/incoming/` דרך המסלול הקנוני (`ingest_internal_decision`) + חילוץ מטא-דאטה לכל תיק (המסלול הפנימי לא מתזמן metadata — INV-ING3). רצף (לא מקבילי, להימנע מעומס CLI). רשימת `DECISIONS` נערכת ידנית לכל batch. config מ-`~/.env`. תומך תהליך [[project_precedent_incoming_workflow]]. | ידני, per-batch (חלופה ל-MCP `internal_decision_upload` כש-batch גדול) |
-| `drain_halacha_queue.py` | python | ריקון תור חילוץ ההלכות (`process_pending_extractions kind='halacha'`) ב-batches של 4 עד שהתור ריק (2 סבבים ריקים). חילוץ-הלכות נשאר על claude_session (לא Gemini). self-heal ל-orphaned `processing`. ההלכות נוחתות `pending_review` (שער-יו"ר). | דרך `legal-halacha-drain.config.cjs` (pm2 cron) / ידני |
-| `legal-halacha-drain.config.cjs` | pm2/js | **תזמון כל שעתיים של `drain_halacha_queue.py`** (cron `47 */2 * * *`, `HALACHA_DRAIN_CRON` לעקיפה) — מונע סתימה של תור חילוץ-ההלכות. קצב שמרני (Claude איטי + כל ריצה מוסיפה לתור-אישור-היו"ר). דורש claude CLI. התקנה: `pm2 start scripts/legal-halacha-drain.config.cjs && pm2 save`. | pm2 cron (host-side) |
+| `drain_halacha_queue.py` | python | ריקון תור חילוץ ההלכות (`process_pending_extractions kind='halacha'`) ב-batches של 4 עד שהתור ריק (2 סבבים ריקים). **רץ רק בחלון-לילה 23:00–05:00 שעון ישראל** (`_in_window`, zoneinfo DST-safe — המכונה UTC); מחוץ לחלון `===SKIP===`, ונעצר `===STOP===` כשהחלון נסגר (השאר ממשיך בלילה הבא, FIFO+checkpoint). env: `HALACHA_DRAIN_WINDOW_START`/`_END`/`HALACHA_DRAIN_TZ`. חילוץ-הלכות נשאר על claude_session (לא Gemini). self-heal ל-orphaned `processing`. ההלכות נוחתות `pending_review` (שער-יו"ר). **חילוץ תיק-בודד שהיו"ר מבקש רץ מיד דרך ה-CEO (`precedent_extract_halachot`) ואינו מגודר כאן.** | דרך `legal-halacha-drain.config.cjs` (pm2 cron) / ידני |
+| `legal-halacha-drain.config.cjs` | pm2/js | **תזמון חלון-לילה של `drain_halacha_queue.py`** (cron UTC `0 20,21,22,23,0,1,2,3 * * *` = superset שמכסה את 23:00–05:00 ישראל בקיץ ובחורף; הסקריפט גוזם לחלון המדויק ב-zoneinfo). `HALACHA_DRAIN_CRON` לעקיפה. ירייה כל שעה גם מחדשת one-shot שמת באמצע (advisory-lock הופך חפיפה לבטוחה). דורש claude CLI. התקנה: `pm2 start scripts/legal-halacha-drain.config.cjs && pm2 save`. | pm2 cron (host-side) |
 | `ingest_digests_batch.py` | python | קליטת batch של יומוני "כל יום" מ-`data/digests/incoming/` דרך המסלול העצמאי של קורפוס-הגילוי (`digest_library.ingest_digest`) — חילוץ-LLM (תג-מושג, כותרת-הלכה, מראה-מקום, שני-תאריכים), embedding יחיד, ו-autolink לפסק המקורי (X12/INV-DIG3). רצף (לא מקבילי). מזהה-יומון+תאריך נגזרים משם-הקובץ; העלון החודשי מדולג. **לא מעביר קבצים** — ה-DB (content_hash) הוא מקור-האמת היחיד; הרצה חוזרת מדלגת על קיימים (`exists`). config מ-`~/.env`. | ידני, per-batch (חלופה ל-MCP `digest_upload`) |
 | `drain_digests.py` | python | ריקון תור ההעשרה של יומונים (X12): מעבד כל digest בסטטוס `pending` דרך `digest_library.enrich_digest` (חילוץ-LLM Sonnet + embedding + autolink). מקבילי (CONCURRENCY=3, env-tunable), idempotent. מוסיף `~/.local/bin` ל-PATH כדי שה-claude CLI יימצא תחת cron. בודק דגל `drain_controls('legal-digest-drain')` ב-startup → no-op כשכבוי מ-/operations. | דרך `legal-digest-drain.config.cjs` (pm2 cron) + ידני אחרי backfill. חלופת-MCP: `digest_process_pending` |
 | `legal-digest-drain.config.cjs` | pm2/js | **תזמון כל שעתיים של `drain_digests.py`** (cron `0 */2 * * *`, `DIGEST_DRAIN_CRON` לעקיפה) — הועבר מ-crontab של המערכת ל-pm2 כדי שיופיע ויהיה שליט בדף `/operations` (הרץ-עכשיו/הפעל/כבה). `autorestart:false` (one-shot per tick). דורש claude CLI + `VOYAGE_API_KEY`. התקנה: `pm2 start scripts/legal-digest-drain.config.cjs && pm2 save`. | pm2 cron (host-side) |

scripts/drain_halacha_queue.py

@@ -4,18 +4,48 @@ Calls the canonical process_pending_extractions(kind='halacha') in small batches
 until the queue is empty (two consecutive zero-progress rounds). Serial + global
 advisory-lock coordinated inside the service — avoids concurrent Claude load spikes.
 
+NIGHT-WINDOW: halacha extraction is slow (Opus, ~10 min/case) and token-heavy, so
+the backlog drain runs ONLY in an off-hours window (default 23:00–05:00 Israel
+time) — it never competes with daytime interactive work or other agents. A tick
+that starts at 23:00 keeps going until the queue empties OR the window closes
+(checked before every round); whatever's left resumes the next night (FIFO +
+per-chunk checkpoint → no lost or duplicated work). Single-case extraction
+requested by the chair goes through the CEO immediately and is NOT gated here.
+Window is DST-safe (zoneinfo) — the host runs in UTC. Env overrides:
+HALACHA_DRAIN_WINDOW_START / _END (hours, 0–23) · HALACHA_DRAIN_TZ.
+
 Run:  mcp-server/.venv/bin/python scripts/drain_halacha_queue.py
 """
 
 import asyncio
 import os
 import sys
+from datetime import datetime
+from zoneinfo import ZoneInfo
 
 sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..", "mcp-server", "src"))
 
 from legal_mcp.services import db
 from legal_mcp.services import precedent_library as pl
 
+_TZ = ZoneInfo(os.environ.get("HALACHA_DRAIN_TZ", "Asia/Jerusalem"))
+_WINDOW_START = int(os.environ.get("HALACHA_DRAIN_WINDOW_START", "23"))
+_WINDOW_END = int(os.environ.get("HALACHA_DRAIN_WINDOW_END", "5"))
+
+
+def _in_window() -> bool:
+    """True iff the current Israel-time hour is inside [START, END).
+
+    Handles the midnight wrap (e.g. 23→5): the window is the union of
+    [START,24) and [0,END). If START == END the window is treated as 'always'.
+    """
+    if _WINDOW_START == _WINDOW_END:
+        return True
+    hour = datetime.now(_TZ).hour
+    if _WINDOW_START < _WINDOW_END:  # same-day window, e.g. 1→5
+        return _WINDOW_START <= hour < _WINDOW_END
+    return hour >= _WINDOW_START or hour < _WINDOW_END  # wraps midnight, e.g. 23→5
+
 
 async def main():
     # /operations "disable" switch — no-op immediately if turned off (pm2
@@ -23,10 +53,19 @@ async def main():
     if await db.is_drain_disabled("legal-halacha-drain"):
         print("===SKIP=== legal-halacha-drain disabled via /operations", flush=True)
         return
+    if not _in_window():
+        now = datetime.now(_TZ).strftime("%H:%M %Z")
+        print(f"===SKIP=== outside drain window {_WINDOW_START:02d}:00–"
+              f"{_WINDOW_END:02d}:00 (now {now})", flush=True)
+        return
     total = 0
     empty_rounds = 0
     rnd = 0
     while empty_rounds < 2:
+        if not _in_window():
+            print(f"===STOP=== drain window closed ({_WINDOW_END:02d}:00) — "
+                  f"{total} cases this run; rest resumes next night", flush=True)
+            break
         rnd += 1
         out = await pl.process_pending_extractions(kind="halacha", limit=4)
         processed = out.get("processed", 0)

scripts/legal-halacha-drain.config.cjs

@@ -10,18 +10,33 @@
  *
  * Pattern: cron_restart fires the script; autorestart:false → one-shot per tick
  * (pm2 shows "stopped" between ticks). Cheap no-op when the queue is empty.
- * Cadence is conservative (every 2h) because Claude extraction is slow/rate-
- * limited and each run adds to the chair's review queue.
+ *
+ * NIGHT-WINDOW (23:00–05:00 Israel time): backlog extraction is slow (Opus) and
+ * token-heavy, so it runs only off-hours — never competing with daytime
+ * interactive work / other agents (avoids the heartbeat timeout+process_lost
+ * storm we hit when the CEO drained the whole queue mid-day). Single-case
+ * extraction requested by the chair still runs immediately via the CEO; only
+ * the bulk backlog is gated to the night.
+ *
+ * TIMEZONE: pm2's daemon runs in the host TZ (UTC here), so cron strings are
+ * UTC. We fire across a UTC *superset* band (20:00–03:00 UTC) that covers the
+ * Israel window in BOTH DST states (UTC+3 summer / UTC+2 winter); the script's
+ * zoneinfo('Asia/Jerusalem') window-guard then trims to exactly 23:00–05:00
+ * and no-ops on the margin ticks. Firing each hour also re-arms the one-shot if
+ * a tick died mid-drain — the global advisory lock makes overlap safe.
  *
  * Requires the local ``claude`` CLI + host ~/.env (POSTGRES_URL, etc.).
  *
  * Install (once):
  *     pm2 start /home/chaim/legal-ai/scripts/legal-halacha-drain.config.cjs
  *     pm2 save
- * Run now (manual): mcp-server/.venv/bin/python scripts/drain_halacha_queue.py
- * Schedule override: HALACHA_DRAIN_CRON (default every 2 hours at :47).
+ * Run now (manual, ignores window only if env-overridden):
+ *     mcp-server/.venv/bin/python scripts/drain_halacha_queue.py
+ * Overrides: HALACHA_DRAIN_CRON (UTC cron) · HALACHA_DRAIN_WINDOW_START/_END
+ * (Israel hours, default 23/5) · HALACHA_DRAIN_TZ.
  */
-const cron = process.env.HALACHA_DRAIN_CRON || "47 */2 * * *";
+// UTC band covering Israel 23:00–05:00 across DST; script trims to exact window.
+const cron = process.env.HALACHA_DRAIN_CRON || "0 20,21,22,23,0,1,2,3 * * *";
 
 module.exports = {
   apps: [