Merge 'feat/parallel-lines-cap'：一條線一份自己的工作目錄（inkstone/ISEP#109）

總管逐筆審過並自己實測（不採信交回的數字）：

  hooks/tests/line-needs-own-worktree.test.sh      59/59
  hooks/tests/parallel-lines-cap-guard.test.sh     33/33
  hooks/tests/main-and-prod-push-guard.test.sh     10/10   ← 共用檔改動的迴歸
  hooks/tests/…-cross-repo.test.sh                 19/19   ← 同上

實地打四次（不是只跑測試）：
  · cd <repo> && git checkout       → 擋，且認出的是那個 repo（原缺陷已修）
  · git -C <repo> checkout          → 擋，認得對
  · cd <自己的 worktree> && checkout → 放行（舊版會誤攔正確做法）
  · cd <不是 repo 的地方> && checkout → 放行

🔴 併進來不等於送達：安裝端停在 0.9.0，repo 是 0.16.2，
   而這支閘在任何一份安裝裡都不存在（find 零命中）
   ⇒ 這一格仍是 ◐，缺的是 plugin update，不是 merge。

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "isep",
-  "description": "InkStone Environment Plugin —— leo 的 Claude Code 環境唯一真相源：60 支機械閘（82 條註冊，白話盤點見 docs/hooks-inventory.md）、7 支 slash command、2 支 skill、7 位有名字的工人（agents/，見 docs/governance/worker-roster.md）、48 支腳本，外加治理規範與標籤真相源。本機與雲端裝同一份，沒有子集。",
-  "version": "0.16.1",
+  "description": "InkStone Environment Plugin —— leo 的 Claude Code 環境唯一真相源：62 支機械閘（85 條註冊，白話盤點見 docs/hooks-inventory.md）、7 支 slash command、2 支 skill、7 位有名字的工人（agents/，見 docs/governance/worker-roster.md）、48 支腳本，外加治理規範與標籤真相源。本機與雲端裝同一份，沒有子集。",
+  "version": "0.16.2",
   "keywords": [
     "inkstone",
     "guardrails",

README.md

@@ -23,7 +23,7 @@
 
 | | 數量 | 是什麼 |
 |---|---|---|
-| `hooks/` | 60 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 82 條註冊）。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家** |
+| `hooks/` | 62 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 85 條註冊）。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家** |
 | `agents/` | 7 位 | **工人名單**（`inkstone/ISEP#86`）——派工時指名派給誰，規約見 `docs/governance/worker-roster.md` |
 | `commands/` | 7 支 | `/wiki-recall` `/ship-check` `/cp-write` … |
 | `skills/` | 2 支 | |

docs/TESTING.md

@@ -470,6 +470,51 @@ python3 scripts/wiki-compress bench  /tmp/w/mistakes.md.before-compress /tmp/w/m
 ```
 
 
+### A23 — 同時跑的線有上限：33 條
+```
+bash hooks/tests/parallel-lines-cap-guard.test.sh
+```
+**該看到**：`33/33 通過`。**離線、不打網路、不花錢**——每個案例自己搭一份假的 harness 佈局
+（`<sid>.jsonl` ＋ `<sid>/subagents/agent-*.meta.json`），判準只有檔案的存在與 mtime，沒有語意判官。
+
+**它在守什麼**（inkstone/ISEP#109，2026-08-29 實撞）：總管同時開七條線，8 GB 的 Mac 重開機；
+同一天還派錯線 1 次、量錯東西 6 次、停掉正確的工作 1 次。leo：「**跑 2-3 條應該是極限了**」。
+
+**失敗**：
+- A 群 14 條任一紅 ⇒ **誤攔**。這比漏擋嚴重——④⑤紅代表「收工了還在擋」，
+  那會變成**整台機器永遠派不了工**
+- ⑬⑭ 紅 ⇒ fail-open 壞了。這支刻意選「算不出來就放行、但出聲」：
+  算不出來就擋會卡死所有派工，那是比漏擋貴得多的失敗
+- ㉒ 紅 ⇒ 安靜窗的邊界算錯了，那是唯一擋著「永久卡死」的保險
+
+📌 **這支閘的三個機械前提是實測出來的，不是推測的**（改它之前先重測這三件）：
+`SubagentStop` 在實測的 session 裡**一次都沒觸發**（所以不能拿它當減法）；
+`PostToolUse:Agent` 在**送出後 5 秒**就觸發（不是收工）；
+subagent **不是獨立行程**（`ps` 只有一個 claude-code 行程，所以數行程數不到線）。
+
+### A24 — 一條線要有自己的工作目錄：59 條
+```
+bash hooks/tests/line-needs-own-worktree.test.sh
+```
+**該看到**：`59/59 通過`。離線，每個案例自己開**兩顆**真的 git repo ＋一份真的 linked worktree。
+
+**D 群在守什麼**（comment 5398，2026-08-29 補）：不只要擋對，還要**說得出是哪一個 repo**。
+舊版一律拿 payload 的 `cwd` 當答案，於是 `cd <別的 repo> && git checkout` 擋是擋對了，
+訊息卻指著 `cwd` 那個 repo ⇒ 照著做的人會在**錯的 repo** 開一份用不到的 worktree，
+真正要隔離的那個沒開到，而他以為隔離好了。🔴 **一道閘給錯下一步，比不擋更糟。**
+D 群同時釘住反面：認不出來（`cd $VAR`、`cd -`、cd 到不是 repo 的地方）就**放行**，不猜。
+
+**它在守什麼**（inkstone/ISEP#109 → comment 5391，2026-08-29 實撞）：
+每個 repo 只有**一份**工作目錄，所有線共用。`arcrun-rag#163` 切到自己的分支、交回時沒切回來，
+總管後來在同一個目錄跑 `ship.mjs`，**讀到的是別人留下的 HEAD**。
+🔴 票號說得出「這是哪個任務」，**沒有任何東西說得出「這個目錄現在是誰留下的狀態」**。
+
+**失敗**：
+- A 群 16 條任一紅 ⇒ **誤攔**。特別是⑤⑥⑦（還原檔案）與⑨（已經在自己的 worktree 裡）——
+  擋掉它們等於線動不了工
+- ① 紅 ⇒ 連總管在自己的目錄裡切分支都被擋。那不是嚴格，那是把共用目錄的主人趕出去
+- ㉞㉟ 紅 ⇒ `prune` 做錯了。㉞是沒清掉說謊的登記；**㉟是把還在的 worktree 也弄掉了，那是災難**
+
 ### A5 — 開票前的搜尋是跨 repo 的
 ```
 python3 scripts/ticket where 標籤 模組化
@@ -736,6 +781,8 @@ B2（信標那行）／B3（setup 輸出）／B4（閘的訊息）三個畫面
 | **A17 未經調查不寫診斷（ISEP#87）** | 總管 | ✅ 26/26（2026-08-28） |
 | **A11 派工單只剩票號** | 總管 | ✅ 19/19（2026-08-27） |
 | **A12 留言身份欄（兩道門）** | 總管 | ✅ 11/11（2026-08-27） |
+| **A23 同時跑的線有上限** | isep-guard | ✅ 33/33（2026-08-29，inkstone/ISEP#109） |
+| **A24 一條線要有自己的工作目錄** | isep-guard | ✅ 35/35（2026-08-29，inkstone/ISEP#109→5391） |
 | **A16 放行的門真的打得開** | 總管 | ✅ 17/17（2026-08-28，inkstone/ISEP#90） |
 | **A17 未推警察不誤攔雲端分支** | 總管 | ✅ 10/10（2026-08-28，inkstone/ISEP#90） |
 | **A18 信標會報雲端接線缺陷** | 總管 | ✅ 14/14（2026-08-28，inkstone/ISEP#90） |

docs/hooks-inventory.md

@@ -1,4 +1,4 @@
-# 60 支閘，白話盤點表
+# 62 支閘，白話盤點表
 
 > 回應 `inkstone/InkStoneCo#40`：「如果加入了，我應該可以白話文看到 hooks 的內容？」
 > 這份表就是那個「白話文」——不用點開任何 `.sh` 檔，一行看懂一支閘在管什麼。
@@ -7,14 +7,14 @@
 
 ## 一句話結論
 
-`hooks/` 底下有 **60 個 `.sh` 檔**，`hooks.json` 實際掛上 **82 條註冊**（同一支閘常被多種情境同時掛上）；
+`hooks/` 底下有 **62 個 `.sh` 檔**，`hooks.json` 實際掛上 **85 條註冊**（同一支閘常被多種情境同時掛上）；
 其中 **3 支檔案存在但沒被掛上**（2 支是待人填的空範本、1 支是刻意留著沒開的止血帶，見下面「未生效」表）。
 下面按「你會在什麼時候撞到它」分組，一支一行。
 
 > 🔴 **這兩個數字上一版是錯的（2026-08-26 實際數過才發現）**：本頁原本寫「43 個檔、53 條註冊」，
 > 而當時真實是 **45 個檔、55 條註冊**——中間有兩支閘進來時沒有回頭改這裡。
 > 現在的寫法是實際數出來的：
-> `ls hooks/*.sh | wc -l` ＝ 60；`grep -c '"command":' hooks/hooks.json` ＝ 82。
+> `ls hooks/*.sh | wc -l` ＝ 62；`grep -c '"command":' hooks/hooks.json` ＝ 85。
 > ⚠️ **冒號不能省**：`grep -c '"command"'`（沒冒號）會連 `"type": "command"` 一起數到，回 **120**。
 > 本頁 2026-08-27 之前寫的是沒冒號那版——**照著它跑會拿到一個跟本頁不符的數字**。
 > **一份會偷偷過期的盤點表，跟沒有盤點表差不多**——見本頁最後「怎麼跟實況對帳」那段。
@@ -124,6 +124,7 @@
 | `reply-identity-guard.sh` | 直接打 Gitea API 貼留言到票上時，內文第一行沒有 `【身份】`（`總管`／`subagent`／`leo`）就擋下——票上多條線並行時，看不出哪一則是誰寫的。純讀取、走 `scripts/ticket` 正門、指令裡加 `reply-identity-ok` 都放行。 | 🛑 擋 |
 | `comment-carries-task-guard.sh` | AI 要在票裡留一則「等某某上線才驗得了」這種**還沒做完的事**，卻沒有把它開成一張子票時，擋一次。留言沒人會回頭讀，票的 open／closed 撈一次就看得到。 | 🛑 擋（同一輪只擋一次） |
 | `search-is-not-proof-guard.sh` | AI 用知識庫的**搜尋**找到一筆東西，然後把那筆東西的原始編號直接貼進票裡或派工單裡，當成「某個功能壞了」的證據——而它從沒用正規的檢索路徑去查過那筆——擋一次。你關心的是：不會再有人拿錯的方法量出一個錯的結論，然後退回一張其實已經做完的票。 | 🛑 擋（同一輪只擋一次） |
+| `line-needs-own-worktree.sh` | 一條派工線想在**大家共用的那份工作目錄**裡切分支（`git checkout`／`git switch`）就擋下，叫它先開一份自己的 worktree。你關心的是：不會再有人交回工作時把某個 repo 留在自己的分支上，而下一個人在同一個目錄跑出貨、讀到的是別人留下的 HEAD。**總管在自己的目錄裡切分支不管**（那是他的目錄）；已經在自己 worktree 裡的切換全部放行；還原檔案（`git checkout -- 檔`）不管。擋下來的同時會順手把「指向空氣」的 worktree 登記清掉。 | 🛑 擋 |
 | `diagnosis-evidence-guard.sh` | 你想把一段有份量的東西寫上票，而這個 session **沒派人去查過那張票**、那段話裡也**沒有任何走得過去的出處**（檔案:行號／commit／comment 號／票號／網址／貼出來的實測輸出）就擋一次——未經調查的診斷寫在票上會長得像事實，工人會照著它去驗證而不是去查。派過人查、或把出處帶上，都放行；一句短回覆不管。 | 🛑 擋 |
 ## B. AI 想寫檔案／改程式碼的當下（PreToolUse / Write·Edit·MultiEdit）
 
@@ -161,6 +162,7 @@
 | `roster-guard.sh` | 派工要**指名派給誰**：`Task` 的 `subagent_type` 得是 `agents/` 名單上的名字（`isep-hand`／`arcrun-hand`／`scout`…），沒指名或指了不存在的名字就擋下，並把整份名單印出來。指對了它會**自動把那位工人的檔案原文注入**給它——你是誰、負責哪個 repo、開工前先讀什麼、你的紅線是什麼（這些每個工人都不一樣，共通規定補不了）。名單是資料：加一個工人＝在 `agents/` 加一個 `.md`，不必改任何 hook。 | 🛑 擋（＋注入） |
 | `mainline-focus-guard.sh` | 派出去的票**不在「現在的主線」上**，就擋一次，並問你是「補收」（它本來就該掛在主線上）還是「跳線」（真的插件事）。背景：2026-08-27 實查有 **14 個 milestone 同時開著**，其中「Mira 現代化」同名活在 5 個 repo ⇒ SOP 說的「只做該 milestone 的事」在現場**沒有指涉對象**，等於不存在。現在主線是一個查得到的事實（`scripts/mainline`，答案唯一），這支就是那個事實的用處。🔴 **沒有標主線 ⇒ 一律放行**；多張票只要有一張在主線上就放行；查不到那張票掛在哪也放行（**讀不到 ≠ 不屬於**）；**同一張票只擋一次**，重送就過。跳線會留一筆紀錄——不留痕的話，跳線與專注在機器上長得一模一樣。 | 🛑 擋（同一張票至多一次） |
 | `dispatch-format-guard.sh` | **派工單 ＝ 票號，就這樣。** 票號以外還寫了別的東西（背景、驗收條件、紅線、交件方式、「這個 session 才知道的事」）就擋下，並告訴你那些內容該搬去哪：每次都一樣的 → 共通規定；這次才知道的 → **寫進那張票**。反過來，合規的派工它會**自動把共通規定注入**給收工方（交件方式、不准 push main、org 是 `inkstone`…），所以你不寫也不會漏。判準是「這一行是不是【工單】欄位」——**在不在**，不是寫了什麼，所以講得再謹慎也不會被多罰。純禮貌收尾（「謝謝」）不算違規；`（→ comment M）` 不論全形或半形括號都認得（ISEP#65 修過一次：CLAUDE.md 自己規定的合格寫法曾經被這支閘自己擋下）。 | 🛑 擋（＋注入） |
+| `parallel-lines-cap-guard.sh` | **同時在跑的線超過上限就派不出下一條**（預設 3，`ISEP_MAX_PARALLEL_LINES` 可調），而且訊息會列出現在有哪幾條在跑、各跑了多久。你關心的是：不會再因為一次派七條而讓機器爆掉，也不會再有「同時盯七條線所以派錯、量錯」那種錯。**條數是從 harness 自己寫的檔案數出來的，不是靠誰記得**——所以某一條收工，下一條立刻派得出去，不會卡死。真的非同時不可：`touch /tmp/.parallel-ok-<session_id>`（用一次就消失）。 | 🛑 擋 |
 
 ## D2. AI 想開口問你問題的當下（PreToolUse / AskUserQuestion）
 
@@ -390,4 +392,4 @@ A1 缺人話、A2 表格有幽靈、C 全頁有幽靈。
 
 1. **有沒有新閘沒被收進這張表**：跑本文「落差偵測」段落**第二組**（`inv_fs` vs `inv_table` 的兩行 `comm`）**加第三格 C**，比對 `hooks/*.sh` 的檔名清單跟這張表列出的閘名清單。**不是第一組**——第一組比的是 `hooks.json`，只驗證有沒有註冊，驗不了有沒有寫進這張人話表。2026-08-27 漏掉的那兩列，第一組是綠的、第二組才紅。**抓表格列的那組 `grep` 一定要帶 `^\| \`` 錨點**，理由與拿掉之後會冒出的 3 個假警報，就寫在那一段裡。
 2. **有沒有閘的行為跟這裡寫的不一樣了**：抽幾支重新讀一次源碼，跟這裡的「一句話」對一遍——就是本文「抽驗 5 支」做的事，可以照同樣方法定期重做。
-3. **`.claude-plugin/plugin.json` 與 `README.md` 的數字**：這兩處各自寫了一次「幾支、幾條註冊」，前面已經抓到一次對不上（42/52 vs 實際 43/53）。這兩個數字沒有機制保證跟著 `hooks/` 目錄自動更新，是本表發現的第一個具體漂移案例。
+3. **`.claude-plugin/plugin.json` 與 `README.md` 的數字**：這兩處各自寫了一次「幾支、幾條註冊」，前面已經抓到一次對不上（42/52 vs 實際 43/53）。這兩個數字沒有機制保證跟著 `hooks/` 目錄自動更新，是本表發現的第一個具體漂移案例。

hooks/hooks.json

@@ -68,6 +68,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/dispatch-format-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/line-needs-own-worktree.sh"
           }
         ]
       },
