Merge pull request 'fix(routing): הוראת-יו"ר תעבוד בדרך הטבעית — הערה פותחת הרצת-CEO' (#415 ) from worktree-natural-comment-routing into main

fix(routing): הוראת-יו"ר תעבוד בדרך הטבעית — הערה פותחת הרצת-CEO
**התסמין:** היו"ר כותב הוראה על תיק והסוכן "מתעלם". ההרצה מדווחת succeeded/exit 0 ואפילו עולה כסף — ולכן זה שרד חודשים בלי שמישהו שם לב. **שתי סיבות-שורש בלתי-תלויות, שתיהן מאומתות:** 1. ה-wakeup הישיר על ה-issue של התיק מבוטל תמיד: תיק שממתין ליו"ר הוא `in_review` ומשויך *לאדם*, ו-Paperclip עונה `issue_assignee_changed` → "אעיר את הבעלים החדש" → הבעלים אדם → אף סוכן לא מתעורר. 2. רשת-הביטחון בפלאגין מוסרת את ההוראה כ-`payload.prompt`, וה-runner קורא רק `payload.issueId` — הפרומפט נבלע. 18/18 מדידה ב-DB: 0% מסירה, אי-פעם. **התיקון:** המסלול הטבעי (הערה בטאב-הסוכנים) מפרסם את ההערה בשרשור כרגיל **וגם** פותח הרצת-CEO עם ההוראה, דרך `pc_open_ceo_run` — הפרימיטיב היחיד שאומת כמגיע לסוכן (הוכח היום על 1043-02-26: 3,212→7,697 מילים). אותו תיקון ל-interaction-response, שסובל מאותה תקלה (החצי השני של #228). **G2 — הסרת מסלול מקביל:** ה-wakeup הנדון-לביטול הוסר מ-`post_comment`; הוא היה המסלול השני, זה ששותק. כעת מסלול-מסירה קנוני אחד. `mark_comment_routed` מסמן את ההערה כמנותבת כדי שה-sweep לא יירה הרצת-סרק על מה שכבר טופל. **G12 — שער-הפלטפורמה:** המגע החדש (`mark_comment_routed`) נחשף דרך `agent_platform_port.py` בלבד; leak-guard עובר. התיקון יושב ב-backend (REST) ולא בפלאגין, ולכן אינו חשוף לבאג ה-invocation-scope שמפיל את ה-sweep. תועד ב-docs/paperclip-quirks.md §7 עם המלכודות שנתקלנו בהן. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-16 12:33:29 +00:00 · 2026-07-16 12:32:20 +00:00 · 2026-07-07 17:31:17 +00:00 · 2026-07-07 17:30:42 +00:00 · 2026-07-07 15:49:28 +00:00 · 2026-07-07 15:48:26 +00:00
19 changed files with 2728 additions and 158 deletions
--- a/.claude/agents/HEARTBEAT.md
+++ b/.claude/agents/HEARTBEAT.md
@@ -101,6 +101,8 @@ ATTACHMENTS=$(echo "$CONTEXT" | jq '.attachments')
 ```
 **אסור** לפענח טקסט מ-comment חופשי כשיש APPROVAL_ID — זה הקלט הסטרוקטורלי.

+**1.5ד. המשך-עבודה על תיק — קרא predecessor תחילה (seance, #220).** אם אתה מתעורר-מחדש על תיק שכבר עבדת עליו (continuation — issue פתוח עם היסטוריית-ריצות), **לפני** שתגלה-מחדש את ההקשר מאפס, קרא את הכלי `legal_predecessor_context(case_number=<מספר-התיק>)`. הוא מחזיר את מסקנות הריצות-הקודמות על התיק (ה-`summary` שכל heartbeat השאיר, newest-first) — כך תמשיך מנקודת-העצירה במקום לחזור על עבודה שכבר בוצעה (מונע את ה-*blind heartbeat*). אם אין ריצות-קודמות עם מסקנות — המשך רגיל.
+
 ---

 ## §2. קבצים מצורפים — דרך `heartbeat-context`, **לא psql**
--- a/docs/paperclip-quirks.md
+++ b/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.
--- a/web-ui/src/app/cases/[caseNumber]/page.tsx
+++ b/web-ui/src/app/cases/[caseNumber]/page.tsx
@@ -14,6 +14,7 @@ import { CaseHeader } from "@/components/cases/case-header";
 import { CaseEditDialog } from "@/components/cases/case-edit-dialog";
 import { DocumentsPanel } from "@/components/cases/documents-panel";
 import { DraftsPanel } from "@/components/cases/drafts-panel";
+import { CaseFilesBrowser } from "@/components/cases/case-files-browser";
 import { DecisionBlocksPanel } from "@/components/cases/decision-blocks-panel";
 import { LegalArgumentsPanel } from "@/components/cases/legal-arguments-panel";
 import { PositionsPanel } from "@/components/cases/positions-panel";
@@ -243,12 +244,17 @@ export default function CaseDetailPage({
            </Card>
          </TabsContent>

-          <TabsContent value="drafts" className="mt-0">
+          <TabsContent value="drafts" className="mt-0 space-y-4">
            <Card className="bg-surface border-rule shadow-sm">
              <CardContent className="px-6 py-5">
                <DraftsPanel caseNumber={caseNumber} status={data?.status} />
              </CardContent>
            </Card>
+            <Card className="bg-surface border-rule shadow-sm">
+              <CardContent className="px-6 py-5">
+                <CaseFilesBrowser caseNumber={caseNumber} />
+              </CardContent>
+            </Card>
          </TabsContent>

          <TabsContent value="agents" className="mt-0">
--- a/web-ui/src/app/operations/page.tsx
+++ b/web-ui/src/app/operations/page.tsx
@@ -29,12 +29,15 @@ import {
  useRunLog,
  useCancelRun,
  useResetAgentSession,
+  useAgentHealth,
+  useRecentEscalations,
  type OpsService,
  type OperationsSnapshot,
  type PipelineStats,
  type AgentRun,
  type SubscriptionUsage,
  type UsageWindow,
+  type AgentHealthState,
 } from "@/lib/api/operations";
 import { formatTime, israelParts } from "@/lib/format-date";

@@ -802,6 +805,154 @@ function LiveAgentsPanel() {
  );
 }

+// ── Agent health taxonomy (#222) + recent escalations (#218) ───────────────
+const HEALTH_LABEL: Record<AgentHealthState, string> = {
+  zombie: "זומבי",
+  stalled: "תקוע",
+  working: "עובד",
+  idle: "רגוע",
+};
+
+function AgentHealthPanel() {
+  const { data, isLoading } = useAgentHealth();
+  const { data: esc } = useRecentEscalations();
+
+  const counts = data?.counts;
+  // Only zombies/stalled are "problems" — the backend already sorts worst-first.
+  // An escalated issue is chair-owned, so it leaves this list; the escalations
+  // card below is the handled-loop history.
+  const problems = (data?.items ?? []).filter(
+    (i) => i.health === "zombie" || i.health === "stalled",
+  );
+  const healthyWorking = counts?.working ?? 0;
+  const healthyIdle = counts?.idle ?? 0;
+
+  return (
+    <div className="space-y-4">
+      <Card className="bg-surface border-rule shadow-sm">
+        <CardContent className="px-6 py-5">
+          {isLoading || !data ? (
+            <Skeleton className="h-24 w-full" />
+          ) : (
+            <>
+              <div className="flex flex-wrap gap-2 mb-4">
+                <StatTile
+                  label="זומבי"
+                  value={counts?.zombie ?? 0}
+                  tone="red"
+                  title="לולאת-recovery — משויך+פעיל-כביכול אך אין ריצה חיה. מוסלם אוטומטית."
+                />
+                <StatTile
+                  label="תקוע"
+                  value={counts?.stalled ?? 0}
+                  tone="amber"
+                  title="ננער חוזר בלי התקדמות"
+                />
+                <StatTile label="עובד" value={counts?.working ?? 0} tone="green" />
+                <StatTile label="רגוע" value={counts?.idle ?? 0} tone="muted" />
+              </div>
+
+              {problems.length === 0 ? (
+                <p className="text-sm text-emerald-600">
+                  אין סוכן תקוע כרגע — כל הסוכנים תקינים.
+                </p>
+              ) : (
+                <div className="grid gap-2">
+                  {problems.map((p) => (
+                    <div
+                      key={p.issue_id}
+                      className={
+                        p.health === "zombie"
+                          ? "flex items-center justify-between gap-3 rounded-md border border-destructive/30 bg-destructive/5 px-3 py-2"
+                          : "flex items-center justify-between gap-3 rounded-md border border-gold/40 bg-gold-wash px-3 py-2"
+                      }
+                    >
+                      <div className="flex items-center gap-2 flex-wrap min-w-0">
+                        <Badge
+                          variant={p.health === "zombie" ? "destructive" : "outline"}
+                          className={
+                            p.health === "stalled"
+                              ? "border-warn/50 text-warn font-normal"
+                              : "font-normal"
+                          }
+                        >
+                          {HEALTH_LABEL[p.health]}
+                        </Badge>
+                        <span dir="ltr" className="font-mono text-[0.82rem] text-navy font-semibold">
+                          {p.identifier}
+                        </span>
+                        <span className="text-[0.82rem] text-navy font-semibold">
+                          {p.agent_name}
+                        </span>
+                        <span className="text-[0.7rem] text-ink-muted">
+                          {p.recovery_wakeups > 0
+                            ? `${p.recovery_wakeups} יקיצות-שחזור`
+                            : `${p.wakeups} יקיצות`}
+                        </span>
+                      </div>
+                      <span className="text-[0.7rem] text-ink-muted shrink-0">
+                        {p.health === "zombie" ? "יוסלם אוטומטית" : "מנוטר"}
+                      </span>
+                    </div>
+                  ))}
+                </div>
+              )}
+
+              <p className="mt-3 text-[0.78rem] text-ink-muted">
+                <b className="text-navy">{healthyWorking + healthyIdle} סוכנים תקינים</b> —{" "}
+                {healthyWorking} עובדים, {healthyIdle} רגועים. מוצגות רק בעיות.
+              </p>
+            </>
+          )}
+        </CardContent>
+      </Card>
+
+      {/* handled-loop history — the watchdog's escalations, gold-wash like a gate */}
+      <Card className="bg-gold-wash border-gold/40 shadow-sm">
+        <CardContent className="px-5 py-4">
+          <h3 className="text-navy text-sm font-semibold mb-0.5">הסלמות אוטומטיות אחרונות</h3>
+          <p className="text-ink-muted text-[0.72rem] mb-3">
+            כל זומבי מתמשך (לולאת-recovery ≥2 יקיצות-שחזור) משויך אליך אוטומטית עם הערת-מערכת
+            — בלי להעיר סוכן מחדש.
+          </p>
+          {!esc?.items?.length ? (
+            <p className="text-sm text-ink-muted">אין הסלמות אחרונות.</p>
+          ) : (
+            <div className="grid gap-1">
+              {esc.items.map((e) => (
+                <div
+                  key={`${e.issue_id}-${e.created_at ?? ""}`}
+                  className="flex items-start gap-2.5 border-t border-gold/15 first:border-0 pt-2 first:pt-0"
+                >
+                  <Badge
+                    variant={e.severity === "medium" ? "outline" : "destructive"}
+                    className={
+                      e.severity === "medium"
+                        ? "border-gold/50 text-gold-deep font-normal shrink-0"
+                        : "font-normal shrink-0"
+                    }
+                  >
+                    {e.severity}
+                  </Badge>
+                  <div className="min-w-0 flex-1">
+                    <span dir="ltr" className="font-mono text-[0.8rem] text-navy font-semibold">
+                      {e.identifier}
+                    </span>
+                    <div className="text-[0.78rem] text-ink-soft">{e.reason}</div>
+                  </div>
+                  <span className="text-[0.68rem] text-ink-muted shrink-0">
+                    {e.created_at ? ago(Date.parse(e.created_at)) : ""}
+                  </span>
+                </div>
+              ))}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
 export default function OperationsPage() {
  const { data, isLoading, error } = useOperations();

@@ -840,6 +991,9 @@ export default function OperationsPage() {
            <SectionHeader>סוכנים פעילים</SectionHeader>
            <LiveAgentsPanel />

+            <SectionHeader>בריאות-הסוכנים</SectionHeader>
+            <AgentHealthPanel />
+
            <SectionHeader>מתאמי-סוכנים</SectionHeader>
            <AgentAdaptersPanel />

--- a/web-ui/src/components/cases/agent-activity-feed.tsx
+++ b/web-ui/src/components/cases/agent-activity-feed.tsx
@@ -1,6 +1,6 @@
 "use client";

-import { useRef, useState, useEffect, useMemo } from "react";
+import { useState, useMemo } from "react";
 import { Button } from "@/components/ui/button";
 import { Textarea } from "@/components/ui/textarea";
 import { Badge } from "@/components/ui/badge";
@@ -34,6 +34,9 @@ import {
  HelpCircle,
  ChevronDown,
  Ban,
+  Target,
+  Plus,
+  AlertTriangle,
 } from "lucide-react";

 /* ── Role → color mapping ────────────────────────────────────── */
@@ -818,6 +821,312 @@ function IssueGroup({
  );
 }

+/* ── Compose: directive box + target selector (top of tab) ────── */
+
+const isOpenStatus = (s: string) => s !== "done" && s !== "cancelled";
+
+/** Client mirror of the server's pick_default_comment_target
+ * (web/paperclip_client.py): prefer the newest OPEN top-level issue (the live
+ * CEO main issue), then any open issue, then any top-level, else newest.
+ * `issues` arrives oldest→newest, so the last match is the newest. */
+function pickDefaultTarget(issues: PaperclipIssue[]): PaperclipIssue | null {
+  if (!issues.length) return null;
+  const isTop = (i: PaperclipIssue) => i.parent_id == null;
+  const preds: ((i: PaperclipIssue) => boolean)[] = [
+    (i) => isOpenStatus(i.status) && isTop(i),
+    (i) => isOpenStatus(i.status),
+    isTop,
+  ];
+  for (const p of preds) {
+    const m = issues.filter(p);
+    if (m.length) return m[m.length - 1];
+  }
+  return issues[issues.length - 1];
+}
+
+const STATUS_TONE: Record<string, string> = {
+  in_progress: "bg-emerald-100 text-emerald-700",
+  in_review: "bg-amber-100 text-amber-700",
+  todo: "bg-emerald-100 text-emerald-700",
+  backlog: "bg-emerald-100 text-emerald-700",
+  blocked: "bg-red-100 text-red-700",
+  done: "bg-gray-100 text-gray-500",
+  cancelled: "bg-red-50 text-red-600",
+};
+function statusTone(s: string) {
+  return STATUS_TONE[s] ?? "bg-gray-100 text-gray-600";
+}
+
+/** Where a chair instruction is routed. `auto` lets the server pick the live
+ * CEO main issue; `issue` targets an explicit one; `new_run` opens a fresh
+ * CEO-owned run (bypasses the human-owned-issue cancellation). */
+type Target =
+  | { kind: "auto" }
+  | { kind: "issue"; id: string }
+  | { kind: "new_run" };
+
+function TargetSelector({
+  issues,
+  target,
+  onChange,
+}: {
+  issues: PaperclipIssue[];
+  target: Target;
+  onChange: (t: Target) => void;
+}) {
+  const [open, setOpen] = useState(false);
+  const defaultIssue = useMemo(() => pickDefaultTarget(issues), [issues]);
+  const activeIssues = issues.filter((i) => isOpenStatus(i.status));
+  const closedIssues = issues.filter((i) => !isOpenStatus(i.status));
+
+  // The issue the pill currently represents (explicit pick, or the auto default).
+  const effectiveIssue =
+    target.kind === "issue"
+      ? issues.find((i) => i.id === target.id) ?? null
+      : target.kind === "auto"
+        ? defaultIssue
+        : null;
+
+  return (
+    <div className="relative min-w-0">
+      <button
+        type="button"
+        onClick={() => setOpen((o) => !o)}
+        aria-expanded={open}
+        className="flex items-center gap-2 bg-sand-soft/60 border border-rule rounded-lg px-2.5 py-1.5 hover:border-gold/60 min-w-0 max-w-full"
+      >
+        <Target className="w-3.5 h-3.5 text-gold-deep shrink-0" />
+        {target.kind === "new_run" ? (
+          <span className="text-xs font-semibold text-navy">פתח הרצה חדשה</span>
+        ) : effectiveIssue ? (
+          <>
+            <Badge variant="outline" className="text-[10px] font-mono shrink-0">
+              {effectiveIssue.identifier}
+            </Badge>
+            <span className="text-xs font-medium text-navy truncate">
+              {shortIssueTitle(effectiveIssue.title)}
+            </span>
+            <span
+              className={`text-[10px] font-semibold rounded-full px-2 py-0.5 shrink-0 ${statusTone(effectiveIssue.status)}`}
+            >
+              {issueStatusLabel(effectiveIssue.status)}
+            </span>
+          </>
+        ) : (
+          <span className="text-xs text-ink-muted">בחר יעד</span>
+        )}
+        <ChevronDown className="w-3.5 h-3.5 text-ink-faint shrink-0 ms-1" />
+      </button>
+
+      {open && (
+        <>
+          <div
+            className="fixed inset-0 z-10"
+            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="px-2 py-1 text-[10px] font-bold text-ink-faint uppercase tracking-wide">
+              משימות פעילות
+            </div>
+            {activeIssues.map((i) => {
+              const selected =
+                (target.kind === "issue" && target.id === i.id) ||
+                (target.kind === "auto" && defaultIssue?.id === i.id);
+              return (
+                <button
+                  key={i.id}
+                  type="button"
+                  onClick={() => {
+                    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" : ""}`}
+                >
+                  <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>
+                  <span className="text-xs text-ink-soft 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>
+                  {selected && (
+                    <CheckCircle2 className="w-3.5 h-3.5 text-gold-deep shrink-0" />
+                  )}
+                </button>
+              );
+            })}
+
+            {closedIssues.length > 0 && (
+              <>
+                <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>
+                {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)}`}
+                    >
+                      {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>
+        </>
+      )}
+    </div>
+  );
+}
+
+function Composer({
+  caseNumber,
+  issues,
+}: {
+  caseNumber: string;
+  issues: PaperclipIssue[];
+}) {
+  const sendComment = useSendComment(caseNumber);
+  const [body, setBody] = useState("");
+  const [target, setTarget] = useState<Target>({ kind: "auto" });
+
+  const selectedIssue =
+    target.kind === "issue" ? issues.find((i) => i.id === target.id) ?? null : null;
+  const closedTarget = !!selectedIssue && !isOpenStatus(selectedIssue.status);
+
+  const handleSend = () => {
+    if (!body.trim() || closedTarget) return;
+    const vars =
+      target.kind === "new_run"
+        ? { body: body.trim(), new_run: true }
+        : target.kind === "issue"
+          ? { body: body.trim(), issue_id: target.id }
+          : { body: body.trim() };
+    sendComment.mutate(vars, {
+      onSuccess: (res) => {
+        setBody("");
+        setTarget({ kind: "auto" });
+        toast.success(
+          res.new_run
+            ? `נפתחה הרצה חדשה — ${res.issue_identifier}`
+            : `נשלח ל-${res.issue_identifier}`,
+        );
+      },
+      onError: () => toast.error("שגיאה בשליחת ההודעה"),
+    });
+  };
+
+  return (
+    <div className="bg-white border border-rule rounded-xl shadow-sm p-3.5">
+      <div className="flex items-center gap-2 mb-2.5">
+        <MessageSquare className="w-4 h-4 text-gold-deep" />
+        <h3 className="text-sm font-bold text-navy">הוראה לסוכנים</h3>
+        <span className="text-[11px] text-ink-faint ms-auto">
+          Ctrl+Enter לשליחה
+        </span>
+      </div>
+
+      <div className="flex items-center gap-2 mb-2 flex-wrap">
+        <span className="text-[11px] font-semibold text-ink-muted shrink-0">
+          שליחה אל:
+        </span>
+        <TargetSelector issues={issues} target={target} onChange={setTarget} />
+      </div>
+
+      {closedTarget && (
+        <div className="flex items-start gap-2 bg-red-50 border border-red-200 rounded-lg px-3 py-2 mb-2 text-[11.5px] text-red-700 leading-snug">
+          <AlertTriangle className="w-4 h-4 shrink-0 mt-0.5" />
+          <div>
+            <b className="font-bold">יעד סגור.</b> שליחה למשימה סגורה לא תעיר סוכן —
+            ההוראה לא תטופל. בחר משימה פעילה או{" "}
+            <button
+              type="button"
+              className="font-bold underline"
+              onClick={() => setTarget({ kind: "new_run" })}
+            >
+              פתח הרצה חדשה
+            </button>
+            .
+          </div>
+        </div>
+      )}
+
+      <Textarea
+        value={body}
+        onChange={(e) => setBody(e.target.value)}
+        placeholder="כתוב הוראה לסוכנים..."
+        aria-label="הוראה לסוכנים"
+        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 mt-2">
+        <span className="text-[11px] text-ink-faint">
+          ההודעה תנותב דרך סוכן ה-CEO · היעד ניתן לשינוי למעלה
+        </span>
+        <Button
+          size="sm"
+          className="ms-auto"
+          onClick={handleSend}
+          disabled={!body.trim() || closedTarget || sendComment.isPending}
+        >
+          {sendComment.isPending ? (
+            <Loader2 className="w-4 h-4 animate-spin" />
+          ) : (
+            <Send className="w-4 h-4 me-1" />
+          )}
+          שלח
+        </Button>
+      </div>
+    </div>
+  );
+}
+
 /* ── Main Feed ───────────────────────────────────────────────── */

 export function AgentActivityFeed({
@@ -826,9 +1135,6 @@ export function AgentActivityFeed({
  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 (memoized — the feed refetches every 10s,
  // and a fresh Map each render would defeat the child cards' memoization).
@@ -838,27 +1144,6 @@ export function AgentActivityFeed({
    return m;
  }, [data?.issues]);

-  // Auto-scroll on new comments or interactions
-  const commentCount = data?.comments?.length ?? 0;
-  const interactionCount = data?.interactions?.length ?? 0;
-  useEffect(() => {
-    endRef.current?.scrollIntoView({ behavior: "smooth" });
-  }, [commentCount, interactionCount]);
-
-  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) {
@@ -939,14 +1224,18 @@ export function AgentActivityFeed({
  );

  return (
-    <div className="flex flex-col h-full">
+    <div className="flex flex-col h-full gap-3">
+      {/* directive box — moved to the TOP, above the activity (most available,
+          no scrolling). Carries the target selector. */}
+      <Composer caseNumber={caseNumber} issues={data.issues} />
+
      {/* agent roster — who's who, compact one-row (mockup 18i v2) */}
      <AgentRoster agents={data.agents ?? []} />

-      {/* pending interactions surfaced to the top — each an accordion, first
-          open (mockup 18i v2 — awaiting you). Excluded from the timeline. */}
+      {/* pending interactions surfaced to the top — each an accordion, all
+          COLLAPSED by default (chair opens to look). Excluded from the timeline. */}
      {pending.length > 0 && (
-        <div className="mb-3 rounded-lg border border-amber-300 bg-amber-50 p-3 space-y-2">
+        <div className="rounded-lg border border-amber-300 bg-amber-50 p-3 space-y-2">
          <div className="flex items-center gap-2 text-[0.82rem] font-bold text-amber-800">
            <Clock className="w-4 h-4" />
            ממתין לתשובתך
@@ -954,27 +1243,30 @@ export function AgentActivityFeed({
              {pending.length}
            </span>
          </div>
-          {pending.map((i, idx) => (
+          {pending.map((i) => (
            <InteractionCard
              key={`pending-${i.id}`}
              interaction={i}
              caseNumber={caseNumber}
              issueMap={issueMap}
-              defaultOpen={idx === 0}
+              defaultOpen={false}
            />
          ))}
        </div>
      )}

      {/* Timeline header */}
-      <div className="flex items-center gap-2 px-2 py-2 border-b border-rule mb-1">
+      <div className="flex items-center gap-2 px-2 py-2 border-b border-rule">
        <span className="text-[0.82rem] font-bold text-navy">פעילות לפי משימה</span>
-        <span className="text-[0.72rem] text-ink-muted">
+        <span className="text-[0.68rem] font-semibold text-gold-deep bg-gold/10 rounded-full px-2 py-0.5">
+          החדש למעלה
+        </span>
+        <span className="text-[0.72rem] text-ink-muted ms-auto">
          {data.issues.length} משימות · {totalFeedItems} הודעות
        </span>
      </div>

-      {/* Per-issue accordions */}
+      {/* Per-issue accordions — all COLLAPSED by default, newest group first */}
      <div className="flex-1 overflow-y-auto max-h-[500px]">
        {totalFeedItems === 0 ? (
          hasActiveIssue ? (
@@ -989,56 +1281,17 @@ export function AgentActivityFeed({
            </div>
          )
        ) : (
-          issueGroups.map(({ iss, items }, idx) => (
+          issueGroups.map(({ iss, items }) => (
            <IssueGroup
              key={iss.id}
              issue={iss}
              items={items}
              caseNumber={caseNumber}
              issueMap={issueMap}
-              defaultOpen={
-                idx === 0 ||
-                (iss.status !== "done" && iss.status !== "cancelled")
-              }
+              defaultOpen={false}
            />
          ))
        )}
-        <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="כתוב הוראה לסוכנים..."
-          aria-label="הוראה לסוכנים"
-          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 me-1" />
-            )}
-            שלח
-          </Button>
-        </div>
      </div>
    </div>
  );
--- a/web-ui/src/components/cases/case-files-browser.tsx
+++ b/web-ui/src/components/cases/case-files-browser.tsx
@@ -0,0 +1,304 @@
+"use client";
+
+import { useMemo, useState } from "react";
+import {
+  useCaseFiles,
+  useCaseFileText,
+  caseFileUrl,
+  type CaseFileFolder,
+} from "@/lib/api/case-files";
+import { Markdown } from "@/components/ui/markdown";
+import { Badge } from "@/components/ui/badge";
+import { formatDateTime } from "@/lib/format-date";
+import {
+  Folder,
+  FileText,
+  File as FileIcon,
+  Download,
+  ChevronDown,
+  Loader2,
+  FolderOpen,
+} from "lucide-react";
+
+/* ── Helpers ─────────────────────────────────────────────────── */
+
+const FOLDER_LABELS: Record<string, string> = {
+  research: "מחקר וטיוטות",
+  originals: "מסמכי מקור",
+  extracted: "טקסט מחולץ (OCR)",
+  proofread: "לאחר הגהה",
+  drafts: "טיוטות DOCX",
+  backup: "גיבויים",
+};
+
+// Extensions the inline viewer can render (everything else → download only).
+const TEXT_EXT = new Set(["md", "txt", "json", "csv", "log", "markdown"]);
+
+function fileExt(filename: string): string {
+  return filename.includes(".") ? filename.split(".").pop()!.toLowerCase() : "";
+}
+
+function folderLabel(f: CaseFileFolder): string {
+  return FOLDER_LABELS[f.name] ?? f.name;
+}
+
+function fmtSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}
+
+const EXT_TONE: Record<string, string> = {
+  md: "bg-teal-100 text-teal-700",
+  markdown: "bg-teal-100 text-teal-700",
+  txt: "bg-blue-100 text-blue-700",
+  json: "bg-blue-100 text-blue-700",
+  pdf: "bg-red-100 text-red-700",
+  docx: "bg-indigo-100 text-indigo-700",
+  doc: "bg-indigo-100 text-indigo-700",
+};
+function extTone(ext: string): string {
+  return EXT_TONE[ext] ?? "bg-gray-100 text-gray-600";
+}
+
+type Selected = { folderKey: string; filename: string };
+
+/* ── Component ───────────────────────────────────────────────── */
+
+export function CaseFilesBrowser({ caseNumber }: { caseNumber: string }) {
+  const { data, isLoading, error } = useCaseFiles(caseNumber);
+  const folders = useMemo(() => data?.folders ?? [], [data?.folders]);
+
+  const totalFiles = folders.reduce((n, f) => n + f.files.length, 0);
+
+  // Default selection derived (not via an effect): a text file in research,
+  // else any text file. The chair's explicit pick overrides it.
+  const defaultSelected = useMemo<Selected | null>(() => {
+    const pick = (
+      pred: (f: CaseFileFolder, name: string) => boolean,
+    ): Selected | null => {
+      for (const f of folders)
+        for (const file of f.files)
+          if (pred(f, file.filename))
+            return { folderKey: f.key, filename: file.filename };
+      return null;
+    };
+    return (
+      pick((f, name) => f.name === "research" && TEXT_EXT.has(fileExt(name))) ??
+      pick((_f, name) => TEXT_EXT.has(fileExt(name)))
+    );
+  }, [folders]);
+
+  const [userSelected, setUserSelected] = useState<Selected | null>(null);
+  const selected = userSelected ?? defaultSelected;
+
+  // A folder is open if explicitly toggled; otherwise the folder of the current
+  // selection (or the first non-empty folder) is open by default.
+  const defaultOpenKey =
+    selected?.folderKey ?? folders.find((f) => f.files.length)?.key ?? null;
+  const [openOverrides, setOpenOverrides] = useState<Map<string, boolean>>(
+    new Map(),
+  );
+  const isOpen = (key: string) =>
+    openOverrides.has(key) ? openOverrides.get(key)! : key === defaultOpenKey;
+
+  const selExt = selected ? fileExt(selected.filename) : "";
+  const selIsText = TEXT_EXT.has(selExt);
+  const {
+    data: fileText,
+    isLoading: textLoading,
+    error: textError,
+  } = useCaseFileText(
+    caseNumber,
+    selIsText ? selected?.folderKey : undefined,
+    selIsText ? selected?.filename : undefined,
+  );
+
+  const toggleFolder = (key: string) => {
+    const next = !isOpen(key);
+    setOpenOverrides((prev) => new Map(prev).set(key, next));
+  };
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center py-10 text-ink-faint">
+        <Loader2 className="w-5 h-5 animate-spin me-2" />
+        <span>טוען קבצים...</span>
+      </div>
+    );
+  }
+  if (error) {
+    return (
+      <div className="text-center py-10 text-red-500 text-sm">
+        שגיאה בטעינת קבצי-התיק
+      </div>
+    );
+  }
+
+  return (
+    <div className="border border-rule rounded-xl overflow-hidden">
+      {/* header */}
+      <div className="flex items-center gap-2 px-4 py-3 border-b border-rule-soft bg-parchment">
+        <FolderOpen className="w-4 h-4 text-gold-deep" />
+        <h3 className="text-sm font-bold text-navy">קבצי-התיק</h3>
+        <span className="text-[11px] text-ink-muted ms-auto">
+          כל תתי-התיקיות · {totalFiles} קבצים
+        </span>
+      </div>
+
+      <div className="grid md:grid-cols-[320px_1fr]">
+        {/* file tree */}
+        <div className="border-b md:border-b-0 md:border-e border-rule-soft max-h-[560px] overflow-y-auto">
+          {folders.map((f) => {
+            const open = isOpen(f.key);
+            return (
+              <div key={f.key} className="border-b border-rule-soft last:border-b-0">
+                <button
+                  type="button"
+                  onClick={() => toggleFolder(f.key)}
+                  aria-expanded={open}
+                  className="w-full flex items-center gap-2 px-3.5 py-2.5 hover:bg-sand-soft/60 text-start"
+                >
+                  <Folder className="w-4 h-4 text-gold-deep shrink-0" />
+                  <span className="text-[0.78rem] font-bold text-navy">
+                    {folderLabel(f)}
+                  </span>
+                  <span className="text-[9px] font-mono text-ink-faint hidden sm:inline">
+                    {f.path}
+                  </span>
+                  <span
+                    className={`text-[10px] font-semibold rounded-full px-2 ms-auto ${f.files.length ? "bg-gray-100 text-ink-muted" : "text-ink-light"}`}
+                  >
+                    {f.files.length || "ריק"}
+                  </span>
+                  <ChevronDown
+                    className={`w-4 h-4 text-ink-faint shrink-0 transition-transform ${open ? "rotate-180" : ""}`}
+                  />
+                </button>
+
+                {open && f.files.length > 0 && (
+                  <div className="pb-1 bg-parchment/50">
+                    {f.files.map((file) => {
+                      const ext = fileExt(file.filename);
+                      const isSel =
+                        selected?.folderKey === f.key &&
+                        selected?.filename === file.filename;
+                      const viewable = TEXT_EXT.has(ext);
+                      return (
+                        <div
+                          key={file.filename}
+                          className={`flex items-center gap-2.5 py-1.5 pe-3.5 ps-5 cursor-pointer border-s-2 ${isSel ? "bg-gold-wash border-gold" : "border-transparent hover:bg-sand-soft/60"}`}
+                          onClick={() =>
+                            viewable
+                              ? setUserSelected({
+                                  folderKey: f.key,
+                                  filename: file.filename,
+                                })
+                              : undefined
+                          }
+                        >
+                          <span
+                            className={`w-6 h-6 rounded-md flex items-center justify-center shrink-0 ${extTone(ext)}`}
+                          >
+                            {viewable ? (
+                              <FileText className="w-3.5 h-3.5" />
+                            ) : (
+                              <FileIcon className="w-3.5 h-3.5" />
+                            )}
+                          </span>
+                          <div className="min-w-0 flex-1">
+                            <div className="text-[11.5px] font-medium text-ink-soft truncate">
+                              {file.filename}
+                            </div>
+                            <div className="text-[9.5px] text-ink-light">
+                              {fmtSize(file.size)} ·{" "}
+                              {formatDateTime(file.modified_at * 1000)}
+                            </div>
+                          </div>
+                          <a
+                            href={caseFileUrl(caseNumber, f.key, file.filename)}
+                            download={file.filename}
+                            onClick={(e) => e.stopPropagation()}
+                            className="w-7 h-7 rounded-md border border-rule bg-surface flex items-center justify-center text-ink-muted hover:text-navy shrink-0"
+                            title="הורדה"
+                          >
+                            <Download className="w-3.5 h-3.5" />
+                          </a>
+                        </div>
+                      );
+                    })}
+                  </div>
+                )}
+              </div>
+            );
+          })}
+          {folders.length === 0 && (
+            <div className="text-center py-10 text-ink-faint text-sm">
+              אין קבצים בתיק.
+            </div>
+          )}
+        </div>
+
+        {/* viewer */}
+        <div className="min-w-0 flex flex-col">
+          {!selected ? (
+            <div className="flex-1 flex flex-col items-center justify-center py-16 text-ink-faint text-sm">
+              <FileText className="w-8 h-8 mb-2 opacity-40" />
+              בחר קובץ טקסט מהרשימה לצפייה
+            </div>
+          ) : (
+            <>
+              <div className="flex items-center gap-2.5 px-4 py-3 border-b border-rule-soft">
+                <span
+                  className={`w-7 h-7 rounded-md flex items-center justify-center shrink-0 ${extTone(selExt)}`}
+                >
+                  <FileText className="w-4 h-4" />
+                </span>
+                <div className="min-w-0">
+                  <div className="text-[12.5px] font-bold text-navy truncate">
+                    {selected.filename}
+                  </div>
+                </div>
+                <a
+                  href={caseFileUrl(
+                    caseNumber,
+                    selected.folderKey,
+                    selected.filename,
+                  )}
+                  download={selected.filename}
+                  className="ms-auto inline-flex items-center gap-1.5 text-[11.5px] font-semibold text-navy bg-parchment border border-rule rounded-md px-3 py-1.5 hover:bg-sand-soft"
+                >
+                  <Download className="w-3.5 h-3.5" />
+                  הורדה
+                </a>
+              </div>
+              <div className="px-5 py-4 overflow-y-auto max-h-[520px] bg-[#fdfcf9]">
+                {!selIsText ? (
+                  <div className="text-center py-12 text-sm text-ink-muted">
+                    קובץ מסוג <Badge variant="outline">{selExt || "?"}</Badge> —
+                    לא ניתן לצפייה מוטבעת. הורד כדי לפתוח.
+                  </div>
+                ) : textLoading ? (
+                  <div className="flex items-center justify-center py-12 text-ink-faint">
+                    <Loader2 className="w-5 h-5 animate-spin me-2" />
+                    טוען תוכן...
+                  </div>
+                ) : textError ? (
+                  <div className="text-center py-12 text-red-500 text-sm">
+                    שגיאה בטעינת תוכן הקובץ
+                  </div>
+                ) : selExt === "md" || selExt === "markdown" ? (
+                  <Markdown content={fileText ?? ""} />
+                ) : (
+                  <pre className="whitespace-pre-wrap text-xs text-ink-soft font-mono leading-relaxed">
+                    {fileText}
+                  </pre>
+                )}
+              </div>
+            </>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}
--- a/web-ui/src/lib/api/agents.ts
+++ b/web-ui/src/lib/api/agents.ts
@@ -26,6 +26,8 @@ export type PaperclipIssue = {
  completed_at: string | null;
  created_at: string | null;
  company_id: string;
+  /** Null for top-level issues (the CEO "start process" issue); set for sub-issues. */
+  parent_id: string | null;
 };

 export type PaperclipComment = {
@@ -151,8 +153,14 @@ export function useAgentActivity(caseNumber: string | undefined) {
 export function useSendComment(caseNumber: string | undefined) {
  const qc = useQueryClient();
  return useMutation({
-    mutationFn: (vars: { body: string; issue_id?: string }) =>
-      apiRequest<{ comment_id: string; issue_id: string; issue_identifier: string }>(
+    mutationFn: (vars: { body: string; issue_id?: string; new_run?: boolean }) =>
+      apiRequest<{
+        comment_id: string | null;
+        issue_id: string;
+        issue_identifier: string;
+        issue_status?: string;
+        new_run?: boolean;
+      }>(
        `/api/cases/${caseNumber}/agents/comment`,
        { method: "POST", body: vars },
      ),
--- a/web-ui/src/lib/api/case-files.ts
+++ b/web-ui/src/lib/api/case-files.ts
@@ -0,0 +1,66 @@
+/**
+ * Case files API — browse & read every content subfolder of a case on disk.
+ *
+ * Surfaces the agent-produced work files (drafts, OCR text, research, originals…)
+ * that previously lived only on the server filesystem. Backed by the pre-existing
+ * `/local-files` endpoints, generalized to all subfolders (path-safe on the
+ * server via `_resolve_case_file`).
+ */
+
+import { useQuery } from "@tanstack/react-query";
+import { apiRequest } from "./client";
+
+export type CaseFile = {
+  filename: string;
+  size: number;
+  /** Unix epoch seconds (float) of last modification. */
+  modified_at: number;
+};
+
+export type CaseFileFolder = {
+  /** Opaque folder key for the read endpoint (e.g. "documents__research"). */
+  key: string;
+  /** Leaf folder name (e.g. "research"). */
+  name: string;
+  /** Case-relative path (e.g. "documents/research"). */
+  path: string;
+  files: CaseFile[];
+};
+
+export type CaseFilesResponse = { folders: CaseFileFolder[] };
+
+export function useCaseFiles(caseNumber: string | undefined) {
+  return useQuery({
+    queryKey: ["case-files", caseNumber ?? ""],
+    queryFn: () =>
+      apiRequest<CaseFilesResponse>(`/api/cases/${caseNumber}/local-files`),
+    enabled: !!caseNumber,
+  });
+}
+
+/** Direct URL to a single file — use as an <a href> for download/open. */
+export function caseFileUrl(
+  caseNumber: string,
+  folderKey: string,
+  filename: string,
+): string {
+  return `/api/cases/${encodeURIComponent(caseNumber)}/local-files/${encodeURIComponent(folderKey)}/${encodeURIComponent(filename)}`;
+}
+
+/** Fetch a text file's contents (md/txt/json) for the inline viewer. */
+export function useCaseFileText(
+  caseNumber: string | undefined,
+  folderKey: string | undefined,
+  filename: string | undefined,
+) {
+  return useQuery({
+    queryKey: ["case-file-text", caseNumber ?? "", folderKey ?? "", filename ?? ""],
+    queryFn: async () => {
+      const res = await fetch(caseFileUrl(caseNumber!, folderKey!, filename!));
+      if (!res.ok) throw new Error(`שגיאה בטעינת הקובץ (${res.status})`);
+      return res.text();
+    },
+    enabled: !!caseNumber && !!folderKey && !!filename,
+    staleTime: 30_000,
+  });
+}
--- a/web-ui/src/lib/api/operations.ts
+++ b/web-ui/src/lib/api/operations.ts
@@ -190,6 +190,61 @@ export function useAgentRuns() {
  });
 }

+// ── Agent health taxonomy (#222) + recent escalations (#218) ───────────────
+export type AgentHealthState = "zombie" | "stalled" | "working" | "idle";
+
+export type AgentHealthItem = {
+  issue_id: string;
+  identifier: string;
+  status: string;
+  agent_id: string;
+  agent_name: string;
+  health: AgentHealthState;
+  wakeups: number;
+  recovery_wakeups: number;
+};
+
+export type AgentHealthResponse = {
+  ok: boolean;
+  items: AgentHealthItem[]; // worst-first (zombie → stalled → working → idle)
+  counts: Record<AgentHealthState, number>;
+};
+
+/** Per-issue agent health — surfaces recovery-loop zombies automatically. */
+export function useAgentHealth() {
+  return useQuery({
+    queryKey: ["operations", "agents", "health"],
+    queryFn: ({ signal }) =>
+      apiRequest<AgentHealthResponse>("/api/operations/agents/health", { signal }),
+    refetchInterval: 5000, // live alongside the running-agents view
+    staleTime: 3000,
+  });
+}
+
+export type EscalationItem = {
+  issue_id: string;
+  identifier: string;
+  severity: "critical" | "high" | "medium";
+  reason: string;
+  created_at: string | null;
+};
+
+export type RecentEscalationsResponse = {
+  ok: boolean;
+  items: EscalationItem[]; // newest-first
+};
+
+/** Recent chair escalations (watchdog + manual) — the handled-loop history. */
+export function useRecentEscalations() {
+  return useQuery({
+    queryKey: ["operations", "agents", "escalations"],
+    queryFn: ({ signal }) =>
+      apiRequest<RecentEscalationsResponse>("/api/operations/agents/escalations", { signal }),
+    refetchInterval: 15000, // escalations change slowly (watchdog runs every 15m)
+    staleTime: 10000,
+  });
+}
+
 /** Full output log of one run — fetched on demand (drawer open). */
 export function useRunLog(runId: string | null) {
  return useQuery({
--- a/web/agent_health.py
+++ b/web/agent_health.py
@@ -0,0 +1,110 @@
+"""Agent health taxonomy (TaskMaster #222) — one crisp state per stuck issue.
+
+Classifies each open, agent-assigned issue into a single health state so the
+stranded-child / recovery-loop cases we diagnose by hand today
+([[reference_recovery_loop_stranded_child]], [[reference_paperclip_recovery_loops]])
+surface automatically in the dashboard — the ``gt feed --problems`` idea from
+Gastown, grounded in *our* failure modes.
+
+Two layers, split for testability (same shape as web.agent_telemetry):
+- :func:`classify_issue_health` is a **pure function** over three primitives
+  (live-run flag + wakeup counts). No DB, no platform symbols — trivially
+  unit-tested and platform-agnostic (INV-G12).
+- The Paperclip-specific fetch that derives those primitives from
+  ``heartbeat_runs`` / ``agent_wakeup_requests`` lives in the shell
+  (``web.paperclip_client.get_agent_health``); this module only decides *how to
+  label* what the fetch measured, so the taxonomy survives a platform swap.
+
+The wakeup/recovery signals it reads are the very ones #219 telemetry now emits
+(``agent.wakeup`` with recovery reasons) — this is the consumer that turns that
+stream into an at-a-glance verdict.
+"""
+from __future__ import annotations
+
+# Severity order (worst first) — the dashboard sorts problems by this.
+HEALTH_STATES: tuple[str, ...] = ("zombie", "stalled", "working", "idle")
+
+# Substrings of Paperclip wakeup ``reason`` values that mark a recovery-loop
+# wake (as opposed to a genuine new task). Sourced from the recovery-loop
+# forensics in memory: an issue that keeps getting these while agent-owned is a
+# zombie — assigned + "active" but nothing is really executing.
+RECOVERY_REASON_MARKERS: tuple[str, ...] = (
+    "source_scoped_recovery",
+    "stranded_assigned",
+    "issue_continuation",
+    "issue_reopened",
+    "missing_disposition",
+    "successful_run_missing_state",
+    "waiting_on_review",
+)
+
+# ≥ this many wakeups inside the fetch window, with no recovery marker and no
+# live run, reads as "poked repeatedly but not progressing" = stalled.
+STALL_WAKEUP_THRESHOLD = 3
+
+
+def is_recovery_reason(reason: str | None) -> bool:
+    """True if a wakeup ``reason`` is a recovery-loop marker (not a new task)."""
+    if not reason:
+        return False
+    return any(marker in reason for marker in RECOVERY_REASON_MARKERS)
+
+
+def classify_issue_health(
+    *,
+    has_live_run: bool,
+    recovery_wakeups: int,
+    total_wakeups: int,
+) -> str:
+    """Label one open, agent-assigned issue. Pure — no I/O.
+
+    - ``working`` — a live run is executing right now.
+    - ``zombie`` — no live run but recovery-loop wakeups are firing: the issue
+      looks agent-owned + active yet nothing is really running (the stranded
+      child we chase manually).
+    - ``stalled`` — no live run, no recovery markers, but poked ``>=``
+      :data:`STALL_WAKEUP_THRESHOLD` times in-window (repeated wakes, no
+      progress).
+    - ``idle`` — open + assigned but quiet: benign waiting.
+
+    Called only for issues that are already open and agent-assigned; unassigned
+    or closed issues are not health-tracked (the fetch filters them out).
+    """
+    if has_live_run:
+        return "working"
+    if recovery_wakeups >= 1:
+        return "zombie"
+    if total_wakeups >= STALL_WAKEUP_THRESHOLD:
+        return "stalled"
+    return "idle"
+
+
+# A zombie needs at least this many recovery-marker wakeups before the watchdog
+# auto-escalates it — filters a single transient recovery wake from a genuine,
+# budget-burning loop. Escalation reassigns the issue to the chair (via
+# escalate_issue), so an escalated issue is agent-unowned next sweep and never
+# re-escalates (idempotent by construction).
+ZOMBIE_ESCALATE_MIN_RECOVERY = 2
+
+
+def zombie_escalation(item: dict) -> tuple[str, str] | None:
+    """Decide whether a health item warrants auto-escalation to the chair.
+
+    Pure (no I/O) so the watchdog's policy is unit-tested. Returns
+    ``(severity, reason)`` for a persistent zombie, else ``None``. Severity
+    scales with loop intensity — a long-running loop (``>=5`` recovery wakes)
+    is ``high``, a fresh one ``medium``. Only ``zombie`` items escalate: a
+    ``stalled``/``working``/``idle`` issue is not a recovery loop.
+    """
+    if item.get("health") != "zombie":
+        return None
+    recovery = int(item.get("recovery_wakeups", 0))
+    if recovery < ZOMBIE_ESCALATE_MIN_RECOVERY:
+        return None
+    severity = "high" if recovery >= 5 else "medium"
+    reason = (
+        f"auto-escalation (watchdog): זוהתה לולאת-recovery — {recovery} יקיצות-שחזור "
+        f"על {item.get('identifier')} ({item.get('agent_name')}); ה-issue נמסר לחיים "
+        f"במקום להמשיך לשרוף budget."
+    )
+    return severity, reason
--- a/web/agent_platform_port.py
+++ b/web/agent_platform_port.py
@@ -33,42 +33,111 @@ from web.paperclip_api import (
    pc_request,
    require_paperclip_db_url,
 )
+from web.agent_telemetry import instrument
 from web.paperclip_client import (
    COMPANIES as PAPERCLIP_COMPANIES,
    accept_interaction as pc_accept_interaction,
    archive_project as pc_archive_project,
-    cancel_interaction as pc_cancel_interaction,
-    cancel_run as pc_cancel_run,
    create_project as pc_create_project,
    create_workflow_issue as pc_create_workflow_issue,
+    get_agent_health as pc_get_agent_health,
+    get_recent_escalations as pc_get_recent_escalations,
+    get_predecessor_context as pc_get_predecessor_context,
+    get_predecessor_for_case as pc_get_predecessor_for_case,
    get_agents_for_case as pc_get_agents_for_case,
    get_agents_for_company as pc_get_agents,
    get_case_issues as pc_get_case_issues,
+    pick_default_comment_target as pc_pick_default_comment_target,
    get_issue_comments as pc_get_issue_comments,
    get_issue_interactions as pc_get_issue_interactions,
    get_project_url,
    get_run_events as pc_get_run_events,
    get_run_log as pc_get_run_log,
    list_live_runs as pc_list_live_runs,
-    post_comment as pc_post_comment,
-    reap_stale_interactions as pc_reap_stale_interactions,
    reject_interaction as pc_reject_interaction,
-    reset_agent_session as pc_reset_agent_session,
-    reset_case_agents as pc_reset_case_agents,
    respond_to_interaction as pc_respond_to_interaction,
    restore_project as pc_restore_project,
    update_project_name as pc_update_project_name,
-    wake_analyst_for_appraiser_facts as pc_wake_analyst_for_appraiser_facts,
-    wake_analyst_for_argument_aggregation as pc_wake_analyst_for_argument_aggregation,
-    wake_analyst_for_protocol_analysis as pc_wake_analyst_for_protocol_analysis,
    get_generation_run_status as pc_get_generation_run_status,
-    wake_ceo_agent as pc_wake_ceo,
-    wake_ceo_for_action as pc_wake_ceo_for_action,
-    wake_ceo_for_feedback_fold as pc_wake_ceo_for_feedback_fold,
-    wake_curator_for_final as pc_wake_curator_for_final,
-    wake_for_precedent_extraction as pc_wake_for_precedent_extraction,
+    # ── raw imports: wrapped with telemetry below (state-affecting ops, #219) ──
+    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,
+    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,
+    wake_ceo_agent as _wake_ceo,
+    wake_ceo_for_action as _wake_ceo_for_action,
+    open_ceo_run as _open_ceo_run,
+    wake_ceo_for_feedback_fold as _wake_ceo_for_feedback_fold,
+    wake_curator_for_final as _wake_curator_for_final,
+    wake_for_precedent_extraction as _wake_for_precedent_extraction,
 )

+# ── telemetry-wrapped platform ops (#219 / docs/spec/X15) ───────────────────
+# Every state-affecting platform op the Port exposes emits one structured event
+# through web.agent_telemetry, so recovery-loop behaviour (repeated wakeups,
+# stranded dispositions) is observable in real time rather than reconstructed
+# from the Paperclip DB. The wrappers preserve the public ``pc_*`` names and
+# signatures — call sites in app.py are unchanged. Read-only observability ops
+# (list_live_runs / get_run_log / get_issue_comments …) are intentionally NOT
+# instrumented: they neither wake agents nor change disposition state.
+pc_wake_ceo = instrument("agent.wakeup", role="ceo")(_wake_ceo)
+pc_wake_ceo_for_action = instrument(
+    "agent.wakeup", role="ceo", keys=("case_number", "company_id", "action"),
+)(_wake_ceo_for_action)
+pc_open_ceo_run = instrument(
+    "agent.wakeup", role="ceo", keys=("case_number", "company_id"),
+)(_open_ceo_run)
+pc_wake_ceo_for_feedback_fold = instrument(
+    "agent.wakeup", role="ceo", keys=("feedback_id", "category", "block_id"),
+)(_wake_ceo_for_feedback_fold)
+pc_wake_curator_for_final = instrument(
+    "agent.wakeup", role="curator", keys=("case_number", "company_id", "task"),
+)(_wake_curator_for_final)
+pc_wake_for_precedent_extraction = instrument(
+    "agent.wakeup", role="ceo", keys=("case_law_id", "citation", "practice_area"),
+)(_wake_for_precedent_extraction)
+pc_wake_analyst_for_appraiser_facts = instrument(
+    "agent.wakeup", role="analyst",
+)(_wake_analyst_for_appraiser_facts)
+pc_wake_analyst_for_argument_aggregation = instrument(
+    "agent.wakeup", role="analyst",
+)(_wake_analyst_for_argument_aggregation)
+pc_wake_analyst_for_protocol_analysis = instrument(
+    "agent.wakeup", role="analyst", keys=("case_number", "company_id", "document_id"),
+)(_wake_analyst_for_protocol_analysis)
+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)
+# First-class escalation-to-chair (#218): the loop-safe alternative to leaving an
+# issue agent-owned+blocked. Emits a severity-tagged event so escalations are
+# countable per case in the same stream as the wakeups they replace.
+pc_escalate_issue = instrument(
+    "agent.escalated", keys=("issue_id", "severity", "company_id", "reason"),
+)(_escalate_issue)
+pc_reap_stale_interactions = instrument(
+    "interaction.reaped", result_keys=("cancelled",),
+)(_reap_stale_interactions)
+pc_cancel_run = instrument("run.cancelled", keys=("run_id",))(_cancel_run)
+pc_reset_agent_session = instrument(
+    "agent.session_reset", keys=("agent_id",),
+)(_reset_agent_session)
+pc_reset_case_agents = instrument(
+    "agent.session_reset", keys=("case_number",),
+)(_reset_case_agents)
+
 # ── domain-named lifecycle aliases (preferred for new call sites) ───────────
 archive_case_project = pc_archive_project
 restore_case_project = pc_restore_project
@@ -98,11 +167,13 @@ __all__ = [
    # issues / workflow
    "pc_create_workflow_issue",
    "pc_get_case_issues",
+    "pc_pick_default_comment_target",
    # agents / wakeups
    "pc_get_agents_for_case",
    "pc_get_agents",
    "pc_wake_ceo",
    "pc_wake_ceo_for_action",
+    "pc_open_ceo_run",
    "pc_wake_ceo_for_feedback_fold",
    "pc_wake_curator_for_final",
    "pc_wake_for_precedent_extraction",
@@ -112,6 +183,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",
@@ -119,7 +191,12 @@ __all__ = [
    "pc_respond_to_interaction",
    "pc_cancel_interaction",
    "pc_reap_stale_interactions",
+    "pc_escalate_issue",
    # agent-run observability + control (live view + smart management)
+    "pc_get_agent_health",
+    "pc_get_recent_escalations",
+    "pc_get_predecessor_context",
+    "pc_get_predecessor_for_case",
    "pc_list_live_runs",
    "pc_get_run_log",
    "pc_get_run_events",
--- a/web/agent_telemetry.py
+++ b/web/agent_telemetry.py
@@ -0,0 +1,157 @@
+"""Agent-platform telemetry (TaskMaster #219) — structured, platform-agnostic events.
+
+Emits one structured event per agent-platform operation (wakeup, disposition
+comment, interaction reap/cancel, run cancel, session reset) so recovery-loop
+behaviour is **observable in real time** instead of reconstructed forensically
+from the Paperclip DB (``agent_wakeup_requests`` / ``heartbeat_runs``). See
+[[reference_paperclip_recovery_loops]] / [[reference_recovery_loop_stranded_child]]
+for the failure modes this makes visible.
+
+**Platform-agnostic by design (INV-G12 / docs/spec/X15).** Events are named in
+domain terms and carry no Paperclip-specific symbols — this module imports
+*nothing* from the Paperclip shell. The Port (``web/agent_platform_port.py``)
+calls :func:`instrument` / :func:`emit` around its operations, so the telemetry
+semantics survive a platform swap.
+
+**OTLP-ready, "logs first" (#219).** Each event is a flat dict with a stable
+schema, written today as one JSON line on the ``agent.telemetry`` logger
+(greppable in Coolify logs). Swapping :data:`_SINK` for an OTLP exporter — or
+attaching an OTLP handler to that logger — is the later step, with **no
+call-site changes**. Timestamps are stored in UTC (display-in-Israel is a
+read-side concern; see [[feedback_israel_time]]).
+
+Single path (INV-G2): the only telemetry emitter for the agent platform. Do not
+add a parallel structured-log format for these events elsewhere — route through
+:func:`emit`.
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+import json
+import logging
+import time
+from collections.abc import Awaitable, Callable, Sequence
+from datetime import datetime, timezone
+from typing import Any, TypeVar
+
+logger = logging.getLogger("agent.telemetry")
+
+# Schema version — bump when the event shape changes so downstream consumers
+# (dashboards, the #222 health taxonomy) can migrate deliberately.
+SCHEMA_VERSION = 1
+
+# Standard argument keys lifted onto every event when present on the wrapped call.
+_STANDARD_KEYS: tuple[str, ...] = ("case_number", "issue_id", "company_id", "reason")
+
+T = TypeVar("T")
+
+
+def _now_iso() -> str:
+    """UTC ISO-8601 with a trailing ``Z`` — store-UTC (feedback_israel_time)."""
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+def _sink(payload: dict[str, Any]) -> None:
+    """Where an event goes. Today: a JSON line on the ``agent.telemetry`` logger.
+
+    Isolated so a future OTLP exporter is a one-line swap with no call-site
+    churn (#219 "backend later").
+    """
+    logger.info(json.dumps(payload, ensure_ascii=False, default=str))
+
+
+_SINK: Callable[[dict[str, Any]], None] = _sink
+
+
+def emit(event: str, *, outcome: str = "ok", **fields: Any) -> None:
+    """Emit one structured agent-platform event. Never raises.
+
+    Telemetry must never break the operation it observes — any failure in the
+    sink is swallowed to a warning. ``event`` is a dotted domain name
+    (``agent.wakeup``, ``interaction.reaped``, ``run.cancelled`` …). Extra
+    ``fields`` are merged flat into the event; ``None`` values are dropped to
+    keep events terse.
+    """
+    payload: dict[str, Any] = {
+        "ts": _now_iso(),
+        "v": SCHEMA_VERSION,
+        "event": event,
+        "outcome": outcome,
+    }
+    for key, value in fields.items():
+        if value is not None:
+            payload[key] = value
+    try:
+        _SINK(payload)
+    except Exception:  # pragma: no cover — telemetry is best-effort, never fatal
+        logger.warning("agent.telemetry emit failed for event=%s", event, exc_info=True)
+
+
+def _outcome_of(result: Any) -> str:
+    """Derive an outcome from a platform call's return value.
+
+    Our platform helpers return either a plain dict (Paperclip API JSON) or a
+    ``{"ok": bool, ...}`` envelope. A falsy ``ok`` is a *no-op* (e.g. an
+    interaction that was already resolved), distinct from a raised error.
+    """
+    if isinstance(result, dict) and result.get("ok") is False:
+        return "noop"
+    return "ok"
+
+
+def _duration_ms(t0: float) -> int:
+    return int((time.monotonic() - t0) * 1000)
+
+
+def instrument(
+    event: str,
+    *,
+    role: str | None = None,
+    keys: Sequence[str] = _STANDARD_KEYS,
+    result_keys: Sequence[str] = (),
+    **static: Any,
+) -> Callable[[Callable[..., Awaitable[T]]], Callable[..., Awaitable[T]]]:
+    """Decorate an async platform op so it emits a structured event per call.
+
+    Fields are pulled from the call's bound arguments (``keys`` present on the
+    signature), plus a static ``role`` and any ``static`` attributes, plus
+    ``duration_ms`` and an ``outcome`` derived from the result (or ``error`` on
+    exception). ``result_keys`` lifts named keys out of a dict return value onto
+    the event (e.g. the ``cancelled`` count from the reaper).
+
+    The emit is wrapped so a telemetry bug can never fail the underlying call.
+    """
+
+    def deco(fn: Callable[..., Awaitable[T]]) -> Callable[..., Awaitable[T]]:
+        sig = inspect.signature(fn)
+
+        @functools.wraps(fn)
+        async def wrapper(*args: Any, **kwargs: Any) -> T:
+            try:
+                bound = sig.bind(*args, **kwargs)
+                bound.apply_defaults()
+                arguments = bound.arguments
+            except TypeError:
+                arguments = {}
+            fields: dict[str, Any] = {k: arguments.get(k) for k in keys}
+            if role is not None:
+                fields["agent_role"] = role
+            fields.update(static)
+
+            t0 = time.monotonic()
+            try:
+                result = await fn(*args, **kwargs)
+            except Exception as exc:
+                emit(event, outcome="error", error=repr(exc), duration_ms=_duration_ms(t0), **fields)
+                raise
+            if isinstance(result, dict):
+                for rk in result_keys:
+                    if rk in result:
+                        fields[rk] = result[rk]
+            emit(event, outcome=_outcome_of(result), duration_ms=_duration_ms(t0), **fields)
+            return result
+
+        return wrapper
+
+    return deco
--- a/web/app.py
+++ b/web/app.py
@@ -61,9 +61,15 @@ from web.agent_platform_port import (
    pc_cancel_run,
    pc_create_project,
    pc_create_workflow_issue,
+    pc_escalate_issue,
+    pc_get_agent_health,
+    pc_get_recent_escalations,
+    pc_get_predecessor_context,
+    pc_get_predecessor_for_case,
    pc_get_agents,
    pc_get_agents_for_case,
    pc_get_case_issues,
+    pc_pick_default_comment_target,
    pc_get_issue_comments,
    pc_get_issue_interactions,
    pc_get_run_events,
@@ -84,6 +90,8 @@ from web.agent_platform_port import (
    rename_case_project,
    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,
@@ -121,18 +129,66 @@ async def _interaction_reaper_loop():
            logger.warning("interaction reaper sweep failed", exc_info=True)


+# Watchdog kill-switch — set AGENT_ZOMBIE_AUTO_ESCALATE=0 to observe health
+# without acting (escalation stays available manually via the endpoint).
+_ZOMBIE_AUTO_ESCALATE = os.environ.get("AGENT_ZOMBIE_AUTO_ESCALATE", "1") != "0"
+
+
+async def _zombie_escalation_loop():
+    """Watchdog: auto-escalate persistent recovery-loop zombies to the chair (#218+#222).
+
+    Every 15 min, derive per-issue health (#222) and hand any persistent zombie
+    (a recovery loop, ``>=`` ``ZOMBIE_ESCALATE_MIN_RECOVERY`` recovery wakeups)
+    to the human via the loop-safe escalate primitive (#218) — closing the loop
+    that today burns budget until a human notices. Server-side on purpose: an
+    agent stuck in a recovery loop cannot reliably self-escalate. Idempotent —
+    an escalated issue is agent-unowned next sweep, so it is not re-escalated.
+    """
+    from web.agent_health import zombie_escalation
+
+    while True:
+        try:
+            await asyncio.sleep(900)
+            if not _ZOMBIE_AUTO_ESCALATE:
+                continue
+            health = await pc_get_agent_health()
+            for item in health.get("items", []):
+                decision = zombie_escalation(item)
+                if decision is None:
+                    continue
+                severity, reason = decision
+                result = await pc_escalate_issue(item["issue_id"], severity, reason)
+                if result.get("ok"):
+                    logger.warning(
+                        "watchdog auto-escalated %s (%s, %d recovery wakeups) to chair [%s]",
+                        item.get("identifier"), item.get("agent_name"),
+                        item.get("recovery_wakeups", 0), severity,
+                    )
+                else:
+                    logger.warning(
+                        "watchdog escalation failed for %s: %s",
+                        item.get("identifier"), result.get("error"),
+                    )
+        except asyncio.CancelledError:
+            raise
+        except Exception:
+            logger.warning("zombie escalation sweep failed", exc_info=True)
+
+
@asynccontextmanager
 async def lifespan(app: FastAPI):
    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
    await db.init_schema()
    sync_task = asyncio.create_task(git_sync.sweep_loop())
    reaper_task = asyncio.create_task(_interaction_reaper_loop())
+    watchdog_task = asyncio.create_task(_zombie_escalation_loop())
    try:
        yield
    finally:
        sync_task.cancel()
        reaper_task.cancel()
-        for _t in (sync_task, reaper_task):
+        watchdog_task.cancel()
+        for _t in (sync_task, reaper_task, watchdog_task):
            try:
                await _t
            except asyncio.CancelledError:
@@ -3014,42 +3070,82 @@ async def api_learn(case_number: str):
 # ── Local files API — research, drafts, proofread ──


+# Directories under a case that are infrastructure/cache, not chair-facing
+# content. Hidden dirs (``.git``, ``.claude`` …) are skipped separately.
+_CASE_FILE_EXCLUDE_DIRS = {"thumbnails"}
+
+
+def _is_content_dir(p: Path) -> bool:
+    return p.is_dir() and not p.name.startswith(".") and p.name not in _CASE_FILE_EXCLUDE_DIRS
+
+
+def _case_file_folders(case_dir: Path) -> list[tuple[str, Path]]:
+    """Enumerate every content subdirectory under a case dir as (key, path).
+
+    Covers *all* subfolders (not just research) — recursing one level into
+    ``documents/`` — while skipping hidden (``.git``/``.claude``…) and cache
+    dirs. The ``key`` is the case-relative path with ``/`` encoded as ``__`` so
+    it survives a single URL path segment; ``_resolve_case_file`` re-validates it
+    against this same enumeration, so the key set is the serve allowlist (no path
+    traversal).
+    """
+    folders: list[tuple[str, Path]] = []
+    if not case_dir.exists():
+        return folders
+    for child in sorted(case_dir.iterdir()):
+        if not _is_content_dir(child):
+            continue
+        if child.name == "documents":
+            folders.extend(
+                (f"documents__{sub.name}", sub)
+                for sub in sorted(child.iterdir())
+                if _is_content_dir(sub)
+            )
+        else:
+            folders.append((child.name, child))
+    return folders
+
+
+def _resolve_case_file(case_dir: Path, folder_key: str, filename: str) -> Path | None:
+    """Safely resolve (folder_key, filename) to a file inside the case dir.
+
+    Returns None unless ``folder_key`` is one of the enumerated content folders
+    AND ``filename`` resolves to a regular file directly inside it (no traversal).
+    """
+    base = dict(_case_file_folders(case_dir)).get(folder_key)
+    if base is None:
+        return None
+    target = (base / filename).resolve()
+    if target.parent != base.resolve() or not target.is_file():
+        return None
+    return target
+
+
@app.get("/api/cases/{case_number}/local-files")
 async def api_local_files(case_number: str):
-    """List local files from case subdirectories (research, drafts, proofread)."""
+    """List local files across ALL content subfolders under a case (not just
+    research) — so the chair can reach any agent-produced file (drafts, OCR text,
+    originals…) from the UI instead of only over SSH. Empty folders are returned
+    too (with an empty ``files`` list) so the UI can show them as such."""
    case_dir = config.find_case_dir(case_number)
-    result = {}
-    for folder in ("research", "proofread"):
-        folder_path = case_dir / "documents" / folder
-        if folder_path.exists():
-            files = []
-            for f in sorted(folder_path.iterdir()):
-                if f.is_file() and not f.name.startswith("."):
-                    stat = f.stat()
-                    files.append({
-                        "filename": f.name,
-                        "size": stat.st_size,
-                        "modified_at": stat.st_mtime,
-                        "folder": folder,
-                    })
-            if files:
-                result[folder] = files
-    # Drafts are at case level, not under documents
-    drafts_path = case_dir / "drafts"
-    if drafts_path.exists():
+    folders = []
+    for key, path in _case_file_folders(case_dir):
        files = []
-        for f in sorted(drafts_path.iterdir()):
+        for f in sorted(path.iterdir()):
            if f.is_file() and not f.name.startswith("."):
                stat = f.stat()
                files.append({
                    "filename": f.name,
                    "size": stat.st_size,
                    "modified_at": stat.st_mtime,
-                    "folder": "drafts",
                })
-        if files:
-            result["drafts"] = files
-    return result
+        folders.append({
+            "key": key,
+            "name": path.name,
+            "path": str(path.relative_to(case_dir)),
+            "files": files,
+        })
+    return {"folders": folders}


 async def serve_blob(
@@ -3119,17 +3215,32 @@ async def _seal_blob_file(dest: Path, *, bucket=storage.Bucket.DOCUMENTS) -> Non

@app.get("/api/cases/{case_number}/local-files/{folder}/{filename}")
 async def api_read_local_file(case_number: str, folder: str, filename: str):
-    """Read contents of a local case file."""
-    if folder not in ("research", "proofread", "drafts"):
-        raise HTTPException(400, "Invalid folder")
+    """Serve a single local case file from any content subfolder.
+
+    ``folder`` is a key from ``/local-files`` (``documents__research``, ``drafts``…);
+    ``_resolve_case_file`` validates it against the folder allowlist and blocks
+    path traversal before the bytes are served.
+    """
    case_dir = config.find_case_dir(case_number)
-    if folder == "drafts":
-        path = case_dir / "drafts" / filename
-    else:
-        path = case_dir / "documents" / folder / filename
-    if not path.exists() or not path.is_file():
+    path = _resolve_case_file(case_dir, folder, filename)
+    if path is None:
        raise HTTPException(404, "קובץ לא נמצא")
-    return await serve_blob(path, media_type="text/plain; charset=utf-8", filename=filename)
+    media_type = _local_file_media_type(filename)
+    return await serve_blob(path, media_type=media_type, filename=filename)
+
+
+def _local_file_media_type(filename: str) -> str:
+    """Best-effort content type for a served case file (text renders inline,
+    binaries download)."""
+    ext = filename.rsplit(".", 1)[-1].lower() if "." in filename else ""
+    return {
+        "md": "text/markdown; charset=utf-8",
+        "txt": "text/plain; charset=utf-8",
+        "json": "application/json; charset=utf-8",
+        "pdf": "application/pdf",
+        "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+        "doc": "application/msword",
+    }.get(ext, "application/octet-stream")


 # ── Research analysis (analysis-and-research.md) — parse + edit ────
@@ -4550,14 +4661,39 @@ async def api_case_agents(case_number: str):
 class AgentCommentRequest(BaseModel):
    body: str
    issue_id: str | None = None
+    # "פתח הרצה חדשה" — 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


@app.post("/api/cases/{case_number}/agents/comment")
 async def api_post_agent_comment(case_number: str, req: AgentCommentRequest):
-    """Post a comment on a Paperclip issue linked to a case.
+    """Post a chair instruction to a Paperclip issue linked to a case.

-    If issue_id is omitted, the most recent non-done issue is used.
+    Routing (agents-tab target selector):
+      - ``new_run=True`` → open a fresh CEO-owned run (child issue assigned to the
+        CEO + wakeup), sidestepping the ``issue_assignee_changed`` cancellation on
+        a human-owned parent. Overrides ``issue_id``.
+      - ``issue_id`` given → post to that issue (explicit chair choice).
+      - neither → prefer the live CEO main issue, never a closed one
+        (``pick_default_comment_target``).
    """
+    if req.new_run:
+        result = await pc_open_ceo_run(case_number, req.body)
+        if result.get("status") != "ok":
+            raise HTTPException(
+                502,
+                f"פתיחת הרצה חדשה נכשלה: {result.get('reason', 'unknown')}",
+            )
+        return {
+            "comment_id": None,
+            "issue_id": result["issue_id"],
+            "issue_identifier": result.get("identifier", ""),
+            "issue_status": "in_progress",
+            "new_run": True,
+        }
+
    issues = await pc_get_case_issues(case_number)
    if not issues:
        raise HTTPException(404, f"לא נמצא פרויקט Paperclip לתיק {case_number}")
@@ -4567,14 +4703,35 @@ async def api_post_agent_comment(case_number: str, req: AgentCommentRequest):
        if not target:
            raise HTTPException(404, f"Issue {req.issue_id} לא שייך לתיק {case_number}")
    else:
-        # Pick the most recent non-done issue, or the last one
-        active = [i for i in issues if i["status"] != "done"]
-        target = active[-1] if active else issues[-1]
+        target = pc_pick_default_comment_target(issues)

    result = await pc_post_comment(target["id"], target["company_id"], req.body)

-    # Find the identifier for the response
+    # 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


@@ -4591,8 +4748,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):
@@ -4604,7 +4763,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:
@@ -4613,6 +4772,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
@@ -4651,6 +4827,30 @@ async def api_reset_case_agents(case_number: str):
    return result


+class EscalateRequest(BaseModel):
+    issue_id: str
+    severity: Literal["critical", "high", "medium"]
+    reason: str
+
+
+@app.post("/api/cases/{case_number}/agents/escalate")
+async def api_escalate_issue(case_number: str, req: EscalateRequest):
+    """Escalate a single stuck issue to the chair (#218).
+
+    The loop-safe alternative to leaving an issue agent-owned+blocked: hands the
+    issue to the human in one atomic transition (in_review + assignee_user_id)
+    and records a severity note, without re-waking any agent. Emits an
+    ``agent.escalated`` telemetry event via the Port.
+    """
+    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_escalate_issue(req.issue_id, req.severity, req.reason)
+    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:
@@ -7506,6 +7706,50 @@ async def operations_agents():
    }


+@app.get("/api/operations/agents/health")
+async def operations_agent_health():
+    """Per-issue agent health taxonomy (#222): zombie / stalled / working / idle.
+
+    Read-only. Surfaces the stranded-child / recovery-loop cases (``zombie``)
+    automatically — the ``gt feed --problems`` idea grounded in our failure
+    modes — so they no longer need hand-querying the Paperclip DB. Consumed by
+    the /operations dashboard (UI is design-gated, follow-up).
+    """
+    return await pc_get_agent_health()
+
+
+@app.get("/api/operations/agents/escalations")
+async def operations_agent_escalations(limit: int = 10, hours: int = 24):
+    """Recent chair escalations — watchdog + manual (#218/#222).
+
+    Read-only history of what was handed to the chair, for the ops health panel.
+    """
+    return await pc_get_recent_escalations(limit, hours)
+
+
+@app.get("/api/operations/issues/{issue_id}/predecessor")
+async def operations_issue_predecessor(issue_id: str, limit: int = 3):
+    """Recent finished runs on an issue for session continuation (#220, "seance").
+
+    Read-only. Lets a fresh heartbeat read what its predecessors on the same
+    issue concluded (the run ``summary`` each leaves) instead of rediscovering
+    context from scratch. Agent-facing wiring (MCP tool + HEARTBEAT) is a
+    follow-up; this is the backend it will call.
+    """
+    return await pc_get_predecessor_context(issue_id, limit)
+
+
+@app.get("/api/operations/cases/{case_number}/predecessor")
+async def operations_case_predecessor(case_number: str, limit: int = 5):
+    """Recent finished runs across a case's issues (#220, agent-facing "seance").
+
+    Case-scoped sibling of the by-issue endpoint — the plugin tool
+    ``legal_predecessor_context`` calls this so a resuming agent reads what prior
+    sessions on the case concluded (agents key on case_number, not issue UUID).
+    """
+    return await pc_get_predecessor_for_case(case_number, limit)
+
+
@app.get("/api/operations/agents/runs/{run_id}/log")
 async def operations_agent_run_log(run_id: str):
    """Full output log (NDJSON stream) of one heartbeat run."""
--- a/web/paperclip_client.py
+++ b/web/paperclip_client.py
@@ -9,6 +9,7 @@ from __future__ import annotations
 import json
 import logging
 import os
+import re
 import uuid

 import asyncpg
@@ -326,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(
@@ -483,7 +518,8 @@ async def get_case_issues(case_number: str) -> list[dict]:
            """SELECT DISTINCT ON (i.id)
                      i.id, i.title, i.status, i.identifier, i.priority,
                      i.assignee_agent_id, a.name AS assignee_name,
-                      i.started_at, i.completed_at, i.created_at, i.company_id
+                      i.started_at, i.completed_at, i.created_at, i.company_id,
+                      i.parent_id
               FROM issues i
               LEFT JOIN agents a ON i.assignee_agent_id = a.id
               LEFT JOIN plugin_state ps ON ps.scope_id = i.id::text
@@ -509,6 +545,7 @@ async def get_case_issues(case_number: str) -> list[dict]:
                "completed_at": r["completed_at"].isoformat() if r["completed_at"] else None,
                "created_at": r["created_at"].isoformat() if r["created_at"] else None,
                "company_id": str(r["company_id"]),
+                "parent_id": str(r["parent_id"]) if r["parent_id"] else None,
            }
            for r in sorted_rows
        ]
@@ -516,6 +553,43 @@ async def get_case_issues(case_number: str) -> list[dict]:
        await conn.close()


+# A comment posted to a closed issue never wakes an agent — Paperclip skips the
+# wakeup for done/cancelled issues, so the chair's instruction is silently
+# swallowed. The default-target picker MUST therefore avoid these statuses.
+CLOSED_ISSUE_STATUSES = frozenset({"done", "cancelled"})
+
+
+def pick_default_comment_target(issues: list[dict]) -> dict:
+    """Choose which issue a chair comment routes to when none is specified.
+
+    ``issues`` is ordered oldest→newest (see :func:`get_case_issues`). Comment
+    routing is meant to reach the CEO, whose live "התחל תהליך ניסוח" issue is
+    top-level (``parent_id is None``) and open. Preference order:
+      1. newest OPEN top-level issue — the live CEO main issue;
+      2. newest OPEN issue of any depth — a live sub-issue if no main is open;
+      3. newest top-level issue even if closed — better than a closed child;
+      4. newest issue overall — last resort.
+    Excluding closed statuses is the fix for the recurring bug where the newest
+    non-done issue was a *cancelled* child, so the wakeup was skipped and the
+    instruction vanished. ``issues`` must be non-empty.
+    """
+    def is_open(i: dict) -> bool:
+        return i["status"] not in CLOSED_ISSUE_STATUSES
+
+    def is_top(i: dict) -> bool:
+        return i.get("parent_id") is None
+
+    for pred in (
+        lambda i: is_open(i) and is_top(i),
+        is_open,
+        is_top,
+    ):
+        matches = [i for i in issues if pred(i)]
+        if matches:
+            return matches[-1]
+    return issues[-1]
+
+
 async def get_issue_comments(issue_ids: list[str]) -> list[dict]:
    """Get all comments on a list of Paperclip issues, with agent metadata."""
    if not issue_ids:
@@ -615,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:
@@ -635,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:
@@ -648,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"}


@@ -856,6 +916,78 @@ async def reset_case_agents(case_number: str) -> dict:
    }


+ESCALATION_SEVERITIES = ("critical", "high", "medium")
+
+
+async def escalate_issue(
+    issue_id: str, severity: str, reason: str, company_id: str = "",
+) -> dict:
+    """First-class, severity-routed escalation of a stuck issue to the chair (#218).
+
+    Replaces the fragile manual "PATCH dance" (reassign + set in_review + open an
+    interaction) that repeatedly tripped Paperclip's recovery loops
+    (``source_scoped_recovery_action`` / ``stranded_assigned_issue`` /
+    ``issue_reopened_via_comment``; see memory reference_paperclip_recovery_loops).
+
+    Two effects in **one DB transaction**, mirroring the proven loop-safe path of
+    :func:`reset_case_agents` (raw SQL, not REST):
+
+    1. **Atomic human-owned transition** — a single ``UPDATE`` to the stable end
+       state ``{status:'in_review', assignee_agent_id:null,
+       assignee_user_id:CHAIM_USER_ID}`` (recovery-loops rule #7). Direct-DB on
+       purpose: it bypasses Paperclip's disposition resolver — the very machinery
+       whose multi-PATCH/`issue.released` behaviour *causes* the loops — so the
+       issue lands human-owned in one shot with no ``done→todo`` flip.
+    2. **Durable severity note** — an ``author_type='system'`` comment recording
+       severity + reason. System-authored on purpose: the ``route-pending-comments``
+       sweep routes only ``author_type='user'`` (chair) comments to the CEO, so a
+       system note is inert w.r.t. routing and will **not** re-wake an agent
+       (project_comment_delivery_guarantee). No wakeup is issued — the whole point
+       is to hand off to the human, not re-invoke an agent.
+
+    The ``agent.escalated`` telemetry event is emitted by the Port wrapper
+    (docs/spec/X15) — this is the loop-safe counterpart the CEO/analysts reach
+    for instead of leaving an issue agent-owned+blocked.
+    """
+    if severity not in ESCALATION_SEVERITIES:
+        return {
+            "ok": False,
+            "error": f"invalid severity {severity!r}; expected one of {ESCALATION_SEVERITIES}",
+        }
+
+    body = f"🚨 הסלמה [{severity}] לחיים\n\n{reason}"
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        async with conn.transaction():
+            row = await conn.fetchrow(
+                """UPDATE issues
+                      SET status='in_review', assignee_agent_id=null,
+                          assignee_user_id=$1, updated_at=now()
+                    WHERE id=$2::uuid
+                RETURNING id, identifier, company_id""",
+                CHAIM_USER_ID, 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, body,
+            )
+    finally:
+        await conn.close()
+
+    logger.info("Escalated issue %s to chair [severity=%s]", issue_id, severity)
+    return {
+        "ok": True,
+        "id": str(row["id"]),
+        "identifier": row["identifier"],
+        "severity": severity,
+        "status": "in_review",
+    }
+
+
 async def respond_to_interaction(
    issue_id: str, interaction_id: str, payload: dict,
 ) -> dict:
@@ -962,6 +1094,249 @@ async def reap_stale_interactions() -> dict:
    return {"ok": True, "cancelled": len(rows)}


+# Windows for the agent-health taxonomy (#222). A run with no finished_at older
+# than the live window is treated as dead (not "working"); wakeups are counted
+# over the recovery window to spot loops.
+_HEALTH_LIVE_RUN_WINDOW = "30 minutes"
+_HEALTH_WAKEUP_WINDOW = "2 hours"
+
+
+async def get_agent_health() -> dict:
+    """Classify every open, agent-assigned issue into a health state (#222).
+
+    Read-only. Derives, per issue, the three primitives the pure classifier
+    (:func:`web.agent_health.classify_issue_health`) needs, from Paperclip's
+    ``heartbeat_runs`` (a live run = ``finished_at IS NULL`` within the live
+    window) and ``agent_wakeup_requests`` (total + recovery-marker counts within
+    the recovery window). Scoped to the two legal-ai companies.
+
+    Surfaces the stranded-child / recovery-loop cases (``zombie``) automatically
+    instead of by hand-querying the DB. Returns items sorted worst-first.
+    """
+    from web.agent_health import (  # local import: keep the shell → agnostic dep inward
+        HEALTH_STATES,
+        classify_issue_health,
+        is_recovery_reason,
+    )
+
+    company_ids = list(COMPANIES.values())
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        issues = await conn.fetch(
+            """SELECT i.id, i.identifier, i.status, i.assignee_agent_id,
+                      a.name AS agent_name
+                 FROM issues i
+                 JOIN agents a ON a.id = i.assignee_agent_id
+                WHERE i.company_id = ANY($1::uuid[])
+                  AND i.assignee_agent_id IS NOT NULL
+                  AND i.status IN ('backlog','todo','in_progress','blocked','in_review')""",
+            company_ids,
+        )
+        if not issues:
+            return {"ok": True, "items": [], "counts": {s: 0 for s in HEALTH_STATES}}
+
+        agent_ids = list({str(r["assignee_agent_id"]) for r in issues})
+
+        live_rows = await conn.fetch(
+            f"""SELECT DISTINCT agent_id FROM heartbeat_runs
+                 WHERE agent_id = ANY($1::uuid[])
+                   AND finished_at IS NULL
+                   AND started_at > now() - interval '{_HEALTH_LIVE_RUN_WINDOW}'""",
+            agent_ids,
+        )
+        live_agents = {str(r["agent_id"]) for r in live_rows}
+
+        wake_rows = await conn.fetch(
+            f"""SELECT agent_id, payload->>'issueId' AS issue_id, reason
+                  FROM agent_wakeup_requests
+                 WHERE agent_id = ANY($1::uuid[])
+                   AND requested_at > now() - interval '{_HEALTH_WAKEUP_WINDOW}'""",
+            agent_ids,
+        )
+    finally:
+        await conn.close()
+
+    total_by_issue: dict[str, int] = {}
+    recovery_by_issue: dict[str, int] = {}
+    for w in wake_rows:
+        iid = w["issue_id"]
+        if not iid:
+            continue
+        total_by_issue[iid] = total_by_issue.get(iid, 0) + 1
+        if is_recovery_reason(w["reason"]):
+            recovery_by_issue[iid] = recovery_by_issue.get(iid, 0) + 1
+
+    items = []
+    counts = {s: 0 for s in HEALTH_STATES}
+    for r in issues:
+        iid = str(r["id"])
+        state = classify_issue_health(
+            has_live_run=str(r["assignee_agent_id"]) in live_agents,
+            recovery_wakeups=recovery_by_issue.get(iid, 0),
+            total_wakeups=total_by_issue.get(iid, 0),
+        )
+        counts[state] += 1
+        items.append({
+            "issue_id": iid,
+            "identifier": r["identifier"],
+            "status": r["status"],
+            "agent_id": str(r["assignee_agent_id"]),
+            "agent_name": r["agent_name"],
+            "health": state,
+            "wakeups": total_by_issue.get(iid, 0),
+            "recovery_wakeups": recovery_by_issue.get(iid, 0),
+        })
+
+    order = {s: i for i, s in enumerate(HEALTH_STATES)}
+    items.sort(key=lambda it: (order[it["health"]], -it["recovery_wakeups"]))
+    return {"ok": True, "items": items, "counts": counts}
+
+
+# The escalation note escalate_issue() writes as an author_type='system' comment.
+# One prefix + a [severity] tag — parsed back here for the ops panel (#218/#222 UI).
+_ESCALATION_BODY_PREFIX = "🚨 הסלמה"
+_ESCALATION_SEVERITY_RE = re.compile(r"\[(critical|high|medium)\]")
+
+
+async def get_recent_escalations(limit: int = 10, hours: int = 24) -> dict:
+    """Recent chair escalations (watchdog + manual), newest-first (#218/#222 UI).
+
+    Read-only. Reconstructs escalations from the ``author_type='system'`` notes
+    escalate_issue() leaves (``🚨 הסלמה [severity] לחיים\\n\\n<reason>``) — severity
+    parsed from the tag, reason from the body, identifier joined from the issue.
+    Scoped to the two legal-ai companies; ``limit`` clamped 1..50, ``hours`` 1..168.
+    """
+    limit = max(1, min(int(limit), 50))
+    hours = max(1, min(int(hours), 168))
+    company_ids = list(COMPANIES.values())
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        rows = await conn.fetch(
+            f"""SELECT ic.issue_id, ic.body, ic.created_at, i.identifier
+                  FROM issue_comments ic
+                  JOIN issues i ON i.id = ic.issue_id
+                 WHERE ic.author_type = 'system'
+                   AND ic.company_id = ANY($1::uuid[])
+                   AND ic.body LIKE $2
+                   AND ic.deleted_at IS NULL
+                   AND ic.created_at > now() - interval '{hours} hours'
+              ORDER BY ic.created_at DESC
+                 LIMIT $3""",
+            company_ids, f"{_ESCALATION_BODY_PREFIX}%", limit,
+        )
+    finally:
+        await conn.close()
+
+    items = []
+    for r in rows:
+        body = r["body"] or ""
+        m = _ESCALATION_SEVERITY_RE.search(body)
+        severity = m.group(1) if m else "medium"
+        reason = body.split("\n\n", 1)[1].strip() if "\n\n" in body else body
+        items.append({
+            "issue_id": str(r["issue_id"]),
+            "identifier": r["identifier"],
+            "severity": severity,
+            "reason": reason,
+            "created_at": r["created_at"].isoformat() if r["created_at"] else None,
+        })
+    return {"ok": True, "items": items}
+
+
+async def get_predecessor_context(issue_id: str, limit: int = 3) -> dict:
+    """Recent finished runs on an issue, newest-first, for session continuation (#220).
+
+    The "seance" idea from Gastown, grounded in our data: each ephemeral heartbeat
+    rediscovers context every wake (the generic *blind heartbeat*; see
+    [[project_comment_delivery_guarantee]]). This lets a fresh wake read what its
+    predecessors on the SAME issue concluded — the run ``summary`` each heartbeat
+    leaves in ``heartbeat_runs.result_json`` — instead of re-deriving from scratch.
+
+    Read-only. Runs are tied to the issue via ``wakeup_request_id`` →
+    ``agent_wakeup_requests.payload->>'issueId'`` (only finished runs are useful
+    as predecessors). ``limit`` is clamped to 1..10.
+    """
+    limit = max(1, min(int(limit), 10))
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        rows = await conn.fetch(
+            """SELECT h.id, h.status, h.started_at, h.finished_at,
+                      h.result_json->>'summary' AS summary,
+                      h.error_code, h.session_id_after, a.name AS agent_name
+                 FROM heartbeat_runs h
+                 JOIN agent_wakeup_requests w ON w.id = h.wakeup_request_id
+                 LEFT JOIN agents a ON a.id = h.agent_id
+                WHERE w.payload->>'issueId' = $1
+                  AND h.finished_at IS NOT NULL
+                ORDER BY h.started_at DESC
+                LIMIT $2""",
+            issue_id, limit,
+        )
+    finally:
+        await conn.close()
+
+    runs = [_shape_predecessor_run(r) for r in rows]
+    return {"ok": True, "issue_id": issue_id, "runs": runs}
+
+
+def _shape_predecessor_run(r) -> dict:
+    """Shared row → predecessor-run dict (by-issue and by-case entry points, G2)."""
+    return {
+        "run_id": str(r["id"]),
+        "status": r["status"],
+        "started_at": r["started_at"].isoformat() if r["started_at"] else None,
+        "finished_at": r["finished_at"].isoformat() if r["finished_at"] else None,
+        "summary": r["summary"],
+        "error_code": r["error_code"],
+        "session_id": r["session_id_after"],
+        "agent_name": r["agent_name"],
+    }
+
+
+async def get_predecessor_for_case(case_number: str, limit: int = 5) -> dict:
+    """Recent finished runs across a CASE's issues, newest-first (#220, agent-facing).
+
+    The case-scoped sibling of :func:`get_predecessor_context`. The agent knows its
+    ``case_number`` (not the Paperclip issue UUID), so the plugin tool
+    ``legal_predecessor_context`` calls this. Resolves the case's Paperclip project,
+    then returns finished heartbeat-run summaries across its issues — so a resuming
+    wake reads what prior sessions on the case concluded instead of re-deriving.
+
+    Read-only. The issue join casts the known-valid ``issues.id`` to text (rather
+    than the free-form ``payload->>'issueId'`` to uuid) so a malformed payload
+    can't break the query. ``limit`` clamped 1..10.
+    """
+    limit = max(1, min(int(limit), 10))
+    conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+    try:
+        project = await conn.fetchrow(
+            "SELECT id FROM projects WHERE name LIKE $1 LIMIT 1", f"%{case_number}%",
+        )
+        if not project:
+            return {"ok": True, "case_number": case_number, "runs": []}
+        rows = await conn.fetch(
+            """SELECT h.id, h.status, h.started_at, h.finished_at,
+                      h.result_json->>'summary' AS summary,
+                      h.error_code, h.session_id_after, a.name AS agent_name,
+                      i.identifier
+                 FROM heartbeat_runs h
+                 JOIN agent_wakeup_requests w ON w.id = h.wakeup_request_id
+                 JOIN issues i ON i.id::text = w.payload->>'issueId'
+                 LEFT JOIN agents a ON a.id = h.agent_id
+                WHERE i.project_id = $1
+                  AND h.finished_at IS NOT NULL
+                  AND h.result_json->>'summary' IS NOT NULL
+                ORDER BY h.started_at DESC
+                LIMIT $2""",
+            project["id"], limit,
+        )
+    finally:
+        await conn.close()
+
+    runs = [{**_shape_predecessor_run(r), "identifier": r["identifier"]} for r in rows]
+    return {"ok": True, "case_number": case_number, "runs": runs}
+
+
 # Singleton project for the precedent-library extraction queue. One issue per
 # uploaded precedent — assigned to the CEO who runs the local-MCP extractor.
 _LIBRARY_PROJECT_NAME = "ספריית פסיקה — תור חילוץ"
@@ -1384,6 +1759,93 @@ async def wake_ceo_for_action(
    }


+async def open_ceo_run(
+    case_number: str,
+    instruction: str,
+    company_id: str = "",
+) -> dict:
+    """Open a FRESH CEO-owned run carrying a free-form chair instruction.
+
+    Drives the "פתח הרצה חדשה" option of the agents-tab target selector: instead
+    of appending the instruction to an existing (possibly human-owned or closed)
+    issue, a **child issue assigned to the CEO** is created under the case's main
+    issue and the CEO is woken on it. This is the same CEO-child primitive as
+    :func:`wake_ceo_for_action` (#227) — it sidesteps the ``issue_assignee_changed``
+    cancellation that fires when an agent is woken on a human-owned parent (the
+    exact silent failure the chair hit on 1027-04-26; see TaskMaster #228).
+
+    Wakeup goes through the Paperclip API, never a direct DB insert. Returns
+    ``{"status":"ok", "issue_id"(=child), "identifier", ...}`` or
+    ``{"status":"skipped", "reason": ...}``.
+    """
+    if not PAPERCLIP_BOARD_API_KEY:
+        logger.warning("PAPERCLIP_BOARD_API_KEY not set — skipping CEO new-run")
+        return {"status": "skipped", "reason": "no_api_key"}
+
+    issues = await get_case_issues(case_number)
+    if not issues:
+        logger.warning("No Paperclip issues for case %s — skipping CEO new-run", case_number)
+        return {"status": "skipped", "reason": "no_issue"}
+
+    # Parent the new run under the live main issue (never a closed child).
+    main_issue = pick_default_comment_target(issues)
+    main_issue_id = main_issue["id"]
+    if not company_id:
+        company_id = main_issue.get("company_id", "")
+    ceo_id = CEO_AGENTS.get(company_id, CEO_AGENT_ID)
+
+    title = f'[ערר {case_number}] הוראת יו"ר — הרצה חדשה'
+    description = (
+        'הוראת יו"ר שנשלחה כ"הרצה חדשה" מטאב הסוכנים. קרא את מצב התיק, טפל בהוראה '
+        "בסגנון דפנה, ומסור disposition תקין בסיום.\n\n---\n\n" + instruction
+    )
+    child_resp = await pc_request(
+        "POST",
+        f"/api/issues/{main_issue_id}/children",
+        json={
+            "title": title,
+            "description": description,
+            "status": "in_progress",
+            "priority": "medium",
+            "assigneeAgentId": ceo_id,
+        },
+        raise_on_error=True,
+    )
+    sub_issue = child_resp.json()
+    sub_issue_id = sub_issue["id"]
+
+    try:
+        conn = await asyncpg.connect(PAPERCLIP_DB_URL)
+        try:
+            await _link_case_to_issue(conn, sub_issue_id, case_number)
+        finally:
+            await conn.close()
+    except Exception as e:
+        logger.warning("plugin_state link failed for new-run sub_issue=%s: %s", sub_issue_id, e)
+
+    await pc_request(
+        "POST",
+        f"/api/agents/{ceo_id}/wakeup",
+        json={
+            "source": "on_demand",
+            "triggerDetail": "manual",
+            "reason": f"chair_new_run_{case_number}",
+            "payload": {"issueId": sub_issue_id, "case_number": case_number},
+        },
+        raise_on_error=True,
+    )
+    logger.info(
+        "CEO new-run for case %s: child_issue=%s ceo=%s", case_number, sub_issue_id, ceo_id,
+    )
+    return {
+        "status": "ok",
+        "issue_id": sub_issue_id,
+        "identifier": sub_issue.get("identifier", ""),
+        "main_issue_id": main_issue_id,
+        "ceo_id": ceo_id,
+    }
+
+
 # Substring of the generation child-issue title per action (see _ceo_action_brief).
 GENERATION_TITLE_SUBSTR = {
    "party_claims_summary": "סיכום-מנהלים",
--- a/web/tests/test_agent_health.py
+++ b/web/tests/test_agent_health.py
@@ -0,0 +1,251 @@
+"""Tests for #222 — agent health taxonomy (pure classifier + Paperclip fetch).
+
+Pure-classifier tests need no deps. The fetch test fakes an asyncpg connection
+(routing the three queries by content) so it never touches the live DB.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # web/
+
+from agent_health import (  # noqa: E402
+    STALL_WAKEUP_THRESHOLD,
+    classify_issue_health,
+    is_recovery_reason,
+    zombie_escalation,
+)
+from agent_health import ZOMBIE_ESCALATE_MIN_RECOVERY  # noqa: E402
+
+
+# ── pure classifier ────────────────────────────────────────────────────────
+def test_live_run_is_working_regardless_of_wakeups():
+    assert classify_issue_health(has_live_run=True, recovery_wakeups=9, total_wakeups=9) == "working"
+
+
+def test_recovery_wakeup_without_live_run_is_zombie():
+    # the stranded-child signature: assigned+open, nothing running, recovery firing
+    assert classify_issue_health(has_live_run=False, recovery_wakeups=1, total_wakeups=1) == "zombie"
+
+
+def test_repeated_wakeups_no_recovery_is_stalled():
+    assert (
+        classify_issue_health(
+            has_live_run=False, recovery_wakeups=0, total_wakeups=STALL_WAKEUP_THRESHOLD
+        )
+        == "stalled"
+    )
+
+
+def test_quiet_open_issue_is_idle():
+    assert classify_issue_health(has_live_run=False, recovery_wakeups=0, total_wakeups=1) == "idle"
+
+
+# ── watchdog escalation policy (pure) ───────────────────────────────────────
+def _item(health, recovery):
+    return {"health": health, "recovery_wakeups": recovery, "identifier": "CMP-141", "agent_name": "writer"}
+
+
+def test_zombie_escalation_medium_for_fresh_loop():
+    decision = zombie_escalation(_item("zombie", ZOMBIE_ESCALATE_MIN_RECOVERY))
+    assert decision is not None
+    severity, reason = decision
+    assert severity == "medium"
+    assert "CMP-141" in reason and "recovery" in reason.lower()
+
+
+def test_zombie_escalation_high_for_long_loop():
+    severity, _ = zombie_escalation(_item("zombie", 5))
+    assert severity == "high"
+
+
+def test_zombie_below_threshold_is_not_escalated():
+    assert zombie_escalation(_item("zombie", ZOMBIE_ESCALATE_MIN_RECOVERY - 1)) is None
+
+
+def test_non_zombie_never_escalates():
+    assert zombie_escalation(_item("stalled", 9)) is None
+    assert zombie_escalation(_item("idle", 0)) is None
+    assert zombie_escalation(_item("working", 9)) is None
+
+
+def test_is_recovery_reason_markers():
+    assert is_recovery_reason("source_scoped_recovery_action")
+    assert is_recovery_reason("issue_continuation_needed")
+    assert is_recovery_reason("issue_reopened_via_comment")
+    assert not is_recovery_reason("start_workflow_8125-09-24")
+    assert not is_recovery_reason(None)
+
+
+# ── Paperclip fetch (fake DB) ───────────────────────────────────────────────
+os.environ.setdefault("PAPERCLIP_DB_URL", "postgres://x:x@127.0.0.1:54329/paperclip")
+pc = pytest.importorskip("paperclip_client", reason="web deps unavailable")
+
+
+class _FakeConn:
+    def __init__(self, issues, live, wakeups):
+        self._issues, self._live, self._wakeups = issues, live, wakeups
+
+    async def fetch(self, query, *args):
+        if "FROM issues" in query:
+            return self._issues
+        if "heartbeat_runs" in query:
+            return self._live
+        if "agent_wakeup_requests" in query:
+            return self._wakeups
+        raise AssertionError(f"unexpected query: {query[:40]}")
+
+    async def close(self):
+        pass
+
+
+def test_get_agent_health_classifies_and_sorts(monkeypatch):
+    # zombie agent A (recovery wake, no live run); working agent B (live run);
+    # idle agent C (quiet).
+    issues = [
+        {"id": "iA", "identifier": "CMP-1", "status": "blocked", "assignee_agent_id": "agA", "agent_name": "writer"},
+        {"id": "iB", "identifier": "CMP-2", "status": "in_progress", "assignee_agent_id": "agB", "agent_name": "analyst"},
+        {"id": "iC", "identifier": "CMP-3", "status": "todo", "assignee_agent_id": "agC", "agent_name": "qa"},
+    ]
+    live = [{"agent_id": "agB"}]
+    wakeups = [
+        {"agent_id": "agA", "issue_id": "iA", "reason": "source_scoped_recovery_action"},
+        {"agent_id": "agC", "issue_id": "iC", "reason": "start_workflow_x"},
+    ]
+
+    async def _connect(_url):
+        return _FakeConn(issues, live, wakeups)
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+
+    result = asyncio.run(pc.get_agent_health())
+    assert result["ok"] is True
+    by_issue = {it["issue_id"]: it["health"] for it in result["items"]}
+    assert by_issue == {"iA": "zombie", "iB": "working", "iC": "idle"}
+    assert result["counts"]["zombie"] == 1
+    assert result["counts"]["working"] == 1
+    assert result["counts"]["idle"] == 1
+    # worst-first: zombie leads
+    assert result["items"][0]["health"] == "zombie"
+    assert result["items"][0]["recovery_wakeups"] == 1
+
+
+def test_get_agent_health_empty(monkeypatch):
+    async def _connect(_url):
+        return _FakeConn([], [], [])
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    result = asyncio.run(pc.get_agent_health())
+    assert result == {"ok": True, "items": [], "counts": {"zombie": 0, "stalled": 0, "working": 0, "idle": 0}}
+
+
+# ── recent escalations (fake DB) — parses severity + reason from system notes ──
+class _FetchConn:
+    def __init__(self, rows):
+        self._rows = rows
+
+    async def fetch(self, query, *args):
+        return self._rows
+
+    async def close(self):
+        pass
+
+
+def test_get_recent_escalations_parses_severity_and_reason(monkeypatch):
+    from datetime import datetime
+
+    rows = [
+        {
+            "issue_id": "iss-1",
+            "identifier": "CMP-141",
+            "body": "🚨 הסלמה [high] לחיים\n\nזוהתה לולאת-recovery — 4 יקיצות-שחזור; נמסר לחיים.",
+            "created_at": datetime(2026, 7, 7, 3, 30, 0),
+        },
+        {
+            "issue_id": "iss-2",
+            "identifier": "CMPA-112",
+            "body": "🚨 הסלמה [medium] לחיים\n\nזוהתה לולאת-recovery — 2 יקיצות.",
+            "created_at": datetime(2026, 7, 7, 2, 49, 0),
+        },
+    ]
+
+    async def _connect(_url):
+        return _FetchConn(rows)
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    result = asyncio.run(pc.get_recent_escalations())
+    assert result["ok"] is True
+    a, b = result["items"]
+    assert a["identifier"] == "CMP-141" and a["severity"] == "high"
+    assert "4 יקיצות" in a["reason"] and "🚨" not in a["reason"]
+    assert a["created_at"] == "2026-07-07T03:30:00"
+    assert b["severity"] == "medium"
+
+
+def test_get_recent_escalations_defaults_severity_when_untagged(monkeypatch):
+    rows = [{"issue_id": "x", "identifier": "CMP-9", "body": "🚨 הסלמה לחיים", "created_at": None}]
+
+    async def _connect(_url):
+        return _FetchConn(rows)
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    (item,) = asyncio.run(pc.get_recent_escalations())["items"]
+    assert item["severity"] == "medium"  # fallback
+    assert item["created_at"] is None
+
+
+# ── predecessor by case (#220 agent-facing) — resolve project then shape runs ──
+class _ProjectRunsConn:
+    def __init__(self, project, runs):
+        self._project, self._runs = project, runs
+
+    async def fetchrow(self, query, *args):
+        return self._project
+
+    async def fetch(self, query, *args):
+        return self._runs
+
+    async def close(self):
+        pass
+
+
+def test_get_predecessor_for_case_shapes_runs(monkeypatch):
+    from datetime import datetime
+
+    runs = [
+        {
+            "id": "run-1", "status": "succeeded",
+            "started_at": datetime(2026, 7, 5, 10, 0, 0),
+            "finished_at": datetime(2026, 7, 5, 10, 5, 0),
+            "summary": "הלולאה נסגרה כראוי", "error_code": None,
+            "session_id_after": "sess-9", "agent_name": "עוזר משפטי",
+            "identifier": "CMP-141",
+        },
+    ]
+
+    async def _connect(_url):
+        return _ProjectRunsConn({"id": "proj-1"}, runs)
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    result = asyncio.run(pc.get_predecessor_for_case("1043-02-26"))
+    assert result["ok"] is True and result["case_number"] == "1043-02-26"
+    (run,) = result["runs"]
+    assert run["run_id"] == "run-1"
+    assert run["identifier"] == "CMP-141"  # by-case adds which issue
+    assert run["started_at"] == "2026-07-05T10:00:00"
+    assert "הלולאה" in run["summary"]
+
+
+def test_get_predecessor_for_case_unknown_case_is_empty(monkeypatch):
+    async def _connect(_url):
+        return _ProjectRunsConn(None, [])  # no project row
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    result = asyncio.run(pc.get_predecessor_for_case("9999-99-99"))
+    assert result == {"ok": True, "case_number": "9999-99-99", "runs": []}
--- a/web/tests/test_agent_telemetry.py
+++ b/web/tests/test_agent_telemetry.py
@@ -0,0 +1,104 @@
+"""Tests for #219 — web.agent_telemetry structured agent-platform events.
+
+Verifies the emitter contract the recovery-loop observability relies on:
+- ``emit`` stamps ts/v/event/outcome and drops ``None`` fields.
+- ``instrument`` lifts standard + result keys, times the call, and derives the
+  outcome (ok / noop for ``{"ok": False}`` / error on exception).
+- an exception is re-raised after the error event — the wrapped op is **never
+  silently swallowed** (constitution §6 / INV-G4).
+- the decorator is transparent: wrapped functions stay coroutine functions.
+
+Pure-stdlib module (no Paperclip/web deps), so this runs without importorskip.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import inspect
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # web/
+
+from agent_telemetry import SCHEMA_VERSION, emit, instrument  # noqa: E402
+import agent_telemetry  # noqa: E402
+
+
+@pytest.fixture
+def captured(monkeypatch):
+    """Intercept the sink; yield the list of emitted event dicts."""
+    events: list[dict] = []
+    monkeypatch.setattr(agent_telemetry, "_SINK", events.append)
+    return events
+
+
+def test_emit_stamps_schema_and_drops_none(captured):
+    emit("x.test", role="ceo", case_number="8125-09-24", issue_id=None)
+    (e,) = captured
+    assert e["event"] == "x.test"
+    assert e["v"] == SCHEMA_VERSION
+    assert e["outcome"] == "ok"
+    assert e["ts"].endswith("Z")
+    assert e["case_number"] == "8125-09-24"
+    assert "issue_id" not in e  # None fields dropped
+
+
+def test_instrument_success_lifts_result_keys(captured):
+    @instrument("interaction.reaped", result_keys=("cancelled",))
+    async def reap():
+        return {"ok": True, "cancelled": 3}
+
+    result = asyncio.run(reap())
+    assert result == {"ok": True, "cancelled": 3}
+    (e,) = captured
+    assert e["event"] == "interaction.reaped"
+    assert e["outcome"] == "ok"
+    assert e["cancelled"] == 3
+    assert "duration_ms" in e
+
+
+def test_instrument_ok_false_is_noop(captured):
+    @instrument("interaction.cancelled", keys=("issue_id",))
+    async def cancel(issue_id, interaction_id):
+        return {"ok": False, "error": "already resolved"}
+
+    asyncio.run(cancel("iss-1", "int-9"))
+    (e,) = captured
+    assert e["outcome"] == "noop"
+    assert e["issue_id"] == "iss-1"
+
+
+def test_instrument_reraises_after_error_event(captured):
+    @instrument("agent.wakeup", role="ceo")
+    async def wake(case_number, company_id=""):
+        raise RuntimeError("boom")
+
+    with pytest.raises(RuntimeError, match="boom"):
+        asyncio.run(wake("1043-04-26", company_id="cmp"))
+
+    (e,) = captured
+    assert e["outcome"] == "error"
+    assert "boom" in e["error"]
+    assert e["agent_role"] == "ceo"
+    assert e["case_number"] == "1043-04-26"
+    assert e["company_id"] == "cmp"
+
+
+def test_decorator_is_transparent():
+    @instrument("agent.wakeup", role="analyst")
+    async def wake(case_number, company_id=""):
+        return {"ok": True}
+
+    assert inspect.iscoroutinefunction(wake)
+    assert wake.__name__ == "wake"
+
+
+def test_emit_never_raises_on_sink_failure(monkeypatch):
+    def boom(_payload):
+        raise ValueError("sink down")
+
+    monkeypatch.setattr(agent_telemetry, "_SINK", boom)
+    # Must not propagate — telemetry is best-effort, never fatal to the op.
+    emit("agent.wakeup", role="ceo")
--- a/web/tests/test_comment_target.py
+++ b/web/tests/test_comment_target.py
@@ -0,0 +1,78 @@
+"""Tests for pick_default_comment_target — chair-comment routing.
+
+Regression guard for the recurring bug where a chair instruction typed into the
+"כתוב הוראה לסוכנים..." box was routed to a *cancelled* child issue, so
+Paperclip skipped the wakeup and the instruction was silently swallowed.
+
+The picker must never default to a closed (done/cancelled) issue and must prefer
+the live top-level CEO issue. Pure function — no DB, no FastAPI.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("PAPERCLIP_DB_URL", "postgres://x:x@127.0.0.1:54329/paperclip")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # web/
+
+pc = pytest.importorskip("paperclip_client", reason="web deps unavailable")
+
+
+def _iss(id_, status, parent_id=None):
+    return {"id": id_, "status": status, "parent_id": parent_id, "identifier": id_}
+
+
+def test_prefers_open_top_level_over_newer_cancelled_child():
+    """The exact 1027-04-26 scenario: newest non-done issue is a cancelled child;
+    routing must still land on the live top-level CEO issue."""
+    issues = [
+        _iss("main-old", "done"),                       # oldest top-level, closed
+        _iss("main-live", "in_review"),                 # live CEO main issue
+        _iss("child-cancelled", "cancelled", "main-live"),  # newest non-done → the trap
+        _iss("child-done", "done", "main-live"),
+    ]
+    assert pc.pick_default_comment_target(issues)["id"] == "main-live"
+
+
+def test_never_returns_cancelled_when_an_open_issue_exists():
+    issues = [
+        _iss("a", "done"),
+        _iss("b", "in_progress", "a"),
+        _iss("c", "cancelled", "a"),
+    ]
+    assert pc.pick_default_comment_target(issues)["status"] != "cancelled"
+
+
+def test_falls_back_to_open_child_when_no_open_top_level():
+    issues = [
+        _iss("main", "done"),
+        _iss("child-live", "in_progress", "main"),
+    ]
+    assert pc.pick_default_comment_target(issues)["id"] == "child-live"
+
+
+def test_prefers_top_level_when_everything_closed():
+    """No open issue anywhere — pick the newest top-level (better than a child)."""
+    issues = [
+        _iss("main-1", "done"),
+        _iss("main-2", "cancelled"),
+        _iss("child", "done", "main-2"),
+    ]
+    assert pc.pick_default_comment_target(issues)["id"] == "main-2"
+
+
+def test_single_issue():
+    issues = [_iss("only", "cancelled")]
+    assert pc.pick_default_comment_target(issues)["id"] == "only"
+
+
+def test_picks_newest_open_top_level():
+    issues = [
+        _iss("main-1", "in_review"),
+        _iss("main-2", "in_review"),
+    ]
+    assert pc.pick_default_comment_target(issues)["id"] == "main-2"
--- a/web/tests/test_escalate_issue.py
+++ b/web/tests/test_escalate_issue.py
@@ -0,0 +1,118 @@
+"""Tests for #218 — paperclip_client.escalate_issue (loop-safe chair escalation).
+
+Verifies the primitive that replaces the fragile manual PATCH dance:
+- invalid severity is rejected before any DB work.
+- the happy path performs ONE atomic human-owned transition
+  (``status='in_review'``, ``assignee_user_id=CHAIM_USER_ID``) and records a
+  ``author_type='system'`` severity note carrying the reason.
+- **no wakeup / REST call is issued** — escalation hands off to the human, it
+  must never re-invoke an agent (that is what caused the recovery loops).
+- a missing issue reports ``ok:False`` and writes no comment.
+
+Uses a fake asyncpg connection — never touches the live Paperclip DB.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("PAPERCLIP_DB_URL", "postgres://x:x@127.0.0.1:54329/paperclip")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # web/
+
+pc = pytest.importorskip("paperclip_client", reason="web deps unavailable")
+
+
+class _FakeTxn:
+    async def __aenter__(self):
+        return None
+
+    async def __aexit__(self, *exc):
+        return False
+
+
+class _FakeConn:
+    def __init__(self, row):
+        self._row = row
+        self.updates: list[tuple] = []
+        self.inserts: list[tuple] = []
+        self.closed = False
+
+    def transaction(self):
+        return _FakeTxn()
+
+    async def fetchrow(self, query, *args):
+        self.updates.append((query, args))
+        return self._row
+
+    async def execute(self, query, *args):
+        self.inserts.append((query, args))
+
+    async def close(self):
+        self.closed = True
+
+
+@pytest.fixture
+def fake_db(monkeypatch):
+    """Patch asyncpg.connect + guard that no wakeup/REST is issued."""
+    conns: list[_FakeConn] = []
+    row = {"id": "iss-uuid", "identifier": "CMP-141", "company_id": "cmp-uuid"}
+    holder = {"row": row}
+
+    async def _connect(_url):
+        conn = _FakeConn(holder["row"])
+        conns.append(conn)
+        return conn
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+
+    async def _forbidden(*a, **k):  # any REST/wakeup would be a loop-risk
+        raise AssertionError("escalate_issue must not issue a wakeup/REST call")
+
+    monkeypatch.setattr(pc, "pc_request", _forbidden, raising=False)
+    return {"conns": conns, "holder": holder}
+
+
+def test_invalid_severity_rejected_before_db(fake_db):
+    result = asyncio.run(pc.escalate_issue("iss-1", "urgent", "boom"))
+    assert result["ok"] is False
+    assert "invalid severity" in result["error"]
+    assert fake_db["conns"] == []  # never connected
+
+
+def test_happy_path_atomic_transition_and_system_note(fake_db):
+    result = asyncio.run(
+        pc.escalate_issue("iss-uuid", "high", "analyst wedged on protocol parse")
+    )
+    assert result == {
+        "ok": True,
+        "id": "iss-uuid",
+        "identifier": "CMP-141",
+        "severity": "high",
+        "status": "in_review",
+    }
+    conn = fake_db["conns"][0]
+    # 1) one human-owned UPDATE with the chair user + in_review
+    (update_sql, update_args) = conn.updates[0]
+    assert "status='in_review'" in update_sql
+    assert "assignee_agent_id=null" in update_sql
+    assert update_args[0] == pc.CHAIM_USER_ID
+    assert update_args[1] == "iss-uuid"
+    # 2) a system-authored severity note carrying the reason
+    (insert_sql, insert_args) = conn.inserts[0]
+    assert "issue_comments" in insert_sql
+    assert "'system'" in insert_sql
+    assert "high" in insert_args[3] and "wedged on protocol parse" in insert_args[3]
+    assert conn.closed is True
+
+
+def test_missing_issue_reports_not_found_and_writes_no_comment(fake_db):
+    fake_db["holder"]["row"] = None
+    result = asyncio.run(pc.escalate_issue("ghost", "medium", "nope"))
+    assert result["ok"] is False and "not found" in result["error"]
+    conn = fake_db["conns"][0]
+    assert conn.inserts == []  # no comment on a non-existent issue
--- a/web/tests/test_predecessor_context.py
+++ b/web/tests/test_predecessor_context.py
@@ -0,0 +1,84 @@
+"""Tests for #220 — paperclip_client.get_predecessor_context ("seance").
+
+Fakes an asyncpg connection so it never touches the live DB. Verifies the
+limit clamp, row shaping (timestamps → isoformat), and the empty case.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+os.environ.setdefault("PAPERCLIP_DB_URL", "postgres://x:x@127.0.0.1:54329/paperclip")
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))  # web/
+
+pc = pytest.importorskip("paperclip_client", reason="web deps unavailable")
+
+
+class _FakeConn:
+    def __init__(self, rows):
+        self._rows = rows
+        self.calls: list[tuple] = []
+
+    async def fetch(self, query, *args):
+        self.calls.append((query, args))
+        return self._rows
+
+    async def close(self):
+        pass
+
+
+def _row():
+    return {
+        "id": "run-1",
+        "status": "succeeded",
+        "started_at": datetime(2026, 7, 5, 10, 0, 0),
+        "finished_at": datetime(2026, 7, 5, 10, 5, 0),
+        "summary": "כתבתי בלוק ז — 3,206 מילים",
+        "error_code": None,
+        "session_id_after": "sess-abc",
+        "agent_name": "writer",
+    }
+
+
+@pytest.fixture
+def fake(monkeypatch):
+    holder = {"rows": [_row()], "conn": None}
+
+    async def _connect(_url):
+        holder["conn"] = _FakeConn(holder["rows"])
+        return holder["conn"]
+
+    monkeypatch.setattr(pc.asyncpg, "connect", _connect)
+    return holder
+
+
+def test_shapes_runs_newest_first(fake):
+    result = asyncio.run(pc.get_predecessor_context("iss-1"))
+    assert result["ok"] is True and result["issue_id"] == "iss-1"
+    (run,) = result["runs"]
+    assert run["run_id"] == "run-1"
+    assert run["status"] == "succeeded"
+    assert run["started_at"] == "2026-07-05T10:00:00"
+    assert run["finished_at"] == "2026-07-05T10:05:00"
+    assert "בלוק ז" in run["summary"]
+    assert run["session_id"] == "sess-abc"
+    assert run["agent_name"] == "writer"
+
+
+def test_limit_is_clamped(fake):
+    asyncio.run(pc.get_predecessor_context("iss-1", limit=99))
+    assert fake["conn"].calls[0][1] == ("iss-1", 10)  # clamped high
+    asyncio.run(pc.get_predecessor_context("iss-1", limit=0))
+    assert fake["conn"].calls[0][1] == ("iss-1", 1)  # clamped low
+
+
+def test_empty(fake):
+    fake["rows"] = []
+    result = asyncio.run(pc.get_predecessor_context("ghost"))
+    assert result == {"ok": True, "issue_id": "ghost", "runs": []}