把主線接進派工與注入（inkstone/ISEP#82）

- hooks.json mainline-focus-guard 掛 Agent＋Task（派工的兩個入口都要守）； SessionStart 多一條 `scripts/mainline refresh`（0.8s，不輪詢） - hooks-inventory 54 支／71 條（當場數的）＋補人話一列；順手修掉上一版重複的那一行，並把「指向空氣」那格的假警報寫清楚（countdown-milestone-refresh 在 scripts/） - TESTING A16（24 條離線）＋ A17（要網路的那半怎麼驗） - plugin.json 描述數字對齊；版本不動，待總管定版
現在的主線是哪一個，變成一個查得到的事實（inkstone/ISEP#82）
2026-08-28 00:34:07 +00:00 · 2026-08-28 00:30:09 +00:00
18 changed files with 26 additions and 1801 deletions
@@ -1,7 +1,7 @@
 {
  "name": "isep",
-  "description": "InkStone Environment Plugin —— leo 的 Claude Code 環境唯一真相源：54 支機械閘（71 條註冊，白話盤點見 docs/hooks-inventory.md）、7 支 slash command、2 支 skill、37 支腳本，外加治理規範與標籤真相源。本機與雲端裝同一份，沒有子集。",
+  "description": "InkStone Environment Plugin —— leo 的 Claude Code 環境唯一真相源：54 支機械閘（71 條註冊，白話盤點見 docs/hooks-inventory.md）、7 支 slash command、2 支 skill、36 支腳本，外加治理規範與標籤真相源。本機與雲端裝同一份，沒有子集。",
-  "version": "0.12.0",
+  "version": "0.11.0",
  "keywords": [
    "inkstone",
    "guardrails",
@@ -23,23 +23,10 @@
 | | 數量 | 是什麼 |
 |---|---|---|
-| `hooks/` | 54 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse 共 71 條註冊。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家**） |
+| `hooks/` | 48 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse 共 59 條註冊；`ISEP#60` 移除 `claim-verify-police.sh`／`subagent-claim-worksheet.sh` 這對自造機制，改由 Gitea 原生三格承接見 `ISEP#59`） |
 | `commands/` | 7 支 | `/wiki-recall` `/ship-check` `/cp-write` … |
 | `skills/` | 2 支 | |
-| `scripts/` | 38 支 | `ticket`／`github-arm.sh`／`gitea-bootstrap.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
+| `scripts/` | 23 支 | `ticket`／`github-arm.sh`／`gitea-bootstrap.sh` … |
 > 🔴 **這四個數字要用數的，不要用推的**（2026-08-28：上一版寫 48／59／23，
 > 而真實是 54／71／38——三個都錯，錯了不知道多久）。重數一次：
 >
 > ```sh
 > ls hooks/*.sh | wc -l                      # hooks
 > ls commands/*.md | wc -l ; ls -d skills/*/ | wc -l
 > find scripts -maxdepth 1 -type f | wc -l   # scripts（頂層）
 > python3 -c "import json;h=json.load(open('hooks/hooks.json'));h=h.get('hooks',h);\
 > print(sum(len(m.get('hooks',[])) for ev in h.values() for m in ev))"   # 註冊條數
 > ```
 >
 > **這是 leo 的驗收介面**——多報就是假綠（`docs/hooks-inventory.md` 開頭記著同一個病）。
 **不放**：`.env`（金鑰，違 D36「金鑰只有一個家」）、`wiki/`、`docs/`、`_archive/`
 ——那些是**知識**不是**環境**。
@@ -208,103 +208,6 @@ bash hooks/tests/prod-write-guard.test.sh hooks/prod-write-guard.sh
 - 「卡點二」2 條任一紅 ⇒ 「談論它」又被當成「執行它」（同款第八次），
  或是剝了內文之後連真的部署都放行了
 ### A16 — 「總管可以放行」那道門真的打得開：17 條
 ```
 bash hooks/tests/gate-ok.test.sh
 ```
 **該看到**：`通過 17 條，失敗 0 條`。
 **它在守什麼**（inkstone/ISEP#90 ④，2026-08-28 實查）：三支閘
 （`prod-write-guard`／`main-and-prod-push-guard`／`stage-before-prod-guard`）
 都是「擋下來、但**總管看過就能放行**」的設計，而**既有測試只驗了擋得住，
 一條都沒驗過放得開**。於是這個 bug 活了很久：`stat -f %m` 在 GNU coreutils 上
 是「檔案系統資訊」，它一邊回非零一邊吐一整段文字 ⇒ 秒數被污染 ⇒
 **在 Linux（＝每一個雲端 session）上戳記永遠不被接受** ⇒ 那三支閘在雲端等於純擋，
 而閘不會告訴你門是壞的。
 **失敗**：
 - ②⑤（門打得開）紅 ⇒ 逃生口又焊死了，那三支閘在雲端變回純擋
 - ⑥⑦⑧（門沒變寬）任一紅 ⇒ **更嚴重**：綁 repo／有效期／空戳記那三條性質是
  08-11、08-12 兩次真的被穿透之後才補上的，不准為了「好放行」而鬆掉
 - ⑫ 紅 ⇒ `gate-ok` 在解不出 repo 時留下了一枚註定打不開的空戳記，
  那會讓人以為門開了（而空戳記本身就是 08-12 那把萬用鑰匙的形狀）
 - ⑰ 紅 ⇒ 判準又變回「行為取決於 cwd 裡有沒有一個叫 `%m` 的檔」。
  這條是這個 bug 的最後一層：**GNU 的 `-f` 是布林旗標，`%m` 被當成另一個檔名運算元**
  ⇒ 有那個檔就 `exit 0`、`||` 連跑都不跑。所以修法不能只是「把順序反過來」，
  **每一步都要驗它是不是純數字**
 ⚠️ 這支會真的寫 `/tmp` 的戳記檔（那是閘寫死的路徑）。**不要在「已經蓋好戳記正要推東西」
 的當下跑它**——它會把那枚戳記洗掉。
 ### A17 — 未推警察不會對雲端的工作分支亂叫：10 條
 ```
 bash hooks/tests/unpushed-police.test.sh
 ```
 **該看到**：`通過 10 條，失敗 0 條`。全離線（用本機 bare repo 當「遠端」）。
 **它在守什麼**（inkstone/ISEP#90 ①）：雲端 session 開出來的工作分支天生沒有 upstream，
 內容卻等於遠端 main ⇒ 舊判準「沒 upstream＝從沒推過」讓**每個雲端 session、每次收工
 都被攔一次**（08-27 一個 session 五次全是誤報）。
 **失敗**：
 - A 群（①—⑥，不該報）任一紅 ⇒ **誤攔**，比漏擋嚴重：永遠在響的警報＝訓練人忽略它，
  下一條真的失蹤的分支會混在雜訊裡
 - B 群（⑦—⑩，該報）任一紅 ⇒ 為了不吵而改成放行了，那是把閘關掉不是修好
 - 特別看 ④：問不到遠端（離線）**不准當成「你沒推」**
 ### A18 — 信標會講出雲端會壞掉的那三件事：14 條
 ```
 bash hooks/tests/isep-presence-beacon.test.sh
 ```
 **該看到**：`通過 14 條，失敗 0 條`。全離線。
 **它在守什麼**（inkstone/ISEP#90 ②③）：信標原本只證明「有一份 plugin 載入了」，
 不證明「載入的是哪一份」——08-27 雲端載 0.3.9、main 0.9.0，差 7 個 release，
 而它照樣是綠的。
 **失敗**：
 - ⑫⑬⑭（信標永遠在）任一紅 ⇒ **最嚴重**：那一行消失＝leo 會判定這個 session 零閘
 - ③ 紅 ⇒ 版本落差報不出來，`ISEP#67` 那個病又變回看不見
 - ⑤⑦ 紅 ⇒ 舊複本遮蔽正門抓不到（`InkStoneCo/scripts/ticket` 那件）
 - ⑥ 紅 ⇒ **誤攔**：同步過的複本被念，人就學會忽略它
 - ⑪ 紅 ⇒ 內層迴圈變數撞名的回歸（同一個 `.claude` 下第二個殘骸會被靜靜跳過）
 ### A19 — 下游做完時頂層跟著關：49 條
 ```
 bash scripts/test-ticket-handoff-writeback.sh
 ```
 **該看到**：`通過 49 條，失敗 0 條`。**全程離線**——`TICKET_HOST` 指到連不上的位址，
 會打 API 的兩段（`_writeback`／`cmd_subtask`）把 `api()` 換成錄音機跑，
 **不打真實 Gitea、不開票、不關票、不留任何測試票**。
 **它在守什麼**（`inkstone/ISEP#92`）：
 「開在頂層的票，下游做完了卻沒人回來關⋯⋯頂層票會永遠掛著，**而 leo 是看頂層的**。」
 四格對應票上的四條驗收條件：
 - ①②③ 純函式（`is_loose`／`writeback_plan`／`journey_label`）——**判準本身**，
  不必開真票就驗得動
 - ④⑤ `subtask`／`handoff` 的參數閘：該擋的擋、齊全的放得過
 - ⑦ **完工回寫的接線**（驗收第 2 條）：關掉一張下游票之後，它到底對頂層票做了什麼
 - ⑧ **雙向連結的接線**（驗收第 1 條）：兩張票互相看得到對方，不是靠人記得補
 **失敗**：
 - ①「open ＋ 從來沒有下游 → 不撈」紅 ⇒ **誤攔**：`ticket loose` 會把每一張普通票
  都列出來，那張表就變成雜訊，人學會忽略它（本 repo 心法第 2 條）
 - ②「還有別的下游沒關 → 只記一筆」紅 ⇒ 母票會在下游還沒做完時被指派回總管，
  假綠
 - ⑦「沒有去關母票」變綠 ⇒ 回寫從「處理」滑成「自動關掉」。
  **默默關掉跟默默留著是同一個病的兩面**——關票要有交付物、要有人看過
 - ⑦「留言第一行有身份欄」紅 ⇒ 機器貼的留言看起來像某個人寫的，
  下一個讀票的人會去找那個人（`reply-identity-guard` 管的是同一件事）
 - ⑧「母子兩端都被貼」剩 1 ⇒ journey 只貼了一端，**聚類時撈得到一半**，
  比完全沒貼更危險
 - ⑤ 任何一條紅 ⇒ 誤攔，合規的交辦被擋掉等於這條路不能走
 🔴 **這支測不到的那一格（要 leo 或總管接手）**：`labels.yaml` 的 `j/` 段
 **刻意是空的**——旅程怎麼切、叫什麼名字是方向題，不由工具代決。
 在有人往那裡加第一條旅程之前，`--journey` 只會擋、不會貼。
 機制驗過了，**資料還沒有**。
 ### A5 — 開票前的搜尋是跨 repo 的
 ```
 python3 scripts/ticket where 標籤 模組化
@@ -508,10 +411,6 @@ B2（信標那行）／B3（setup 輸出）／B4（閘的訊息）三個畫面
 | **A10 人閘警察準度** | 總管 | ✅ 9/9，連跑三次（2026-08-26），A 群誤攔 0 |
 | **A11 派工單只剩票號** | 總管 | ✅ 19/19（2026-08-27） |
 | **A12 留言身份欄（兩道門）** | 總管 | ✅ 11/11（2026-08-27） |
 | **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） |
 | **A19 下游做完頂層跟著關** | 總管 | ✅ 49/49（2026-08-28，inkstone/ISEP#92） |
 | A7 plugin 裝得起來 | 總管 | ✅ |
 | **A8 新 session 閘會觸發** | 總管 | 見本版 release note |
 | **B1–B5 雲端** | **leo** | 還沒跑（機器碰不到 Cloud environment） |
@@ -1,195 +0,0 @@
 # 雲端 session 的閘為什麼跟地端不一樣（inkstone/ISEP#90）
 > leo 的目標一句話：**讓雲端 session 跟地端拿到同一組閘、同一組能用的工具。**
 雲端不是「地端少幾支閘」，是**同一批閘在雲端的行為不一樣**。四個實例，
 每一個都穩定重現，而且每一個都**不會自己喊痛**——這才是它們活這麼久的原因。
 ---
 ## 四個缺陷，兩種病
 | | 缺陷 | 病 |
 |---|---|---|
 | ① | 未推警察每個雲端 session 都誤攔 | 判準在雲端**不成立** |
 | ② | `scripts/ticket` 在雲端拿不到 token | 跑到的是**另一份**（舊複本） |
 | ③ | 已刪除的機制在雲端重生 | 載到的是**另一版**（0.3.9 vs 0.9.0） |
 | ④ | 總管的「我確認過了」出口打不開 | 判準在雲端**不成立**（平台差異） |
 ①④ 是同一種病：**閘的判準寫的是地端才成立的假設**。
 ②③ 是同一種病：**同一個東西有兩份，而雲端跑到的是舊的那份**。
 ---
 ## ① 未推警察：判準是「有沒有 upstream」，而雲端的分支天生沒有
 雲端 session 開出來的工作分支沒有 upstream，**內容卻等於遠端 main**：
 ```
 薄殼 HEAD        = 081c547d90dc2d80692485af083ca1f71f2094f2
 GitHub 遠端 main = 081c547d90dc2d80692485af083ca1f71f2094f2   ← 同一顆
 ```
 ⇒ 每個雲端 session、每次收工都被攔一次（2026-08-27 一個 session 五次全是誤報）。
 **修法**：判準改成「**遠端有沒有這顆 commit**」（`git ls-remote`）。
 本機的 remote-tracking ref 只答得準「有」——08-28 實測那份 `origin/main` 落後遠端 4 天
 ——所以答「沒有」的時候才打網路。三態：有／沒有／**問不到**；問不到一律不報。
 **順手補的**：`$CLAUDE_PROJECT_DIR` 在雲端是**薄殼根**，真身在 `$TOP/InkStoneCo/`。
 舊的掃描清單四個路徑在雲端一個都不存在 ⇒ **真身有東西沒推，這支閘一輩子不會知道。**
 同一支閘在雲端既亂叫、又看不到該看的地方。
 ---
 ## ② `scripts/ticket`：跑到的是舊複本，不是 plugin 那一份
 - ISEP 的 `scripts/ticket` **早在 2026-08-20 就修好了**（掃所有 remote ＋ 環境變數 fallback）
 - 但雲端 cwd 是真身，那裡有一份 `InkStoneCo/scripts/ticket` 的**舊複本**，
  取 token 邏輯還停在「只認名叫 `gitea` 的 remote」，而 `bootstrap.sh` 把 Gitea 設成 `origin`
 - ⇒ 雲端一律死在「拿不到 gitea token」
 🔴 **後果比「一支腳本壞了」嚴重**：`scripts/ticket` 是開票/留言的**正門**，
 它一壞，人就繞過去直接打 Gitea API——**而那正是 `ticket-api-bypass-guard.sh` 在防的事**。
 **一道閘把人逼去走它自己禁止的那條路，那道閘就是在製造違規。**
 **ISEP 這半的修法**：信標在 session 開頭就點名「專案裡有 ISEP 腳本的舊複本，
 而且**內容不同**」。判準不是檔名一樣，是**檔名一樣而內容不同**——同步過的複本不吵。
 **真身那半（把那份複本同步或刪掉）不在 ISEP，要在 `inkstone/InkStoneCo` 修。**
 ---
 ## ③ 已刪除的機制在雲端重生
 ```
 ISEP main .claude-plugin/plugin.json  →  0.9.0
 雲端實際載入                            →  0.3.9      ← 差 7 個 release
 ```
 0.3.9 裡還活著兩支在 v0.9.0 已整支刪除的 hook ⇒ `.claude/pending-verification/`
 被清掉之後又長回來。**一個看不見的版本落差，會讓已經刪掉的機制在別人的工作區裡復活。**
 **傳輸那半是 `inkstone/ISEP#67`**（新版到不到得了手上），本票不重複那件。
 **ISEP 這半能做的是讓它不再看不見**：信標匿名讀 ISEP main 的 `plugin.json`
 （D20 判準下屬於「讀」，不需開閘），落後就講清楚差幾版、怎麼重拍快照；
 同時掃 `.claude/` 底下**這一份 plugin 的 hooks/scripts 一個字都沒提到**的目錄，
 點名它們是殘骸。判準是「plugin 現在還認不認得它」，**不是關鍵字黑名單**
 （leo 2026-08-17 已證明那條路 8 次誤攔、0 次正確攔截）。
 ---
 ## ④ 「總管可以放行」的門，在雲端是焊死的
 三支閘（`prod-write-guard`／`main-and-prod-push-guard`／`stage-before-prod-guard`）
 都是「擋下來、但**總管看過就能放行**」。它們判斷戳記新不新都用同一行：
 ```sh
 MT=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
 ```
 macOS（BSD stat）上 `-f %m` 就是 mtime，對的。
 **GNU coreutils 的 `-f` 是「顯示檔案系統資訊」**，而且它**一邊回非零、一邊往 stdout
 吐一整段區塊**：
 ```
 $ stat -f %m /tmp/.probe
 stat: cannot read file system information for '%m': No such file or directory   ← stderr
  File: "/tmp/.probe"                                                            ← stdout
    ID: 0        Namelen: 255     Type: ext2/ext3
 ```
 ⇒ `2>/dev/null` 吃掉錯誤訊息、`||` 把正確的秒數接在那堆垃圾**後面**
 ⇒ `case "$NOW$MT" in *[!0-9]*) return 1` 必然命中
 ⇒ **在 Linux（＝每一個雲端 session）上，那三支閘的戳記永遠不會被接受。**
 ### 再往下一層：`-f` 根本不吃格式參數，所以連離開碼都不可靠
 總管 2026-08-28 自己驗這一格時量到 `exit=0`，而我量到 `exit=1`。
 **兩個都是真的**，而分歧本身就是這個 bug 最後一塊拼圖：
 **GNU 的 `-f` 是 `--file-system`，它是布林旗標、不接格式字串**
 ⇒ `%m` 不是格式，它被當成**另一個檔名運算元** ⇒ 離開碼取決於
 「當前目錄裡有沒有一個叫 `%m` 的檔」：
 ```
 $ cd /tmp/statprobe && touch .mt
 # A. 沒有名為 %m 的檔（一般情況）
 $ stat -f %m .mt ; echo "exit=$?"
 stat: cannot read file system information for '%m': No such file or directory
  File: ".mt"  …                                    ← 檔案系統資訊照樣印到 stdout
 exit=1        ← `||` **會**跑 ⇒ 正確的秒數接在那堆垃圾後面
 # B. 剛好有一個叫 %m 的檔
 $ touch '%m' && stat -f %m .mt ; echo "exit=$?"
 exit=0        ← `||` **不會**跑 ⇒ 整包連一個數字都沒有
 ```
 （實測環境：`stat (GNU coreutils) 9.4`）
 **兩種情況下閘的結果一模一樣**——`MT` 都不是純數字，
 `case "$NOW$MT" in *[!0-9]*) return 1` 都必然命中，戳記都作廢：
 ```
 情況 A：非數字 ⇒ return 1 ⇒ 戳記作廢
 情況 B：非數字 ⇒ return 1 ⇒ 戳記作廢
 ```
 🔴 **這一層才是真正該記住的教訓**：舊寫法的 `||` fallback 之所以救不了，
 **不是因為它沒跑，而是因為「跑不跑」根本不由這支腳本決定**
 ——它由「當前目錄裡有沒有一個叫 `%m` 的檔」決定。
 一個**行為取決於 cwd 裡有沒有某個檔名**的判斷式，不管跑不跑都是壞的。
 ⇒ 所以 `lib/mtime.sh` 的修法不是「把順序反過來」而已，是
 **每一步都驗它是不是純數字**：這個 bug 的成因正是「命令失敗了卻還是印了東西」，
 **只看離開碼會再被騙一次**。
 📌 這一格的實害（總管 2026-08-28 原話）：「我今天為了發一則通知，
 用了兩種方式蓋 `prod-write-ok` 都無效，一度以為是權限問題。」
 ⇒ **閘不會告訴你門是壞的**，所以人會往錯的方向查（權限、classifier、設定），
 而根因在閘自己身上。
 🔴 **後果**：那三支閘在雲端**等於純擋**。總管照著閘自己印的指示做，
 做幾次都打不開，**而閘不會告訴他門是壞的**。
 **為什麼活這麼久**：既有的三支測試（29／16／10 條）**只驗了「擋得住」，
 一條都沒驗過「放得開」**。⇒ 這正是「閘的另外一半從來沒被測過」的代價。
 **修法**：`hooks/lib/mtime.sh` —— 先 `-c %Y`（GNU）再 `-f %m`（BSD），
 **每一步都驗它是不是純數字**（這個 bug 的成因正是「命令失敗了卻還是印了東西」，
 只看離開碼會再被騙一次）。
 ### 附帶：逃生口收斂成一個入口 `scripts/gate-ok`
 原本每支閘的門長得都不一樣，而且藏在被擋下的那則訊息裡：
 ```
 touch /tmp/.prod-write-ok
 git rev-parse --show-toplevel > /tmp/.main-push-ok
 touch /tmp/.solo-ok-<session_id>
 …
 ```
 兩個後果：**記不住**（抄錯一個字門就打不開），以及**沒有穩定形狀可以事先放行**
 ——`.claude/settings.json` 的 allow 只能逐條完全比對（現場真的寫著
 `Bash(touch /tmp/.prod-write-ok)` 這種一行），多一個 `&&`、換一個 session id
 就落在規則之外，然後由權限層自己判斷。
 ⇒ `bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" <閘名> [參數]`：**一個名字、一種形狀**，
 一條前綴規則涵蓋全部，以後新增閘不必再動一次設定。
 🔴 **它沒有弱化任何一道閘**：蓋的是同一個檔、同一種語意——單次用完即丟、綁 repo、
 綁 session、有效期全部沒動。換掉的只有「怎麼蓋」。
 `hooks/tests/gate-ok.test.sh` 的 ⑥⑦⑧ 三條就是在守這件事（那三條性質是 08-11、08-12
 兩次真的被穿透之後才補上的）。
 ---
 ## 還沒關掉的那兩格（不屬於 ISEP）
 | 缺口 | 住在哪 |
 |---|---|
 | 雲端載到的版本追上 ISEP main | `inkstone/ISEP#67` |
 | `InkStoneCo/scripts/ticket` 這份舊複本 | `inkstone/InkStoneCo`（真身） |
 ISEP 這一側能做的是**讓它們不再是看不見的**：兩件現在都會在 session 開頭被信標點名。
@@ -42,28 +42,12 @@ case "$ROOT" in
  *)                 SRC="來源不明" ;;
 esac
 # ── 交給 lib/beacon_report.py 組訊息 ─────────────────────────────────
 #
 # 🔴 為什麼改成走 python 而不是繼續用 printf 拼 JSON（inkstone/ISEP#90）：
 #   下面要多報三件事（版本落差／舊複本遮蔽正門／退役機制的殘骸），
 #   而那三段的內容含引號與換行。**用 shell 內插拼 JSON，一個引號就會把整包 JSON 弄壞，
 #   而壞掉的 JSON 讓信標整行消失** —— 那正是本檔要偵測的「零閘狀態」的長相。
 #   ⇒ 訊息本身可以變複雜，但**序列化這件事不准手拼**。
 #
 # 🔴 fail-open：python 掛掉、網路不通、什麼都不准讓這行消失。
 #   信標消失＝leo 會判定這個 session 沒有閘（本檔第 8 行寫的判準），
 #   所以組不出加料版就退回原本那一行乾淨的訊息。
 MSG="🟢 ISEP v${VER} 已載入（${GATES} 支閘｜來源：${SRC}｜${ROOT}）"
-FALLBACK="{
+
 printf '%s\n' "{
  \"systemMessage\": \"${MSG}\",
  \"hookSpecificOutput\": {
    \"hookEventName\": \"SessionStart\",
    \"additionalContext\": \"${MSG}。這行是 ISEP plugin 自己發的——看得到它就表示閘真的生效了。若某個 session 從頭到尾沒有這行，那個 session 是零閘狀態，先修 plugin 再做事，不要用『跑得動』當證據。\"
  }
 }"
 OUT="$(python3 "$ROOT/hooks/lib/beacon_report.py" "$VER" "$GATES" "$SRC" 2>/dev/null || true)"
 case "$OUT" in
  \{*) printf '%s\n' "$OUT" ;;
  *)   printf '%s\n' "$FALLBACK" ;;
 esac