@@ -176,6 +180,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/search-is-not-proof-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/parallel-lines-cap-guard.sh"
           }
         ]
       },
@@ -227,6 +235,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/search-is-not-proof-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/parallel-lines-cap-guard.sh"
           }
         ]
       },

hooks/lib/checkout_target_dir.py

@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+"""解出一條指令裡的 `git checkout` / `git switch` **真正會落在哪個目錄**。
+
+管什麼
+  line-needs-own-worktree.sh 要回答「這次切分支動的是哪個 repo」。舊版拿
+  payload 的 `cwd` 當答案，於是 `cd <別的 repo> && git checkout <分支>` 這個
+  形狀會**認錯 repo**（inkstone/ISEP#109 → comment 5398 實測）：
+
+      指令：cd .../matrix/arcrun && git checkout fix/library-lifecycle-187
+      舊版訊息：目錄：.../InkStoneCo   它現在在：feat/ticket-bell-webhook
+                          ↑ 動的是 matrix/arcrun，講的卻是 InkStoneCo
+
+  🔴 擋是擋對了，但**印給人的補救指令是另一個 repo 的**——照著做會在
+  InkStoneCo 開一份用不到的 worktree，真正要隔離的 matrix/arcrun 沒開到，
+  而人以為自己隔離好了。**一道閘給錯下一步，比不擋更糟。**
+  而 `cd X && git checkout` 正是這條線最常出現的寫法（本票的來由那次就是它）。
+
+為什麼接既有的解析器，不另寫一支
+  `push_target_dir.py` 2026-08-23 已經替 `git push` 解過同一個問題
+  （inkstone/ISEP#30 comment 3949），連多層 cd 鏈與**子殼的 cd 不外洩**
+  （`(cd A && …); git checkout` 落在殼外而不是 A）都算過了。
+  ⇒ 本檔只加「哪個動詞」與「哪些形狀不動 HEAD」，tokenize 與路徑接合一律沿用
+  那支，不養第二套會漂的 parser。那支的 42 條既有測試在本次改動後全數重跑通過。
+
+回傳三種，呼叫端要分開處理
+  ""   這條指令裡沒有會**移動 HEAD** 的 checkout/switch ⇒ 不關這道閘的事
+  "?"  有，但目錄**解不出來**（`cd $VAR`、`cd -`、引號壞掉）
+       ⇒ 🔴 呼叫端必須放行。寧可漏擋，也不要指著錯的 repo 叫人去開 worktree
+         ——那正是本檔要修的病，猜一個回去等於原地打轉。
+  其他 目錄運算式，可能是相對的；呼叫端自己 `cd` 進去問 git（唯讀）。
+       "." ＝「就是呼叫端自己的 cwd」（指令裡沒有 cd 也沒有 -C）。
+
+用法：printf '%s' "$CMD" | python3 checkout_target_dir.py
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from push_target_dir import _events, _join  # noqa: E402
+
+VERBS = ("checkout", "switch")
+UNKNOWN = "?"
+
+
+def _step(base, path):
+    """走一步 cd／-C。不確定就一路標 unknown，不要往回猜成呼叫端的 cwd。"""
+    if base == UNKNOWN:
+        return UNKNOWN
+    if not path or path == "-" or path.startswith("$") or path.startswith("`"):
+        return UNKNOWN
+    return _join(base, path)
+
+
+def _moves_head(tokens):
+    """tokens 是整串 `git …`。回傳 (會不會動 HEAD, -C 指的路徑 or None)。
+
+    判準只有「這個動作動不動 HEAD」，不看任何措辭：
+      git checkout -- <檔>／git checkout HEAD -- <檔>  ⇒ 還原檔案，不動
+      git checkout -p                                  ⇒ 挑 hunk，不動
+      git checkout（沒有任何目標）                      ⇒ git 自己會報錯
+    """
+    tok = list(tokens[1:])          # 去掉 "git"
+    c_path = None
+    while tok and tok[0].startswith("-"):
+        if tok[0] == "-C" and len(tok) > 1:
+            c_path = tok[1] if c_path is None else c_path + "/" + tok[1]
+            tok = tok[2:]
+            continue
+        if tok[0].startswith("-C") and len(tok[0]) > 2:
+            seg = tok[0][2:]
+            c_path = seg if c_path is None else c_path + "/" + seg
+            tok.pop(0)
+            continue
+        if tok[0].startswith("--git-dir"):
+            return (False, None)    # 自己指 git-dir 的花式用法，不猜
+        tok.pop(0)
+    if not tok or tok[0] not in VERBS:
+        return (False, None)
+
+    rest = tok[1:]
+    if "--" in rest or "-p" in rest or "--patch" in rest:
+        return (False, None)
+    if not [a for a in rest if not a.startswith("-")] and \
+       not any(a in ("-b", "-B", "-c", "-C") for a in rest):
+        return (False, None)
+    return (True, c_path)
+
+
+def find_checkout_target(cmd):
+    events = _events(cmd, VERBS, strip_env=True)
+    if not events:
+        return ""                   # 引號壞掉之類——沿用「不擋在不確定上」
+
+    stack = [None]                  # 每層括號各自的 cwd；None ＝ 同呼叫端的 cwd
+    for kind, val in events:
+        if kind == "enter":
+            stack.append(stack[-1])          # 子殼繼承「進去那一刻」的位置
+        elif kind == "exit":
+            if len(stack) > 1:
+                stack.pop()                  # 子殼自己 cd 到哪，出來不算數
+        elif kind == "cd":
+            stack[-1] = _step(stack[-1], val)
+        elif kind == "verb":
+            moves, c_path = _moves_head(val)
+            if not moves:
+                continue
+            where = stack[-1]
+            if c_path is not None:
+                # -C 贏過 cd：git 自己就是這個優先序
+                # （而且 -C 若是相對路徑，是接在 cd 之後算，不是接在 cwd）
+                where = _step(where, c_path)
+            if where == UNKNOWN:
+                return UNKNOWN
+            return where or "."
+    return ""
+
+
+def main():
+    sys.stdout.write(find_checkout_target(sys.stdin.read()))
+
+
+if __name__ == "__main__":
+    main()

hooks/lib/push_target_dir.py

@@ -57,10 +57,12 @@ have opened before.
 Usage:
     printf '%s' "$CMD" | python3 push_target_dir.py
 """