@@ -1,167 +0,0 @@
 # ── 以下三格是 inkstone/ISEP#90 加的「這一份是不是還有效」自檢 ──────────
 # 都**只是報告，不擋任何事**（SessionStart 本來就不該擋），而且每一格拿不到答案就閉嘴。
 import json, os, re, subprocess, sys, time, urllib.request
 ROOT = os.environ.get("CLAUDE_PLUGIN_ROOT", "")
 PROJ = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
 VER = sys.argv[1] if len(sys.argv) > 1 else "未知"
 GATES = sys.argv[2] if len(sys.argv) > 2 else "?"
 SRC = sys.argv[3] if len(sys.argv) > 3 else "來源不明"
 MSG = "🟢 ISEP v%s 已載入（%s 支閘｜來源：%s｜%s）" % (VER, GATES, SRC, ROOT)
 notes = []
 # ══ ① 這一份跟 ISEP main 是不是同一版 ═══════════════════════════════════
 #
 # 🔴 為什麼要自己查（inkstone/ISEP#90，2026-08-27 實查）：
 #     ISEP main 的 plugin.json  →  0.9.0
 #     雲端實際載入              →  0.3.9      ← 中間差 7 個 release
 #   而信標**照樣是綠的**——它只證明「有一份 plugin 載入了」，不證明「載入的是哪一份」。
 #   後果不是抽象的：0.3.9 裡還活著兩支已經在 v0.9.0 整支刪掉的 hook，
 #   於是 `.claude/pending-verification/` 在雲端**被清掉之後又長回來**。
 #   ⇒ 一個看不見的落差，會讓「已經刪掉的機制」在別人的工作區裡復活。
 #
 # 匿名讀（不帶任何憑證）⇒ D20 判準下屬於「讀」，不需要開閘、不計次。
 # 快取 6 小時、逾時 6 秒、任何失敗一律閉嘴——信標不能因為網路而變吵或變慢。
 def main_version():
    cache = os.path.join(os.environ.get("ISEP_BEACON_CACHE_DIR", "/tmp"), ".isep-main-version")
    try:
        if time.time() - os.path.getmtime(cache) < 6 * 3600:
            v = open(cache, encoding="utf-8").read().strip()
            return v or None
    except Exception:
        pass
    url = os.environ.get("ISEP_MAIN_MANIFEST_URL",
                         "https://git.uncle6.me/inkstone/ISEP/raw/branch/main/.claude-plugin/plugin.json")
    try:
        with urllib.request.urlopen(url, timeout=6) as r:
            v = (json.loads(r.read().decode("utf-8")) or {}).get("version") or ""
    except Exception:
        v = ""
    try:
        open(cache, "w", encoding="utf-8").write(v)
    except Exception:
        pass
    return v or None
 def vtuple(v):
    return tuple(int(x) for x in re.findall(r"\d+", v)[:3]) or (0,)
 MAIN = main_version() if os.environ.get("ISEP_BEACON_SKIP_NET") != "1" else os.environ.get("ISEP_FAKE_MAIN_VERSION")
 if MAIN and VER != "未知" and MAIN != VER:
    if vtuple(MAIN) > vtuple(VER):
        notes.append(
            "🔴 **這一份落後 ISEP main**（載入 %s ／ main %s）——你現在跑的不是最新那組閘，"
            "而且**已經刪掉的機制可能還活著**（0.3.9 就是這樣讓 .claude/pending-verification/ 復活的）。"
            "修：本機 `claude plugin update isep@inkstone`；雲端要去動一下 Environment 的 setup script "
            "內容逼它重拍快照（快取約 7 天）。追蹤票 inkstone/ISEP#67。" % (VER, MAIN))
    else:
        notes.append("ℹ️ 這一份比 ISEP main 新（載入 %s ／ main %s）——沒發版的改動只在這台機器上。" % (VER, MAIN))
 # ══ ② 專案裡有沒有 ISEP 腳本的舊複本在遮蔽正門 ══════════════════════════
 #
 # 🔴 實例（inkstone/ISEP#90 ②）：`InkStoneCo/scripts/ticket` 是 ISEP `scripts/ticket`
 #   的**舊複本**，它的取 token 邏輯還停在「只認名叫 gitea 的 remote」，
 #   而 bootstrap.sh 在雲端把 Gitea 設成 `origin`
 #   ⇒ 在雲端跑 `scripts/ticket` 一律死在「拿不到 gitea token」
 #   ⇒ 人只好繞過正門直接打 API——而那正是 ticket-api-bypass-guard.sh 在防的事。
 #   **一道閘把人逼去走它自己禁止的那條路，那道閘就是在製造違規。**
 #
 # 判準不是「檔名一樣」，是「檔名一樣**而內容不同**」——同步過的複本不吵。
 def shadow_copies():
    out = []
    src = os.path.join(ROOT, "scripts")
    if not os.path.isdir(src):
        return out
    roots = [PROJ, os.path.join(PROJ, "InkStoneCo")]
    for name in sorted(os.listdir(src)):
        a = os.path.join(src, name)
        if not os.path.isfile(a):
            continue
        try:
            ab = open(a, "rb").read()
        except Exception:
            continue
        for base in roots:
            b = os.path.join(base, "scripts", name)
            if os.path.realpath(b) == os.path.realpath(a):
                continue
            if not os.path.isfile(b):
                continue
            try:
                if open(b, "rb").read() != ab:
                    out.append(os.path.relpath(b, PROJ))
            except Exception:
                pass
    return out
 sh = shadow_copies()
 if sh:
    notes.append(
        "🟡 **專案裡有 ISEP 腳本的舊複本**，而它們排在 plugin 前面被叫到：%s。"
        "兩份必然漂移，漂移的那份會安靜地騙人——`InkStoneCo/scripts/ticket` 就是這樣"
        "在雲端一律死在「拿不到 gitea token」。要嘛刪掉複本改叫 "
        "`\"$CLAUDE_PLUGIN_ROOT\"/scripts/<名字>`，要嘛把複本同步回 ISEP。" % "、".join(sh))
 # ══ ③ 工作區有沒有「已退役機制」留下的產物 ══════════════════════════════
 #
 # 判準是機械的、而且會自己長大：**plugin 自己的原始碼裡有沒有任何一個字提到這個目錄**。
 #   提到了 ⇒ 它是現行機制的產物，正常。
 #   一個字都沒提到 ⇒ 產生它的東西已經不在這一份 ISEP 裡了 ⇒ 它是殘骸。
 # 刻意**不用關鍵字黑名單**（leo 2026-08-17 已證明那條路 8 次誤攔、0 次正確攔截）：
 # 這裡問的是「plugin 現在還認不認得它」，不是「這個名字看起來像不像壞東西」。
 NATIVE = {"hooks", "commands", "skills", "agents", "plugins", "wiki", "cloud-shell",
          "projects", "statsig", "shell-snapshots", "todos", "ide", "local", "isep"}
 def orphan_artifacts():
    out = []
    for base in [PROJ, os.path.join(PROJ, "InkStoneCo")]:
        d = os.path.join(base, ".claude")
        if not os.path.isdir(d):
            continue
        for name in sorted(os.listdir(d)):
            p = os.path.join(d, name)
            if not os.path.isdir(p) or name in NATIVE or name.startswith("."):
                continue
            # 🔴 只搜「會產生東西的那些檔」（hooks／scripts），不搜 docs：
            #   docs 提到一個名字**不會讓那個目錄長出來**，但會讓這一格閉嘴。
            # 🔴 也要把本檔排除掉：本檔的註解裡就寫著 `pending-verification` 當例子，
            #   第一次跑就因此漏報了真正存在的那一個——**自己提到自己＝這格靜音**。
            try:
                hit = False
                for sub in ("hooks", "scripts"):
                    # 🔴 變數名不要跟外層的 `d`（.claude 那個目錄）撞——撞了會把
                    #   外層迴圈的基準目錄換掉，第二個名字之後全部被靜靜跳過。
                    #   第一版就是這樣寫的，實測結果：真的存在的 `verified-claims`
                    #   一聲不吭地消失了。**假綠不是漏寫檢查，是檢查跑在錯的對象上。**
                    sd = os.path.join(ROOT, sub)
                    if not os.path.isdir(sd):
                        continue
                    if subprocess.run(["grep", "-rqlF", "--exclude", os.path.basename(__file__),
                                       "--", name, sd],
                                      capture_output=True, timeout=20).returncode == 0:
                        hit = True
                        break
            except Exception:
                hit = True          # 問不出來就當它有效，不亂報
            if not hit:
                out.append(os.path.relpath(p, PROJ))
    return out
 orph = orphan_artifacts()
 if orph:
    notes.append(
        "🟡 **工作區有已退役機制的產物**：%s。這一份 ISEP 裡沒有任何東西提到它們"
        "（v0.9.0 已整支刪除產生它的 hook），所以它們是殘骸——"
        "**它們還在長，就表示這台機器跑的是舊版**（見上面那格）。確認之後刪掉。" % "、".join(orph))
 CONTEXT = ("%s。這行是 ISEP plugin 自己發的——看得到它就表示閘真的生效了。"
           "若某個 session 從頭到尾沒有這行，那個 session 是零閘狀態，"
           "先修 plugin 再做事，不要用『跑得動』當證據。" % MSG)
 if notes:
    MSG = MSG + "\n" + "\n".join(notes)
    CONTEXT = CONTEXT + "\n\n" + "\n".join(notes)
 print(json.dumps({"systemMessage": MSG,
                  "hookSpecificOutput": {"hookEventName": "SessionStart",
                                         "additionalContext": CONTEXT}},
                 ensure_ascii=False))