+import re
 import shlex
 import sys
 
 _SEPARATORS = {";", "&&", "||", "|", "&", "\n"}
+_ENV_ASSIGN = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*=")
 
 
 def _join(base, path):
@@ -82,17 +84,33 @@ def _join(base, path):
     return base.rstrip("/") + "/" + path
 
 
-def _classify(tokens):
+def _classify(tokens, verbs=("push",), strip_env=False):
+    """`verbs` is which git subcommand(s) count as the action being located.
+    It defaults to push so find_push_target's behaviour is byte-identical to
+    before; checkout_target_dir.py passes checkout/switch instead. Matching
+    stays deliberately loose here (the verb may sit anywhere after `git`) --
+    callers re-walk the returned token list to confirm command position, so
+    a false positive at this layer costs nothing."""
+    if strip_env:
+        # `FOO=1 git checkout …` -- an env prefix doesn't change which command
+        # runs. Opt-in so find_push_target's behaviour stays byte-identical;
+        # checkout_target_dir.py turns it on (its predecessor stripped these,
+        # and dropping that would have been a silent regression -- caught by
+        # the worktree gate's own case ㉒).
+        i = 0
+        while i < len(tokens) and _ENV_ASSIGN.match(tokens[i]):
+            i += 1
+        tokens = tokens[i:]
     if not tokens:
         return ("other", None)
     if tokens[0] == "cd" and len(tokens) > 1:
         return ("cd", tokens[1])
-    if tokens[0] == "git" and "push" in tokens[1:]:
-        return ("push", tokens)
+    if tokens[0] == "git" and any(v in tokens[1:] for v in verbs):
+        return ("verb", tokens)
     return ("other", None)
 
 