@@ -1,57 +0,0 @@
 # hooks/lib/mtime.sh — 「這個檔幾點被動的」，跨 macOS／Linux 都問得出來。
 # 不是獨立掛的閘（沒進 hooks.json），給那幾支用 /tmp 戳記的閘 `source` 用。
 #
 # ══ 為什麼要有這支（inkstone/ISEP#90 ④，2026-08-28 實查）═══════════════
 #
 # 三支閘（prod-write-guard、main-and-prod-push-guard、stage-before-prod-guard）
 # 的戳記檢查都寫成這一行：
 #
 #     MT=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
 #
 # 在 macOS（BSD stat）上它是對的：`-f %m` 就是 mtime。
 # 在 **Linux（GNU coreutils）上 `-f` 是「顯示檔案系統資訊」**，而且它
 # **一邊回非零、一邊往 stdout 吐一整段檔案系統的區塊**：
 #
 #     $ stat -f %m /tmp/.probe
 #     stat: cannot read file system information for '%m': No such file or directory   ← stderr
 #       File: "/tmp/.probe"                                                            ← stdout
 #         ID: 0        Namelen: 255     Type: ext2/ext3
 #     …
 #
 # ⇒ `2>/dev/null` 把錯誤訊息吃掉、`||` 接著跑 `stat -c %Y` 把正確的秒數**接在那堆垃圾後面**
 # ⇒ `MT` 變成「一段多行文字＋一個數字」
 # ⇒ 閘下一行的 `case "$NOW$MT" in *[!0-9]*) return 1` 一定命中
 # ⇒ **在 Linux 上，那三支閘的戳記永遠不會被接受。**
 #
 # 🔴 這件事的後果不是「少一個便利功能」：
 #   那三支閘都是「擋下來，但**總管看過就可以放行**」的設計。
 #   放行的那道門在雲端（Linux）打不開 ⇒ **它們在雲端等於純擋**，
 #   總管照著閘自己印的指示做，做幾次都打不開，而閘不會告訴他門是壞的。
 #   inkstone/InkStoneCo#99 記的「連續四次蓋不出戳記」就是這個形狀。
 #
 # ── 再往下一層：`-f` 根本不吃格式參數，所以連離開碼都不可靠 ────────────
 #
 # 2026-08-28 兩個人量這一格，一個量到 `exit=0`、一個量到 `exit=1`。**兩個都是真的**，
 # 而分歧本身就是最後一塊拼圖：**GNU 的 `-f` 是 `--file-system`，布林旗標、不接格式字串**
 # ⇒ `%m` 被當成**另一個檔名運算元** ⇒ 離開碼取決於「cwd 裡有沒有一個叫 `%m` 的檔」：
 #
 #     A. 沒有（一般情況）  → exit 1 ⇒ `||` **會**跑 ⇒ 正確的秒數接在垃圾後面
 #     B. 剛好有            → exit 0 ⇒ `||` **不會**跑 ⇒ 整包連一個數字都沒有
 #
 # 兩種情況下閘的結果一樣：`MT` 都不是純數字，戳記都作廢。（實測 GNU coreutils 9.4）
 #
 # 🔴 **這才是該記住的教訓**：舊寫法的 `||` fallback 救不了，
 #   **不是因為它沒跑，而是因為「跑不跑」根本不由這支腳本決定**
 #   ——它由「cwd 裡有沒有某個檔名」決定。
 #   一個**行為取決於 cwd 裡有沒有某個檔**的判斷式，不管跑不跑都是壞的。
 #
 # 🔴 所以修法不是「把順序反過來」而已：改成先 `-c %Y`（GNU）再 `-f %m`（BSD），
 #   而且**每一步都驗它是不是純數字**——因為這個 bug 的成因正是
 #   「命令失敗了卻還是印了東西出來」，只看離開碼會再被騙一次。
 file_mtime() {
  _fm=$(stat -c %Y "$1" 2>/dev/null || true)
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(stat -f %m "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(python3 -c 'import os,sys; print(int(os.path.getmtime(sys.argv[1])))' "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=0 ;; esac
  printf '%s' "$_fm"
 }
@@ -74,18 +74,6 @@ esac
 #   ⇒ 沒有可靠的身分辨識時，改成**正向確認**：推 main 前要有一枚新鮮的戳記。
 #     subagent 當然造得出那枚戳記——但它得刻意繞過一段明講「不要這樣做」的訊息。
 #     **閘擋的是無心，不是惡意。** 而現在這個版本連無心都擋不了（它誰都擋）。
 # 🔴 戳記的 mtime 一律走 lib/mtime.sh：舊寫法（`stat -f %m || stat -c %Y`）在 Linux 上
 #   **永遠算不出數字**（GNU 的 `-f` 是「檔案系統資訊」，它一邊回非零一邊吐一整段文字，
 #   於是後面接上的秒數被那段垃圾污染）⇒ 這支閘給總管的逃生口在雲端整個焊死，
 #   而閘不會告訴他門是壞的（inkstone/ISEP#90 ④，全文見 hooks/lib/mtime.sh）。
 #   lib 不在時就地補一份同順序的定義——這道門不能因為少一個檔案就再關上一次。
 . "$(dirname "$0")/lib/mtime.sh" 2>/dev/null || file_mtime() {
  _fm=$(stat -c %Y "$1" 2>/dev/null || true)
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(stat -f %m "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=0 ;; esac
  printf '%s' "$_fm"
 }
 STAMP="/tmp/.main-push-ok"
 # 🔴 2026-08-11 這道閘被自己的戳記穿透了，修法寫在這裡：
@@ -99,7 +87,7 @@ STAMP="/tmp/.main-push-ok"
 stamp_ok() {
  [ -f "$STAMP" ] || return 1
  NOW=$(date +%s 2>/dev/null || echo 0)
-  MT=$(file_mtime "$STAMP")
+  MT=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
  case "$NOW$MT" in *[!0-9]*) return 1 ;; esac
  [ "$NOW" -gt 0 ] && [ "$MT" -gt 0 ] || return 1
  [ $((NOW - MT)) -lt 900 ] || return 1
@@ -273,9 +261,7 @@ leo 原話：
 逐筆看過那些 commit（`git log --oneline gitea/main..<branch>`、`git diff --stat`），
 確定它們該進 main，再：
-    bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" main-push <那個 repo 的路徑>
+    git rev-parse --show-toplevel > /tmp/.main-push-ok && <你的 git push 指令>
    <你的 git push 指令>
    （等價的手打法：git rev-parse --show-toplevel > /tmp/.main-push-ok）
 戳記 **綁這個 repo、只能用一次、15 分鐘失效**——它代表「**這一次、這個 repo，我看過了**」。
@@ -68,23 +68,11 @@ CMD=$(printf '%s' "$CMD" | python3 "$(dirname "$0")/lib/strip_""heredoc.py" 2>/d
 #    **15 分鐘內一條並行的 subagent 把 commit 推上了另一個 repo 的 main**。
 #    ⇒ **多條 subagent 並行時，「時間窗」本身就是漏洞。** 所以改成單次用完即丟。
 #    ⇒ 而且只在**真的要擋的那一刻**才檢查——放在檔頭會被任何一條無關指令把戳記燒掉。
 # 🔴 戳記的 mtime 一律走 lib/mtime.sh：舊寫法（`stat -f %m || stat -c %Y`）在 Linux 上
 #   **永遠算不出數字**（GNU 的 `-f` 是「檔案系統資訊」，它一邊回非零一邊吐一整段文字，
 #   於是後面接上的秒數被那段垃圾污染）⇒ 這支閘給總管的逃生口在雲端整個焊死，
 #   而閘不會告訴他門是壞的（inkstone/ISEP#90 ④，全文見 hooks/lib/mtime.sh）。
 #   lib 不在時就地補一份同順序的定義——這道門不能因為少一個檔案就再關上一次。
 . "$(dirname "$0")/lib/mtime.sh" 2>/dev/null || file_mtime() {
  _fm=$(stat -c %Y "$1" 2>/dev/null || true)
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(stat -f %m "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=0 ;; esac
  printf '%s' "$_fm"
 }
 STAMP="/tmp/.prod-write-ok"
 stamp_ok() {
  [ -f "$STAMP" ] || return 1
  NOW=$(date +%s 2>/dev/null || echo 0)
-  MT=$(file_mtime "$STAMP")
+  MT=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
  case "$NOW$MT" in *[!0-9]*) return 1 ;; esac
  [ "$NOW" -gt 0 ] && [ "$MT" -gt 0 ] || return 1
  [ $((NOW - MT)) -lt 900 ] || return 1
@@ -124,9 +112,7 @@ leo 原話：
 ━━━ 你是總管 ━━━
 看清楚它會覆蓋什麼（`arcrun_get_workflow` 先撈一份現況存起來，好回滾），確定要推，再：
-    bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" prod-write   # ⚠️ 只放行「下一個」動作，用完即消失
+    touch /tmp/.prod-write-ok      # ⚠️ 只放行「下一個」動作，用完即消失
    （等價的手打法：touch /tmp/.prod-write-ok。gate-ok 是所有閘共用的同一個入口，
      好處是它的形狀固定 ⇒ 一條規則就能事先放行，不會每次被權限層擋在門外）
 戳記 15 分鐘有效。**若這一推會讓封測者／用戶當場拿到東西，那就不是你的層級——要 leo 解保險。**
 MSG
@@ -324,9 +310,7 @@ leo 原話：
 ━━━ 你是總管 ━━━
 確認過要推什麼、會蓋掉什麼之後：
-    bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" prod-write   # ⚠️ 只放行「下一個」動作，用完即消失
+    touch /tmp/.prod-write-ok      # ⚠️ 只放行「下一個」動作，用完即消失
    （等價的手打法：touch /tmp/.prod-write-ok。gate-ok 是所有閘共用的同一個入口，
      好處是它的形狀固定 ⇒ 一條規則就能事先放行，不會每次被權限層擋在門外）
 ⚠️ `acr recipe push` 另有一道**互動式暴露同意閘**（終端機裡要人親手輸入資源名）。
 那道閘擋的是「把資源變成可被外部呼叫」，**本閘的戳記蓋不過它**——那是 leo 的手。
@@ -159,18 +159,6 @@ fi
 #    ⇒ 改成兩者都認：內容有數字就用內容，沒有就用 mtime（`touch` 因此真的有效）。
 #
 # 另外認 leo 親手蓋的章（scripts/stage-ok.sh 產生），那是比我自評更強的訊號。
 # 🔴 戳記的 mtime 一律走 lib/mtime.sh：舊寫法（`stat -f %m || stat -c %Y`）在 Linux 上
 #   **永遠算不出數字**（GNU 的 `-f` 是「檔案系統資訊」，它一邊回非零一邊吐一整段文字，
 #   於是後面接上的秒數被那段垃圾污染）⇒ 這支閘給總管的逃生口在雲端整個焊死，
 #   而閘不會告訴他門是壞的（inkstone/ISEP#90 ④，全文見 hooks/lib/mtime.sh）。
 #   lib 不在時就地補一份同順序的定義——這道門不能因為少一個檔案就再關上一次。
 . "$(dirname "$0")/lib/mtime.sh" 2>/dev/null || file_mtime() {
  _fm=$(stat -c %Y "$1" 2>/dev/null || true)
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(stat -f %m "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=0 ;; esac
  printf '%s' "$_fm"
 }
 for STAMP in /tmp/.stage-ok-by-leo /tmp/.stage-verified; do
  [ -f "$STAMP" ] || continue
  now=$(date +%s)
@@ -184,7 +172,7 @@ for STAMP in /tmp/.stage-ok-by-leo /tmp/.stage-verified; do
  #    抽數字會得到天文數字 ⇒ `now - t` 是**負數** ⇒ `< 21600` 成立 ⇒ **永遠放行**。
  #    ⇒ 只有「不晚於現在」的時間戳才算數；不合理就退回 mtime，別當成通過。
  if [ "$t" -eq 0 ] || [ "$t" -gt "$now" ]; then
-    t=$(file_mtime "$STAMP")
+    t=$(stat -f %m "$STAMP" 2>/dev/null || stat -c %Y "$STAMP" 2>/dev/null || echo 0)
  fi
  [ "$t" -gt 0 ] && [ "$((now - t))" -lt 21600 ] && exit 0   # 6 小時內驗過 stage → 放行
 done
@@ -208,8 +196,7 @@ cat >&2 <<'EOF'
 ⚠️ 身分：leo 2026-07-25 令「測試一律用 youlin，別拿 leo21c 當探針（會製造假信號）」
   ⇒ 部署前先 `acr whoami` 確認身分。
-驗過了 ⇒ `bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" stage-verified` 後重送
+驗過了 ⇒ `touch /tmp/.stage-verified` 後重送，並在回覆裡**貼 stage 的實測輸出**
 （等價：`touch /tmp/.stage-verified`），並在回覆裡**貼 stage 的實測輸出**
 （「我測過了」不算——貼指令與它吐出來的東西）。
 EOF
 exit 2
@@ -1,88 +0,0 @@
 #!/usr/bin/env bash
 # scripts/gate-ok ＋「戳記真的打得開門」的迴歸測試（inkstone/ISEP#90 ④）
 #
 # ══ 這支守的是什麼 ═════════════════════════════════════════════════════
 # 三支閘（prod-write／main-and-prod-push／stage-before-prod）都是
 # 「擋下來，但**總管看過就可以放行**」的設計。既有的測試只驗了「擋得住」，
 # **一條都沒有驗過「放得開」**——於是 2026-08-28 才發現：
 #   `stat -f %m` 在 GNU coreutils 上是「檔案系統資訊」，它一邊回非零一邊吐一整段文字，
 #   把接在後面的秒數污染掉 ⇒ **在 Linux（＝每一個雲端 session）上，那三支閘的戳記
 #   永遠不會被接受** ⇒ 它們在雲端等於純擋，而閘不會告訴你門是壞的。
 #
 # 所以這支的第一優先是「門打得開」，第二優先是「門沒有因此變寬」。
 #
 # 🔴 這支會真的寫 /tmp 的戳記檔（那是閘寫死的路徑，沒有覆寫的開關）。
 #    每一條測完就把它刪掉；跑之前若有真的在等的戳記，會被這支洗掉——
 #    請不要在「已經蓋好戳記正要推東西」的當下跑它。
 set -u
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"        # hooks/
 REPO="$(cd "$ROOT/.." && pwd)"
 GATEOK="$REPO/scripts/gate-ok"
 TMP=$(mktemp -d); trap 'rm -rf "$TMP"; rm -f /tmp/.prod-write-ok /tmp/.main-push-ok /tmp/.stage-verified /tmp/.solo-ok-TESTSID' EXIT
 export GIT_CONFIG_GLOBAL="$TMP/gitconfig"; : > "$GIT_CONFIG_GLOBAL"
 export GIT_AUTHOR_NAME=t GIT_AUTHOR_EMAIL=t@t GIT_COMMITTER_NAME=t GIT_COMMITTER_EMAIL=t@t
 PASS=0; FAIL=0
 ok(){ if [ "$2" = "$3" ]; then printf '  ✅ %s\n' "$1"; PASS=$((PASS+1));
      else printf '  ❌ %s —— 期望 %s，實得 %s\n' "$1" "$3" "$2"; FAIL=$((FAIL+1)); fi; }
 mkrepo(){ d="$TMP/$1"; git init -q -b main "$d"; ( cd "$d" && echo a>a && git add a && git commit -qm x ) >/dev/null 2>&1; printf '%s\n' "$d"; }
 fire_prod(){ printf '{"tool_name":"Bash","tool_input":{"command":"acr push x.yaml"}}' \
             | bash "$ROOT/prod-write-guard.sh" >/dev/null 2>&1; echo $?; }
 fire_push(){ printf '{"tool_name":"Bash","tool_input":{"command":"git push origin main"}}' \
             | ( cd "$1" && bash "$ROOT/main-and-prod-push-guard.sh" >/dev/null 2>&1; echo $? ); }
 rm -f /tmp/.prod-write-ok /tmp/.main-push-ok /tmp/.stage-verified
 echo "── 最重要：門打得開（Linux 上 stat -f %m 那個 bug 的迴歸）──────"
 ok "① 沒戳記 → prod-write 擋"            "$(fire_prod)" 2
 bash "$GATEOK" prod-write >/dev/null
 ok "② gate-ok prod-write 之後 → 放行"     "$(fire_prod)" 0
 ok "③ 單次用完即丟：同一枚不能放行第二次" "$(fire_prod)" 2
 R1=$(mkrepo r1); R2=$(mkrepo r2)
 ok "④ 沒戳記 → 推 main 擋"                "$(fire_push "$R1")" 2
 bash "$GATEOK" main-push "$R1" >/dev/null
 ok "⑤ gate-ok main-push <repo> 之後 → 放行" "$(fire_push "$R1")" 0
 echo "── 門沒有因此變寬 ────────────────────────────────────────────"
 bash "$GATEOK" main-push "$R1" >/dev/null
 ok "⑥ 替 r1 開的門，r2 走不過（綁 repo 沒鬆）" "$(fire_push "$R2")" 2
 rm -f /tmp/.main-push-ok
 # 過期的戳記不算數：把 mtime 調到 16 分鐘前
 bash "$GATEOK" prod-write >/dev/null
 touch -d '16 minutes ago' /tmp/.prod-write-ok 2>/dev/null || touch -A -001600 /tmp/.prod-write-ok 2>/dev/null
 ok "⑦ 16 分鐘前的戳記 → 過期，照樣擋"      "$(fire_prod)" 2
 rm -f /tmp/.prod-write-ok
 # 空內容的 main-push 戳記＝萬用鑰匙，08-12 那次穿透的形狀，不准復活
 : > /tmp/.main-push-ok
 ok "⑧ 空內容的 main-push 戳記 → 不算數"    "$(fire_push "$R1")" 2
 rm -f /tmp/.main-push-ok
 echo "── gate-ok 自己：不認得的就要拒絕，別蓋一枚打不開的戳記 ──────"
 bash "$GATEOK" nonsense >/dev/null 2>&1; ok "⑨ 不認得的閘名 → 離開碼 2" "$?" 2
 bash "$GATEOK" solo >/dev/null 2>&1;     ok "⑩ solo 沒帶 session id → 離開碼 2" "$?" 2
 bash "$GATEOK" main-push "$TMP" >/dev/null 2>&1; ok "⑪ 不是 git repo → 離開碼 2" "$?" 2
 ok "⑫ 而且**沒有**留下一枚註定打不開的空戳記" "$([ -f /tmp/.main-push-ok ] && echo yes || echo no)" no
 bash "$GATEOK" solo TESTSID >/dev/null 2>&1
 ok "⑬ solo <sid> → 蓋出 /tmp/.solo-ok-<sid>" "$([ -f /tmp/.solo-ok-TESTSID ] && echo yes || echo no)" yes
 bash "$GATEOK" stage-verified >/dev/null 2>&1
 ok "⑭ stage-verified → 蓋出 /tmp/.stage-verified" "$([ -f /tmp/.stage-verified ] && echo yes || echo no)" yes
 echo "── file_mtime 本身：兩個平台的寫法都要答得出純數字 ────────────"
 . "$ROOT/lib/mtime.sh"
 touch "$TMP/probe"
 M=$(file_mtime "$TMP/probe")
 case "$M" in ''|*[!0-9]*) R=bad ;; *) R=ok ;; esac
 ok "⑮ file_mtime 回純數字（舊寫法在 Linux 上會回一整段文字）" "$R" ok
 ok "⑯ 檔案不存在 → 回 0，不是空字串" "$(file_mtime "$TMP/nope")" 0
 # 🔴 ⑰ 守的是這個 bug 的最後一層：舊寫法的行為**取決於 cwd 裡有沒有一個叫 `%m` 的檔**
 #    （GNU 的 -f 是布林旗標，`%m` 被當成另一個檔名運算元）。有 ⇒ exit 0 ⇒ `||` 連跑都不跑。
 #    一個行為取決於 cwd 有沒有某個檔的判斷式，不管跑不跑都是壞的。
 M2=$( cd "$TMP" && touch '%m' && file_mtime "$TMP/probe" )
 case "$M2" in ''|*[!0-9]*) R2=bad ;; *) R2=ok ;; esac
 ok "⑰ cwd 裡有一個叫 %m 的檔 → 仍要回純數字" "$R2" ok
 echo
 printf '通過 %s 條，失敗 %s 條\n' "$PASS" "$FAIL"
 [ "$FAIL" = 0 ] || exit 1
@@ -1,117 +0,0 @@
 #!/usr/bin/env bash
 # isep-presence-beacon.sh 的迴歸測試（inkstone/ISEP#90 ②③）
 #
 # 信標的價值全在鑑別力，所以這支要同時證明兩件相反的事：
 #   ① 該報的三件真的報得出來（版本落差／舊複本遮蔽正門／退役機制的殘骸）
 #   ② **不管加多少報告，那行綠色信標永遠在**——它消失＝leo 會判定這個 session 零閘。
 #      所以連 python 掛掉、網路不通、訊息裡有引號，都要還有一行合法 JSON。
 #
 # 🔴 全程離線（ISEP_BEACON_SKIP_NET=1，版本用 ISEP_FAKE_MAIN_VERSION 造），
 #    造假的 plugin root 與 project dir 都在 TMP 底下，不碰真 repo。
 set -u
 HOOK="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/isep-presence-beacon.sh}"
 REAL_HOOKS="$(cd "$(dirname "$HOOK")" && pwd)"
 TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
 export ISEP_BEACON_SKIP_NET=1 ISEP_BEACON_CACHE_DIR="$TMP"
 PASS=0; FAIL=0; N=0
 # mkplugin <版本> → 造一份假的 plugin root（只放信標真的會讀的東西）
 mkplugin() {
  d="$TMP/plugin-$1"; mkdir -p "$d/.claude-plugin" "$d/hooks/lib" "$d/scripts"
  printf '{"name":"isep","version":"%s"}\n' "$1" > "$d/.claude-plugin/plugin.json"
  printf '{"hooks":{"Stop":[{"hooks":[{"command":"hooks/a.sh"},{"command":"hooks/b.sh"}]}]}}\n' \
    > "$d/hooks/hooks.json"
  cp "$HOOK" "$d/hooks/$(basename "$HOOK")"
  cp "$REAL_HOOKS/lib/beacon_report.py" "$d/hooks/lib/beacon_report.py"
  printf '#!/bin/sh\necho real\n' > "$d/scripts/ticket"
  printf '%s\n' "$d"
 }
 # run <plugin root> <project dir> → 印出 systemMessage（JSON 壞掉就印 __BADJSON__）
 run() {
  CLAUDE_PLUGIN_ROOT="$1" CLAUDE_PROJECT_DIR="$2" bash "$1/hooks/$(basename "$HOOK")" 2>/dev/null \
    | python3 -c 'import json,sys
 try: print(json.load(sys.stdin)["systemMessage"])
 except Exception: print("__BADJSON__")'
 }
 check() { # check <說明> <輸出> <該出現|!不該出現>...
  desc="$1"; out="$2"; shift 2; N=$((N+1)); ok=1; why=""
  for w in "$@"; do
    case "$w" in
      "!"*) if printf '%s' "$out" | grep -qF -- "${w#!}"; then ok=0; why="不該出現卻出現了：${w#!}"; fi ;;
      *)    if ! printf '%s' "$out" | grep -qF -- "$w"; then ok=0; why="少了：$w"; fi ;;
    esac
  done
  if [ "$ok" = 1 ]; then printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
  else printf '  ❌ %s —— %s\n' "$desc" "$why"; printf '%s\n' "$out" | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
 }
 echo "── 基本盤：那行綠色信標永遠在 ────────────────────────────────"
 P=$(mkplugin 0.9.0); J="$TMP/proj-clean"; mkdir -p "$J"
 out=$(run "$P" "$J")
 check "① 乾淨環境：只有一行信標，版本與閘數都在" "$out" \
  "🟢 ISEP v0.9.0 已載入" "2 支閘" "!🔴" "!🟡" "!__BADJSON__"
 echo "── ①版本落差 ────────────────────────────────────────────────"
 out=$(ISEP_FAKE_MAIN_VERSION=0.9.0 run "$P" "$J")
 check "② 載入版＝main 版 → 不吵" "$out" "🟢 ISEP v0.9.0" "!落後"
 P39=$(mkplugin 0.3.9)
 out=$(ISEP_FAKE_MAIN_VERSION=0.9.0 run "$P39" "$J")
 check "③ 載入 0.3.9、main 0.9.0 → 要說它落後（雲端那個現場）" "$out" \
  "🟢 ISEP v0.3.9 已載入" "落後 ISEP main" "0.9.0" "inkstone/ISEP#67"
 out=$(ISEP_FAKE_MAIN_VERSION=0.1.0 run "$P" "$J")
 check "④ 載入版比 main 新 → 說「沒發版」，不說「落後」" "$out" "比 ISEP main 新" "!落後 ISEP main"
 echo "── ②舊複本遮蔽正門 ──────────────────────────────────────────"
 J2="$TMP/proj-shadow"; mkdir -p "$J2/scripts"
 printf '#!/bin/sh\necho OLD\n' > "$J2/scripts/ticket"
 out=$(run "$P" "$J2")
 check "⑤ 專案裡有內容不同的同名腳本 → 要點名（ticket 那件）" "$out" \
  "舊複本" "scripts/ticket"
 J3="$TMP/proj-same"; mkdir -p "$J3/scripts"; cp "$P/scripts/ticket" "$J3/scripts/ticket"
 out=$(run "$P" "$J3")
 check "⑥ 複本內容一模一樣（同步過的）→ 不吵" "$out" "!舊複本"
 J4="$TMP/proj-body"; mkdir -p "$J4/InkStoneCo/scripts"
 printf '#!/bin/sh\necho OLD\n' > "$J4/InkStoneCo/scripts/ticket"
 out=$(run "$P" "$J4")
 check "⑦ 雲端排法：複本在 \$TOP/InkStoneCo/ 底下也要抓到" "$out" \
  "舊複本" "InkStoneCo/scripts/ticket"
 echo "── ③退役機制的殘骸 ──────────────────────────────────────────"
 J5="$TMP/proj-orphan"; mkdir -p "$J5/.claude/pending-verification" "$J5/.claude/hooks"
 out=$(run "$P" "$J5")
 check "⑧ plugin 的 hooks/scripts 完全沒提到的目錄 → 報殘骸" "$out" \
  "已退役機制的產物" ".claude/pending-verification"
 check "⑨ Claude Code 自己的目錄（hooks）不算殘骸" "$out" "!.claude/hooks"
 # 現行機制的產物不該被報：讓 plugin 的某支 hook 提到它
 mkdir -p "$J5/.claude/pending-main-push"
 printf '#!/bin/sh\n# 寫到 pending-main-push/\n' > "$P/hooks/x.sh"
 out=$(run "$P" "$J5")
 check "⑩ hooks 裡有東西提到它 → 那是現行機制的產物，不報" "$out" "!pending-main-push"
 # 🔴 這條守的是第一版真的犯過的 bug：內層迴圈的變數名跟外層的 `d` 撞，
 #    第二個名字之後全部被靜靜跳過 ⇒ 真的存在的殘骸一聲不吭地消失。
 mkdir -p "$J5/.claude/verified-claims"
 out=$(run "$P" "$J5")
 check "⑪ 同一個 .claude 底下有多個殘骸 → 每一個都要報（變數撞名的迴歸）" "$out" \
  ".claude/pending-verification" ".claude/verified-claims"
 echo "── 最重要：加了報告也不准讓信標消失 ──────────────────────────"
 # python 掛掉（把 report 換成一定會爆的內容）→ 仍要有一行合法 JSON 的信標
 PB=$(mkplugin 0.9.0); printf 'raise SystemExit(3)\n' > "$PB/hooks/lib/beacon_report.py"
 out=$(run "$PB" "$J")
 check "⑫ 組訊息的 python 整支掛掉 → 退回乾淨的那一行，不是沉默" "$out" \
  "🟢 ISEP v0.9.0 已載入" "!__BADJSON__"
 rm -f "$PB/hooks/lib/beacon_report.py"
 out=$(run "$PB" "$J")
 check "⑬ 連 report 檔都不見 → 一樣要有信標" "$out" "🟢 ISEP v0.9.0 已載入" "!__BADJSON__"
 # 訊息裡有引號/換行時 JSON 仍要合法（舊版是 printf 手拼的，這正是它會壞的地方）
 J6="$TMP/proj-quote"; mkdir -p "$J6/scripts"
 printf '#!/bin/sh\necho "OLD"\n' > "$J6/scripts/ticket"
 out=$(run "$P" "$J6")
 check "⑭ 報告內容含引號 → JSON 仍然合法" "$out" "🟢 ISEP" "!__BADJSON__"
 echo
 printf '通過 %s 條，失敗 %s 條（共 %s 條）\n' "$PASS" "$FAIL" "$N"
 [ "$FAIL" = 0 ] || exit 1
@@ -1,137 +0,0 @@
 #!/usr/bin/env bash
 # unpushed-police.sh 的迴歸測試（inkstone/ISEP#90）
 #
 # 這支存在的理由是一個**穩定重現**的誤報：雲端 session 開出來的工作分支
 # 天生沒有 upstream，內容卻等於遠端 main ⇒ 每個雲端 session、每次收工都被攔一次。
 # 2026-08-27 一個 session 攔五次，五次全是誤報。
 #
 # 兩個方向都要有證據，而且 **A 群（不該報）比 B 群更重要**：
 #   永遠在響的警報＝訓練人忽略這個警報，下一條真的失蹤的分支會混在雜訊裡。
 #
 # 🔴 全程離線：用本機 bare repo 當「遠端」，`git ls-remote` 打的是檔案路徑。
 #    不碰任何真 repo、不打網路、不寫 /tmp 的正式快取（走 UNPUSHED_CACHE_DIR）。
 set -u
 HOOK="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/unpushed-police.sh}"
 TMP=$(mktemp -d)
 trap 'rm -rf "$TMP"' EXIT
 export GIT_CONFIG_GLOBAL="$TMP/gitconfig"; : > "$GIT_CONFIG_GLOBAL"
 export GIT_AUTHOR_NAME=t GIT_AUTHOR_EMAIL=t@t GIT_COMMITTER_NAME=t GIT_COMMITTER_EMAIL=t@t
 PASS=0; FAIL=0; N=0
 # mk <名字> → 造一個「遠端 bare + 本機 clone」的場，印出本機 repo 路徑
 mk() {
  d="$TMP/$1"; mkdir -p "$d"
  git init -q --bare "$d/remote.git"
  git init -q -b main "$d/work"
  ( cd "$d/work"
    echo a > a.txt; git add a.txt; git commit -qm first
    git remote add origin "$d/remote.git"
    git push -q origin main
    git branch --unset-upstream 2>/dev/null || true ) >/dev/null 2>&1
  printf '%s\n' "$d/work"
 }
 # fire <repo> <期望 exit> <說明> [期望訊息片段]
 fire() {
  repo="$1"; want="$2"; desc="$3"; want_msg="${4:-}"
  N=$((N+1))
  out=$(printf '{}' | CLAUDE_PROJECT_DIR="$repo" UNPUSHED_CACHE_DIR="$TMP/cache-$N" \
        bash "$HOOK" 2>&1); rc=$?
  mkdir -p "$TMP/cache-$N" 2>/dev/null
  ok=1
  [ "$rc" -eq "$want" ] || ok=0
  if [ -n "$want_msg" ] && ! printf '%s' "$out" | grep -qF "$want_msg"; then ok=0; fi
  if [ "$ok" = 1 ]; then
    printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
  else
    printf '  ❌ %s —— 期望 exit=%s%s，實得 exit=%s\n' "$desc" "$want" \
      "${want_msg:+ 且訊息含「$want_msg」}" "$rc"
    printf '%s\n' "$out" | sed -n '1,14p' | sed 's/^/     /'
    FAIL=$((FAIL+1))
  fi
 }
 # 每個案例先把快取目錄準備好（fire 用的是自己那一格，互不污染）
 for i in $(seq 1 40); do mkdir -p "$TMP/cache-$i"; done
 echo "── A 群：不該報（誤攔比漏擋更該修）──────────────────────────"
 # ① 這就是雲端那個現場：分支沒有 upstream，但它那顆 commit 就是遠端 main 那顆
 r=$(mk cloud)
 ( cd "$r" && git checkout -q -b claude/session-xyz && git branch -D main -q 2>/dev/null
  git remote set-head origin -d 2>/dev/null; git update-ref -d refs/remotes/origin/main ) >/dev/null 2>&1
 fire "$r" 0 "① 沒 upstream，但遠端就有這顆 commit（雲端每個 session 的現場）"
 # ② HEAD 是遠端 main 的**祖先**（遠端已經走在前面）——同樣不是「沒推」
 r=$(mk ancestor)
 ( cd "$r"
  echo b > b.txt && git add b.txt && git commit -qm second && git push -q origin main
  git checkout -q -b work HEAD~1
  git update-ref -d refs/remotes/origin/main ) >/dev/null 2>&1
 fire "$r" 0 "② HEAD 是遠端 main 的祖先 → 遠端已經有它"
 # ③ 本機的 remote-tracking ref **過期**（08-28 實測落後遠端 4 天的那一格）
 r=$(mk stale)
 ( cd "$r"
  old=$(git rev-parse HEAD)
  echo b > b.txt && git add b.txt && git commit -qm second && git push -q origin main
  git update-ref refs/remotes/origin/main "$old"     # 本機那份停在舊的
  git checkout -q -b claude/session-abc ) >/dev/null 2>&1
 fire "$r" 0 "③ 本機 origin/main 過期，但遠端真的有這顆 → 不報"
 # ④ 完全問不到遠端（沒有任何 remote）→ **不當成沒推**
 r="$TMP/noremote"; git init -q -b main "$r"
 ( cd "$r" && echo a > a.txt && git add a.txt && git commit -qm only ) >/dev/null 2>&1
 fire "$r" 0 "④ 沒有任何 remote＝問不到 → 不報（不拿離線當罪證）"
 # ⑤ 基準過期時，已經在遠端 main 上的分支不算散落
 r=$(mk straystale)
 ( cd "$r"
  old=$(git rev-parse HEAD)
  git checkout -q -b feat/done
  echo b > b.txt && git add b.txt && git commit -qm done
  git push -q origin feat/done:main                  # 遠端 main 已經含它
  git update-ref refs/remotes/origin/main "$old" ) >/dev/null 2>&1
 fire "$r" 0 "⑤ 分支已在遠端 main 上，只是本機基準舊 → 不算散落"
 # ⑥ stop_hook_active → 一律放行
 r=$(mk stopactive)
 ( cd "$r" && echo x >> a.txt ) >/dev/null 2>&1
 N=$((N+1))
 out=$(printf '{"stop_hook_active":true}' | CLAUDE_PROJECT_DIR="$r" \
      UNPUSHED_CACHE_DIR="$TMP/cache-$N" bash "$HOOK" 2>&1); rc=$?
 if [ "$rc" -eq 0 ]; then printf '  ✅ %s\n' "⑥ stop_hook_active＝true → 放行"; PASS=$((PASS+1))
 else printf '  ❌ %s（exit=%s）\n' "⑥ stop_hook_active＝true → 放行" "$rc"; FAIL=$((FAIL+1)); fi
 echo "── B 群：該報（不能為了不吵就變成放行）────────────────────"
 # ⑦ 真的有遠端沒有的 commit ＝ 真的沒推
 r=$(mk unpushed)
 ( cd "$r"
  git checkout -q -b feat/real
  echo b > b.txt && git add b.txt && git commit -qm "沒推的那筆" ) >/dev/null 2>&1
 fire "$r" 2 "⑦ 分支有遠端沒有的 commit → 要報" "從未推過"
 # ⑧ 有改動沒 commit
 r=$(mk dirty)
 ( cd "$r" && echo more >> a.txt ) >/dev/null 2>&1
 fire "$r" 2 "⑧ 工作區有未 commit 的改動 → 要報" "未 commit"
 # ⑨ 散落分支：本地分支有遠端 main 沒有的東西
 r=$(mk stray)
 ( cd "$r"
  git checkout -q -b feat/lost
  echo c > c.txt && git add c.txt && git commit -qm "躺著的那筆"
  git checkout -q main ) >/dev/null 2>&1
 fire "$r" 2 "⑨ 有分支沒併回、遠端也沒有 → 要報散落" "feat/lost"
 # ⑩ 判準沒有滑回「有沒有 upstream」：有 upstream 但真的領先，照樣要報
 r=$(mk ahead)
 ( cd "$r"
  git branch --set-upstream-to=origin/main main
  echo b > b.txt && git add b.txt && git commit -qm "領先一筆" ) >/dev/null 2>&1
 fire "$r" 2 "⑩ 有 upstream 且真的領先 → 照樣要報" "領先"
 echo
 printf '通過 %s 條，失敗 %s 條（共 %s 條）\n' "$PASS" "$FAIL" "$N"
 [ "$FAIL" = 0 ] || exit 1