-def _events(cmd):
+def _events(cmd, verbs=("push",), strip_env=False):
     """Tokenize cmd into (kind, value) events in source order: 'enter'/
     'exit' for parens (subshell boundaries), 'cd'/'push'/'other' for
     statements split on the usual shell separators. Returns [] on any
@@ -109,10 +127,10 @@ def _events(cmd):
 
     def flush():
         if seg:
-            # _classify's "push" branch returns `tokens` by reference; copy
+            # _classify's "verb" branch returns `tokens` by reference; copy
             # before clear() below, or the event's tuple would observe the
             # list emptied out from under it (aliasing, not a value copy).
-            events.append(_classify(seg[:]))
+            events.append(_classify(seg[:], verbs, strip_env))
             seg.clear()
 
     for tok in toks:
@@ -147,7 +165,7 @@ def find_push_target(cmd):
                 stack.pop()          # subshell's own cd's don't leak out
         elif kind == "cd":
             stack[-1] = _join(stack[-1], val)
-        elif kind == "push":
+        elif kind == "verb":
             saw_push = True
             c_path = None
             toks = val

hooks/line-needs-own-worktree.sh

@@ -0,0 +1,149 @@
+#!/usr/bin/env bash
+# 管什麼: 一條派工線要在「共用的工作目錄」裡切分支時擋下來，叫它去開一份自己的 worktree。
+# 為什麼: 2026-08-29 inkstone/ISEP#109 comment 5391——每個 repo 只有一份工作目錄，所有線共用。#163 切到自己的分支、交回時沒切回來，總管後來在同一個目錄跑 ship.mjs，讀到的是別人留下的 HEAD。票號說得出「這是哪個任務」，沒有任何東西說得出「這個目錄現在是誰留下的狀態」。
+# 誤觸時怎麼關: `WORKTREE_OK=1 git checkout …`（留痕，跟 NOT_MY_BRANCH_OK 同形狀）。
+#
+# line-needs-own-worktree.sh — 共用工作目錄裡不准切分支（PreToolUse: Bash）
+#
+# ── 判準：git 自己回答的兩個問題，不看任何措辭 ────────────────────────
+#   ① 這條命令會不會**移動 HEAD**？（checkout / switch，含 -b / -c）
+#      —— 動作有限且可枚舉。`git checkout -- <檔>`／`git restore` 是還原檔案，不動 HEAD，放行。
+#   ② 它要動的那個目錄，是不是那個 repo 的**主工作目錄**（＝大家共用的那一份）？
+#         git rev-parse --git-dir  ==  git rev-parse --git-common-dir   ⇒ 主工作目錄（共用）
+#         兩者不同                                                       ⇒ 這已經是一份 worktree（自己的）
+#      —— 這是 git 自己算出來的事實，**不需要任何人去登記**。
+#
+#   ①②都成立、而且送出命令的是一條線（`CLAUDE_CODE_CHILD_SESSION=1`）⇒ 擋。
+#
+# ── 為什麼是「線」而不是所有人（這不是總管例外）──────────────────────
+#   共用工作目錄**就是總管那一份**——他在自己的目錄裡切分支不會偷走別人的狀態。
+#   會出事的是**線把總管的目錄留在自己的分支上**（08-29 實錄就是這個形狀）。
+#   ⇒ 規則不是「誰比較大」，是「**誰的目錄**」。線要動工，就去開一份自己的。
+#
+# ── 為什麼不靠 `.claude/branch-holds.md`（驗收條件 6 的原話：不靠人記得）─────
+#   `not-my-branch-guard.sh` 守的是「**別 commit 到別人登記過的分支**」——
+#   ① 只認 `git commit`、② 只看頂層 repo、③ **要有人先手動登記**。
+#   而 08-29 出事的是子 repo（`products/arcrun-rag`、`matrix/arcrun`）、動作是 `checkout`、
+#   而且沒有人登記過。**兩支守的不是同一件事，這支不動那支。**
+#
+# ── worktree 開在哪：開在 repo 的旁邊，不要開在 /tmp（2026-08-29 實測）──────
+#     $ git -C products/arcrun-rag worktree list
+#       /private/tmp/.../scratchpad/wt-180   … prunable   ← 目錄被系統清掉了
+#       /private/tmp/.../scratchpad/wt164    … prunable   ← 同上
+#       /private/tmp/wt167src                … prunable
+#       products/arcrun-rag-wt88             … 完好
+#       products/arcrun-rag-wt104ingest      … 完好
+#     ISEP 同一天有 **12 筆 prunable**，全部在 /private/tmp 底下。
+#   ⇒ 開在 `/tmp` 的會被系統清掉，而**登記簿還留著** ⇒ 登記簿說謊。
+#     開在 repo 旁邊的那幾份，一份都沒掉。
+#
+# ── 順手把說謊的登記清掉（驗收條件 7：prune 是收工動作，不是偶爾整理）───────
+#   擋下來的同時對那個 repo 跑一次 `git worktree prune`，並把清掉幾筆講出來。
+#   prune **只刪「目錄已經不存在」的登記**，不碰任何還在的 worktree、不碰任何檔案。
+#
+# ── 誠實邊界 ────────────────────────────────────────────────────
+#   1. 它只擋 `checkout`／`switch`。**已經切過去之後**的 commit／build 這支看不到
+#      （那是別的閘的地盤）。它守的是「別把共用目錄帶離原位」這一個動作。
+#   2. 它不知道那個 repo 現在有沒有別條線在動——**不知道就一律隔離**，
+#      因為「現在剛好沒人」是會變的，而分支留在那裡是不會自己回去的。
+#   3. `git worktree add` 之後那份 worktree 裡的 checkout 全部放行（判準 ②）。
+#   4. **目錄解不出來就放行**（`cd $VAR && git checkout`、`cd -`、引號壞掉）。
+#      不是漏了，是選的：猜錯會指著別的 repo 叫人去開 worktree，而他會照做、
+#      然後以為自己隔離好了。**寧可漏擋，也不要給錯的下一步**（comment 5398）。
+set -eu
+
+[ "${WORKTREE_OK:-}" = "1" ] && exit 0
+[ "${CLAUDE_CODE_CHILD_SESSION:-}" = "1" ] || exit 0   # 總管在自己的目錄裡，不管
+
+PAYLOAD=$(cat 2>/dev/null || echo '{}')
+
+# 這條指令會動到哪個目錄的 HEAD——**不是問「hook 站在哪」**。
+#   2026-08-29 實測（inkstone/ISEP#109 → comment 5398）：`cd <別的 repo> && git checkout`
+#   舊版拿 payload 的 cwd 當答案，於是擋對了、卻**指著另一個 repo 叫人去開 worktree**。
+#   照著做的人會在錯的 repo 開一份用不到的，真正要隔離的那個沒開到，而他以為隔離好了。
+#   🔴 一道閘給錯下一步，比不擋更糟。解析住在 lib/checkout_target_dir.py（純 tokenize，
+#   不執行任何指令；cd 鏈、子殼不外洩、-C 贏過 cd 的優先序都在那裡，理由見該檔檔頭）。
+CMD=$(printf '%s' "$PAYLOAD" | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    raise SystemExit
+ti = d.get("tool_input") or {}
+sys.stdout.write((ti.get("command") or "") if isinstance(ti, dict) else "")
+' 2>/dev/null) || exit 0
+[ -n "${CMD:-}" ] || exit 0
+
+CWD=$(printf '%s' "$PAYLOAD" | python3 -c '
+import json, sys
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    raise SystemExit
+sys.stdout.write(d.get("cwd") or "")
+' 2>/dev/null) || exit 0
+[ -n "${CWD:-}" ] && [ -d "$CWD" ] || CWD=$PWD
+
+RESOLVER="$(dirname "$0")/lib/checkout_target_dir.py"
+if [ ! -f "$RESOLVER" ]; then
+  # 解析器不見了＝安裝壞了。**不靜默**：講出來再放行，因為這時候唯一能給的
+  # 「下一步」就是錯的那一個（拿 cwd 當答案），而那正是本輪修掉的病。
+  echo "⚠️ line-needs-own-worktree：找不到 lib/checkout_target_dir.py，這一次沒有檢查。" >&2
+  exit 0
+fi
+
+EXPR=$(printf '%s' "$CMD" | python3 "$RESOLVER" 2>/dev/null) || exit 0
+[ -n "${EXPR:-}" ] || exit 0        # 沒有會移動 HEAD 的 checkout/switch
+[ "$EXPR" = "?" ] && exit 0         # 目錄解不出來（cd $VAR / cd -）⇒ 不猜，見該檔檔頭
+
+TARGET=$(cd "$CWD" 2>/dev/null && cd "$EXPR" 2>/dev/null && pwd) || exit 0
+[ -n "${TARGET:-}" ] || exit 0
+
+# 那個目錄是不是 repo 的**主工作目錄**（＝共用的那一份）——git 自己回答
+GD=$(git -C "$TARGET" rev-parse --git-dir 2>/dev/null) || exit 0
+CD=$(git -C "$TARGET" rev-parse --git-common-dir 2>/dev/null) || exit 0
+ABS() { (cd "$TARGET" 2>/dev/null && cd "$1" 2>/dev/null && pwd) || printf '%s' "$1"; }
+[ "$(ABS "$GD")" = "$(ABS "$CD")" ] || exit 0          # 已經在自己的 worktree 裡 ⇒ 放行
+
+TOP=$(git -C "$TARGET" rev-parse --show-toplevel 2>/dev/null) || exit 0
+NAME=$(basename "$TOP")
+PARENT=$(dirname "$TOP")
+NOW=$(git -C "$TOP" rev-parse --abbrev-ref HEAD 2>/dev/null || echo '?')
+
+# 驗收條件 7：說謊的登記順手清掉（只刪目錄已經不存在的那些）
+BEFORE=$(git -C "$TOP" worktree list 2>/dev/null | grep -c 'prunable' || true)
+git -C "$TOP" worktree prune 2>/dev/null || true
+PRUNED=""
+[ "${BEFORE:-0}" -gt 0 ] && PRUNED="
+🧹 順手清掉 $BEFORE 筆**指向空氣**的 worktree 登記（目錄早就被清掉、登記還留著）。
+   只刪登記，沒有動任何還在的 worktree、沒有動任何檔案。"
+
+cat >&2 <<EOF
+🌳 這是**共用的工作目錄**，不要在這裡切分支。
+
+  目錄：$TOP
+  它現在在：$NOW
+$PRUNED
+【為什麼（inkstone/ISEP#109，2026-08-29 實錄）】
+  每個 repo 只有**一份**工作目錄，所有線共用。那天 arcrun-rag#163 切到自己的分支、
+  交回時沒切回來；總管後來在同一個目錄跑 ship.mjs，**讀到的是別人留下的 HEAD**。
+  🔴 票號說得出「這是哪個任務」，**沒有任何東西說得出「這個目錄現在是誰留下的狀態」**。
+  （那次沒出錯貨——是文案契約閘擋下來的。閘有效，但那是最後一道。）
+
+【現在怎麼做】開一份自己的，然後在裡面做事：
+
+    git -C $TOP worktree add $PARENT/$NAME-wt-<票號> -b <你的分支>
+    cd $PARENT/$NAME-wt-<票號>
+
+  🔴 **不要開在 /tmp 底下。** 同一天實測：$NAME 的登記簿裡指向 /private/tmp 的
+     那幾筆全部 prunable（目錄被系統清掉、登記還在），而開在 repo 旁邊的一份都沒掉。
+
+  收工時：
+    git -C $TOP worktree remove $PARENT/$NAME-wt-<票號>
+    git -C $TOP worktree prune
+
+【真的要在共用目錄裡切（接手、緊急止血）】
+    WORKTREE_OK=1 git -C $TOP checkout <分支>
+  留痕在指令歷史上，而且**切完要切回去**——$NOW 是你進來時的樣子。
+EOF
+exit 2

hooks/parallel-lines-cap-guard.sh

@@ -0,0 +1,283 @@
+#!/usr/bin/env bash
+# 管什麼: 同時在跑的派工線已經到上限時，再派下一條就擋下來，並列出現在有哪幾條在跑。
+# 為什麼: 2026-08-29 總管同時開七條線，8 GB 的 Mac 被吃爆重開機；同一天還派錯線一次、量錯東西六次、停掉正確的工作一次。leo：「跑 2-3 條應該是極限了」。在這之前這條規則只活在總管的回覆文字裡。
+# 誤觸時怎麼關: `touch /tmp/.parallel-ok-<session_id>` 後重送（用掉就消失，會留在指令歷史上）。上限本身用 `ISEP_MAX_PARALLEL_LINES` 調。
+#
+# parallel-lines-cap-guard.sh — 同時跑的線有上限（PreToolUse: Agent / Task）
+#
+# ── 判準：數 harness 自己寫下來的檔案，不數我自己記的數字 ──────────────
+#   這支一個字都不看派工單的內容。它只回答一個機械問題：
+#
+#       **現在有幾條線還在跑？**
+#
+#   一條線算「還在跑」，要三個條件同時成立：
+#     ① `<projects>/<sid>/subagents/agent-<id>.meta.json` 存在
+#        —— harness 在啟動那條線的當下寫的，不是我寫的
+#     ② 主 transcript 裡**還沒有**它的完工通知 `<task-id><id></task-id>`
+#     ③ 它自己的 `agent-<id>.jsonl` 在 IDLE 秒內還在被寫（預設 900 秒）
+#
+#   ①②③ 都是別人寫的事實，這支只是去讀。**沒有任何一個計數器要我去減。**
+#
+# ── 為什麼不用計數器（PreToolUse ＋1 / SubagentStop −1）────────────────
+#   減不掉就永遠卡死。而這張票的驗收條件第 2 條寫死：
+#   「前一條收工後，下一條派得出去——不能變成永久卡死」。
+#   🔴 更關鍵的是**那個減法根本不會發生**（2026-08-29 實測，非推測）：
+#
+#     $ grep -oh '"hookEvent":[ ]*"[^"]*"' <本 session 的 transcript> | sort | uniq -c
+#       4545 "hookEvent":"PreToolUse"
+#        530 "hookEvent":"Stop"
+#         22 "hookEvent":"PostToolUse"
+#         20 "hookEvent":"SessionStart"
+#     ⇒ **`SubagentStop` 在這個 session 一次都沒出現過。**
+#        （hooks.json 目前有 7 條掛在 SubagentStop 上——那是另一張票的事，本票不動它們。）
+#
+# ── 為什麼不數行程 ────────────────────────────────────────────────
+#   票上引的是「claude 12 支 923 MB」。2026-08-29 20:31 在同一台機器實測：
+#
+#     $ ps -Ao pid,ppid,rss,comm | grep -i claude
+#       ...一堆 /Applications/Claude.app/... 的 Electron helper...
+#       2196  2195  389584  .../claude-code/2.1.246/claude.app/Contents/MacOS/claude
+#
+#   ⇒ **Claude Code 只有一個行程（pid 2196）**，那 12 支是 Claude Desktop 的 helper。
+#     subagent 不是獨立行程，**數行程數不到線**。（在別的 surface 可能不同——但這台是這樣。）
+#
+# ── 為什麼不掛在 PostToolUse(Agent) 上做「收工」的判斷 ─────────────────
+#   實測：PostToolUse:Agent 是在**送出後約 5 秒**觸發，那條線還在跑。
+#     12:26:46  PreToolUse:Agent    toolu_01SPDbSPvzXCXHgMehcy3UKq
+#     12:26:51  tool_result          "Async agent launched successfully... agentId: a6019a…"
+#     12:26:51  PostToolUse:Agent    （同一秒）
+#     ⇒ agent 這時候才剛開始跑。真正的完工通知是 66 分鐘後才進 transcript 的
+#       `<task-notification>`（另一條線實測：10:35:59 送出 → 11:40:13 通知）。
+#
+# ── 誤攔的方向被刻意壓在「漏擋」那一邊 ────────────────────────────────
+#   `.claude/branch-holds.md` 檔頭：**永遠在響的警報，等於訓練人忽略這個警報。**
+#   所以：
+#   • 條件 ③ 的 IDLE 窗是**上限保險**——就算完工通知的格式哪天變了、②整個失效，
+#     一條線最多也只會被多算 15 分鐘，**不可能永久卡死**。
+#   • 讀不到 payload／算不出來 ⇒ **放行**，但**出聲**（把「這次沒把關」講給模型聽），
+#     不是靜默放行。房規要的是「內部錯誤不准變成**靜默**放行」，
+#     而在這支身上「算不出來就擋」會變成整台機器派不了工——那是比漏擋貴得多的失敗。
+#
+# ── 誠實邊界（不補，補了就變成猜）────────────────────────────────────
+#   1. **只認得這個 surface 的檔案佈局**（`~/.claude/projects/<slug>/<sid>/subagents/`）。
+#      雲端 CC 的佈局沒實測過 ⇒ 那裡找不到目錄時這支等於不存在（會出聲說它數不出來）。
+#   2. **同步 agent**（不背景跑的）靠「tool_result 不是 launch ack」判收工；
+#      這條路在本機沒有實跡可對（這個 session 的 81 次派工全是背景），只有測試涵蓋。
+#   3. 它管的是**條數**，不是記憶體。真正吃掉 8 GB 的是什麼，這支不知道也不猜。
+set -uo pipefail
+
+INPUT=$(cat)
+
+CAP="${ISEP_MAX_PARALLEL_LINES:-3}"
+IDLE="${ISEP_PARALLEL_IDLE_SEC:-900}"
+
+export ISEP_CAP="$CAP" ISEP_IDLE="$IDLE"
+
+OUT=$(printf '%s' "$INPUT" | python3 -c '
+import json, os, re, sys, time
+
+def bail(msg=""):
+    # 算不出來 ⇒ 放行，但把原因印出來（下面的 shell 會轉成 additionalContext）
+    if msg:
+        print("NOTE\t" + msg)
+    raise SystemExit
+
+try:
+    d = json.load(sys.stdin)
+except Exception:
+    bail("並行閘讀不到 hook payload，這一次沒有把關。")
+
+tool = d.get("tool_name") or ""
+if tool not in ("Agent", "Task"):
+    raise SystemExit                       # 不是派工，這支沒有立場說話
+
+sid = d.get("session_id") or ""
+tp  = d.get("transcript_path") or ""
+if not sid or not tp:
+    bail("並行閘拿不到 session_id / transcript_path，這一次沒有把關。")
+
+# ── 找 subagents 目錄 ────────────────────────────────────────────
+#   主 session 的 transcript：  <projects>/<sid>.jsonl
+#   子 agent 的 transcript：    <projects>/<sid>/subagents/agent-<id>.jsonl
+#   兩種都要能回推到 <projects>。
+base = os.path.dirname(tp)
+if os.path.basename(base) == "subagents":
+    base = os.path.dirname(os.path.dirname(base))
+
+subdir = os.path.join(base, sid, "subagents")
+main   = os.path.join(base, sid + ".jsonl")
+
+if not os.path.isdir(subdir):
+    raise SystemExit                       # 一條線都還沒派過 ⇒ 沒得數，也沒什麼好說的
+
+cap  = int(os.environ.get("ISEP_CAP", "3"))
+idle = int(os.environ.get("ISEP_IDLE", "900"))
+now  = time.time()
+
+# ── ① harness 寫下來的那些線 ＋ ③ 還在動的那些 ─────────────────────
+cand = {}
+try:
+    names = os.listdir(subdir)
+except OSError:
+    bail("並行閘讀不到 subagents 目錄，這一次沒有把關。")
+
+for fn in names:
+    if not (fn.startswith("agent-") and fn.endswith(".meta.json")):
+        continue
+    aid = fn[len("agent-"):-len(".meta.json")]
+    jl  = os.path.join(subdir, "agent-%s.jsonl" % aid)
+    try:
+        quiet = now - os.path.getmtime(jl)
+    except OSError:
+        continue                           # 連 transcript 都沒有 ⇒ 不是活的線
+    if quiet > idle:
+        continue                           # ③ 安靜太久 ⇒ 收工了或死了，一律不算
+    try:
+        meta = json.load(open(os.path.join(subdir, fn), encoding="utf-8"))
+    except Exception:
+        meta = {}
+    try:
+        started = now - os.path.getmtime(os.path.join(subdir, fn))
+    except OSError:
+        started = 0
+    cand[aid] = {
+        "name":  meta.get("name") or meta.get("description") or "(沒取名字)",
+        "type":  meta.get("agentType") or "?",
+        "desc":  meta.get("description") or "",
+        "tuid":  meta.get("toolUseId") or "",
+        "quiet": int(quiet),
+        "age":   int(started),
+    }
+
+if not cand:
+    raise SystemExit
+
+# ── ② 主 transcript 裡的完工通知 ─────────────────────────────────
+#   實跡：{"type":"queue-operation","operation":"enqueue", ... "<task-notification>
+#          <task-id>a76283ec07f38ed24</task-id><tool-use-id>toolu_…</tool-use-id>"}
+done  = set()
+byuid = {v["tuid"]: a for a, v in cand.items() if v["tuid"]}
+acked = {}
+
+if os.path.isfile(main):
+    marks = {a: "<task-id>%s</task-id>" % a for a in cand}
+    try:
+        with open(main, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                for a, mk in marks.items():
+                    if a in done:
+                        continue
+                    if mk in line:
+                        done.add(a)
+                if not byuid or "tool_result" not in line:
+                    continue
+                if not any(u in line for u in byuid):
+                    continue
+                try:
+                    e = json.loads(line)
+                except Exception:
+                    continue
+                msg = e.get("message")
+                if not isinstance(msg, dict):
+                    continue
+                for b in (msg.get("content") or []):
+                    if not isinstance(b, dict) or b.get("type") != "tool_result":
+                        continue
+                    a = byuid.get(b.get("tool_use_id"))
+                    if not a:
+                        continue
+                    txt = json.dumps(b.get("content"), ensure_ascii=False)
+                    # launch ack ＝ 這條線才剛開始；別的內容 ＝ 同步 agent 已經交件
+                    acked[a] = ("Async agent launched successfully" in txt)
+    except OSError:
+        pass
+# 主 transcript 讀不到 ⇒ 只靠 ③ 的 IDLE 窗，仍然不會卡死（誠實邊界 1）
+
+running = [a for a in cand if a not in done and acked.get(a, True)]
+if len(running) < cap:
+    raise SystemExit
+
+running.sort(key=lambda a: -cand[a]["age"])
+
+def human(s):
+    if s < 90:
+        return "%d 秒" % s
+    if s < 5400:
+        return "%d 分" % (s // 60)
+    return "%.1f 小時" % (s / 3600.0)
+
+rows = []
+for i, a in enumerate(running, 1):
+    c = cand[a]
+    # 🔴 只印名字/類型/時間，**不印 agentId**——那是 harness 明文說不要往外貼的內部值
+    rows.append("  %d. %s（%s）｜已跑 %s｜最後一個動作 %s前"
+                % (i, c["name"], c["type"], human(c["age"]), human(c["quiet"])))
+
+print("BLOCK\t%d\t%d" % (len(running), cap))
+print("\n".join(rows))
+' 2>/dev/null) || {
+  cat >&2 <<'EOM'
+⚠️ 並行閘（parallel-lines-cap-guard）自己出錯了，這一次**沒有把關**。
+   放行是刻意的（算不出來就擋 ＝ 整台機器派不了工），但它不該安靜地過去。
+   請把這一行連同當時的動作記到 inkstone/ISEP#109。
+EOM
+  exit 0
+}
+
+[ -n "${OUT:-}" ] || exit 0
+
+KIND=$(printf '%s' "$OUT" | head -1 | cut -f1)
+
+if [ "$KIND" = "NOTE" ]; then
+  MSG=$(printf '%s' "$OUT" | head -1 | cut -f2-)
+  printf '⚠️ %s\n   放行是刻意的，但它不該安靜地過去（inkstone/ISEP#109）。\n' "$MSG" >&2
+  exit 0
+fi
+
+N=$(printf '%s' "$OUT" | head -1 | cut -f2)
+CAPN=$(printf '%s' "$OUT" | head -1 | cut -f3)
+ROWS=$(printf '%s' "$OUT" | tail -n +2)
+
+# ── 逃生門：用掉就消失，留在指令歷史上 ────────────────────────────────
+ESC="/tmp/.parallel-ok-${CLAUDE_SESSION_ID:-}"
+if [ -z "${CLAUDE_SESSION_ID:-}" ]; then
+  ESC=$(printf '%s' "$INPUT" | python3 -c '
+import sys, json
+try: print("/tmp/.parallel-ok-" + (json.load(sys.stdin).get("session_id") or "nosid"))
+except Exception: print("/tmp/.parallel-ok-nosid")
+' 2>/dev/null || echo /tmp/.parallel-ok-nosid)
+fi
+if [ -f "$ESC" ]; then
+  rm -f "$ESC"
+  printf '🔓 並行閘：現在有 %s 條線在跑（上限 %s），逃生門已用掉，這一次放行。\n' "$N" "$CAPN" >&2
+  exit 0
+fi
+
+cat >&2 <<EOF
+🚦 同時跑的線已經到上限：**現在有 $N 條在跑，上限 $CAPN**。
+
+現在在跑的是這幾條：
+$ROWS
+
+【上限從哪來】leo 2026-08-29 原話：「因為剛剛造成 Mac 重啓，它很少這樣⋯⋯
+  **跑 2-3 條應該是極限了**」——取他自己講的上限 3，所以第 4 條才擋。
+  這台機器：Mac14,2 / M2 / 記憶體 8 GB / Swap 已用 914 MB。
+
+【它花掉過什麼（2026-08-29，這張閘的來由）】
+  同時開七條線（arcrun-rag#163／#164／Arcrun#176／#180／#185／#187／InkStoneCo#104）
+  ⇒ leo 的 Mac **重新開機**。而且同一天：派錯線 1 次、量錯東西 6 次、
+    停掉正確的工作 1 次（MISTAKE 134）。
+  ⇒ **平行度超過盯得住的範圍時，錯誤率跟著上去。這條閘同時在省機器與省判斷力。**
+
+【出路，挑一條】
+  ① **等**——上面某一條收工，這條就派得出去（收工通知一進 transcript 就解鎖，不用等 15 分鐘）。
+     同一個回合可以先做別的不需要開新線的事。
+  ② **這條更急** ⇒ 用 SendMessage 把某一條停下來／收掉，再派。
+  ③ **真的非同時不可** ⇒ 在終端機跑
+        touch $ESC
+     然後重送。用掉就消失，會留在指令歷史上。
+  ④ 上限本身要調 ⇒ ISEP_MAX_PARALLEL_LINES=<n>（安靜窗 ISEP_PARALLEL_IDLE_SEC，預設 900 秒）。
+
+🔴 這道閘擋的是總管自己，**沒有總管例外**。
+EOF
+exit 2

hooks/tests/line-needs-own-worktree.test.sh

@@ -0,0 +1,219 @@
+#!/usr/bin/env bash
+# line-needs-own-worktree.sh 的迴歸測試（inkstone/ISEP#109 → comment 5391）。
+#
+# **離線、不打網路、不花錢、每次結果一樣**——判準只有兩個，兩個都是 git 自己回答的：
+# ①這條命令會不會移動 HEAD ②那個目錄是不是主工作目錄。所以不需要語意判官。
+#
+# 每個案例都自己開一顆真的 git repo（外加一份真的 linked worktree）。
+#
+# 三群，兩個方向都要有證據：
+#   A 群「不該擋」——總管、唯讀動作、還原檔案、已經在自己的 worktree 裡、逃生門、
+#                    worktree add 本身（**這群紅了比漏擋嚴重**：擋掉它等於線動不了工）
+#   B 群「該擋」  ——線在共用目錄裡 checkout／switch／-b，含 -C 與複合命令
+#   C 群「訊息與副作用」——講得出目錄與指令、不要開在 /tmp、逃生門、
+#                    以及**真的把說謊的登記清掉**（驗收條件 7）
+#
+# 用法：hooks/tests/line-needs-own-worktree.test.sh [hook 路徑]
+
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HOOK="${1:-$(cd "$HERE/.." && pwd)/line-needs-own-worktree.sh}"
+
+PASS=0; FAIL=0; N=0
+ROOT=$(mktemp -d "${TMPDIR:-/tmp}/isep-wt.XXXXXX")
+clean() { rm -rf "$ROOT"; }
+trap clean EXIT
+
+# 🔴 macOS 的 $TMPDIR 是 /var/folders/… 而 git 回的是解析過的 /private/var/…
+#    測試比對前先把路徑解析掉，不然會拿「同一個目錄的兩種寫法」互比而假紅。
+ROOT=$(cd "$ROOT" && pwd -P)
+REPO="$ROOT/shared-repo"
+mkdir -p "$REPO"
+git -C "$REPO" init -q -b main
+git -C "$REPO" config user.email t@t; git -C "$REPO" config user.name t
+echo hi > "$REPO/a.txt"; git -C "$REPO" add -A; git -C "$REPO" commit -qm init
+git -C "$REPO" worktree add -q "$ROOT/own-wt" -b mine
+OWN="$ROOT/own-wt"
+PLAIN="$ROOT/not-a-repo"; mkdir -p "$PLAIN"
+
+# 第二顆 repo：D 群要驗「認出的是哪一個」，一顆 repo 分不出對錯
+REPO2="$ROOT/other-repo"
+mkdir -p "$REPO2"
+git -C "$REPO2" init -q -b main
+git -C "$REPO2" config user.email t@t; git -C "$REPO2" config user.name t
+echo hi > "$REPO2/b.txt"; git -C "$REPO2" add -A; git -C "$REPO2" commit -qm init
+
+# payload <command> [cwd]
+payload() {
+  python3 - "$1" "${2:-$REPO}" <<'PY'
+import json, sys
+print(json.dumps({"session_id": "S-WT", "hook_event_name": "PreToolUse", "cwd": sys.argv[2],
+                  "tool_name": "Bash", "tool_input": {"command": sys.argv[1]}},
+                 ensure_ascii=False))
+PY
+}
+
+# t <期望 exit> <說明> <command> [cwd] [env 前綴]
+t() {
+  local want="$1" desc="$2" cmd="$3" cwd="${4:-$REPO}" envs="${5:-CLAUDE_CODE_CHILD_SESSION=1}"
+  N=$((N+1))
+  local err rc
+  err=$(printf '%s' "$(payload "$cmd" "$cwd")" | env $envs bash "$HOOK" 2>&1 >/dev/null); rc=$?
+  LAST_ERR="$err"
+  if [ "$rc" -eq "$want" ]; then
+    printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 期望 exit=%s，實得 exit=%s\n' "$desc" "$want" "$rc"
+    printf '%s\n' "$err" | sed -n '1,8p' | sed 's/^/     /'
+    FAIL=$((FAIL+1))
+  fi
+}
+has()   { N=$((N+1)); if printf '%s' "$LAST_ERR" | grep -qF -- "$1"; then printf '  ✅ %s\n' "$2"; PASS=$((PASS+1)); else printf '  ❌ %s —— 找不到「%s」\n' "$2" "$1"; FAIL=$((FAIL+1)); fi; }
+hasnt() { N=$((N+1)); if printf '%s' "$LAST_ERR" | grep -qF -- "$1"; then printf '  ❌ %s —— 出現了「%s」\n' "$2" "$1"; FAIL=$((FAIL+1)); else printf '  ✅ %s\n' "$2"; PASS=$((PASS+1)); fi; }
+
+echo
+echo "── A 群：不該擋（誤攔比漏擋嚴重——擋錯了線就動不了工）──"
+
+t 0 "① 總管（不是線）在共用目錄切分支 ⇒ 不管（那是他自己的目錄）" \
+  "git checkout -b feat/x" "$REPO" "CLAUDE_CODE_CHILD_SESSION="
+t 0 "② git status ⇒ 唯讀，不管"                 "git status"
+t 0 "③ git log --oneline ⇒ 唯讀，不管"          "git log --oneline -5"
+t 0 "④ git branch -a ⇒ 唯讀，不管"              "git branch -a"
+t 0 "⑤ git checkout -- a.txt（還原檔案，不動 HEAD）⇒ 放行"     "git checkout -- a.txt"
+t 0 "⑥ git checkout HEAD -- a.txt ⇒ 放行"                      "git checkout HEAD -- a.txt"
+t 0 "⑦ git restore a.txt ⇒ 放行（根本不是 checkout）"          "git restore a.txt"
+t 0 "⑧ git checkout -p ⇒ 互動式挑 hunk，不動 HEAD，放行"       "git checkout -p"
+t 0 "⑨ **已經在自己的 worktree 裡**切分支 ⇒ 放行（這是我們要它做的事）" \
+  "git checkout -b feat/inside" "$OWN"
+t 0 "⑩ git worktree add ⇒ 放行（那是解法本身，不是病）" \
+  "git worktree add $ROOT/wt2 -b feat/y"
+t 0 "⑪ 逃生門 WORKTREE_OK=1 ⇒ 放行" \
+  "git checkout -b feat/z" "$REPO" "CLAUDE_CODE_CHILD_SESSION=1 WORKTREE_OK=1"
+t 0 "⑫ 不是 git 命令 ⇒ 不管"                    "npm test"
+t 0 "⑬ 目錄根本不是 git repo ⇒ 不管"            "git checkout -b feat/x" "$PLAIN"
+t 0 "⑭ 命令裡有 checkout 這個字但不是 git 的（不看措辭，看動作）" \
+  "echo '別忘了 git checkout 回 main'"
+t 0 "⑮ payload 壞掉 ⇒ 放行（不擋在不確定上）"   ""
+
+N=$((N+1))
+brc=$(printf 'not json' | CLAUDE_CODE_CHILD_SESSION=1 bash "$HOOK" >/dev/null 2>&1; echo $?)
+if [ "$brc" -eq 0 ]; then printf '  ✅ ⑯ 完全不是 JSON 的 payload ⇒ 放行\n'; PASS=$((PASS+1));
+else printf '  ❌ ⑯ payload 壞掉卻擋下來了（exit=%s）\n' "$brc"; FAIL=$((FAIL+1)); fi
+
+echo
+echo "── B 群：該擋 ──"
+
+t 2 "⑰ 線在共用目錄 git checkout -b ⇒ 擋"        "git checkout -b feat/new"
+t 2 "⑱ 線在共用目錄 git switch -c ⇒ 擋"          "git switch -c feat/new2"
+t 2 "⑲ 線在共用目錄 git checkout main ⇒ 擋（切回去也是切）"  "git checkout main"
+t 2 "⑳ git -C <共用目錄> checkout（人在別的地方）⇒ 擋"       "git -C $REPO checkout -b feat/c" "$PLAIN"
+t 2 "㉑ 複合命令 cd … && git checkout ⇒ 擋（一段一段拆）"    "cd $REPO && git checkout -b feat/d"
+t 2 "㉒ 前面掛 env 的 git checkout ⇒ 擋"                     "FOO=1 git checkout -b feat/e"
+t 2 "㉓ git switch main ⇒ 擋"                                "git switch main"
+
+echo
+echo "── C 群：訊息與副作用 ──"
+
+t 2 "㉔ 擋下來（下面幾條檢查這一次的訊息）" "git checkout -b feat/msg"
+has "$REPO"                    "㉕ 說得出是哪個目錄"
+has "worktree add"             "㉖ 給得出開自己 worktree 的指令"
+has "不要開在 /tmp"            "㉗ 講得出不要開在 /tmp（08-29 實測：那些全 prunable）"
+has "WORKTREE_OK=1"            "㉘ 講得出逃生門"
+has "worktree prune"           "㉙ 講得出收工要怎麼收"
+hasnt '$('                     "㉚ 訊息沒有被 shell 展開"
+
+# 驗收條件 7：說謊的登記真的被清掉
+git -C "$REPO" worktree add -q "$ROOT/ghost" -b ghosted
+rm -rf "$ROOT/ghost"
+N=$((N+1))
+if git -C "$REPO" worktree list 2>/dev/null | grep -q prunable; then
+  printf '  ✅ ㉛ 造出一筆「指向空氣」的登記（目錄砍掉、登記還在）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ㉛ 造不出 prunable 的登記，下一條測不到東西\n'; FAIL=$((FAIL+1))
+fi
+t 2 "㉜ 這時候擋下來" "git checkout -b feat/prune"
+has "指向空氣"       "㉝ 訊息說得出清掉了幾筆說謊的登記"
+N=$((N+1))
+if git -C "$REPO" worktree list 2>/dev/null | grep -q prunable; then
+  printf '  ❌ ㉞ prune 沒有真的執行——登記簿還在說謊\n'; FAIL=$((FAIL+1))
+else
+  printf '  ✅ ㉞ 說謊的登記真的被清掉了（prune 是收工動作，不是偶爾整理）\n'; PASS=$((PASS+1))
+fi
+N=$((N+1))
+if [ -d "$OWN" ] && git -C "$REPO" worktree list | grep -q "own-wt"; then
+  printf '  ✅ ㉟ 而且還在的那份 worktree 一根寒毛都沒動\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ㉟ prune 把還在的 worktree 也弄掉了——那是災難\n'; FAIL=$((FAIL+1))
+fi
+
+echo
+echo "── D 群：認得出是**哪一個** repo（inkstone/ISEP#109 → comment 5398）──"
+# 為什麼這群非有不可：舊版一律拿 payload 的 cwd 當答案，於是
+# `cd <別的 repo> && git checkout` 擋是擋對了，訊息卻指著 cwd 那個 repo。
+# 🔴 照著那個訊息做的人，會在錯的 repo 開一份用不到的 worktree，
+#    真正要隔離的那個沒開到——而他以為自己隔離好了。給錯下一步比不擋更糟。
+
+t 2 "㊱ cd <另一個 repo> && git checkout ⇒ 擋（人站在 REPO）" \
+  "cd $REPO2 && git checkout -b feat/x" "$REPO"
+has   "$REPO2"   "㊲ 認出的是 cd 進去的那個 repo"
+hasnt "$REPO/"   "㊳ **不是** cwd 那個 repo（舊版就是在這裡指錯）"
+
+t 2 "㊴ git -C <另一個 repo> checkout ⇒ 擋" \
+  "git -C $REPO2 checkout -b feat/y" "$REPO"
+has   "$REPO2"   "㊵ 認出的是 -C 指的那個 repo"
+hasnt "$REPO/"   "㊶ 不是 cwd 那個"
+
+t 2 "㊷ cd A && git -C B checkout ⇒ 擋（兩個都在，誰贏？）" \
+  "cd $REPO2 && git -C $REPO checkout -b feat/z" "$PLAIN"
+has   "$REPO"    "㊸ **-C 贏**——git 自己就是這個優先序（-C 蓋掉當下的 cwd）"
+hasnt "$REPO2"   "㊹ cd 的目標沒有贏"
+
+t 2 "㊺ 相對路徑的 cd ⇒ 擋，而且接得對" \
+  "cd shared-repo && git checkout main" "$ROOT"
+has   "$REPO"    "㊻ 相對 cd 接在 cwd 後面算出正確的 repo"
+
+t 2 "㊼ cd A && git -C <相對> checkout ⇒ 相對的 -C 接在 cd **之後**算" \
+  "cd $ROOT && git -C shared-repo checkout main" "$PLAIN"
+has   "$REPO"    "㊽ 不是接在 cwd 後面（接錯會指到 not-a-repo/shared-repo）"
+
+t 2 "㊾ 從自己的 worktree cd 回共用目錄再切 ⇒ 擋" \
+  "cd ../shared-repo && git checkout main" "$OWN"
+has   "$REPO"    "㊿ 認出的是走回去的那個共用目錄"
+
+t 2 "(51) 子殼的 cd 不外洩：(cd 別處 && true) ; git checkout ⇒ 擋在 cwd 這個 repo" \
+  "(cd $REPO2 && true) ; git checkout -b feat/sub" "$REPO"
+has   "$REPO"    "(52) 子殼裡的 cd 出來就不算數了（沿用 push_target_dir 已驗過的範圍化）"
+
+# 🔴 已知邊界，寫成測試而不是寫成註解——註解會過期，測試紅了才知道它變了。
+#    `);` 中間沒空白時，shlex 的 punctuation_chars 會把它併成一顆 token，
+#    整段就斷在那裡 ⇒ **漏擋**（不是指錯 repo，是完全沒看到）。
+#    這個邊界是 push_target_dir 的 tokenize 層帶來的，兩道閘一起有；
+#    要修得動那層，會連帶改到推 main 那道閘的偵測範圍 ⇒ 不在本票裡動（另報）。
+t 0 "(53) 已知邊界：右括號與分號黏在一起 ⇒ 這道閘看不到（漏擋，不是誤攔）" \
+  "(cd $REPO2 && true); git checkout -b feat/glued" "$REPO"
+
+echo
+echo "── D 群反面：認不出來的時候**不准猜**（誤攔＋指錯路，兩個一起犯）──"
+
+t 0 "(54) cd 到不是 repo 的地方 ⇒ 放行（舊版會擋，還會指著 cwd 那個 repo）" \
+  "cd $PLAIN && git checkout -b feat/x" "$REPO"
+t 0 "(55) cd 進**自己的 worktree** 再切 ⇒ 放行（那正是我們要它做的事）" \
+  "cd $OWN && git checkout -b feat/inside2" "$REPO"
+t 0 "(56) cd 的目標是沒展開的變數 ⇒ 放行（猜錯會叫人去錯的 repo 開 worktree）" \
+  'cd $SOMEREPO && git checkout -b feat/x' "$REPO"
+t 0 "(57) cd - ⇒ 放行（上一個目錄是什麼，tokenize 看不出來）" \
+  "cd - && git checkout -b feat/x" "$REPO"
+t 0 "(58) cd 到別的 repo 但只是還原檔案 ⇒ 放行（不動 HEAD 的形狀照樣認得）" \
+  "cd $REPO2 && git checkout -- b.txt" "$REPO"
+
+N=$((N+1))
+if [ -f "$(cd "$HERE/.." && pwd)/lib/checkout_target_dir.py" ]; then
+  printf '  ✅ (59) 解析器跟閘住在一起（少了它，閘只會印出錯的下一步）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ (59) lib/checkout_target_dir.py 不見了\n'; FAIL=$((FAIL+1))
+fi
+
+clean
+echo
+echo "══ $PASS/$N 通過${FAIL:+，$FAIL 個失敗} ══"
+[ "$FAIL" -eq 0 ]

hooks/tests/parallel-lines-cap-guard.test.sh

@@ -0,0 +1,255 @@
+#!/usr/bin/env bash
+# parallel-lines-cap-guard.sh 的迴歸測試（inkstone/ISEP#109）。
+#
+# **離線、不打網路、不花錢、每次結果一樣**——這支閘只讀檔案的存在與 mtime，
+# 沒有語意判官，所以不需要像 ask-user-question-guard 那樣另開一支 live 測試量準度。
+#
+# 每個案例都自己搭一份假的 harness 佈局（跟真的同形狀）：
+#     <root>/<sid>.jsonl                                主 transcript
+#     <root>/<sid>/subagents/agent-<id>.meta.json       harness 啟動那條線時寫的
+#     <root>/<sid>/subagents/agent-<id>.jsonl           那條線自己的 transcript
+#
+# 三群，兩個方向都要有證據：
+#   A 群「不該擋」——沒到上限、已收工、當掉的線、逃生門、不是派工的工具、
+#                    主 transcript 讀不到（**這群紅了比漏擋嚴重**：誤攔會讓整台機器派不了工）
+#   B 群「該擋」  ——到上限、超過上限、上限可調、巢狀也算
+#   C 群「訊息本身」——列得出現在有哪幾條在跑、不外洩 agentId、沒有被 shell 展開
+#
+# 用法：hooks/tests/parallel-lines-cap-guard.test.sh [hook 路徑]
+
+set -u
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+HOOK="${1:-$(cd "$HERE/.." && pwd)/parallel-lines-cap-guard.sh}"
+
+PASS=0; FAIL=0; N=0
+ROOT=$(mktemp -d "${TMPDIR:-/tmp}/isep-parcap.XXXXXX")
+SID="S-PARCAP-TEST"
+ESC="/tmp/.parallel-ok-$SID"
+clean() { rm -rf "$ROOT"; rm -f "$ESC"; }
+trap clean EXIT
+
+# reset —— 每個案例從空的佈局開始
+reset() {
+  rm -rf "$ROOT/$SID" "$ROOT/$SID.jsonl"
+  mkdir -p "$ROOT/$SID/subagents"
+  : > "$ROOT/$SID.jsonl"
+}
+
+# line <id> <名字> <型別> <安靜幾秒> [tool_use_id]
+#   造一條「在跑的線」：meta 在、jsonl 在、jsonl 的 mtime 是 <安靜幾秒> 前
+line() {
+  local id="$1" name="$2" typ="$3" quiet="$4" tuid="${5:-toolu_$1}"
+  local d="$ROOT/$SID/subagents"
+  printf '{"agentType":"%s","description":"%s 的說明","name":"%s","toolUseId":"%s","spawnDepth":1}\n' \
+    "$typ" "$name" "$name" "$tuid" > "$d/agent-$id.meta.json"
+  printf '{"agentId":"%s"}\n' "$id" > "$d/agent-$id.jsonl"
+  python3 - "$d/agent-$id.jsonl" "$quiet" <<'PY'
+import os, sys, time
+p, q = sys.argv[1], int(sys.argv[2])
+t = time.time() - q
+os.utime(p, (t, t))
+PY
+}
+
+# finished <id> —— 在主 transcript 補一則完工通知（實跡格式）
+finished() {
+  printf '{"type":"queue-operation","operation":"enqueue","sessionId":"%s","content":"<task-notification>\\n<task-id>%s</task-id>\\n<tool-use-id>toolu_%s</tool-use-id>\\n"}\n' \
+    "$SID" "$1" "$1" >> "$ROOT/$SID.jsonl"
+}
+
+# launch_ack <tool_use_id> —— 背景 agent 剛啟動時的 tool_result（實跡文字）
+launch_ack() {
+  python3 - "$1" <<'PY' >> "$ROOT_ENV/$SID_ENV.jsonl"
+import json, sys
+tuid = sys.argv[1]
+print(json.dumps({"type": "user", "message": {"role": "user", "content": [
+  {"type": "tool_result", "tool_use_id": tuid,
+   "content": [{"type": "text", "text": "Async agent launched successfully. agentId: xyz"}]}]}},
+  ensure_ascii=False))
+PY
+}
+
+# sync_result <tool_use_id> —— 同步 agent 交件了：tool_result 是真的結果，不是 launch ack
+sync_result() {
+  python3 - "$1" <<'PY' >> "$ROOT_ENV/$SID_ENV.jsonl"
+import json, sys
+tuid = sys.argv[1]
+print(json.dumps({"type": "user", "message": {"role": "user", "content": [
+  {"type": "tool_result", "tool_use_id": tuid,
+   "content": [{"type": "text", "text": "做完了，結論如下……"}]}]}},
+  ensure_ascii=False))
+PY
+}
+export ROOT_ENV="$ROOT" SID_ENV="$SID"
+
+# payload [tool_name] [transcript_path]
+payload() {
+  python3 - "${1:-Agent}" "${2:-$ROOT/$SID.jsonl}" "$SID" <<'PY'
+import json, sys
+print(json.dumps({"session_id": sys.argv[3], "hook_event_name": "PreToolUse",
+                  "transcript_path": sys.argv[2], "tool_name": sys.argv[1],
+                  "tool_input": {"prompt": "【工單】inkstone/ISEP#109"}},
+                 ensure_ascii=False))
+PY
+}
+
+# t <期望 exit> <說明> [tool_name] [transcript_path] [env 前綴]
+t() {
+  local want="$1" desc="$2" tool="${3:-Agent}" tpath="${4:-$ROOT/$SID.jsonl}" envs="${5:-}"
+  N=$((N+1))
+  local err rc
+  err=$(printf '%s' "$(payload "$tool" "$tpath")" | env $envs bash "$HOOK" 2>&1 >/dev/null); rc=$?
+  LAST_ERR="$err"
+  if [ "$rc" -eq "$want" ]; then
+    printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 期望 exit=%s，實得 exit=%s\n' "$desc" "$want" "$rc"
+    printf '%s\n' "$err" | sed -n '1,8p' | sed 's/^/     /'
+    FAIL=$((FAIL+1))
+  fi
+}
+
+# has <該出現的字串> <說明>
+has() {
+  N=$((N+1))
+  if printf '%s' "$LAST_ERR" | grep -qF -- "$1"; then
+    printf '  ✅ %s\n' "$2"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 訊息裡找不到「%s」\n' "$2" "$1"; FAIL=$((FAIL+1))
+  fi
+}
+
+# hasnt <不該出現的字串> <說明>
+hasnt() {
+  N=$((N+1))
+  if printf '%s' "$LAST_ERR" | grep -qF -- "$1"; then
+    printf '  ❌ %s —— 訊息裡出現了「%s」\n' "$2" "$1"; FAIL=$((FAIL+1))
+  else
+    printf '  ✅ %s\n' "$2"; PASS=$((PASS+1))
+  fi
+}
+
+echo
+echo "── A 群：不該擋（誤攔比漏擋嚴重——擋錯了整台機器派不了工）──"
+
+reset
+t 0 "① 一條線都沒派過（連 subagents 目錄都空）⇒ 放行"
+
+reset; line a1 收檔那條 rag-collector 5
+t 0 "② 只有 1 條在跑（上限 3）⇒ 放行"
+
+reset; line a1 一號 rag-collector 5; line a2 二號 arcrun-engineer 5
+t 0 "③ 2 條在跑（上限 3）⇒ 放行"
+
+reset
+for i in 1 2 3 4 5; do line "b$i" "第$i號" rag-collector 5; finished "b$i"; done
+t 0 "④ 5 條都收到完工通知 ⇒ 放行（前一條收工後，下一條派得出去）"
+
+reset
+for i in 1 2 3 4 5; do line "c$i" "第$i號" rag-collector 3600; done
+t 0 "⑤ 5 條的 transcript 都安靜超過 15 分（收工了或當掉）⇒ 放行，不會永久卡死"
+
+reset; line d1 一號 rag-collector 5; line d2 二號 rag-collector 5; line d3 三號 rag-collector 5
+t 0 "⑥ 到上限，但動作不是派工（Bash）⇒ 這支不管" Bash
+
+reset; line e1 一號 rag-collector 5; line e2 二號 rag-collector 5; line e3 三號 rag-collector 5
+touch "$ESC"
+t 0 "⑦ 到上限但逃生門在 ⇒ 放行"
+N=$((N+1))
+if [ -f "$ESC" ]; then
+  printf '  ❌ ⑧ 逃生門用完沒被消耗——那會變成永久豁免\n'; FAIL=$((FAIL+1))
+else
+  printf '  ✅ ⑧ 逃生門用掉就消失（不是永久豁免）\n'; PASS=$((PASS+1))
+fi
+
+reset; line f1 一號 rag-collector 5; line f2 二號 rag-collector 5; line f3 三號 rag-collector 5
+finished f2
+t 0 "⑨ 3 條裡有 1 條收工了 ⇒ 剩 2 條，放行"
+
+reset; line g1 一號 rag-collector 5 toolu_G1; line g2 二號 rag-collector 5 toolu_G2; line g3 三號 rag-collector 5 toolu_G3
+sync_result toolu_G2
+t 0 "⑩ 同步 agent 的 tool_result 不是 launch ack ⇒ 算它交件了，放行"
+
+reset; line h1 一號 rag-collector 5; line h2 二號 rag-collector 5
+rm -f "$ROOT/$SID.jsonl"
+t 0 "⑪ 主 transcript 讀不到，只靠安靜窗 ⇒ 2 條不到上限，放行"
+
+reset; line i1 一號 rag-collector 5; line i2 二號 rag-collector 5; line i3 三號 rag-collector 5
+t 0 "⑫ transcript_path 指到不存在的佈局 ⇒ 數不出來就放行（不擋在不確定上）" \
+  Agent "$ROOT/nowhere/NOPE.jsonl"
+
+N=$((N+1))
+brc=$(printf 'this is not json' | bash "$HOOK" >/dev/null 2>&1; echo $?)
+if [ "$brc" -eq 0 ]; then
+  printf '  ✅ ⑬ payload 壞掉 ⇒ 放行（fail-open 是刻意的）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ⑬ payload 壞掉卻擋下來了（exit=%s）——那會卡死整台機器\n' "$brc"; FAIL=$((FAIL+1))
+fi
+N=$((N+1))
+bmsg=$(printf 'this is not json' | bash "$HOOK" 2>&1 >/dev/null)
+if printf '%s' "$bmsg" | grep -q "沒有把關"; then
+  printf '  ✅ ⑭ 而且它會出聲說「這一次沒有把關」（不是靜默放行）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ⑭ 出錯時靜默放行了——房規禁止靜默\n'; FAIL=$((FAIL+1))
+fi
+
+echo
+echo "── B 群：該擋 ──"
+
+reset; line j1 一號 rag-collector 5; line j2 二號 arcrun-engineer 5; line j3 三號 isep-guard 5
+t 2 "⑮ 剛好 3 條在跑（上限 3）⇒ 擋第 4 條"
+
+reset
+for i in 1 2 3 4 5 6 7; do line "k$i" "第$i號" rag-collector 5; done
+t 2 "⑯ 7 條在跑（就是 08-29 那天的形狀）⇒ 擋"
+
+reset; line l1 一號 rag-collector 5
+t 2 "⑰ 上限調成 1，1 條在跑 ⇒ 擋（上限可調）" Agent "$ROOT/$SID.jsonl" "ISEP_MAX_PARALLEL_LINES=1"
+
+reset; line m1 一號 rag-collector 5; line m2 二號 rag-collector 5; line m3 三號 rag-collector 5
+t 2 "⑱ Task 這條路也管得到（不是只認 Agent）" Task
+
+reset; line n1 一號 rag-collector 5 toolu_N1; line n2 二號 rag-collector 5 toolu_N2; line n3 三號 rag-collector 5 toolu_N3
+launch_ack toolu_N1; launch_ack toolu_N2; launch_ack toolu_N3
+t 2 "⑲ 三條都只有 launch ack（還在跑）⇒ 擋"
+
+reset
+for i in 1 2 3; do line "o$i" "第$i號" rag-collector 5; done
+python3 - "$ROOT/$SID/subagents/agent-o2.meta.json" <<'PY'
+import json, sys
+p = sys.argv[1]; d = json.load(open(p)); d["spawnDepth"] = 2
+json.dump(d, open(p, "w"), ensure_ascii=False)
+PY
+t 2 "⑳ 巢狀派出去的線（spawnDepth 2）一樣算進去——它一樣吃記憶體"
+
+reset; line p1 一號 rag-collector 5; line p2 二號 rag-collector 5; line p3 三號 rag-collector 5
+touch "$ESC"
+printf '%s' "$(payload)" | bash "$HOOK" >/dev/null 2>&1
+t 2 "㉑ 逃生門用過一次之後，第二次照樣擋"
+
+reset; line q1 一號 rag-collector 890; line q2 二號 rag-collector 890; line q3 三號 rag-collector 890
+t 2 "㉒ 安靜 890 秒（還在 900 秒窗內）⇒ 仍算在跑，擋"
+
+echo
+echo "── C 群：訊息本身 ──"
+
+reset
+line r1 install-twice-163 rag-collector 5
+line r2 dup-machine-icon-185 arcrun-engineer 5
+line r3 parallel-cap-109 isep-guard 5
+t 2 "㉓ 到上限 ⇒ 擋（下面幾條檢查這一次的訊息）"
+has "現在有 3 條在跑"          "㉔ 說得出現在有幾條在跑"
+has "install-twice-163"        "㉕ 列得出第一條的名字"
+has "dup-machine-icon-185"     "㉖ 列得出第二條的名字"
+has "parallel-cap-109"         "㉗ 列得出第三條的名字"
+has "跑 2-3 條應該是極限了"    "㉘ 說得出上限從哪來（leo 原話）"
+has "touch /tmp/.parallel-ok-" "㉙ 講得出逃生門怎麼開"
+has "ISEP_MAX_PARALLEL_LINES"  "㉚ 講得出上限怎麼調"
+has "沒有總管例外"             "㉛ 講明它擋的是總管自己"
+hasnt "agentId"                "㉜ 不外洩 harness 說不要往外貼的內部 id"
+hasnt '$('                     '㉝ 訊息沒有被 shell 展開（錢字號括號不該留在輸出裡）'
+
+clean
+echo
+echo "══ $PASS/$N 通過${FAIL:+，$FAIL 個失敗} ══"
+[ "$FAIL" -eq 0 ]