@@ -35,119 +35,10 @@ except Exception: print(False)
 ' 2>/dev/null)"
 [ "$stop_active" = "True" ] && exit 0
 # ══════════════════════════════════════════════════════════════════════
 # 「遠端到底有沒有這顆 commit」——本檔唯一的判準（inkstone/ISEP#90，2026-08-28）
 # ══════════════════════════════════════════════════════════════════════
 #
 # 🔴 舊判準是「這條分支有沒有 upstream」，而**雲端 session 開出來的工作分支
 #    天生就沒有 upstream**，內容卻等於遠端 main：
 #
 #      薄殼 HEAD        = 081c547d90dc2d80692485af083ca1f71f2094f2
 #      GitHub 遠端 main = 081c547d90dc2d80692485af083ca1f71f2094f2   ← 同一顆
 #
 #    ⇒ 每個雲端 session、每次收工都被攔一次。2026-08-27 一個 session 攔五次，
 #      **五次全是誤報**。而永遠在響的警報＝訓練人忽略這個警報
 #      （本檔第 ③ 段自己在 08-12 就寫過這句，這次是同一個病長在別的判準上）。
 #
 # 🔴 也不能改成「本機的 remote-tracking ref 有沒有含它」的變體：
 #    那份 ref 會過期——08-28 實測本 session 的 `origin/main` 落後遠端整整 4 天。
 #    本機只答得準「有」，答不準「沒有」⇒ 答「沒有」的時候要去問遠端。
 #
 # 三態，不是兩態：0＝遠端有　1＝遠端沒有　2＝問不到（沒 remote／網路不通／沒權限）。
 # **2 一律不報。** 誤攔比漏擋更該修（leo 2026-08-17：文字層那些閘 8 次誤攔、
 # 0 次正確攔截）——把「離線」當成「你沒推」，就是拿雜訊懲罰謹慎。
 # 🔴 戳記的 mtime 一律走 lib/mtime.sh：舊寫法（`stat -f %m || stat -c %Y`）在 Linux 上
 #   **永遠算不出數字**（GNU 的 `-f` 是「檔案系統資訊」，它一邊回非零一邊吐一整段文字，
 #   於是後面接上的秒數被那段垃圾污染）⇒ 這支閘給總管的逃生口在雲端整個焊死，
 #   而閘不會告訴他門是壞的（inkstone/ISEP#90 ④，全文見 hooks/lib/mtime.sh）。
 #   lib 不在時就地補一份同順序的定義——這道門不能因為少一個檔案就再關上一次。
 . "$(dirname "$0")/lib/mtime.sh" 2>/dev/null || file_mtime() {
  _fm=$(stat -c %Y "$1" 2>/dev/null || true)
  case "${_fm:-}" in ''|*[!0-9]*) _fm=$(stat -f %m "$1" 2>/dev/null || true) ;; esac
  case "${_fm:-}" in ''|*[!0-9]*) _fm=0 ;; esac
  printf '%s' "$_fm"
 }
 GIT_ASK="env GIT_TERMINAL_PROMPT=0 GIT_ASKPASS=/bin/echo GIT_SSH_COMMAND=ssh\ -oBatchMode=yes"
 _TO=""
 command -v timeout  >/dev/null 2>&1 && _TO="timeout 15"
 command -v gtimeout >/dev/null 2>&1 && _TO="gtimeout 15"
 # ls_remote_heads <repo> <remote> → 印出「<sha> <ref>」數行；問不到就印空、離開碼 1
 # 快取 120 秒：Stop hook 每個回合都跑，同一個遠端不必每回合都打一次網路。
 ls_remote_heads() {
  _lr_repo="$1"; _lr_rm="$2"
  _lr_key="$(printf '%s|%s' "$_lr_repo" "$_lr_rm" | cksum | tr -d ' /')"
  # 快取位置可被 UNPUSHED_CACHE_DIR 覆寫——測試要能造「同一個 repo、遠端變了」的場，
  # 不能被上一個案例的快取餵到舊答案（那會是假綠）。
  _lr_cache="${UNPUSHED_CACHE_DIR:-/tmp}/.unpushed-lsremote-$_lr_key"
  if [ -f "$_lr_cache" ]; then
    _lr_now=$(date +%s 2>/dev/null || echo 0)
    _lr_mt=$(file_mtime "$_lr_cache")
    case "$_lr_now$_lr_mt" in *[!0-9]*) _lr_mt=0 ;; esac
    if [ "$_lr_mt" -gt 0 ] && [ $((_lr_now - _lr_mt)) -lt 120 ]; then
      [ -s "$_lr_cache" ] || return 1
      cat "$_lr_cache"; return 0
    fi
  fi
  if _lr_out="$($_TO $GIT_ASK git -C "$_lr_repo" ls-remote --heads "$_lr_rm" 2>/dev/null)" \
     && [ -n "$_lr_out" ]; then
    printf '%s\n' "$_lr_out" > "$_lr_cache" 2>/dev/null || true
    printf '%s\n' "$_lr_out"
    return 0
  fi
  : > "$_lr_cache" 2>/dev/null || true   # 記「這次問不到」，免得每回合都等一次 timeout
  return 1
 }
 # remote_has_commit <repo> <sha> → 0 遠端有／1 遠端沒有／2 問不到
 remote_has_commit() {
  _rh_repo="$1"; _rh_sha="$2"
  [ -n "$_rh_sha" ] || return 2
  # ① 本機就答得出「有」：任何 remote-tracking ref 含這顆 ⇒ 一定推過，不必打網路
  if [ -n "$(git -C "$_rh_repo" branch -r --contains "$_rh_sha" 2>/dev/null | head -1)" ]; then
    return 0
  fi
  _rh_asked=0
  for _rh_rm in $(git -C "$_rh_repo" remote 2>/dev/null); do
    _rh_ls="$(ls_remote_heads "$_rh_repo" "$_rh_rm")" || continue
    _rh_asked=1
    # 遠端某條 head 就是這顆 ⇒ 推過（雲端那個誤報正是落在這一格）
    printf '%s\n' "$_rh_ls" | awk '{print $1}' | grep -qx "$_rh_sha" && return 0
    # 遠端那顆本機也有時，才問得出祖先關係（本機沒有就只能靠上面的等值比對）
    printf '%s\n' "$_rh_ls" | while read -r _rh_rsha _; do
      [ -n "$_rh_rsha" ] || continue
      git -C "$_rh_repo" cat-file -e "${_rh_rsha}^{commit}" 2>/dev/null || continue
      git -C "$_rh_repo" merge-base --is-ancestor "$_rh_sha" "$_rh_rsha" 2>/dev/null && exit 7
    done
    [ $? = 7 ] && return 0
  done
  [ "$_rh_asked" = 1 ] && return 1
  return 2
 }
 # remote_sha_of <repo> <遠端名> <分支名> → 印出遠端那顆 sha（拿不到印空）
 remote_sha_of() {
  ls_remote_heads "$1" "$2" 2>/dev/null \
    | awk -v b="refs/heads/$3" '$2 == b { print $1; exit }'
 }
 TOP="${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
 # 掃描對象：頂層 + 各子 repo（存在才掃）。worktree 一併涵蓋（git -C 會自己解）。
-#
+REPOS="$TOP $TOP/matrix/arcrun $TOP/products/arcrun-rag $TOP/polaris/mira"
 # 🔴 2026-08-28（inkstone/ISEP#90）補雲端那一格：雲端的 `$CLAUDE_PROJECT_DIR`
 #    是**薄殼根**，真身被 bootstrap.sh clone 到 `$TOP/InkStoneCo/`，子 repo 在
 #    `$TOP/InkStoneCo/matrix/arcrun` …。舊清單只認地端那種「頂層就是真身」的排法
 #    ⇒ **雲端上真身有東西沒推，本閘一輩子不會知道**（它掃的四個路徑一個都不存在）。
 #    ⇒ 這跟 ① 的誤攔是同一個病的兩面：在雲端，這支閘既亂叫、又看不到該看的地方。
 REPOS=""
 for _body in "$TOP" "$TOP/InkStoneCo"; do
  [ -d "$_body/.git" ] || [ -f "$_body/.git" ] || continue
  REPOS="$REPOS $_body $_body/matrix/arcrun $_body/products/arcrun-rag $_body/polaris/mira"
 done
 [ -n "$REPOS" ] || REPOS="$TOP"
 problems=""
 for r in $REPOS; do
@@ -159,33 +50,17 @@ for r in $REPOS; do
  staged="$(git -C "$r" diff --cached --shortstat 2>/dev/null | head -1)"
  # ② 已 commit 但沒推（**當前分支**）
  #
  unknown=""
  # 🔴 判準是「遠端有沒有這顆 commit」，不是「有沒有 upstream」（ISEP#90，見檔頭那段）。
  #    有 upstream 時仍照原本的算法報「領先幾筆」——那個數字有用；
  #    沒 upstream 時去問遠端，問不到就**不報**。
  unpushed=""
  br="$(git -C "$r" branch --show-current 2>/dev/null)"
  if [ -n "$br" ]; then
    head_sha="$(git -C "$r" rev-parse HEAD 2>/dev/null || true)"
    up="$(git -C "$r" rev-parse --abbrev-ref "@{upstream}" 2>/dev/null || true)"
    if [ -n "$up" ]; then
      n="$(git -C "$r" rev-list --count "$up".."$br" 2>/dev/null || echo 0)"
-      if [ "$n" != "0" ]; then
+      [ "$n" != "0" ] && unpushed="領先 $up $n 筆"
        # upstream 本身可能過期（本機那份 ref 落後遠端 4 天是實測過的）
        # ⇒ 先問遠端；遠端已經有這顆就不是「沒推」。
        remote_has_commit "$r" "$head_sha"
        [ "$?" = 0 ] || unpushed="領先 $up $n 筆"
      fi
    else
-      remote_has_commit "$r" "$head_sha"
+      # 沒 upstream＝這條分支從來沒推過（今天 fix/cis-round3-install 就是這樣）
-      case "$?" in
+      has_commits="$(git -C "$r" rev-list --count HEAD 2>/dev/null || echo 0)"
-        1) unpushed="分支 $br **從未推過**（遠端沒有 $(printf '%.7s' "$head_sha")）" ;;
+      [ "$has_commits" != "0" ] && unpushed="分支 $br **從未推過**（無 upstream）"
        # 0＝遠端有這顆（雲端 session 的工作分支就是這種）→ 不報
        # 2＝問不到遠端 → 不報，但這件事本身值得知道，收在下面當脈絡
        2) [ -n "$(git -C "$r" rev-list --count HEAD 2>/dev/null)" ] \
             && unknown="分支 $br 問不到遠端（沒有 remote／網路不通）——**不當成沒推**" ;;
      esac
    fi
  fi
@@ -204,27 +79,9 @@ for r in $REPOS; do
  #   **這正是同一晚重複八次的那個病：檢查跑了，但檢查的對象是錯的。**
  #   ⇒ 基準改成「整合分支」：gitea/main > origin/main > main > 當前分支。
  base="$br"
  base_label=""
  for cand in gitea/main origin/main main; do
    if git -C "$r" rev-parse --verify -q "$cand" >/dev/null 2>&1; then base="$cand"; break; fi
  done
  base_label="$base"
  # 🔴 2026-08-28（inkstone/ISEP#90）：**基準的 ref 也會過期。**
  #   08-28 實測：本機 `origin/main` 落後遠端整整 4 天 ⇒ 拿它當基準，
  #   「已經在遠端 main 上」的分支會被整批報成散落——包括**雲端 session 自己
  #   那條工作分支**（它的內容就等於遠端 main）。
  #   08-15 那次訂正的是「基準挑錯了分支」，這次是「基準挑對了但那份是舊的」：
  #   同一個病的第三面——檢查跑了，但檢查的對象是舊的。
  #   ⇒ 問一次遠端；拿得到、而且本機真的有那顆 commit（不然算不了祖先），才換過去。
  case "$base_label" in
    */*) _base_rm="${base_label%%/*}"; _base_br="${base_label#*/}" ;;
    *)   _base_rm="origin";            _base_br="$base_label" ;;
  esac
  _base_fresh="$(remote_sha_of "$r" "$_base_rm" "$_base_br")"
  if [ -n "$_base_fresh" ] && git -C "$r" cat-file -e "${_base_fresh}^{commit}" 2>/dev/null; then
    base="$_base_fresh"
    base_label="$_base_rm/$_base_br（遠端實際那顆 $(printf '%.7s' "$_base_fresh")）"
  fi
  if [ -n "$base" ]; then
    for b in $(git -C "$r" for-each-ref --format='%(refname:short)' refs/heads/ 2>/dev/null); do
      [ "$b" = "$base" ] && continue
@@ -254,7 +111,7 @@ for r in $REPOS; do
      age="$(git -C "$r" log -1 --format='%ad' --date=format:'%m-%d' "$b" 2>/dev/null)"
      # 用真實換行累積，不用 \n 逃脫——否則後面的 printf '%b' 會把分支名再解讀一次
      stray="$stray
-       - $b：$cnt 筆未併入 $base_label（最後動 $age）"
+       - $b：$cnt 筆未併入 $base（最後動 $age）"
    done
  fi
@@ -266,12 +123,10 @@ for r in $REPOS; do
  [ -n "$unpushed" ] && line="$line
     · $unpushed"
  [ -n "$stray" ]    && line="$line
-     · 🔀 **散落分支**（有 commit 沒併回 $base_label）：$stray"
+     · 🔀 **散落分支**（有 commit 沒併回 $br）：$stray"
  # 刻意保留的分支**不會自己觸發警報**（那正是加它的目的），
  # 但這個 repo 若本來就有別的問題要報，就順便把它列出來當脈絡——
  # 免得「保留」變成另一種看不見。
  [ -n "$line" ] && [ -n "$unknown" ] && line="$line
     · ❔ $unknown"
  [ -n "$line" ] && [ -n "$held" ] && line="$line
     · ⏸️ 刻意保留（不觸發警報，理由在 .claude/branch-holds.md）：$held"
  [ -n "$line" ] && problems="$problems
@@ -101,26 +101,6 @@ labels:
    exclusive: true
    description: "雜務、整理、不改行為"
  # ── 使用者旅程（正交，`j/` scope）──────────────────
  #
  # inkstone/ISEP#92：「這件事服務哪個使用者旅程，沒有記錄⋯⋯後面要把相關的票
  # 聚成一包時，只能靠人重新讀一遍每張票在講什麼。」
  #
  # `ticket subtask/handoff --journey <名>` 會把 `j/<名>` **同時貼在母子兩端**
  # （只貼一端就聚不起來）。標籤不存在時它會擋下來並指回本檔——
  # **「要求標籤在場」，不是「猜哪些名字合法」**。
  #
  # 🔴 這裡刻意是空的。旅程怎麼切、叫什麼名字，是方向題（四題公式第 4 題），
  #    不該由工具或 subagent 代決；隨手造名字會讓同一條旅程長出三個拼法。
  #    要新增一條就照這個形狀加一筆，然後跑 scripts/gitea-labels-sync.sh：
  #
  #  - name: "j/收件匣"
  #    color: "fbca04"
  #    exclusive: false
  #    description: "🧭 旅程：<一句話講這條旅程的頭和尾>"
  #
  #    （票上明講「對不上就不貼，不硬湊」——沒有對應旅程的票就不要加 --journey。）
  # ── 結構（正交）──────────────────────────────────
  - name: "hub"
    color: "0052cc"
@@ -1,113 +0,0 @@
 #!/usr/bin/env bash
 # gate-ok — 各道閘「總管看過了，放行下一個動作」的**單一入口**（inkstone/ISEP#90 ④）
 #
 # ══ 為什麼要有這支 ═════════════════════════════════════════════════════
 #
 # 這些閘每一支都留了一道給總管的門，而每一道門長得都不一樣：
 #     touch /tmp/.prod-write-ok
 #     git rev-parse --show-toplevel > /tmp/.main-push-ok
 #     touch /tmp/.stage-verified
 #     touch /tmp/.solo-ok-<session_id>
 #     …
 # 兩個後果：
 #   ① **記不住**。門的形狀藏在被擋下的那則訊息裡，每支都不同，
 #      而且有兩支還帶參數（綁 repo、綁 session）——照著抄錯一個字，門就打不開。
 #   ② **放行不了**。逃生口是「一條臨時湊出來的 Bash 指令」，
 #      而臨時湊出來的指令**沒有穩定的形狀可以事先放行**：
 #      `.claude/settings.json` 的 allow 只能逐條寫死
 #      （現場真的就寫著 `Bash(touch /tmp/.prod-write-ok)` 這種完全比對的一行），
 #      多一個 `&&`、換一個檔名、加一個 session id，就落在那條規則之外。
 #      2026-08-28（inkstone/InkStoneCo#99）總管在雲端連續四次沒能把
 #      prod-write 的戳記蓋出去 ⇒ **閘留了一道給總管的門，而那道門打不開**
 #      ⇒ 任何「擋下來、但總管可以放行」的閘，在那個環境裡等於「純擋」。
 #
 # ⇒ 這支把所有逃生口收斂成**一個名字、一種形狀**：
 #       bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" <閘名> [參數]
 #   一條前綴規則就涵蓋全部，而且以後新增閘不必再動一次設定。
 #
 # 🔴 這支**不會弱化任何一道閘**：它蓋的戳記跟閘原本認的是同一個檔、同一種語意
 #   （單次用完即丟、綁 repo、綁 session、有效期都不變）。它換掉的只有「怎麼蓋」。
 # 🔴 也**不是給 subagent 用的**：閘擋的是無心不是惡意（見 main-and-prod-push-guard
 #   第 76 行）。subagent 照樣造得出戳記，但它得刻意繞過一段明講「不要這樣做」的訊息。
 set -eu
 usage() {
  cat <<'USAGE'
 用法：gate-ok <閘名> [參數]
  prod-write                改到線上實例（prod-write-guard）——放行下一個動作，用完即消失
  main-push [repo 路徑]     推 gitea main（main-and-prod-push-guard）——綁 repo，預設是 cwd
  stage-verified            stage 真的驗過了（stage-before-prod-guard）——記得在回覆貼實測輸出
  solo <session_id>         這件事真的該自己做（subagent-first-guard）——回覆裡要寫理由
  dispatch <session_id>     派工單真的有例外（dispatch-format-guard）
  ask <session_id>          這題真的是人閘（ask-user-question-guard）
  kbdb-down                 KBDB 真的連不上（history-first-guard）——回覆裡要說明
  --list                    列出目前存在的戳記
 🔴 每一枚戳記都是**留痕**：它會出現在指令歷史上，而且多數是單次用完即丟。
   蓋之前先確定你真的看過那個動作會改到什麼；蓋完在回覆裡寫一句為什麼。
 USAGE
 }
 stamp() {  # stamp <檔> <說明> [內容]
  if [ $# -ge 3 ]; then printf '%s\n' "$3" > "$1"; else : >> "$1"; touch "$1"; fi
  printf '✅ 已蓋戳記：%s\n   %s\n' "$1" "$2"
 }
 [ $# -ge 1 ] || { usage; exit 2; }
 case "$1" in
  -h|--help|help) usage; exit 0 ;;
  --list)
    printf '目前存在的戳記：\n'
    ls -la /tmp/.prod-write-ok /tmp/.main-push-ok /tmp/.stage-verified \
           /tmp/.kbdb-down /tmp/.solo-ok-* /tmp/.dispatch-ok-* /tmp/.ask-ok-* 2>/dev/null \
      || printf '（一枚都沒有）\n'
    exit 0 ;;
 esac
 GATE="$1"; shift || true
 case "$GATE" in
  prod-write)
    stamp /tmp/.prod-write-ok "只放行**下一個**會改到線上那台的動作，用完即消失（15 分鐘失效）" ;;
  main-push)
    # 綁 repo：戳記內容要是那個 repo 的 toplevel，閘會拿它跟「push 的目標 repo」比對。
    # 🔴 解不出 repo 時**寧可失敗也不蓋空的**——閘明文寫著空內容不算數
    #    （08-12 那次穿透就是空檔案變成萬用鑰匙），蓋一個註定打不開的戳記
    #    只會讓人以為門開了。
    D="${1:-$(pwd)}"
    TOP="$(git -C "$D" rev-parse --show-toplevel 2>/dev/null || true)"
    if [ -z "$TOP" ]; then
      printf '❌ %s 不在任何 git repo 裡，解不出要放行哪個 repo。\n' "$D" >&2
      printf '   用法：gate-ok main-push <那個 repo 的路徑>\n' >&2
      exit 2
    fi
    stamp /tmp/.main-push-ok "只放行推 $TOP 的 main，單次、15 分鐘失效" "$TOP" ;;
  stage-verified)
    stamp /tmp/.stage-verified "stage 驗過了（6 小時）——**記得在回覆裡貼 stage 的實測輸出**" ;;
  kbdb-down)
    stamp /tmp/.kbdb-down "KBDB 連不上而放行——**回覆裡要說明**，這是留痕不是豁免" ;;
  solo|dispatch|ask)
    SID="${1:-${CLAUDE_SESSION_ID:-}}"
    if [ -z "$SID" ]; then
      printf '❌ %s 要綁 session id（閘用它認「是不是同一個 session」）。\n' "$GATE" >&2
      printf '   被擋下的那則訊息裡就有；或 gate-ok %s <session_id>\n' "$GATE" >&2
      exit 2
    fi
    case "$GATE" in
      solo)     stamp "/tmp/.solo-ok-$SID"     "這件事自己做——**回覆裡要寫理由**" ;;
      dispatch) stamp "/tmp/.dispatch-ok-$SID" "這張派工單的例外，放行一次" ;;
      ask)      stamp "/tmp/.ask-ok-$SID"      "這題確認是人閘，放行一次" ;;
    esac ;;
  *)
    printf '❌ 不認得的閘名：%s\n\n' "$GATE" >&2
    usage >&2
    exit 2 ;;
 esac
@@ -1,274 +0,0 @@
 #!/bin/bash
 # 「下游做完時頂層跟著關」的測試（inkstone/ISEP#92）
 #
 # 這支測三件事：
 #   ① 判準本身（純函式 is_loose／writeback_plan／journey_label）
 #      —— 這三支不打網路，所以「撈得對不對」「回寫該做什麼」測得動，
 #         不必真的開票、關票來驗。
 #   ② `subtask`／`handoff` 的參數閘：該擋的擋、齊全的放得過
 #   ③ `loose` 這個動詞真的接得上（走到網路那一層才炸）
 #
 # 怎麼在「不真的動任何票」的前提下分辨擋／放行（沿用 test-ticket-where-seen-guard.sh）：
 #   TICKET_HOST 指到一個連不上的位址（127.0.0.1:9）
 #     離開碼 2 ＝ 閘擋下（die）
 #     離開碼 1 ＝ 閘全部放行，走到網路那一層才炸（Connection refused）
 # 全程離線、不打真實 Gitea、不產生任何票、不關任何票。
 cd "$(dirname "$0")/.." || exit 1
 T=scripts/ticket
 TMP=$(mktemp -d)
 trap 'rm -rf "$TMP"' EXIT
 PASS=0; FAIL=0
 cat > "$TMP/body.md" <<'MD'
 ## 目標
 測試用內文。
 ## 驗收條件
 離開碼 2 ＝ 被擋；離開碼 1 ＝ 放行（走到網路才炸）。
 ## deliverable 類型
 code
 MD
 BAD_BODY="$TMP/bad.md"; echo "沒有模板欄位" > "$BAD_BODY"
 TITLE="身為看頂層票的人，我要下游做完時頂層跟著關，我才不會看到一堆早就做完的票"
 # ── 純函式探針：把 scripts/ticket 當模組載進來問 ────────────────────────
 probe() { # probe <python 片段> → 印出結果
  python3 - "$1" <<'PY'
 import sys, importlib.util as u
 from importlib.machinery import SourceFileLoader as L
 spec = u.spec_from_loader("t", L("t", "scripts/ticket"))
 m = u.module_from_spec(spec); spec.loader.exec_module(m)
 print(eval(sys.argv[1], {"m": m}))
 PY
 }
 p() { # p <說明> <want> <python 片段>
  got=$(probe "$3" 2>&1)
  if [ "$got" = "$2" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
  printf 'want=%s got=%s  %s\n' "$2" "$got" "$1"
 }
 O='{"state":"open"}'; C='{"state":"closed"}'
 echo "── ① is_loose：「下游都關了、自己還開著」是機械事實 ──"
 p "★ open ＋ 下游全關 → 撈得到（票上驗收第 3 條）" "True"  "m.is_loose('open',[$C,$C])"
 p "open ＋ 還有一張下游開著 → 不撈（它還在跑）"      "False" "m.is_loose('open',[$C,$O])"
 p "open ＋ 從來沒有下游 → 不撈（它根本不是頂層票）"  "False" "m.is_loose('open',[])"
 p "closed ＋ 下游全關 → 不撈（自己都關了）"          "False" "m.is_loose('closed',[$C,$C])"
 p "open ＋ 下游全開 → 不撈"                          "False" "m.is_loose('open',[$O,$O])"
 echo
 echo "── ② writeback_plan：下游關掉之後，頂層票該被怎麼處理 ──"
 p "★ 最後一張下游關掉 → handback（指派回總管＋s/review，不默默留著）" \
  "('handback', [])" "m.writeback_plan('open',[$C,$C])"
 p "還有別的下游沒關 → 只記一筆，別假裝它可以收了" \
  "('note', [{'state': 'open'}])" "m.writeback_plan('open',[$C,$O])"
 p "頂層票自己已經關了 → skip" \
  "('skip', [])" "m.writeback_plan('closed',[$C,$C])"
 p "頂層票已關但還有 open 下游 → 一樣 skip（不去吵已關的票）" \
  "('skip', [{'state': 'open'}])" "m.writeback_plan('closed',[$O])"
 p "防禦：頂層票沒有任何下游（實務上到不了這裡）→ 不會炸" \
  "('handback', [])" "m.writeback_plan('open',[])"
 echo
 echo "── ③ journey_label：只加前綴，不猜名字合不合法 ──"
 p "收件匣 → j/收件匣"           "j/收件匣" "m.journey_label('收件匣')"
 p "已經帶前綴 → 不重複加"       "j/收件匣" "m.journey_label('j/收件匣')"
 p "前後空白 → 修掉"             "j/收件匣" "m.journey_label('  收件匣 ')"
 echo
 echo "── ④ subtask／handoff 的參數閘（該擋）──"
 run() { # run <want_rc> <說明> <verb> [參數...]
  want=$1; what=$2; verb=$3; shift 3
  out=$(TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN=x \
        python3 "$T" "$verb" inkstone/ISEP#92 "$@" 2>&1)
  got=$?
  LAST_OUT="$out"
  if [ "$got" = "$want" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
  printf 'want=%s got=%s  %s\n' "$want" "$got" "$what"
 }
 has() { if printf '%s' "$LAST_OUT" | grep -q "$1"; then PASS=$((PASS+1)); printf '  ✅ '
        else FAIL=$((FAIL+1)); printf '  ❌ '; fi; printf '訊息裡有「%s」  %s\n' "$1" "$2"; }
 run 2 "缺 --title" subtask -F "$TMP/body.md"
 run 2 "缺 -F" subtask --title "$TITLE"
 run 2 "標題不是 User Story" subtask --title "整理一下票" -F "$TMP/body.md"
 run 2 "內文缺模板欄位" subtask --title "$TITLE" -F "$BAD_BODY"
 run 2 "指派了人卻沒寫 --next" subtask --title "$TITLE" -F "$TMP/body.md" --assign someone
 run 2 "--journey 給了空字串（對不上就不要加這個參數）" \
      subtask --title "$TITLE" -F "$TMP/body.md" --journey ""
 has "不硬湊" "空 journey 的訊息講的是「不硬湊」，不是叫人隨便填一個"
 echo
 echo "── ⑤ 齊全就放得過（誤攔比漏擋更該修）──"
 run 1 "subtask 齊全 → 走到網路才炸" subtask --title "$TITLE" -F "$TMP/body.md"
 run 1 "★ handoff 是同一個動作的別名，一樣放得過" handoff --title "$TITLE" -F "$TMP/body.md" --to arcrun-rag
 run 1 "帶 --journey 一樣放得過" subtask --title "$TITLE" -F "$TMP/body.md" --journey 收件匣
 run 1 "--assign 有配 --next → 放行" subtask --title "$TITLE" -F "$TMP/body.md" --assign someone --next "先看一眼"
 echo
 echo "── ⑥ loose 這個動詞接得上 ──"
 out=$(TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN=x python3 "$T" loose 2>&1); got=$?
 if [ "$got" = 1 ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
 printf 'want=1 got=%s  loose 走到網路那一層才炸（動詞有註冊、參數不擋）\n' "$got"
 out=$(python3 "$T" 2>&1)
 if printf '%s' "$out" | grep -q "ticket loose"; then PASS=$((PASS+1)); printf '  ✅ '
 else FAIL=$((FAIL+1)); printf '  ❌ '; fi
 printf '不帶參數的說明裡列得出 loose（撈不到的東西等於不存在）\n'
 echo
 echo "── ⑦ 完工回寫的接線（票上驗收第 2 條）──"
 echo "     把 api() 換成錄音機跑一次 _writeback，驗它到底打了哪些端點、送了什麼。"
 echo "     不打網路、不動任何真票；/blocks 的回應形狀取自 2026-08-28 實查 inkstone/ISEP#75。"
 w() { # w <說明> <want> <python 片段（用 rec 這個錄音清單）>
  got=$(python3 - "$3" <<'PY' 2>&1
 import sys, json, importlib.util as u
 from importlib.machinery import SourceFileLoader as L
 spec = u.spec_from_loader("t", L("t", "scripts/ticket"))
 m = u.module_from_spec(spec); spec.loader.exec_module(m)
 SCEN = json.loads(__import__("os").environ["SCEN"])
 rec = []
 def fake_api(path, payload=None, method=None):
    rec.append((method or ("POST" if payload is not None else "GET"), path, payload))
    if path.endswith("/blocks"):
        return SCEN["blocks"]
    if path.endswith("/dependencies"):
        return SCEN["deps"]
    if "/labels" in path and (method or "GET") == "GET":
        return [{"name": n, "id": i} for i, n in enumerate(SCEN.get("labels", []), 1)]
    return {}
 m.api = fake_api
 # _writeback 會把進度印出來——那是給人看的，不是這支測試的判準。
 # 判準是**它打了哪些端點、送了什麼**（rec），所以把它的輸出吞掉。
 import contextlib, io
 buf = io.StringIO()
 with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
    m._writeback("inkstone", "arcrun-rag", 143, "https://example/pr/1")
 print(eval(sys.argv[1], {"rec": rec, "m": m}))
 PY
 )
  if [ "$got" = "$2" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
  printf 'want=%s got=%s  %s\n' "$2" "$got" "$1"
 }
 PARENT='{"number":136,"state":"open","title":"頂層票","labels":[{"name":"s/doing"},{"name":"p/high"}],"repository":{"full_name":"inkstone/arcrun-rag"}}'
 LBL='["s/todo","s/doing","s/review","p/high"]'
 # 情境 A：這是最後一張下游 → 母票要被指派回總管＋改 s/review
 export SCEN="{\"blocks\":[$PARENT],\"deps\":[{\"state\":\"closed\",\"number\":143,\"title\":\"x\",\"repository\":{\"full_name\":\"inkstone/arcrun-rag\"}}],\"labels\":$LBL}"
 w "★ 有去問子票的 /blocks（誰在等我）" "True" \
  "any(p.endswith('/issues/143/blocks') for _,p,_ in rec)"
 w "★ 有在母票的時間軸貼回寫留言" "True" \
  "any(mm=='POST' and p=='/repos/inkstone/arcrun-rag/issues/136/comments' for mm,p,_ in rec)"
 w "★ 留言裡點名了剛關掉的那張下游票" "True" \
  "any('arcrun-rag#143' in (pl or {}).get('body','') for _,p,pl in rec if p.endswith('/136/comments'))"
 w "★ 留言裡有交付物連結（不是空口說做完了）" "True" \
  "any('https://example/pr/1' in (pl or {}).get('body','') for _,p,pl in rec if p.endswith('/136/comments'))"
 w "★ 留言第一行有身份欄（機器貼的留言一樣要標）" "True" \
  "all((pl or {}).get('body','').startswith('【身份】') for _,p,pl in rec if p.endswith('/136/comments'))"
 w "★ 母票被指派回總管（欄位，不是一句話）" "['claude-code']" \
  "[(pl or {}).get('assignees') for mm,p,pl in rec if mm=='PATCH' and p=='/repos/inkstone/arcrun-rag/issues/136'][0]"
 w "★ 母票的 s/* 換成 s/review，而非 s/* 的標籤留著" "True" \
  "[sorted(pl['labels'])==sorted([3,4]) for mm,p,pl in rec if mm=='PUT' and p.endswith('/136/labels')][0]"
 w "沒有去關母票（關票要有人驗——默默關掉跟默默留著是同一個病）" "False" \
  "any((pl or {}).get('state')=='closed' for _,_,pl in rec)"
 # 情境 B：母票還有別的下游沒關 → 只記一筆，不准指派、不准改 tag
 export SCEN="{\"blocks\":[$PARENT],\"deps\":[{\"state\":\"closed\",\"number\":143,\"title\":\"x\",\"repository\":{\"full_name\":\"inkstone/arcrun-rag\"}},{\"state\":\"open\",\"number\":150,\"title\":\"還沒做的\",\"repository\":{\"full_name\":\"inkstone/Arcrun\"}}],\"labels\":$LBL}"
 w "還有下游沒關 → 只貼留言，不指派" "False" "any(mm=='PATCH' for mm,_,_ in rec)"
 w "還有下游沒關 → 不改 tag" "False" "any(mm=='PUT' for mm,_,_ in rec)"
 w "留言裡把還沒關的那張列出來（跨 repo 也要列全稱）" "True" \
  "any('inkstone/Arcrun#150' in (pl or {}).get('body','') for _,p,pl in rec if p.endswith('/136/comments'))"
 # 情境 C：母票自己已經關了 → 完全不動它
 PARENT_CLOSED='{"number":136,"state":"closed","title":"頂層票","labels":[],"repository":{"full_name":"inkstone/arcrun-rag"}}'
 export SCEN="{\"blocks\":[$PARENT_CLOSED],\"deps\":[{\"state\":\"closed\",\"number\":143,\"title\":\"x\",\"repository\":{\"full_name\":\"inkstone/arcrun-rag\"}}],\"labels\":$LBL}"
 w "母票已關 → 一則留言都不貼（不去吵已關的票）" "False" \
  "any(p.endswith('/136/comments') for _,p,_ in rec)"
 # 情境 D：這張票沒有任何頂層票在等它 → 不要吵
 export SCEN="{\"blocks\":[],\"deps\":[],\"labels\":$LBL}"
 w "沒有頂層票在等它 → 只問一次 /blocks 就收工" "1" "len(rec)"
 unset SCEN
 echo
 echo "── ⑧ 雙向連結的接線（票上驗收第 1 條）──"
 echo "     同樣用錄音機跑一次 subtask：驗「兩張票互相看得到對方」不是靠人記得補。"
 b() { # b <說明> <want> <python 片段> [額外 argv...]
  what=$1; want=$2; frag=$3; shift 3
  got=$(ARGS_JSON=$(printf '%s\n' "$@" | python3 -c "import sys,json;print(json.dumps([l.rstrip('\n') for l in sys.stdin if l.strip()!='']))") \
        python3 - "$frag" <<'PY' 2>&1
 import sys, os, json, contextlib, io, importlib.util as u
 from importlib.machinery import SourceFileLoader as L
 spec = u.spec_from_loader("t", L("t", "scripts/ticket"))
 m = u.module_from_spec(spec); spec.loader.exec_module(m)
 rec = []
 def fake_api(path, payload=None, method=None):
    rec.append((method or ("POST" if payload is not None else "GET"), path, payload))
    if path.endswith("/labels?limit=100"):
        return [{"name": n, "id": i} for i, n in
                enumerate(["s/todo", "s/review", "p/high", "j/收件匣"], 1)]
    if path.endswith("/dependencies"):
        return [{"state": "open", "number": 900, "title": "子票",
                 "repository": {"full_name": "inkstone/arcrun-rag"}}]
    if path == "/repos/inkstone/ISEP/issues":
        return {"number": 900, "html_url": "https://git.uncle6.me/inkstone/ISEP/issues/900"}
    if path == "/repos/inkstone/arcrun-rag/issues":
        return {"number": 900, "html_url": "https://git.uncle6.me/inkstone/arcrun-rag/issues/900"}
    if path == "/repos/inkstone/ISEP/issues/92":
        return {"number": 92, "labels": [{"name": "p/high"}]}
    return {}
 m.api = fake_api
 argv = ["inkstone/ISEP#92"] + json.loads(os.environ["ARGS_JSON"])
 buf = io.StringIO()
 blocked = False
 with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
    try:
        m.cmd_subtask(argv)
    except SystemExit:
        blocked = True        # 被閘擋下也是一種結果，不該讓整支測試靜靜掛掉
 print(eval(sys.argv[1], {"rec": rec, "m": m, "blocked": blocked, "buf": buf.getvalue()}))
 PY
 )
  if [ "$got" = "$want" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
  printf 'want=%s got=%s  %s\n' "$want" "$got" "$what"
 }
 A_BASE=(--title "$TITLE" -F "$TMP/body.md" --to arcrun-rag)
 b "★ 子票內文寫著它的頂層票是誰（下游看得到上游）" "True" \
  "any('Parent: inkstone/ISEP#92' in (pl or {}).get('body','') for mm,p,pl in rec if p=='/repos/inkstone/arcrun-rag/issues')" \
  "${A_BASE[@]}"
 b "★ 有掛上 Gitea 原生相依（不是只寫在內文裡）" "True" \
  "any(mm=='POST' and p=='/repos/inkstone/ISEP/issues/92/dependencies' for mm,p,pl in rec)" \
  "${A_BASE[@]}"
 b "★ 頂層票的時間軸上有一則指向下游的留言（上游看得到下游）" "True" \
  "any('inkstone/arcrun-rag#900' in (pl or {}).get('body','') for mm,p,pl in rec if p=='/repos/inkstone/ISEP/issues/92/comments')" \
  "${A_BASE[@]}"
 b "★ 那則留言明講「不會因為轉出去就自動關」（第 2 條的預告）" "True" \
  "any('不會因為轉出去就自動關' in (pl or {}).get('body','') for mm,p,pl in rec if p=='/repos/inkstone/ISEP/issues/92/comments')" \
  "${A_BASE[@]}"
 b "沒給 --journey → 留言裡誠實寫「沒有貼」（不硬湊，也不假裝有）" "True" \
  "any('沒有貼' in (pl or {}).get('body','') for mm,p,pl in rec if p=='/repos/inkstone/ISEP/issues/92/comments')" \
  "${A_BASE[@]}"
 b "沒給 --journey → 不去動任何一端的標籤軸（只設子票的 s/*）" "1" \
  "len([1 for mm,p,pl in rec if mm=='PUT' and p.endswith('/labels')])" \
  "${A_BASE[@]}"
 b "★ 給了 --journey → 母子兩端都被貼（只貼一端就聚不起來）" "2" \
  "len([1 for mm,p,pl in rec if mm=='PUT' and p.endswith('/labels') and 4 in pl['labels']])" \
  "${A_BASE[@]}" --journey 收件匣
 b "★ 貼在頂層票上時保留它原本的標籤（不是整組蓋掉）" "True" \
  "any(mm=='PUT' and p=='/repos/inkstone/ISEP/issues/92/labels' and sorted(pl['labels'])==[3,4] for mm,p,pl in rec)" \
  "${A_BASE[@]}" --journey 收件匣
 b "labels.yaml 沒有的旅程名 → 擋下來（要求標籤在場，不是猜名字合不合法）" "True" \
  "blocked" "${A_BASE[@]}" --journey 沒這條旅程
 b "擋下來時直接指回 labels.yaml（不叫人自己猜怎麼修）" "True" \
  "'labels.yaml' in buf" "${A_BASE[@]}" --journey 沒這條旅程
 echo
 echo "通過 $PASS 條，失敗 $FAIL 條"
 [ "$FAIL" = 0 ] || exit 1
@@ -21,10 +21,8 @@ leo 2026-08-16 三句話，本工具就是它們的機械化：
 三個 Gitea 原生欄位（leo 2026-08-27「這些全部都要」，缺一個就會掉棒）：
    ticket subtask <母票> --title <US> -F <檔>   討論串裡的一件事 → 看得見的子票＋相依
    ticket handoff <頂層票> --to <repo> …         同一個動作，換個名字：頂層 → 下游 repo
    ticket handback <票> --to <誰> --next <一句>  收工＝指派＋改 tag＋寫下一步，一個動作
    ticket mine [--user <誰>]                     撈一次：棒子在誰手上、每根下一步是什麼
    ticket loose                                  撈一次：下游都關了、自己還開著的頂層票
 票的寫法：`owner/repo#N`，例：`inkstone/InkStoneCo#44`
 """
@@ -454,87 +452,10 @@ def cmd_close(argv):
    if deliv:
        api(f"/repos/{owner}/{repo}/issues/{num}/comments",
-            {"body": f"{_identity(owner, repo)}\n\n✅ 結案。交付物：{deliv}"})
+            {"body": f"{os.environ.get('ISEP_IDENTITY') or f'【身份】總管／{owner}/{repo}／-'}\n\n✅ 結案。交付物：{deliv}"})
    api(f"/repos/{owner}/{repo}/issues/{num}", {"state": "closed"}, method="PATCH")
    print(f"✅ {owner}/{repo}#{num} 已關（交付物：{deliv or ('PR' if has_pr else '票上回報')}）")
    # ── 完工回寫（inkstone/ISEP#92 最痛的那一格）─────────────────────────
    # 關掉一張下游票之後，**同一個動作**回頭處理它的頂層票。
    # 不做這件事的後果票上寫得很清楚：「頂層票會永遠掛著，而 leo 是看頂層的」。
    _writeback(owner, repo, num, deliv or ("PR" if has_pr else "票上回報"))
 def _writeback(owner, repo, num, deliv):
    """子票關掉 → 回頭處理每一張在等它的頂層票。
    🔴 失敗要吵。回寫悄悄失敗 ＝ 這格等於沒做，而沒有人會發現
       （那正是本票在治的病）。所以任何一張處理失敗就非零離開。
    """
    child = f"{owner}/{repo}#{num}"
    try:
        parents = _blocks(owner, repo, num)
    except SystemExit:
        print(f"\n⚠️ 撈不到 {child} 的頂層票（/blocks 讀失敗）——"
              f"回寫這一格**沒有做**，請手動確認或跑 `ticket loose`", file=sys.stderr)
        sys.exit(1)
    if not parents:
        print("\n📌 這張票沒有任何頂層票在等它（沒有相依邊）⇒ 不需要回寫。")
        return
    print(f"\n🔗 有 {len(parents)} 張頂層票在等這張票，逐一回寫：")
    failed = []
    for pt in parents:
        pfull = pt["repository"]["full_name"]
        po, pr = pfull.split("/")
        pn = pt["number"]
        try:
            pdeps = _deps(po, pr, pn)
            action, open_left = writeback_plan(pt.get("state"), pdeps)
            if action == "skip":
                print(f"   · {pfull}#{pn}　已經是 closed ⇒ 不動")
                continue
            lines = [_identity(po, pr), "",
                     f"⬇️ **下游完工回寫**：`{child}` 已關（交付物：{deliv}）"]
            if open_left:
                lines += ["", f"這張票還在等 {len(open_left)} 張下游（都關了才輪到它）："]
                lines += [f"- ◻ {i['repository']['full_name']}#{i['number']}　{i['title'][:60]}"
                          for i in open_left]
                lines += ["", "⇒ 本票維持原狀，不要當成可以收了。"]
            else:
                lines += ["", "**這是最後一張下游——本票的下游已經全部關閉。**", "",
                          f"{BATON_MARK}　→ `{HANDBACK_TO}`", "",
                          "**下一步**：驗一次頂層要的東西真的到齊了，到齊就 "
                          f"`ticket close {pfull}#{pn} --deliverable <URL>`；"
                          "沒到齊就開下一張下游票，不要把它留在原地。", "",
                          "（本則由 `ticket close` 的完工回寫自動貼上，"
                          "機制見 `inkstone/ISEP#92`）"]
            api(f"/repos/{po}/{pr}/issues/{pn}/comments", {"body": "\n".join(lines)})
            if action == "handback":
                # 指派 ＋ 改 tag：**欄位**才撈得到，留言撈不到。
                # 08-26 那次掉棒就是話有說、欄位沒動，棒子躺在地上 14 小時。
                api(f"/repos/{po}/{pr}/issues/{pn}",
                    {"assignees": [HANDBACK_TO]}, method="PATCH")
                cur = [l["name"] for l in (pt.get("labels") or [])]
                keep = [n for n in cur if not n.startswith("s/")] + ["s/review"]
                _set_labels(po, pr, pn, keep)
                print(f"   · {pfull}#{pn}　下游全關 ⇒ 已指派 {HANDBACK_TO}＋s/review（等人驗）")
            else:
                print(f"   · {pfull}#{pn}　還有 {len(open_left)} 張下游沒關 ⇒ 只記一筆")
        except SystemExit:
            failed.append(f"{pfull}#{pn}")
        except Exception as e:
            failed.append(f"{pfull}#{pn}（{e}）")
    if failed:
        print(f"\n⚠️ 這幾張頂層票**沒有回寫成功**：{'、'.join(failed)}\n"
              f"   回寫失敗要吵——悄悄失敗等於這格沒做。手動補，或稍後跑 `ticket loose` 對帳。",
              file=sys.stderr)
        sys.exit(1)
 # ── decide ───────────────────────────────────────────────────────────────
@@ -605,10 +526,6 @@ def cmd_decide(argv):
 BATON_MARK = "🏃 **棒子交回**"
 # 棒子的預設終點：總管。**這是 Gitea 的 assignee 欄位，不是一句話**——
 # 撈「指派給你的」一頁就看得到，撈留言看不到。
 HANDBACK_TO = os.environ.get("ISEP_HANDBACK_TO") or "claude-code"
 def _labels_of(owner, repo):
    return {l["name"]: l["id"] for l in api(f"/repos/{owner}/{repo}/labels?limit=100")}
@@ -628,97 +545,6 @@ def _deps(owner, repo, num):
    return api(f"/repos/{owner}/{repo}/issues/{num}/dependencies") or []
 def _blocks(owner, repo, num):
    """反方向：**誰把這張票當相依**——也就是這張票的頂層票（可能不只一張、可能跨 repo）。
    Gitea 原生兩個端點是同一條邊的兩端，方向不可混淆：
        /issues/<N>/dependencies   這張票在等誰      → 它的下游
        /issues/<N>/blocks         誰在等這張票      → 它的頂層
    `subtask` POST 的是**母票的 dependencies**，所以子票這端看到的是 `blocks`。
    """
    return api(f"/repos/{owner}/{repo}/issues/{num}/blocks") or []
 def _identity(owner, repo):
    """票上的每一則留言第一行要表明身份（規約見 docs/governance/dispatch-and-reply-format.md §3）。
    機器自動貼的留言同樣要標——不標的話，回寫留言看起來像某個人寫的，
    而下一個讀票的人會去找那個人。
    """
    return os.environ.get("ISEP_IDENTITY") or f"【身份】總管／{owner}/{repo}／-"
 # ══════════════════════════════════════════════════════════════════════════
 # inkstone/ISEP#92 — 「下游做完時頂層跟著關」的三格
 #
 # 票上的原話：「開在頂層的票，下游做完了卻沒人回來關⋯⋯頂層票會永遠掛著，
 #              而 leo 是看頂層的。」
 #
 # 缺的三格，各由下面一段承接：
 #   ① 雙向連結的強制  → cmd_subtask 一個動作同時掛相依 ＋ 在母票留下指回來的留言
 #   ② journey 標籤    → journey_label()（對不上就不貼，不硬湊）
 #   ③ 完工回寫        → writeback_plan() ＋ cmd_close 關完子票立刻回頭處理母票
 #   ④ 撈得出來        → is_loose() ＋ cmd_loose（③ 走側門漏掉的，這張網補回來）
 #
 # 🔴 這四格的判準**全部是機械事實**（相依邊在不在、state 是什麼），
 #    沒有一格在猜文字。leo 2026-08-17 已證偽關鍵字黑名單那條路
 #    （8 次誤攔、0 次正確攔截）。
 # ══════════════════════════════════════════════════════════════════════════
 JOURNEY_PREFIX = "j/"
 def journey_label(name):
    """`--journey 收件匣` → `j/收件匣`。只加前綴，不做語意判斷。
    標籤存不存在由 `_set_labels` 去問 Gitea（不存在就擋，並指回 labels.yaml）——
    **「要求某個東西在場」，不是「猜哪些名字合法」**。
    ⇒ 新的一條旅程要先加進 labels.yaml 再 sync，這是刻意的：
      journey 是**跨票聚類的軸**，隨手造名字會讓同一條旅程長出三個拼法。
    """
    n = (name or "").strip()
    if not n:
        die("🚫 --journey 後面要接旅程名（例：--journey 收件匣）。\n"
            "   對不上任何旅程就**不要加這個參數**——票上明講不硬湊。")
    return n if n.startswith(JOURNEY_PREFIX) else JOURNEY_PREFIX + n
 def is_loose(state, deps):
    """這張票是不是「下游都關了、自己還開著」的頂層票。
    純函式（不打網路）⇒ 判準本身測得動，不必開真的票來驗。
    三個條件缺一不可：
      · 自己還 open        關掉的票不用管
      · 曾經有下游         沒有相依邊 ⇒ 它根本不是頂層票，不要拿它來吵
      · 沒有任何 open 下游 有一張還開著就還在跑，不是掉在地上
    """
    if state != "open":
        return False
    if not deps:
        return False
    return not any(d.get("state") == "open" for d in deps)
 def writeback_plan(parent_state, parent_deps):
    """下游關掉之後，它的頂層票該被怎麼處理。**只回計畫，不做副作用**⇒ 離線測得動。
    回 (動作, 還開著的下游)：
      "skip"      頂層票自己已經關了 ⇒ 沒事
      "note"      還有別的下游沒關   ⇒ 只在頂層票記一筆，別假裝它可以收了
      "handback"  下游全關了          ⇒ 這張票現在**只等人驗**：
                                        指派回總管 ＋ s/review，讓它出現在「指派給你的」
    🔴 為什麼不自動關母票：關票要有交付物、要有人看過（`ticket close` 的既有閘）。
       票上要的是「不能默默留著」，不是「自動消失」——
       默默關掉跟默默留著是同一個病的兩面。
    """
    open_left = [d for d in (parent_deps or []) if d.get("state") == "open"]
    if parent_state != "open":
        return "skip", open_left
    return ("note" if open_left else "handback"), open_left
 # ── subtask ──────────────────────────────────────────────────────────────
 def cmd_subtask(argv):
    """把「討論串裡的一件事」長成看得見的子票，並掛成母票的 Gitea 原生相依。
@@ -739,9 +565,7 @@ def cmd_subtask(argv):
    if len(argv) < 1:
        die("用法：ticket subtask <母票 owner/repo#N> --title \"<User Story>\" -F <內文檔>\n"
            "      [--repo <收件 repo，預設跟母票同一個>] [--label <s/xxx，預設 s/todo>]\n"
-            "      [--journey <旅程名>]　← 這件事服務哪條使用者旅程（對不上就不要加）\n"
+            "      [--assign <誰做> --next \"<他第一件事要做什麼>\"]　← 指派了就一定要寫下一步")
            "      [--assign <誰做> --next \"<他第一件事要做什麼>\"]　← 指派了就一定要寫下一步\n"
            "\n（`ticket handoff` 是同一個動作的別名：頂層票 → 下游 repo）")
    powner, prepo, pnum = parse_ref(argv[0])
    def opt(name, default=None):
@@ -761,13 +585,10 @@ def cmd_subtask(argv):
            "     leo 2026-08-27：『每個事情沒有歷史記錄才是大問題』，\n"
            "     而沒寫驗收條件的票，關掉之後就沒有歷史，只剩一個關字）")
-    # `--to <repo>` 是 `ticket handoff` 那個名字底下比較自然的講法，同一個東西。
+    repo = opt("--repo", prepo)
    # （handback 的 `--to` 是「交給誰」，subtask 沒有那個參數，不會撞。）
    repo = opt("--repo", opt("--to", prepo))
    label = opt("--label", "s/todo")
    assign = opt("--assign")
    nxt = opt("--next")
    jlabel = journey_label(opt("--journey")) if "--journey" in argv else None
    if assign and not nxt:
        die("🚫 指派了人卻沒寫 --next。\n"
            "   **有人被指到這張票，他撈到它的第一件事就是問「所以我要做什麼」**——\n"
@@ -776,8 +597,7 @@ def cmd_subtask(argv):
    body = (f"Parent: {powner}/{prepo}#{pnum}\n"
            f"> 這張票是從母票的討論串裡長出來的一件事。\n"
-            f"> **它沒關，母票關不掉**（Gitea 原生相依，實測 412 硬擋）。\n"
+            f"> **它沒關，母票關不掉**（Gitea 原生相依，實測 412 硬擋）。\n\n") + body
            f"> **它關掉時，母票會收到一則回寫**（`ticket close` 自動做，見 `inkstone/ISEP#92`）。\n\n") + body
    d = api(f"/repos/{ORG}/{repo}/issues", {"title": title, "body": body})
    cnum = d["number"]
@@ -799,38 +619,6 @@ def cmd_subtask(argv):
    deps = _deps(powner, prepo, pnum)
    openn = [i for i in deps if i["state"] == "open"]
    print(f"   相依：已掛上 {powner}/{prepo}#{pnum}（它存在、且擋著母票）")
    # 🔴 雙向連結：相依邊只長在 Gitea 的側欄，**母票的時間軸上什麼都沒有**。
    #    票上的原話：「頂層票寫了『轉去某個 repo』，但那邊的票沒有指回來，
    #    從下游那張票看不出它從哪來，脈絡就斷了。」
    #    ⇒ 兩端各留一個看得見的指標：子票內文的 `Parent:`（上面），母票時間軸的這一則。
    #    跨 repo 時尤其重要——側欄的相依很容易被當成同 repo 的東西。
    plines = [_identity(powner, prepo), "",
              f"➡️ **已轉往下游**：`{ORG}/{repo}#{cnum}`　{title}", "",
              f"{d['html_url']}", "",
              f"- 收件 repo：`{ORG}/{repo}`　tag：`{label}`"
              + (f"　旅程：`{jlabel}`" if jlabel else "")
              + (f"　指派：`{assign}`" if assign else "　（還沒指派，留在票池等人領）")]
    if jlabel is None:
        plines += ["- 旅程：**沒有貼**（開票時判定對不上任何一條，不硬湊）"]
    plines += ["",
               "**這張頂層票不會因為轉出去就自動關**——下游那張關掉時，"
               "`ticket close` 會回頭在這裡貼一則回寫；"
               "全部下游關完，這張票會被指派回總管等驗。（機制：`inkstone/ISEP#92`）"]
    api(f"/repos/{powner}/{prepo}/issues/{pnum}/comments", {"body": "\n".join(plines)})
    print(f"   回指：已在母票 {powner}/{prepo}#{pnum} 的時間軸貼上指向子票的留言")
    # journey 標籤：兩端都貼，聚類才聚得起來（只貼一端＝撈不到另一端）
    if jlabel:
        _set_labels(ORG, repo, cnum, [label, jlabel])
        pcur = [l["name"] for l in (api(f"/repos/{powner}/{prepo}/issues/{pnum}")
                                    .get("labels") or [])]
        if jlabel not in pcur:
            _set_labels(powner, prepo, pnum, pcur + [jlabel])
        print(f"   旅程：`{jlabel}`（母子兩端都貼——只貼一端就聚不起來）")
    else:
        print("   旅程：沒有貼（沒給 --journey）。對得上就補一次："
              f"`ticket subtask … --journey <旅程名>`；對不上就不要硬湊。")
    print(f"\n📌 母票 {powner}/{prepo}#{pnum} 目前有 {len(openn)} 張未關的相依：")
    for i in deps:
        mark = "◻" if i["state"] == "open" else "☑"
@@ -959,86 +747,9 @@ def _last_next(owner, repo, num):
    return None
 # ── loose ────────────────────────────────────────────────────────────────
 def cmd_loose(argv):
    """撈一次：**下游都關了、自己還開著**的頂層票。
    票上的驗收條件第 3、4 條（`inkstone/ISEP#92`）：
      「撈一次『已經沒有 open 下游票、但自己還開著的頂層票』→ 要撈得出來（現在撈不出來）」
      「拿現有的頂層票跑一次 → 要能指出哪幾張是這種情況」
    這是 `ticket close` 自動回寫的**補網**：回寫只在走正門（`ticket close`）時發生，
    而關票的側門（直接 PATCH `state=closed`）是刻意放行的
    （見 `hooks/ticket-api-bypass-guard.sh`：「帶了 ID 的子路徑」一律放行）。
    ⇒ 側門漏掉的，由這張網撈回來。**不是輪詢**——掛在開場／收工對帳跑一次。
    """
    def opt(name, default=None):
        return argv[argv.index(name) + 1] if name in argv else default
    org = opt("--org", ORG)
    only = opt("--repo")
    print(f"🔎 掃 `{org}` 的 open 票，找「下游都關了、自己還開著」的頂層票"
          + (f"（只看 {only}）" if only else "") + " …")
    items, page = [], 1
    while page <= 12:
        q = urllib.parse.urlencode({"state": "open", "type": "issues",
                                    "limit": 50, "page": page, "owner": org})
        got = api(f"/repos/issues/search?{q}") or []
        if not got:
            break
        items += got
        page += 1
    if only:
        items = [i for i in items if i["repository"]["full_name"].split("/")[-1] == only]
    print(f"   open 票 {len(items)} 張，逐張問它的下游 …")
    def probe(it):
        full = it["repository"]["full_name"]
        o, r = full.split("/")
        try:
            deps = _deps(o, r, it["number"])
        except SystemExit:
            return None            # 讀不到 ≠ 沒有下游；寧可漏報也不要編一筆出來
        except Exception:
            return None
        return (full, it, deps)
    from concurrent.futures import ThreadPoolExecutor
    with ThreadPoolExecutor(max_workers=12) as ex:
        probed = [x for x in ex.map(probe, items) if x]
    parents = [x for x in probed if x[2]]
    loose = [x for x in parents if is_loose("open", x[2])]
    print(f"\n   有下游相依的頂層票：{len(parents)} 張")
    print(f"   其中「下游都關了、自己還開著」：**{len(loose)} 張**\n")
    if not loose:
        print("✅ 一張都沒有——每張頂層票都還有下游在跑，或已經跟著關了。")
    for full, it, deps in loose:
        n = it["number"]
        st = [l["name"] for l in it.get("labels") or []]
        who = [a["login"] for a in (it.get("assignees") or [])] or ["（沒有人）"]
        print(f"  ● {full}#{n}　{st}　指派：{'、'.join(who)}")
        print(f"    {it['title'][:64]}")
        for d in deps:
            print(f"      ☑ {d['repository']['full_name']}#{d['number']}"
                  f"　{d['title'][:52]}")
        print(f"    → 驗過就關：ticket close {full}#{n} --deliverable <URL>")
        print(f"      還缺東西：ticket subtask {full}#{n} --title \"<US>\" -F <檔>")
        print()
    print("📌 這張表撈的是**機械事實**（相依邊的 state），不是猜文字。")
    print("   走 `ticket close` 關下游時會自動回寫、這張表就不會長；")
    print("   會長出來的都是走側門關掉的那些。")
    return loose
 CMDS = {"where": cmd_where, "say": cmd_say, "new": cmd_new, "close": cmd_close,
-        "decide": cmd_decide, "subtask": cmd_subtask, "handoff": cmd_subtask,
+        "decide": cmd_decide, "subtask": cmd_subtask, "handback": cmd_handback,
-        "handback": cmd_handback, "mine": cmd_mine, "loose": cmd_loose}
+        "mine": cmd_mine}
 if __name__ == "__main__":
    if len(sys.argv) < 2 or sys.argv[1] not in CMDS: