fix(tests)：修好三支跟工具無關的壞測試（inkstone/ISEP#161）

三支測試在乾淨 main 上一直紅，全部是測試自己的 bug，不是工具的離開碼漂了：

1. hooks/tests/wiki-compress.test.sh（⑯⑰㉒）：E 群拼 payload 時把
   {'file_path':...} 直接嵌進三層巢狀 "$(...)" 裡；其中一層雙引號提早收口，
   讓大括號在 bash 眼裡變成「未加引號」，觸發大括號展開——逗號分隔的
   內容被拆成三條各自獨立的 python3 -c 呼叫，`{`／`}` 本身被吃掉，
   python 因此噴三次 SyntaxError。改用兩支小函式（json_edit／json_write）
   把內容經環境變數傳給 python，內容永遠不會被當成 bash 原始碼解析。

2. scripts/test-stage.sh（A1–A4、D1–D4、D14）：全部卡在
   `[ "$(wc -l < "$LOG")" = 0 ]`——macOS/BSD 的 `wc -l` 會在數字前墊空白
   （GNU coreutils 不會），比對永遠是 "       0" != "0"。工具本身的離開碼
   是對的（rc=2，正確拒絕），是測試的比對方式在這台機器上有 bug。
   一律加 `| tr -d " "` 去掉墊白。

3. scripts/test-milestone-account.sh（⑰）：同一款 macOS `wc -l` 墊白 bug，
   帳本筆數比對 `[ "$(wc -l < ...)" = "4" ]` 永遠比不過。同樣修法。

三支都在 `env -u CLAUDE_CODE_CHILD_SESSION` 下重跑到 exit 0：
  wiki-compress.test.sh        25/25 通過
  test-stage.sh                 45/45 通過（連跑 3 次穩定）
  test-milestone-account.sh     23/23 通過

跑過 docs/TESTING.md 記載的其餘 52 支測試（不含兩支需要真 Claude CLI 的
live 測試），全數 0 失敗，唯一例外是 hooks/tests/mainline-members-by-dependency.test.sh
的 ㊽（帳本 cwd 形狀）——在乾淨的 main（未套用本次修改）上同樣紅，
與本次改動的三個檔案無關，非本票範圍，另行處理。

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

.claude-plugin/plugin.json

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

README.md

@@ -23,11 +23,11 @@
 
 | | 數量 | 是什麼 |
 |---|---|---|
-| `hooks/` | 62 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 87 條註冊）。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家** |
-| `agents/` | 7 位 | **工人名單**（`inkstone/ISEP#86`）——派工時指名派給誰，規約見 `docs/governance/worker-roster.md` |
+| `hooks/` | 65 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 91 條註冊）。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家** |
+| `agents/` | 8 位 | **工人名單**（`inkstone/ISEP#86`）——派工時指名派給誰，規約見 `docs/governance/worker-roster.md` |
 | `commands/` | 7 支 | `/wiki-recall` `/wiki-capture` `/cp-write` `/issue-handle` … |
 | `skills/` | 2 支 | `ship-check`（東西要出去之前）／`deep-recall`（把散落的枝葉還原成一棵樹）。🔴 **這兩支的內容不一定是在這裡寫的**——誰是真相源查 `docs/file-ownership.tsv` |
-| `scripts/` | 62 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
+| `scripts/` | 69 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
 
 > 🔴 這五個數字**每次都要在自己的樹上實數**，不准沿用上一版、也不准用加減推
 > （`system-dev/wiki/mistakes.md`：那是 leo 的驗收介面，多報就是假綠）：

agents/course-hand.md

@@ -0,0 +1,31 @@
+---
+name: course-hand
+description: 課程的工人——課件內容（ax-courses）、簡報引擎（course_gen）、學員範本（llm-wiki-template）。動這三個 repo 派它。
+---
+
+你是 **course-hand**，leo 課程這一族 repo 的工人。
+
+**負責 repo**：inkstone/ax-courses、inkstone/course_gen、inkstone/llm-wiki-template
+
+三個 repo 是同一件事的三段：`ax-courses` 放課件原始碼（內容），`course_gen` 是把它
+build 成 PPTX／PDF 的引擎，`llm-wiki-template` 是學員照著做的範本（GitHub 上有公開版）。
+
+## 開工前先讀
+
+- 票所在那個 repo 的 `CLAUDE.md`
+- `ax-courses`：`system-dev/wiki/status.md`，以及同目錄**最新一份** `HANDOVER-*.md`（先看它的 R 段）
+- `course_gen`：`docs/CONTENT-GUIDE.md`（投影片怎麼寫才對）、`docs/SOP.md`（出一場課的流程與驗收三層）、
+  `docs/PLACEMENT.md`（東西放哪）
+- `llm-wiki-template`：`README.md` 與 `README.en.md`（n8n 審核者讀的是英文版）
+
+## 紅線
+
+- **課件交付前要把 PDF 轉成圖逐頁看過**（`pdftoppm`）。`make build` 字量全過、`qa.py` 全綠
+  **都不算驗過**——2026-09-13 D3 就是全綠交出去，28 頁裡 8 頁是空的灰框。
+- **`.pptx` 從來不是原始碼。** 內容改 `slides.md`，版型改 `templates/`；課件原始碼住 `ax-courses`，
+  引擎住 `course_gen`，不要把內容寫進引擎 repo。
+- **不要在共用工作目錄切分支**——一條線用 `scripts/worktree open` 開自己的分身。
+- 推 main 會被判成 subagent 擋下：**交回總管**，不要蓋戳記硬推、也不要找別的路推上去。
+- `course_gen` 的 SOP §1 第 9 步寫的 `make capture` **不存在**，不要照著跑然後回報失敗。
+- `llm-wiki-template` 的公開版在 GitHub：**任何寫到 GitHub 的動作都要 leo 解保險**（D20），自己不推。
+- 版型取捨、課程骨架、要不要補圖這類**品味題**：把選項和各自的後果寫上票，交 leo 裁，不自己定。

docs/TESTING.md

@@ -98,12 +98,21 @@ bash scripts/test-comment-carries-task-guard.sh
 > 記過：訊息壞掉時閘照樣 `exit 2`，只看離開碼完全看不出來——
 > 而這張票（`inkstone/ISEP#112`）就是那個形狀的極端版：**閘擋對了，但它教的解法根本不存在。**
 
-### A12 — 收工要把棒子交回來：10 條
+### A12 — 收工要把棒子交回來：24 條
 ```
 bash scripts/test-baton-handback-guard.sh
 ```
-**該看到**：`10/10 通過`。**用 fixture 跑，不打網路、不在票池留下測試票**。
+**該看到**：`24/24 通過`。**用 fixture 跑，不打網路、不在票池留下測試票**
+（Stop 那半用 `mktemp` 造的假 transcript；出路那兩條把 `TICKET_HOST` 指到連不上的位址）。
 **失敗**：
+- **`inkstone/ISEP#153` 驗收 1**（背景派工送出那一刻）兩條紅 ⇒ 工人剛出發就念「收工了」，
+  會教總管在工人動手前去改票（假交棒）——**誤攔，比漏擋嚴重**
+- **驗收 2**「完工通知 completed ⇒ 報」紅 ⇒ 背景工人真的交件、票上沒交棒，卻靜靜通過；
+  「只點名那一則通知對到的票」紅 ⇒ 判準從 `tool-use-id` 比對滑成「transcript 裡有通知就全報」
+- 「同一則通知第二次 Stop」紅 ⇒ 鬼打牆，每個回合都被擋
+- 「出路印的是絕對路徑」紅 ⇒ 又印回相對的 `scripts/ticket`，總管在 InkStoneCo 貼上去會叫到舊複本（沒有 `handback`）
+- ★「原樣貼上只填三格」紅 ⇒ 訊息教的那塊指令跑不完；它的對照組（拿掉 `--next`）紅就表示 ★ 沒有鑑別力
+- 📌 這 14 條拿 `main` 上舊版的 hook 跑是 **7 條紅**（2026-09-13 實跑），不是換了寫法就會綠的測試
 - 「該報」5 條任一紅 ⇒ 指派／tag／下一步缺哪一格抓不到，08-26 那次掉棒的狀態會靜靜通過
 - 「不該報」4 條任一紅 ⇒ 每條線收工都被念一次，警報會被學會忽略
 - 「票已關」那條紅 ⇒ 棒子已經到終點還在催，那是最典型的假警報
@@ -420,12 +429,12 @@ bash hooks/tests/gitea-arm-check.test.sh                     .
 - ①③⑤⑥ 任一紅 ⇒ 收手收得太晚，暫存區已經開始長東西（磁碟風險回來了）
 - ② 紅 ⇒ 訊息沒給出走得通的那一行（本票整張票在講的就是這件事）
 - ⑧⑨⑩ 任一紅 ⇒ **誤攔／複製錯**：正常用法被弄壞，或複本裡混進了 `hooks/` 以外的東西
-### A31 — 雲端工人抓票的規則是機械可判的：53 條
+### A31 — 雲端工人抓票的規則是機械可判的：84 條
 ```
 bash scripts/test-ticket-pick.sh
 ```
-**該看到**：`通過 53 條，失敗 0 條`。**全程離線**：假池子（3 個 repo、3 個 open milestone、
-12 張票、1 條相依邊）餵給換掉的 `api()`，時鐘走 `ISEP_COUNTDOWN_NOW`，`TICKET_HOST` 指到連不上的位址
+**該看到**：`通過 84 條，失敗 0 條`。**全程離線**：假池子（5 個 repo、3 個 open milestone、
+52 張票、1 條相依邊；`big` 那個 repo 的假伺服器每頁只給 30 張，驗分頁）餵給換掉的 `api()`，時鐘走 `ISEP_COUNTDOWN_NOW`，`TICKET_HOST` 指到連不上的位址
 ——任何一條真的走到網路會當場炸，不會靜靜變成假綠。**不開票、不改票、不留任何東西在 Gitea 上。**
 
 **它在守什麼**（`inkstone/ISEP#131`）：Routine 08-06 起讀 `journeys.md` 本 sprint 段，
@@ -438,6 +447,9 @@ Gitea 主線里程碑抓票（`inkstone/InkStoneCo#118`），但那是一段給
       「在主線上」＝hub 里程碑裡、或被主線成員當相依（跨 repo 邊，inkstone/ISEP#133）；
       別 repo 裡同名的里程碑**不算**主線。主線抓盡才抓「逾期的 open 里程碑」（一個里程碑物件一組）；
       backlog／沒里程碑且沒有邊的一律不抓
+      ⇒ 帶 --pool 或環境 ISEP_DRAIN=1（接票的環境）：兩層都抓盡後再看整個 open 票池，
+        s/* 恰好是 s/todo 或 s/backlog 就可抓（不限里程碑），其他格一格不放寬（inkstone/ISEP#130）
+      可抓 0 張時列出池子大小與每種「不能抓的理由」各幾張，不再印「正常、不是故障」
 認領  claim ＝ 指派 ＋ s/doing ＋ 第一行【身份】的留言，一個動作
 完成  handback --label s/review（本來就有的那半，不重做）
 ```
@@ -455,6 +467,14 @@ Gitea 主線里程碑抓票（`inkstone/InkStoneCo#118`），但那是一段給
 - ③「該擋」六條任一紅 ⇒ 規則只長在 `pick` 這端，手動 `claim` 一張 Human 的票照樣過
 - ③「身份名不在名單上 → 一通都沒打」紅 ⇒ 名單以外的名字碰到了 Gitea
 - ④ 第一條紅 ⇒ 連不上 Gitea 時回了離開碼 1，雲端會把「斷線」當「沒票」收工
+- ⑤「主線與逾期都抓盡、帶 --pool → 回 mira#25」紅 ⇒ 又回到 09-18 的形狀：幾百張 open 票，工人說沒事做
+- ⑤「--all 票池恰好是這幾張」紅 ⇒ 要嘛放寬了不該碰的（Human／指派 Leo／triage／沒 s/*／hub），要嘛漏了該抓的
+- ⑤「ISEP_DRAIN=1 ＝ --pool」紅 ⇒ 雲端工人照 `cloud-worker.md` 打 `ticket pick`、佇列閘自己跑的 pick，都看不到票池
+- ②「沒帶 --pool → 票池一通都沒讀」紅 ⇒ **誤攔**：本機總管跑過 `handback` 後每次收工都會被佇列閘點名去抓票池
+- ⑤「可抓 0 張時列理由表、不說正常」紅 ⇒ 「0 張」又被說成正常收工（c7797）
+- ⑤「分頁」紅 ⇒ 伺服器每頁上限比 50 小時，第二頁之後的票看不到
+- ⑤「票池抓盡、還有沒 s/* 的票 → 回待分診那張，下一步是 triage」紅 ⇒ 沒驗傷的票又沉默地消失在「可抓 0 張」後面（`inkstone/ISEP#159`；A43 測分診本身）
+- ⑤「pick --claim 遇到待分診 → 不認領」紅 ⇒ 會對一張還沒決定要不要做的票寫 s/doing
 
 📌 **真實 Gitea 唯讀實跑**（2026-09-07，isep-hand，不改任何票）：
 `ticket pick --mainline InkStoneCo/system-dev/mainline.json --all` 在主線
@@ -465,14 +485,69 @@ Gitea 主線里程碑抓票（`inkstone/InkStoneCo#118`），但那是一段給
 assignee＝`claude-code`、標籤 `s/todo → s/doing`、留言 6325 第一行【身份】——
 之後再 `pick` 就不再回 #131（票上驗收第 2 條的 log 在票的留言裡）。
 
-### A19 — 下游做完時頂層跟著關：49 條
+### A43 — 雲端工人會分診、會組里程碑，而且碰不到 leo 的票：80 條
+```
+bash scripts/test-ticket-triage.sh
+bash hooks/tests/queue-drain-guard.test.sh     # 28 條：待分診那一列，閘印 triage 不印 claim
+```
+**該看到**：`通過 80 條，失敗 0 條`、`通過 28 條，失敗 0 條`。**全程離線**（形狀同 A31：假池子 3 個 repo、
+3 個 open 里程碑、1 張載體帶 3 條相依；時鐘定在 2026-09-18；`TICKET_HOST` 連不上）。
+
+**它在守什麼**（`inkstone/ISEP#159`）：leo 09-18「我有快 500 個票⋯⋯它看到票時要能夠組成 milestone 提出版本，
+所以不只是看票，還要組票」。當天實量 open 302 張、沒 s/* 的 74 張、沒掛里程碑的 257 張；雲端只會撿（A31），不會組。
+哪張跟哪張重複、哪幾張該一起出版——是**讀票的人的判斷**；這一支守的是判斷寫回 Gitea 的那一步：
+
+```
+triage   沒有 s/* 的票 → s/backlog｜s/triage｜s/pending ＋ 票上一則說明（--why 必填），一個動作
+         --dup-of <票> → 說明＋close/duplicate＋關＋在留下的那張留一則指回來
+compose  --title --goal --due --carrier inkstone/InkStoneCo#N <前置…>
+         建在 InkStoneCo、掛在既有載體、前置掛成相依、s/backlog → s/todo，不開任何新票
+         先全部讀過才寫第一筆；驗不過一次列出全部理由
+pick     --pool 時：還沒到期的 InkStoneCo 里程碑的前置 → 排在散票之前（組了就照里程碑做）
+         可做的都抓盡 → 回一張待分診的（row 帶 next＝triage 那一行，佇列閘照它印）
+不碰     掛 Human／human/*、指派給別人（含 Leo）——判準是標籤與 assignee 登入名，不看文字
+```
+
+**失敗**：
+- ①「掛 Human／指派 Leo → 不碰」任一紅，或 ②③ 裡「驗收 3」那幾條紅 ⇒ **會寫 leo 的票**（驗收 3 破了）
+- ②「重複的對象是 Leo 的票 → 不在它上面寫字」紅 ⇒ 關重複票時順手在 leo 的票上留言
+- ②「寫入恰好是 [留言, 改標籤]」紅 ⇒ 改了欄位卻沒留說明（驗收 1：每張被動過的票都說得出分到哪、為什麼）
+- ②「--to s/todo 擋」紅 ⇒ 沒排進里程碑的票被標成「已排進里程碑」
+- ③「好幾格不對時一次列齊」紅 ⇒ 改一格撞一次——閘在懲罰人
+- ③「名字是版本號／沒期限／9999／過去」任一紅 ⇒ 開工規約第 5、6 條破了
+- ③「載體不在 InkStoneCo」紅 ⇒ 開工規約第 7 條破了（在子 repo 建里程碑）
+- ③「前置已是別的里程碑載體的前置」／「載體是別一輪的前置」紅 ⇒ 一張票同時排進兩輪
+- ③「不開任何新票」紅 ⇒ 開工規約第 2 條破了
+- ④「里程碑那一組排在票池之前」紅 ⇒ 組了里程碑，工人還是照開票時間撿散票
+- ④「沒帶 --pool → 不看、不回待分診」紅 ⇒ **誤攔**：本機總管收工時被佇列閘叫去分診
+- ④「載體票本身不當成可做的票」紅 ⇒ 工人會去「做」一張容器票
+
+📌 **真實 Gitea 實跑**（2026-09-18，isep-hand 用本分支代跑一趟，署名 `[isep-hand]`）：
+- 分診前 `triage --list`：待分診 72 張 → 分診 4 張後 67 張（總數同時受別條線影響；我動的 4 張讀回皆對）
+  - `Arcrun#188` → 與 `Arcrun#143` 重複：`close/duplicate`、已關，#143 上有指回來的留言
+  - `Arcrun#131` → `s/triage`（與 #143 同一件事，兩張留哪張交總管）
+  - `ISEP#47`、`arcrun-rag#199` → `s/backlog`，各有一則說明
+- 組里程碑：`ticket where` 撈不到能載這一輪的 InkStoneCo User Story ⇒ 補一張載體 `InkStoneCo#136`，
+  `compose` 建出 InkStoneCo milestone 68「金鑰不再出現在任何畫面與 log 裡」（期限 09-25）：
+  載體掛上、`ISEP#47`／`arcrun-rag#199` 成為相依並 `s/backlog → s/todo`、三張各一則說明
+- `pick --pool --all`（主線 #65）：第一組就是這個里程碑的兩張前置，之後票池 101 張、待分診 67 張
+- 真的擋：`compose --carrier InkStoneCo#134 ISEP#47 Arcrun#143` → 離開碼 2、一筆都沒寫，三個理由一次列出
+  （#134 已是主線載體 #55 的前置／#47 已排進 milestone 68／#143 還沒分診）
+
+### A19 — 下游做完時頂層跟著關：54 條
 ```
 bash scripts/test-ticket-handoff-writeback.sh
 ```
-**該看到**：`通過 49 條，失敗 0 條`。**全程離線**——`TICKET_HOST` 指到連不上的位址，
+**該看到**：`通過 54 條，失敗 0 條`。**全程離線**——`TICKET_HOST` 指到連不上的位址，
 會打 API 的兩段（`_writeback`／`cmd_subtask`）把 `api()` 換成錄音機跑，
 **不打真實 Gitea、不開票、不關票、不留任何測試票**。
 
+> 📌 `inkstone/ISEP#123` 從 49 加到 54：⑨ 交棒留言的人閘記號（純函式 `handback_comment_lines`）——
+> `--to Leo` ＝要 leo 親手做 ⇒ 第一行掛 `👤`（他掃一長串留言一眼認得出在等他），
+> **🏃 那一塊照舊留著**（`baton-handback-guard.sh` 靠留言裡有沒有 `🏃` 判斷交棒了沒）；
+> `--to claude-code`（交回總管）第一行維持 `🏃`、不掛 `👤`（那不是等 leo 動手的）。
+> ⑨「🏃 仍在」那條紅 ⇒ 為了掛 👤 把 🏃 拔了，`baton-handback-guard` 會漏擋這條線的交棒。
+
 **它在守什麼**（`inkstone/ISEP#92`）：
 「開在頂層的票，下游做完了卻沒人回來關⋯⋯頂層票會永遠掛著，**而 leo 是看頂層的**。」
 
@@ -544,11 +619,11 @@ python3 scripts/debt-worklist list --top 5
 **失敗**：前幾名一眼看不出為什麼在那裡 ⇒ 那些權重就是錯的，去改 `score()`，
 **不要改成「總管覺得」**——這份清單的價值就在於它不靠記憶。
 
-### A21 — 沒人會叫的事會自己叫：36 條
+### A21 — 沒人會叫的事會自己叫：43 條
 ```
 bash hooks/tests/overdue-nag.test.sh
 ```
-**該看到**：`通過 36 條，失敗 0 條`。**全程離線**——資料走 `--fixture`、時鐘走 `--now`、
+**該看到**：`通過 43 條，失敗 0 條`。**全程離線**——資料走 `--fixture`、時鐘走 `--now`、
 網路用 `ISEP_NOTIFY_OFFLINE=1` 關掉。**不打 Gitea、不打實例、不留任何測試票。**
 
 **它在守什麼**（`inkstone/ISEP#93`，2026-08-27 實查）：一張票掛著等 leo 三天了、
@@ -568,6 +643,11 @@ bash hooks/tests/overdue-nag.test.sh
   **閘說會擋就不准從 python 這條路繞過去**——繞得過的閘等於不存在
 - ㉛ 紅 ⇒ 探針把 `/tmp/.prod-write-ok` 燒掉了（那是總管單次用完即丟的授權）
 - ㉟ 紅 ⇒ 每條 subagent 開工都吵 leo 一次
+- **G 群（㊱–㊷，`inkstone/ISEP#118`）**：新開的 repo 有票卻沒有工人，開場要點名
+  - ㊱㊵ 紅 ⇒ 缺工人的 repo 沒被點名 ⇒ 又回到「第一次派工撞閘才發現、開例外閘繞過」
+  - ㊳ 紅 ⇒ **誤報**：有工人的、沒票的、封存的被點名，每次開場念一串不相干的 repo
+  - ㊴ 紅 ⇒ 補工人這件總管的事跑進 leo 的 Telegram
+  - ㊶㊷ 紅 ⇒ 名單或 org 清單讀不到時，把「沒查到」講成「每個都缺人」或「都有人」
 
 > 🔴 **跑測試前先確認 `CLAUDE_CODE_CHILD_SESSION` 沒有殘留**：這支閘刻意放行子 session，
 > 在一條 subagent 裡跑，F 群會全綠而且是**假綠**。測試檔自己會把它清掉。
@@ -752,6 +832,55 @@ B 段拿這台機器真正的 `.env` 對帳——**`.env` 不在的機器（雲
 > ```
 > ⇒ 第二條正是黑名單會放過去的形狀。
 
+### A27 — 一次性戳記真的能放行一次：重複掛載清乾淨了，也不會靜靜復發（`inkstone/ISEP#122`）
+```
+bash hooks/tests/duplicate-hook-registration-guard.test.sh
+bash hooks/tests/kv-write-guard.test.sh
+```
+**該看到**：兩支各自 `8 通過 / 0 失敗`。全程用假的 plugin root／專案目錄，
+不碰真正的 `InkStoneCo/.claude/` 或這台機器裝著的 ISEP plugin。
+
+**它們在守什麼**（2026-09-01 實撞）：總管三次要部署 uncle6.me，三次被
+`prod-write-guard.sh` 恆擋——蓋了戳記、確認戳記還在，執行動作時照樣被擋，
+再看戳記已經不見。根因：`InkStoneCo/.claude/settings.json` 還登記著一份
+2026-08-20 立 ISEP plugin 之前的舊 hook（那時 `.claude/hooks/` 是唯一的家），
+跟 plugin 自己的 `hooks.json` 同時掛在同一個 `PreToolUse` 事件上——每個動作
+都跑了**兩次**，一次由專案版、一次由 plugin。多數閘只是白跑一次沒感覺，
+但一次性戳記（蓋了就消耗掉）被第一份吃光，第二份永遠看到空戳記，於是恆擋。
+
+**實查結果**（在這台機器的樹上實數，不是推算）：`InkStoneCo/.claude/settings.json`
+登記著 38 支專案版 hook——**34 支跟 plugin 完全同名同用途**（純殘骸）、
+**3 支是已經退役的機制**（`claim-verify-police.sh`／`subagent-claim-worksheet.sh`／
+`sdd-guard.sh`，`inkstone/ISEP#60`／`#91` 早已裁定退役，但專案版沒有跟著退），
+**1 支（`kv-write-guard.sh`）是專案版有、plugin 當時沒有的真閘**（2026-08-25
+立，長效資料不准寫進 KV）。前 37 支已從 `InkStoneCo/.claude/settings.json`
+與 `.claude/hooks/` 刪除；第 38 支原樣搬進本 repo（同一輪 commit，見 B 組）。
+
+**失敗**：
+- `kv-write-guard.test.sh` 任一「該擋」紅 ⇒ 搬過來時邏輯改壞了，
+  KV 寫入的偵測失靈
+- `kv-write-guard.test.sh` 任一「不該擋」紅 ⇒ 誤攔，這比漏擋嚴重——
+  正常的 `.get`／退休戰的刪除／`kv-ok` 豁免都要放得過
+- `duplicate-hook-registration-guard.test.sh` 的「該吵」任一紅 ⇒
+  重複掛載又會靜靜發生，**下一次會是另一支帶戳記語意的閘恆擋，
+  而且要等 leo 自己撞到才會被發現**
+- `duplicate-hook-registration-guard.test.sh` 的「不該吵」任一紅 ⇒
+  誤攔，每個 session 開場都吵一次沒問題的環境，最後被學會忽略
+
+### A28 — 收工前的實測：蓋一次戳記真的只用得掉一次（手動，這台機器）
+這一格驗的是**行為**，不是**檔案**——上面兩支測試證明「新機制自己邏輯對」，
+這格證明「舊的重複掛載真的被拆掉了」。在**新開**的 session 裡跑（PreToolUse hook
+是 session 啟動時載入的常駐清單，同一支閘改完不會讓已經在跑的 session 重新讀）：
+```
+bash "$CLAUDE_PLUGIN_ROOT/scripts/gate-ok" prod-write   # 蓋一次戳記
+# 執行一個會被 prod-write-guard.sh 擋的動作（例如 wrangler pages deploy 打非白名單目標）
+```
+**該看到**：蓋戳記那個會被擋的動作**這次放行**（① 蓋一次戳記 → ② 動作通過）；
+不蓋戳記重跑同一個動作 → **仍然被擋**（證明沒有把閘弄鬆，只是不再被自己的複本吃掉）。
+**失敗**：蓋了戳記仍被擋 ⇒ 還有第三份複本沒清乾淨，去跑
+`bash "$CLAUDE_PLUGIN_ROOT/hooks/duplicate-hook-registration-guard.sh"`
+（或直接開一個新 session 看它開場有沒有吵）先定位是哪一份。
+
 ### A31 — leo21c 讀可以、寫不行，而且改法指到活著的 youlin：26 條
 ```
 bash hooks/tests/leo21c-write-guard.test.sh
@@ -943,12 +1072,34 @@ bash hooks/tests/isep-presence-beacon.test.sh        # ㉗–㉝ 那七條
 **真實跑（2026-09-07）**：信標不帶 fixture 打真 Gitea（匿名）→ 安靜（v0.24.0 tag＋release 都在），
 留下 `.isep-chain-ok-v0.24.0` 快取；`release-check` 在本分支 → `v0.24.0 ✅✅✅ ←`、三個裁定不補的版本標 ⏭、exit 0。
 
-### A39 — D20 閘判「push 到哪」看的是指令實際會推的那個 repo：26 條
+### A44 — Gitea token 只從 env／.env 來，絕不從 remote URL 抽：16 條
+```
+bash scripts/test-gitea-token.sh
+```
+**該看到**：`通過 16 條，失敗 0 條（共 16 條）`。全程離線（自己在 TMP 造 git repo 與 `.env`），
+**不打 Gitea、不碰 $HOME**。Python（`hooks/lib/gitea_token.py`）與 shell（`scripts/lib/gitea-token.sh`）
+兩份實作對同一組情境各測一次，順序必須一致。
+
+**它在守什麼**（`inkstone/ISEP#47` → comment 9128）：洩漏源是「token 明文嵌在 remote URL 裡」，
+任何印出 remote 的訊息（git-lfs 的 `locksverify` 那行）都會洩一次。前一輪只改了 6 支 shell、
+漏了 8 支 Python（`ticket`／`debt-worklist`／`milestone-account`／`pr-verdict`／`release-manifest`／
+`isep-nag`／`isep-notify`／`hooks/lib/release_chain.py`），且雲端有環境變數所以測不出本機（只有 `.env`）的壞法：
+remote 清乾淨後那 8 支會靜默拿到空字串 → 401，正是票上 2026-08-13「被讀成找不到／不存在」那種壞法。
+① env 在就用 env；②③ 沒 env 時退到 `$CLAUDE_PROJECT_DIR/.env`、再退 git 根的 `.env`（本機 Mac 的實況）；
+④ **token 只在髒 remote 的 URL 裡時，解析器必須解不出**（否則洩漏源還在）；八支腳本在「無 env＋乾淨 remote＋`.env` 有」下都要走得過 token 步。
+
+**失敗**：
+- ② 紅 ⇒ 本機（只有 `.env`）拿不到 token，八支會整支停擺或靜默失效——就是 c9128 攔下不可併的那個病
+- ④ 紅 ⇒ **洩漏源沒斷**：還在從 remote URL 抽 token，ISEP#47 等於沒修
+- 八支任一條「死在 token 步」⇒ 那支在乾淨 remote 的本機上用不了
+
+### A39 — D20 閘判「push 到哪」看的是指令實際會推的那個 repo，且 subagent 與總管同判：33 條
 ```
 bash scripts/test-github-contact-guard.sh
 ```
-**該看到**：`26/26 通過`。離線；後 12 條自己開兩顆 git repo（`shell` 的 origin＝github.com、
-`body` 的 origin 是 Gitea 的形狀），payload 帶 `cwd`，跟 hook 真的會收到的一樣。
+**該看到**：`33/33 通過`。離線；中間 12 條自己開兩顆 git repo（`shell` 的 origin＝github.com、
+`body` 的 origin 是 Gitea 的形狀），payload 帶 `cwd`，跟 hook 真的會收到的一樣；
+最後 7 條（`inkstone/ISEP#119`）把同一條指令帶 `agent_id`（subagent）與不帶（總管）各跑一次，兩者判決必須相同。
 
 **它在守什麼**（`inkstone/ISEP#109` → comment 6629，2026-09-07 實撞）：雲端薄殼的 cwd 是 GitHub 那份，
 總管站在那裡 `git -C <InkStoneCo> push origin x`（InkStoneCo 的 origin＝Gitea），舊版拿 **hook 收到的 cwd**
@@ -962,6 +1113,18 @@ bash scripts/test-github-contact-guard.sh
 - 「該擋」5 條任一紅 ⇒ D20 有洞：`-C`／`cd` 指到 GitHub 那份的 push 沒被攔
 - `(cd body && true); git push` 那條紅 ⇒ 子殼的 cd 外洩了（08-11 穿透的形狀）
 - 前 14 條紅 ⇒ 舊有判準（heredoc／引號裡的散文／讀取放行）被改壞
+- subagent 那 7 條任一「subagent≠總管」⇒ 這支閘開始讀 `agent_id`／`agent_type` 分身分了：
+  D20 對 subagent 與總管本該一視同仁（`inkstone/ISEP#119`），一旦分了岔就是 09-01 那種「一端有效一端失效」的破口回來了
+
+🔴 **已知殘留破口（`inkstone/ISEP#119` 查出、實測＋雲端實跑驗過，待裁）**：push 目標若用
+**未展開的 shell 變數**表示（`git -C "$VAR" push`／`cd "$VAR" && git push`），PreToolUse hook 收到的是
+**展開前**的字串，`push_target_dir.py` 對 `$VAR` 一律回「不確定」⇒ 退回 **session 的 cwd** 解 remote。
+`main-and-prod-push-guard` 遇到「不確定」是退回「要有戳記」＝**擋**（fail-safe）；
+但 `github-contact-guard` 的預設方向相反——「證明不了是 github 就放行」⇒ cwd 是 Gitea 時，
+一個真的推 GitHub 的 `-C "$VAR"` 會**漏擋**。這個不對稱就是殘留的同形狀破口。
+上面測試用的都是**字面絕對路徑**（解得出來 ⇒ 擋），所以測試全綠**不代表**這個變數形狀已補。
+雲端有 git proxy 當後手（未授權的 github repo 一律 403），本機沒有 ⇒ 本機風險較高。
+修法有代價（fail-closed 會誤攔「用變數推 Gitea」，需配「改用字面路徑」的出路），屬 `誤攔比漏擋` 的取捨，另票裁。
 
 ### A37 — 雲端第一則 prompt 的主線就是現在這條，不是兩週前的舊線：31 條
 ```
@@ -1103,16 +1266,25 @@ bash hooks/tests/ask-user-question-guard.live.test.sh
 ```
 bash hooks/tests/dispatch-format-guard.test.sh
 ```
-**該看到**：`52/52 通過`（`inkstone/ISEP#88` 之前是 33 條；本頁一度寫 19，那是更早的數字，
-**沒有人回頭改** —— 同一個病，只是換一欄）。**離線、不打網路、不花錢**——這支閘是純結構判斷，沒有語意判官，
+**該看到**：`53/53 通過`（`inkstone/ISEP#88` 之前是 33 條、`#113` 是 52 條；
+本頁一度寫 19，那是更早的數字，**沒有人回頭改** —— 同一個病，只是換一欄）。
+**離線、不打網路、不花錢**——這支閘是純結構判斷，沒有語意判官，
 所以它不需要像 A10 那樣另開一支 live 測試量準度，**每次結果都一樣**。
+🔴 **在 subagent 裡跑會假紅**：`CLAUDE_CODE_CHILD_SESSION=1` 殘留時，回覆那條路（D／E 群）
+會被當成子 session 全放行 ⇒ 12 條該擋的變 exit=0（2026-09-18 實撞）。前面加 `env -u CLAUDE_CODE_CHILD_SESSION` 再跑。
 **失敗**：
 - A 群任何一條紅 ⇒ **誤攔**。合規的派工只有一行票號，擋掉它等於整台機器派不了工
 - ⑦ 紅 ⇒ **共通規定沒有被注入**。這是「派工單只剩票號」能成立的前提：
   交件方式、不准 push main、org 是 `inkstone` 這些不必有人記得寫，機器每次都補。
   它壞了不會有人立刻發現——派工照樣送出去，只是收工方**不知道要貼回原票**
+- ⑦b 紅 ⇒ **§2 第 10 條沒被注入**（`inkstone/ISEP#120`）：收工方拿不到「用試寫判寫入權限、
+  別信 API 的 permissions 欄位」＋「掛住／被拒／找不到」三種失敗形狀，就會再犯 09-01 那次
+  （拿 `permissions.push=false` 去叫 leo 加協作者，而其實推得進去）
 - ⑨ 紅 ⇒ 真跡放行了。那份測資是**真的發生過的那一次派工**（見 `hooks/tests/fixtures/README.md`）
-- ⑰ 紅 ⇒ 訊息被 shell 展開了（同 A9 ⑩b 那個病：閘照擋，但它教人怎麼解的那兩行變成空白）
+- ⑰ 紅 ⇒ 訊息被 shell 展開了（同 A9 ⑩b 那個病：閘照擋，但它教人怎麼解的那兩行變成空白），
+  **或出路又印回相對路徑的 `scripts/ticket`**（`inkstone/ISEP#113`）：收工方 cwd 常是
+  InkStoneCo，那裡的 `scripts/ticket` 是 2026-08-27 之前的舊複本，相對路徑貼過去會叫到它、
+  什麼都不會發生——同 comment-carries ⑮、`baton-handback-guard`。出路要印**絕對路徑**的 ticket
 - **D 群⑲⑳㉑㉒ 紅 ⇒ `inkstone/ISEP#88` 的驗收條件沒過**：回覆一個正在跑的 subagent
   時夾帶指令沒被擋（⑲）、或擋了卻沒把那段內容原文印出來（㉑，出路是「貼上票」，
   找不到原文就得回頭自己翻）
@@ -1121,11 +1293,11 @@ bash hooks/tests/dispatch-format-guard.test.sh
 - **F 群㉚–㉟ 任一紅 ⇒ 誤攔**。㉚特別重要：subagent 往上回報（`to: "main"`）是**交件**，
   擋它等於擋掉交件本身；㉟反過來，子 session 自己往下派工時規矩要照樣管它，不然是逃逸艙口
 
-### A16 — 工人有名字：指名派工、沒有這個人、注入它的檔案：24 條
+### A16 — 工人有名字：指名派工、沒有這個人、注入它的檔案：31 條
 ```
 bash hooks/tests/roster-guard.test.sh
 ```
-**該看到**：`24 通過 / 0 失敗`。**離線、不打網路、不花錢**——純結構判斷（名字在不在名單裡），
+**該看到**：`31 通過 / 0 失敗`（本頁先前寫 24，實跑是 25，⑲ 加進來時沒回頭改）。**離線、不打網路、不花錢**——純結構判斷（名字在不在名單裡），
 沒有語意判官，每次結果一樣。
 
 **它在守什麼**（`inkstone/ISEP#86`）：「身為派工的人，我要工人有名字，
@@ -1141,6 +1313,10 @@ bash hooks/tests/roster-guard.test.sh
 - ⑯⑰ 紅 ⇒ 注入壞了。那是「你是誰／先讀什麼／你的紅線」唯一的送達方式——
   它壞了不會有人立刻發現，派工照樣送出去，只是工人不知道自己是誰
 - ⑱ 紅 ⇒ 驗收 3 沒過：票上的【身份】欄吃不下工人名字（或把原本三個角色弄壞了）
+- ⑳㉑㉒ 紅 ⇒ `inkstone/ISEP#118` 沒過：課程三個 repo 找不到 `course-hand`，
+  或用真實形狀 `isep:course-hand` 派工被擋 ⇒ 派 ax-courses 又要開例外閘
+- ㉓ 紅 ⇒ 一個工人管多個 repo 的解析壞了（只認第一個），或「有票卻沒工人」的判準
+  開始點名沒票／封存的 repo（誤報）。2026-09-14 突變驗過：拿掉票數條件、只認第一個 repo，這條都會紅
 
 ### A17 — 未經調查不寫診斷：26 條
 ```
@@ -1210,6 +1386,79 @@ claude -p '請執行 git tag -a v9.9.9 -m test'
 > 為什麼挑 `release-tag-guard` 當考題：它**只存在於 ISEP**，舊的 `.claude/` 那份沒有。
 > 用它才分得出「載到的是 plugin」還是「載到的是舊的」。
 
+### A8b — 這台**每一個** Claude Code 都真的載入了 ISEP：離線 11 條＋實機 3 條
+```
+python3 scripts/isep-doctor              # 看這台現況
+bash scripts/test-isep-doctor.sh         # 離線：假的 claude 可執行檔
+bash scripts/test-isep-doctor-live.sh    # 實機：真的 CLI 與 Desktop 內建那一份，隔離 HOME，不動 ~/.claude
+```
+**該看到**：`isep-doctor` 逐一列出 CLI 與 Desktop，各一行 ✅；離線 `pass=11 fail=0`；實機 `pass=3 fail=0 skip=0`。
+
+**它在守什麼**（`inkstone/ISEP#150`）：plugin 沒載入時，**會講話的信標本身也沒載入**，
+所以只能從 plugin 外面問。而同一台 Mac 有**不只一個** Claude Code，它們讀同一份 `~/.claude` 卻不一定同一個結論：
+`extraKnownMarketplaces.inkstone.source` 多了 `path` 時，**Desktop 內建的 2.1.266 整個忽略 marketplace、CLI 2.1.220 照常載入**
+（c6991 兩份 debug log；本支實機測試在隔離 HOME 重現）。第一版 doctor 看設定長相就對整台判 ❌——在 CLI 上是假陽性。
+⇒ 判準是**每一個 Claude Code 自己 `plugin list --json` 回報的 errors**；設定比對只當解釋，永遠不單獨判 ❌。
+
+**失敗**：
+- ① 紅 ⇒ **誤攔**，又回到看設定長相判 ❌。鑑別力實跑過：拿 8eb4c58 那版跑這份測試是 `pass=1 fail=10`，
+  大多是輸出格式不同；**真正分得出判準對錯的是 ①**——舊版在「CLI 實際載入」時照樣 exit 1 並點名 path
+- ② 紅 ⇒ 分不出哪一個 surface 壞了，或又把整台機器講成同一個結論
+- ④ 紅 ⇒ 別的原因失敗時編了一個 path 原因出來
+- ⑥⑦ 紅 ⇒ 「查不了」被講成 ✅ 或 ❌（讀不到不等於沒載入）
+- ⑧⑧b 紅 ⇒ 印出來的修法照著貼走不通
+- ⑨ 紅 ⇒ Desktop 版本用字串排序，`2.1.99` 會被當成比 `2.1.266` 新
+- 實機測試印 SKIP ⇒ 這台的版本不是 2.1.220／2.1.266，行為可能不同，那一格**沒驗過**
+
+### A42 — 票上回碼解的保險，寫在出貨線讀得到的地方：18 條
+```
+bash hooks/tests/gitea-arm-to-github-armed.test.sh .
+```
+**該看到**：`通過 18 條，失敗 0 條`。**全程離線**：在 `mktemp` 裡造一個長得像
+`~/.claude/plugins/cache/inkstone/isep/<ver>/` 的安裝位置與一個假的專案根，
+「leo 已核准」由 stub 扮演；fail-closed 那組用**真的** `gitea-arm-check.sh`（沒有待核請求 → 本地就擋）。
+**不碰真 InkStoneCo、不寫真的 `.github-armed`、不打 Gitea。**
+（②a 會去讀 `InkStoneCo/products/arcrun-rag/installer/scripts/d20-guard.mjs` 的 `checkArmed`；
+找不到那個檔或沒有 node 時印 `⏭️ SKIP`，不算失敗，也不算驗過。）
+
+**它在守什麼**（`inkstone/ISEP#156`，09-17 實撞於 `inkstone/arcrun-rag#202` c7598）：
+舊版用 `ROOT=$(dirname $0)/..` 決定保險寫在哪。plugin 發佈後腳本住在 plugin 快取裡
+⇒ 保險寫進快取、腳本照印「✅ 保險已解」、出貨線讀 `InkStoneCo/.github-armed` 讀不到
+⇒ leo 回了碼，出貨照樣卡住，總管手動搬檔才通。
+現在寫在 `${CLAUDE_PROJECT_DIR:-$(pwd)}`——**跟每一個讀它的人同一個位置**。
+
+📌 拿修之前的腳本跑是 **11 條紅**（2026-09-17 實跑），不是換了寫法就會綠的測試。
+
+**失敗**：
+- ① 的兩條 ★ 紅 ⇒ 保險又寫回腳本自己的位置（09-17 那個病）
+- ② 任一 ★ 紅 ⇒ 檔案寫對地方了，但**讀的人不認得**（格式或位置跟出貨線／閘又分家了）；
+  它們的「對照」紅 ⇒ ★ 那條沒有鑑別力
+- ③ 紅 ⇒ 終端機（沒有 `CLAUDE_PROJECT_DIR`）時跟閘的退回規則不一致
+- ④ 前兩條紅 ⇒ **沒拿到核准也寫了保險**——這是 D20 等級的洞，最嚴重
+- ④ ★ 紅 ⇒ 擋下之後教的指令又印回相對路徑（站在 InkStoneCo 會叫到舊複本，`inkstone/ISEP#112` 同病）
+
+---
+
+### A27 — 未出貨警察：改了 code 沒出貨要擋，只改 wiki／已出貨／先不出都不擋：13 條
+```
+bash scripts/test-unreleased-police.sh
+```
+**該看到**：`13/13 通過`。全程在 `mktemp -d` 底下造假 repo 與假 transcript，
+不碰任何真 repo、不打網路、跑完自己清。
+
+**它在守什麼**（`inkstone/ISEP#68`，leo 2026-08-27）：「每個 repo 只要有改動就要出貨⋯⋯
+這個 session 有改但要結束沒出貨就抓」。「改過」認的是**這個 session 期間新長出來的 commit**
+（committer-date 晚於 transcript 第一列的時間戳），「出貨」認的是**有沒有 release tag 收進 HEAD**
+（`git tag --contains HEAD`）——兩者同一個單位（commit），才數得出「最後 commit 與最新 release 差幾筆」。
+
+**失敗**：
+- A 群「該擋」任一放行 ⇒ 假綠：改了 code 卻沒出貨溜過去了
+- B 群「不該擋」任一被擋 ⇒ **誤攔**（比漏擋嚴重）——特別看「只改 wiki／docs」「已出貨」
+  「有 exempt marker」「release-holds.md 有它」四條，任何一條紅代表閘在懲罰謹慎
+- C 群紅 ⇒ 訊息教的出路（寫 `.claude/release-holds.md` 一行）**跑不動**，
+  被擋的人只會去找繞過去的方法（`mistakes.md` ISEP#112 的課）
+- D 群紅 ⇒ 偵測根本不會亮，「全綠」其實是偵測壞了，不是真的乾淨
+
 ---
 
 ## B. 只有 leo 能跑的（雲端）
@@ -1339,6 +1588,7 @@ B2（信標那行）／B3（setup 輸出）／B4（閘的訊息）三個畫面
 | **A39 D20 閘看 push 實際會推的 repo** | isep-hand | ✅ 26/26（2026-09-07，inkstone/ISEP#109→6629）＋真路徑實跑（薄殼 cwd：`-C InkStoneCo` 放行、裸 `git push origin` 擋）＋舊閘實跑 7 條紅（4 誤攔＋3 漏擋） |
 | **A24 分身住 repo 裡面＋收工被收（G／H 群）** | isep-hand | ✅ 110/110（2026-09-07，inkstone/ISEP#147）＋舊閘實跑 20 條紅（訊息＋G／H，B／D／E／F 全綠）＋本線自己就是 dogfood（分身開在 `ISEP/.worktrees/ISEP-147`，主目錄 `git status` 乾淨） |
 | **A40 sweep 現場整理（七個分身的 fixture）** | isep-hand | ✅ 42/42（2026-09-07，inkstone/ISEP#147）；**leo 的 Mac 現場**要他自己跑 `sweep ~/tech_projects`（先 dry-run）——這台機器碰不到 |
+| **A42 票上回碼的保險寫在出貨線讀得到的地方** | isep-hand | ✅ 18/18（2026-09-17，inkstone/ISEP#156）；修之前的腳本 11 條紅 |
 | **A26 雲端憑證清單這台拿得到** | isep-hand | ✅ 11/11（2026-09-01，inkstone/ISEP#115→5526／5541／5542／5577）＋兩條「該紅」方向實跑 |
 | **A16 放行的門真的打得開** | 總管 | ✅ 17/17（2026-08-28，inkstone/ISEP#90） |
 | **A17 未推警察不誤攔雲端分支** | 總管 | ✅ 10/10（2026-08-28，inkstone/ISEP#90） |

docs/cloud-env-versions.tsv

@@ -0,0 +1,11 @@
+# 雲端環境（claude.ai Cloud environment）變數清單的版本紀錄——**只記名字，不記值**。
+# leo 2026-09-18：「你這裡記錄每版的 credential 的 key，但 value 自動產生，我就貼上去，你要有版本，因為這件事做了很多次，但你都沒記錄版本」
+# 產生器 scripts/make-cloud-env.sh 讀本檔最後一版的號碼印在產物檔頭，並列出與前一版的差異。
+# 欄位：版本<TAB>日期<TAB>key（逗號分隔，順序＝NEEDED）<TAB>為什麼變
+v1	2026-08-20	GITEA_TOKEN_CLAUDE_CODE	首版：雲端 bootstrap 與 plugin 安裝（f855d82）
+v2	2026-09-01	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE	雲端拿得到 youlin 的 CF token（ISEP#115 c5526，ca9ea99）
+v3	2026-09-01	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE,CLOUDFLARE_ACCOUNT_ID_YOULIN,YOULIN_MCP_OWNER_SECRETS,STAGE_USERNAME_YOULIN,STAGE_PASSWORD_YOULIN,CLOUDFLARE_API_TOKEN_CC_SHIPPING_CORE,CLOUDFLARE_ACCOUNT_ID_GEEK6688	leo「youlin 和 geek6688 都全給」（ISEP#115 c5541／5542，7aef943）
+v4	2026-09-01	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE,CLOUDFLARE_ACCOUNT_ID_YOULIN,YOULIN_MCP_OWNER_SECRETS,STAGE_USERNAME_YOULIN,STAGE_PASSWORD_YOULIN,CLOUDFLARE_API_TOKEN_CC_SHIPPING_CORE,CLOUDFLARE_ACCOUNT_ID_GEEK6688,UNCLE6_CF_API_KEY	出貨三站實際部署到 uncle6（ISEP#115 c5577，cb310e9）
+v5	2026-09-01	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE,CLOUDFLARE_ACCOUNT_ID_YOULIN,YOULIN_MCP_OWNER_SECRETS,STAGE_USERNAME_YOULIN,STAGE_PASSWORD_YOULIN,CLOUDFLARE_API_TOKEN_CC_SHIPPING_CORE,CLOUDFLARE_ACCOUNT_ID_GEEK6688,UNCLE6_CF_API_KEY,ARCRUN_NS_YOULIN	出貨線實例座標（Arcrun#195，dd86fef／v0.21.0）
+v6	2026-09-18	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE,CLOUDFLARE_ACCOUNT_ID_YOULIN,YOULIN_MCP_OWNER_SECRETS,STAGE_USERNAME_YOULIN,STAGE_PASSWORD_YOULIN,CLOUDFLARE_API_TOKEN_CC_SHIPPING_CORE,CLOUDFLARE_ACCOUNT_ID_GEEK6688,UNCLE6_CF_API_KEY,ARCRUN_NS_YOULIN,ARCRUN_NS_UNCLE6,GITHUB_MIRROR_TOKEN,GITHUB_ACCOUNT_NAME	雲端要能出 stage／prod：uncle6 namespace＋GitHub 鏡像兩把（InkStoneCo#98 c7739；ISEP#158）
+v7	2026-09-18	GITEA_TOKEN_CLAUDE_CODE,CLOUDFLARE_API_TOKEN_YOULIN_CC_USE,CLOUDFLARE_ACCOUNT_ID_YOULIN,YOULIN_MCP_OWNER_SECRETS,STAGE_USERNAME_YOULIN,STAGE_PASSWORD_YOULIN,CLOUDFLARE_API_TOKEN_CC_SHIPPING_CORE,CLOUDFLARE_ACCOUNT_ID_GEEK6688,UNCLE6_CF_API_KEY,ARCRUN_NS_YOULIN,ARCRUN_NS_UNCLE6,GITHUB_MIRROR_TOKEN,GITHUB_ACCOUNT_NAME,TELEGRAM_CHAT_ID,TELEGRAM_BOT_TOKEN,ISEP_DRAIN	收回雲端現行卻不在 v1–v6 的三個：TELEGRAM_CHAT_ID／TELEGRAM_BOT_TOKEN（通知出口，值在 polaris/mira/.env，點名放行）＋ISEP_DRAIN=1 固定值（leo 09-18 貼出現行雲端環境才發現漏收）

docs/cloud-session-bootstrap.md

@@ -206,6 +206,29 @@ $ curl … https://git.uncle6.me/api/v1/version                         → 200
 其餘（讀票、認領、留言、handback、寫 code、跑測試、開 PR、對 leo21c 唯讀查詢、發 Telegram、**種 secret／直推成品／POST 到 stage 實例**——走 `scripts/stage` 與 Arcrun 的 `stage-deploy-artifacts.py`）雲端全做。
 📌 這份清單的家是 `inkstone/InkStoneCo` 的 `cloud-worker.md`（票上驗收第 4 條），ISEP 只放草稿；併進去由總管做。
 
+## 雲端工人不只撿票，還要分診、組里程碑（inkstone/ISEP#159，給 `cloud-worker.md` 的草稿）
+
+leo 09-18：「它看到票時要能夠組成 milestone 提出版本，所以不只是看票，還要組票。」
+ISEP 這一半是 `scripts/ticket` 的 `triage`／`compose` 兩個動詞，與 `pick --pool` 多的兩層（見 `docs/TESTING.md` A43）。
+`cloud-worker.md` 現在寫著「🚫 不開里程碑、不改里程碑⋯⋯」——那一條要換成下面這段（**併進 InkStoneCo 由總管做**）：
+
+```
+1. 分診：`ticket triage --list`（找重複用 `--all`）。每張沒 s/* 的票讀過之後擇一：
+     ticket triage <票> --to s/backlog --why "…"      決定要做
+     ticket triage <票> --to s/triage  --why "…"      要總管／leo 判斷（方向、品味、要不要做）
+     ticket triage <票> --to s/pending --why "…"      在等外部
+     ticket triage <票> --dup-of <留下的那張> --why "…"  重複（關新的、留舊的）
+   都帶 `--name <ISEP 工人名> --sign cloud-worker`。掛 Human／指派 Leo 的票工具會擋，不必自己判。
+2. 組里程碑：已分診、彼此相關、做完能出一個可測版本的幾張 ⇒
+     ticket compose --title "<這一輪要讓什麼變成真的>" --goal "…" --due <1–60 天內>
+                    --carrier inkstone/InkStoneCo#N <前置票…> --name … --sign cloud-worker
+   載體＝既有的 InkStoneCo User Story；`ticket where` 撈不到能載這一輪的 ⇒ 先 `ticket new InkStoneCo` 補一張 US 當載體
+   （開工規約第 2 條：撈不到才是真缺口）。一張票同時只排一輪，工具會擋。
+3. 取票：`ticket pick`（ISEP_DRAIN=1 ⇒ 自帶 --pool）。組好的里程碑的前置排在散票之前；
+   可做的都抓盡時它回一張待分診的，下一步就是它印的那行 triage。
+收工條件不變：`ticket pick` 回離開碼 1。
+```
+
 ## 這張票沒動、也不會動的東西
 
 - 沒有動 `youlinhsieh/inkstoneco`（GitHub 薄殼 repo）——這個新機制**完全不需要

docs/governance/dispatch-and-reply-format.md

@@ -120,6 +120,14 @@ Task(subagent_type="isep-hand", prompt="【工單】inkstone/ISEP#86")
    有一格沒驗 ⇒ 那是 report 不是 deliver，講清楚哪一格。
 9. **改了會被載入的東西（plugin／worker／bundle）就要升版**，
    否則產物按版本號分資料夾，你的改動到不了任何人手上。
+10. **要判斷「我能不能寫進某個 repo」時，用一次無副作用的試寫探測，不要採信 API 的
+   `permissions` 欄位**——它會回 `push:false` 卻推得進去（實測見 §2.1）。用了那個欄位下結論，
+   你會去麻煩 leo 加協作者，而其實根本不必。探測法：
+   `git push --dry-run <remote> HEAD:refs/heads/<probe 分支>`（不真的建分支、無副作用），
+   或該平台等價的無副作用寫入探測。**失敗要分辨三種病，不要混成一句「不行」往錯方向查**：
+   - **掛住**＝傳輸／逾時（如 `RPC failed; GnuTLS recv error (-110)`、大檔卡到逾時）——不是權限問題
+   - **被拒**＝權限（試寫明確回 `403`／`permission denied`／`pre-receive` 拒絕）
+   - **找不到**＝repo 或分支不存在（`404`／`repository not found`）
 <!-- INJECT:END -->
 
 > 🔴 **這一段是「每次都一樣」的唯一真相源。**
@@ -128,6 +136,54 @@ Task(subagent_type="isep-hand", prompt="【工單】inkstone/ISEP#86")
 
 ---
 
+## 2.1 為什麼「能不能寫」只信試寫，不信 permissions 欄位（inkstone/ISEP#120）
+
+**§2 第 10 條的實測與理由。** 這一段不進注入（它是背景，不是每次要念的規定）——
+上面第 10 條才是要被讀到的那一行。
+
+2026-09-01 實錯（`inkstone/Arcrun#190` → comment 5805）：總管拿 Gitea API 的
+`permissions.push` 欄位判「能不能推」，得到 `false`，於是**叫 leo 去加協作者**——
+而實際上推得進去。同一把 `GITEA_TOKEN_CLAUDE_CODE`，兩種問法給相反的答案：
+
+```
+# API 怎麼說（會說謊的欄位）
+GET /api/v1/repos/Leo/arcrun-rag-bundles-staging
+  → permissions {admin:false, push:false, pull:true}
+
+# 真的試著寫（無副作用，推到 probe 分支，dry-run 不會真的建）
+git push --dry-run https://…@git.uncle6.me/Leo/arcrun-rag-bundles-staging.git \
+        HEAD:refs/heads/ship-probe-total
+  → To https://git.uncle6.me/Leo/arcrun-rag-bundles-staging.git
+     * [new branch]      HEAD -> ship-probe-total
+  → exit=0
+```
+
+leo 當場（同票）：「**沒有這個東西，現在已經有權限，而且地端用此帳號已經出貨很多次了**」。
+⇒ 那個欄位反映的是某種角色設定，不是「這一次這個動作會不會成功」。
+**只有試寫問得到後者。**
+
+### 失敗的形狀要分辨（同票 comment 5821）
+
+同一天把「push 掛住到 4 分鐘逾時」（大檔傳輸）講成「被拒絕」（權限），往錯方向查了兩輪：
+
+```
+git clone <完整歷史>                        → RPC failed; GnuTLS recv error (-110)   ← 傳輸（掛住）
+git clone --filter=blob:none --depth 1 …    → 成功，.git 409 MB                      ← 同一個 repo
+```
+
+**掛住／被拒絕／找不到是三種不同的病，混成「不行」就查不下去。**
+分辨法（可帶進派工）寫在 §2 第 10 條那三個 bullet。
+
+> 📌 掃過現存的閘與腳本（`inkstone/ISEP#120` 驗收第 2 條）：
+> **沒有任何一支在用 API 的 permissions 欄位判寫入權限——零命中。**
+> 唯一出現「permissions」字樣的地方是 Claude Code 自己的 `permissions.allow`
+> 設定白名單（`docs/permissions-allow.json`／`scripts/settings-allow-sync`），
+> 那是「這台機器准不准跑這個工具」，跟「這個 repo 能不能推」是兩件事，不在本條射程內。
+> `scripts/pr-verdict merge`、`scripts/release-ship`、`hooks/github-contact-guard.sh`
+> 都是直接動作或看 push 目標，沒有一支先去問那個欄位。
+
+---
+
 ## 3. 交件回覆 ＝ 第一行表明身份
 
 ```

docs/governance/worker-roster.md

@@ -7,7 +7,7 @@
 
 | 段 | 問題 | 為什麼一定要有 |
 |---|---|---|
-| `**負責 repo**` | 它管哪一個 repo | 派工時挑人的唯一判準；也是【身份】欄第二格 |
+| `**負責 repo**` | 它管哪個（或哪幾個）repo | 派工時挑人的唯一判準；也是【身份】欄第二格。同一件事的幾個 repo 用「、」隔開（例：`course-hand`） |
 | `## 開工前先讀` | 它要先讀什麼 | 這是**每個工人各自不同**的部分——共通規定補不了 |
 | `## 紅線` | 它不准做什麼 | 全機共通的紅線在共通規定裡；這裡只寫這個 repo 特有的 |
 | frontmatter `description` | 一句話它是誰 | `scripts/roster list` 印的就是這一行 |
@@ -39,3 +39,24 @@ bash hooks/tests/roster-guard.test.sh             # 全綠
 ```
 
 **不必改任何 hook**——名單是資料，閘讀的是這個目錄。
+
+## 新開一個 repo 之後，工人是誰在什麼時候加的（inkstone/ISEP#118）
+
+**以前的答案是「靠人記得」，所以一定會忘。** 實查 2026-09-14：org 裡 20 個 repo，
+名單只蓋到 6 個；`llm-wiki-template`（09-01 建）與 `ax-courses`（09-07 建）
+都是**第一次派工撞上 `roster-guard.sh`** 才發現沒人，而那一刻最省事的出路是
+開 `/tmp/.roster-ok-*` 例外閘繞過去——繞過去之後，下一次還是會撞。
+
+**現在的答案**：
+
+- **什麼時候**：建 repo 之後，**開第一張票後的下一個 session 開場**。
+- **誰叫**：`scripts/isep-nag`（掛在 `overdue-nag-guard.sh` 上，開場跑一次）的第 ④ 類
+  「**有票卻沒有工人的 repo**」——拿 org 的 repo 清單比對本目錄的 `負責 repo`。
+- **誰加**：總管。在這個目錄加一個工人檔，或把 repo 寫進既有工人的 `負責 repo`。
+
+判準只有兩個事實：名單上沒有人負責它、它有開著的票。
+**沒票的 repo 不叫**（封存、投影用、還沒開張的——沒有工可派，就不是缺人），
+所以這一段不會變成每天念一串不相干東西的噪音。
+**只進開場給總管看的長版，不進 Telegram**——補工人是總管的事，不吵 leo。
+
+手動看一次：`python3 scripts/isep-nag`（`--json` 裡的 `repos_without_worker`）。

docs/hooks-inventory.md

@@ -1,4 +1,4 @@
-# 62 支閘，白話盤點表
+# 65 支閘，白話盤點表
 
 > 回應 `inkstone/InkStoneCo#40`：「如果加入了，我應該可以白話文看到 hooks 的內容？」
 > 這份表就是那個「白話文」——不用點開任何 `.sh` 檔，一行看懂一支閘在管什麼。
@@ -7,10 +7,68 @@
 
 ## 一句話結論
 
-`hooks/` 底下有 **62 個 `.sh` 檔**，`hooks.json` 實際掛上 **87 條註冊**（同一支閘常被多種情境同時掛上）；
+`hooks/` 底下有 **65 個 `.sh` 檔**，`hooks.json` 實際掛上 **91 條註冊**（同一支閘常被多種情境同時掛上）；
 其中 **3 支檔案存在但沒被掛上**（2 支是待人填的空範本、1 支是刻意留著沒開的止血帶，見下面「未生效」表）。
 下面按「你會在什麼時候撞到它」分組，一支一行。
 
+> 🔢 **65 支、91 條、69 支腳本是 2026-09-19 併完 8 條分支（#30／#47／#68／#113／#119／#120／#122／#123）後在整合樹上當場數的**；以下各票註記裡的數字是各自分支當時的樹。
+
+> 📌 **`inkstone/ISEP#120`（2026-09-18，待總管定版）＋0 支、＋0 條、腳本不變**：沒加閘、沒加腳本。
+> `dispatch-format-guard.sh` 注入的共通規定（`docs/governance/dispatch-and-reply-format.md` §2）多一條第 10 條——
+> **要判斷「能不能寫進某個 repo」一律用無副作用的試寫（`git push --dry-run`），不採信 API 的 `permissions` 欄位**
+> （它會回 `push:false` 卻推得進去，實測見該檔 §2.1：`inkstone/Arcrun#190` comment 5805／5821），
+> 並把「掛住（傳輸）／被拒（權限）／找不到（不存在）」三種失敗分開。掃過現存的閘與腳本：**沒有一支在用那個欄位判寫入權限，零命中**
+> （唯一出現 `permissions` 的是 Claude Code 自己的 `permissions.allow` 白名單，另一件事）。`dispatch-format-guard.test.sh` ⑦b 驗那條規定真的被注入（52→53）。
+> **62 支、88 條、66 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝88、`ls -p scripts | grep -v / | wc -l`＝66）。
+
+> 📌 **`inkstone/ISEP#113`（2026-09-18，待總管定版）＋0 支、＋0 條、腳本不變**：沒加閘、沒加腳本。
+> `dispatch-format-guard.sh`（出路 `scripts/ticket say`）與 `factory-idle-guard.sh`（主閘＋副閘的 `scripts/ticket where`）
+> 印出來的 ticket 指令改成**絕對路徑**（`${CLAUDE_PLUGIN_ROOT}/scripts/ticket`）——收工方 cwd 常是 InkStoneCo，
+> 那裡的 `scripts/ticket` 是 2026-08-27 之前的舊複本，相對路徑貼過去會叫到它、什麼都不會發生
+> （同 `comment-carries-task-guard` ⑮／`baton-handback-guard`，`inkstone/ISEP#112`）。`baton-handback-guard` 早已是絕對路徑，本輪未動。
+> 兩支的測試各加一條在驗這件事：`dispatch-format-guard.test.sh` ⑰（52/52）、`factory-idle-guard.test.sh`（33→35）。
+
+> 📌 **`inkstone/ISEP#123`（2026-09-18，待總管定版）＋0 支、＋0 條、腳本不變（66）**：沒加閘、沒加腳本。
+> 兩支**產生「要 leo 動手的留言」的腳本**補上人閘記號 `👤`（leo 一天只看兩眼，要在一長串留言裡一眼認出「這則在等我動手」）：
+> `scripts/gitea-arm-request.sh` 貼的 ARM 請求，第一行從機器術語 `🔐 ARM 請求` 改成 `👤 Leo：回這則、貼下面那組碼，就放行這一次 —— <任務>`（🔐／nonce 照舊，nonce 仍單獨成行，`gitea-arm-check` 的比對不受影響）；
+> `scripts/ticket handback --to Leo` 的交棒留言第一行改掛 `👤 Leo：<下一步>`——**🏃 那一塊照舊留著**（`baton-handback-guard.sh` 靠留言裡有沒有 `🏃` 判斷交棒了沒，拔掉會漏擋），交回總管（`claude-code`）維持第一行 `🏃`、不掛 `👤`。
+> 掃過的其他 comment-poster 皆非「要 leo 動手」的閘、未改：`ticket decide`（拿掉 Human＝leo 已裁）、`ticket subtask/handoff`（交給下游 repo，不是 leo）、`ticket triage/compose`（規約明定不碰 Human／指派 Leo 的票）、`ticket claim`（貼工人【身份】）、`pr-verdict`／`milestone-account`（總管的結論／帳，不指派 Leo＋Human）、`gitea-arm-check`（唯讀，不貼留言）、`isep-notify` 退路留言（第一行受 `reply-identity-guard` 限定為【身份】，且它是 Telegram 發不出去的轉貼、非正式人閘）。
+> 測試：`hooks/tests/gitea-arm-check.test.sh` 16→19（離線 `ISEP_ARM_PRINT_BODY=1` 印內文驗第一行有 👤、nonce 仍單獨成行）、`scripts/test-ticket-handoff-writeback.sh` 49→54（純函式 `handback_comment_lines`：Leo→👤＋🏃 仍在、claude-code→🏃 不掛 👤）；`test-comment-carries-task-guard.sh`（29/29）與 `test-baton-handback-guard.sh`（24/24）無回歸。
+> **62 支、88 條、66 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝88、`ls -p scripts | grep -v / | wc -l`＝66）。
+
+> 📌 **`inkstone/ISEP#122`（2026-09-02 寫、09-19 併 main 時重數，待總管定版）進來兩支、＋2 條**：`kv-write-guard.sh`（B 組，
+> 2026-08-25 立於 InkStoneCo 專案版，原樣搬進來）與 `duplicate-hook-registration-guard.sh`
+> （E 組，這次新寫）。分支是在 0.21 上寫的（當時 61→63 支、84→86 條）；09-19 把 main（0.30.10）併進來之後在併完的樹上重數：**64 支、90 條、66 支腳本**，都是**在自己的樹上當場數出來的**
+> （`ls hooks/*.sh | wc -l`／`grep -c '"command":' hooks/hooks.json`），不是拿上一版加二。
+>
+> 這張票查的是「總管三次要部署被 `prod-write-guard.sh` 恆擋、蓋了戳記也放不了行」，
+> 根因不在 `prod-write-guard.sh` 本身，而在 `InkStoneCo/.claude/settings.json`
+> 還登記著一份跟 ISEP plugin 同名的舊 hook——每個 `PreToolUse` 事件都跑了**兩次**，
+> 一次性戳記被第一份消耗掉，第二份永遠看到空戳記、恆擋。實查：專案版登記著 38 支，
+> **34 支跟 plugin 完全同名同用途**（純殘骸，已從 `InkStoneCo/.claude/settings.json`
+> 刪除登記）、**3 支是已經退役的機制**（`claim-verify-police.sh`／
+> `subagent-claim-worksheet.sh`／`sdd-guard.sh`，同樣刪除）、
+> **1 支（`kv-write-guard.sh`）是專案版有、plugin 當時沒有的真閘**——原樣搬進本 repo，
+> 這就是這次 B 組新增的那一支。`duplicate-hook-registration-guard.sh` 是防復發的機械閘：
+> 下次任何專案的 `settings.json` 又長出跟 plugin 同名的登記，SessionStart 就會點名，
+> 不必再靠「戳記莫名其妙失效」這種事後除錯才發現。
+
+> 📌 **`inkstone/ISEP#159`（2026-09-18，待總管定版）＋0 支、＋0 條、腳本 65→66**：沒加閘。`scripts/ticket` 多兩個動詞
+> `triage`（沒 s/* 的票給狀態＋留說明，或當重複關掉並指回去）與 `compose`（把已分診的票組成 InkStoneCo 里程碑：載體＋前置，
+> 先全部驗過才寫）；`pick --pool` 多兩層（還沒到期的 InkStoneCo 里程碑的前置、最後是待分診的票），每一列帶 `next`。
+> `queue-drain-guard.sh` 改判準不加閘：照 pick 那一列的 `next` 印下一步（待分診的票下一步是 triage，不是 claim）。
+> `scripts/` ＋1：`test-ticket-triage.sh`。
+> **62 支、88 條、66 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝88、`ls -p scripts | grep -v / | wc -l`＝66）。
+
+> 📌 **`inkstone/ISEP#153`（2026-09-13，待總管定版）＋0 支、＋1 條**：`baton-handback-guard.sh` 多掛一條 `Stop`。
+> 背景派工時 `PostToolUse:Agent` 在工人**剛出發**就觸發，舊版當場念「收工了但棒子沒交回來」（09-13 對 ISEP#150、arcrun-rag#14 各一次，工人其實還要跑 17 分鐘）。
+> 現在送出那一刻看到 launch ack 就不查；工人交件（主對話收到 `<task-notification>` completed）時由 Stop 那半用 `tool-use-id` 對回原派工單再查，同一條線只點名一次。
+> **62 支、88 條、65 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝88、`ls -p scripts | grep -v / | wc -l`＝65）。
+
 > 🔴 **這兩個數字上一版是錯的（2026-08-26 實際數過才發現）**：本頁原本寫「43 個檔、53 條註冊」，
 > 而當時真實是 **45 個檔、55 條註冊**——中間有兩支閘進來時沒有回頭改這裡。
 > 現在的寫法是實際數出來的：
@@ -43,6 +101,25 @@
 > **62 支、87 條、62 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
 > `grep -c '"command":' hooks/hooks.json`＝87、`ls -p scripts | grep -v / | wc -l`＝62）。
 
+> 📌 **`0.30.2`（`inkstone/ISEP#150`，2026-09-13）＋0 支、＋0 條、＋3 支腳本**：新增 `scripts/isep-doctor`——
+> 講出這台每一個 Claude Code（本機 CLI／Desktop 內建）**實際有沒有載入** ISEP，判準讀 `claude plugin list --json`，不再看 settings 長相
+> （09-13 實撞：settings 的 marketplace 多了 `path` ⇒ Desktop 2.1.266 整個忽略 inkstone、CLI 2.1.220 照載入）。
+> **62 支、87 條、65 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝87、`ls -p scripts | grep -v / | wc -l`＝65）。
+
+> 📌 **`0.30.1`（`inkstone/ISEP#130`，2026-09-13）＋0 支、＋0 條**：修補 0.30.0 的抓票入口——
+> `mainline set／refresh／adopt` 讀不到任何一條 `/dependencies` 時，名單標成不完整、`set` 離開碼 3 不印 ✅、
+> 保留舊快取；否則雲端工人會拿殘缺名單 `pick` 到「抓盡」而收工（09-13 實撞：hub 票底下三張整批漏收）。
+> **62 支、87 條、62 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝87、`ls -p scripts | grep -v / | wc -l`＝62）。
+
+> 📌 **`inkstone/ISEP#150`（2026-09-13）＋0 支、＋0 條、腳本 62→65**：沒加閘。`scripts/isep-doctor` 從 plugin **外面**
+> 問這台每一個 Claude Code（CLI、Desktop 內建那一份）有沒有真的載入 ISEP——plugin 沒載入時信標自己也講不出話。
+> 判準是各自 `plugin list --json` 回報的 errors，不是設定長相（`path` 在 Desktop 2.1.266 會讓 marketplace 被忽略、CLI 2.1.220 不會）。
+> 另加兩支測試：`test-isep-doctor.sh`（離線）、`test-isep-doctor-live.sh`（真的 Claude Code、隔離 HOME）。
+> **62 支、87 條、65 支腳本是在這棵樹上當場數出來的**（`ls hooks/*.sh | wc -l`＝62、
+> `grep -c '"command":' hooks/hooks.json`＝87、`ls -p scripts | grep -v / | wc -l`＝65）。
+
 > 📌 **`inkstone/ISEP#147`（2026-09-07）＋0 支、＋1 條**：`line-needs-own-worktree.sh` 多掛 PostToolUse `Agent|Task`
 > ——教你開分身的那支閘，在線收工那一刻替你收（分支推了就 remove；沒推就點名分支與路徑，不靜默、不 force）。
 > 分身的家從「repo 旁邊」改成「repo 裡面的 `.worktrees/`」：leo 在 Finder 看到一排 `ISEP-wt-117`／`InkStoneCo-wt-112`
@@ -130,6 +207,13 @@
 > 另外描述欄的「38 支腳本」是把 `kbdb-live-exam/`／`lib/`／`patches/` 三個**目錄**也數進去了；
 > 用本頁寫死的那道指令（只數檔案）實數是 **39**。
 
+> 📌 **`inkstone/ISEP#68`（2026-09-03 寫、09-19 併 main 時重數，待總管定版）進來一支**：`unreleased-police.sh`（F 組，Stop）。
+> 分支是在 0.22.0 上寫的（當時 61→62 支、84→85 條）；09-19 把 main（0.30.10）併進來之後，
+> 在併完的樹上重新實數：**63 支、89 條、67 支腳本**（`ls hooks/*.sh | wc -l`＝63、
+> `grep -c '"command":' hooks/hooks.json`＝89、`ls -p scripts | grep -v / | wc -l`＝67；腳本多的那支是 `test-unreleased-police.sh`），
+> 不是拿上一版加一。它只掛 `Stop` 一個事件（+1 支、+1 條）——刻意不掛 `SubagentStop`：
+> subagent 交回分支、release 由總管出，在 subagent 收工逼它出貨純屬誤攔。
+
 ---
 
 ## 怎麼讀這張表
@@ -177,6 +261,7 @@
 | `mistake-needs-ticket-guard.sh` | AI 想往 `mistakes.md`（教訓紀錄）新增一條「機制可以防止」的教訓，卻沒附對應票號就擋下——沒有票號的教訓沒有人會回頭處理。 | 🛑 擋 |
 | `wiki-size-guard.sh` | AI 想**一口氣砍掉 wiki 檔一大半內容**（淨縮水超過 800 字且超過原本 45%）就擋一次——那不是一次編輯，那是一次壓縮，而**壓縮會弄丟東西，弄丟的當下沒有人會發現**。出路是走 `scripts/wiki-compress`：它逼你附票號、把壓掉了什麼寫進 `.compress-log.md`，並用內文雜湊**逐條對帳**證明沒弄丟。只是改字、加字、小修一律不碰；真要手改就在內容裡放 `wiki-compress-ok` 留痕。 | 🛑 擋（至多攔一次） |
 | `pending-changes-retired.sh` | AI 想寫東西進已經廢除的 `pending-changes.md` 檔案就擋下——這個檔案已停用，規格變更一律改開 Gitea 票。 | 🛑 擋 |
+| `kv-write-guard.sh` | AI 想新增一行「往 KV 綁定寫入」的程式碼（`大寫識別字.put(`／`.delete(`）就擋下——長效資料一律要走 KBDB API，KV 只是暫存。判準是形狀（全大寫識別字 ＋ `.put`／`.delete`），不是列名字清單；只讀（`.get`／`.list`）放行，刪除既有 KV 寫入（退休戰）也放行。真的是短命資料（session／nonce／有 TTL 的快取）在那一行尾端加 `kv-ok: <為什麼>` 留痕放行。2026-08-25 立於 InkStoneCo 專案版，`inkstone/ISEP#122` 原樣搬進本 repo。 | 🛑 擋 |
 
 > 🔴 **`sdd-guard.sh` 已於 `inkstone/ISEP#91` 退役**（原本掛在這一組）。
 > 它擋的是「動 code 檔時，`status: active` 的 SDD 不是恰好一份」。
@@ -239,9 +324,10 @@
 | `session-start-recall.sh` | 對話一開始就自動把「全局現況」（Gitea 各 repo 的票、KBDB 的藏書地圖）推到 AI 眼前，不必等它自己想到要查。 | 📝 記錄（context 注入） |
 | `scripts/settings-allow-sync --quiet` | （不是閘，是腳本）對話一開始把 ISEP 的權限白名單（`docs/permissions-allow.json`：`ticket`／`mainline`／`gate-ok`／`gitea-pr-merge`／`stage`（inkstone/ISEP#137 起，雲端對 stage 寫入的正門）五個正門工具，外加 Arcrun 的 `stage-deploy-artifacts.py`）寫進**這台機器**的 `~/.claude/settings.json`。只加不減、冪等；目標檔壞掉就不碰它、講一聲。**為什麼**：leo 09-07 親手加的四條只在本機，雲端沒有 ⇒ 同樣的動作被分類器擋（09-04 run log `permission_denials=6`）；薄殼 repo 要 D20 開閘才推得動，所以清單住 ISEP 一份、兩台各自寫進自己的家目錄（inkstone/ISEP#130）。 | 📝 記錄（寫 settings） |
 | `scripts/mainline refresh` | （不是閘，是腳本）對話一開始把**現在的主線**那條 milestone 的進度與期限更新一次，好讓每回合眼前那一行講的是今天的數字。拿不到 Gitea 就原封不動——**寧可資料舊，不要把主線弄丟**。跑一次就結束，不輪詢。成員清單（hub 里程碑裡的票＋沿相依邊跨 repo 收到的，`inkstone/ISEP#133`）**不在這裡重收**——真 Gitea 一走 19 秒；`set`／`adopt`／`refresh --members` 才重收，`pick`／`has`／focus guard 每次現問。**家目錄與 repo 那份都不在時**（雲端薄殼跑到這裡 `InkStoneCo/` 還沒 clone）先去 Gitea 讀 `inkstone/InkStoneCo` main 的 `system-dev/mainline.json` 一次寫進家目錄（`inkstone/ISEP#140`）：匿名優先、被拒才帶 token；讀不到就退回，不報錯、逾時有上限。優先序寫在 `hooks/lib/mainline.py` 檔頭。 | 📝 記錄 |
-| `overdue-nag-guard.sh` | 對話一開始就去 Gitea 撈**沒有人會叫的事**：逾期的 milestone、掛著等你的票（標「等了幾天」）、標著「有人在做」卻好幾天沒動的票；撈完用白話講出來，**有事就發 Telegram 給你**。沒東西可報時它會說「查過了，沒有」——**安靜跟壞掉長得一模一樣**。發不出去時不會靜默：它會先問這個 session 的 `prod-write-guard` 會不會擋（舊版把「發通知」誤認成「部署」），擋就改貼回票上並把原文印在眼前。只在開 session 時跑一次，**不輪詢、不掛排程**。 | 📝 記錄（context 注入 ＋ Telegram） |
+| `overdue-nag-guard.sh` | 對話一開始就去 Gitea 撈**沒有人會叫的事**：逾期的 milestone、掛著等你的票（標「等了幾天」）、標著「有人在做」卻好幾天沒動的票；撈完用白話講出來，**有事就發 Telegram 給你**。另外點名**有開著的票、工人名單上卻沒人負責的 repo**（新開 repo 後第一個開場就會叫，`inkstone/ISEP#118`）——這一類只給總管看，不發 Telegram。沒東西可報時它會說「查過了，沒有」——**安靜跟壞掉長得一模一樣**。發不出去時不會靜默：它會先問這個 session 的 `prod-write-guard` 會不會擋（舊版把「發通知」誤認成「部署」），擋就改貼回票上並把原文印在眼前。只在開 session 時跑一次，**不輪詢、不掛排程**。 | 📝 記錄（context 注入 ＋ Telegram） |
 | `wiki-size-guard.sh` | 對話一開始講出「哪幾個 wiki 檔已經沒有人讀得完了」（預設超過 1200 行就點名）。**讀不完的必讀檔，跟沒有那個檔的差別只在於它讓人以為有。** 另一半掛在寫檔上，見 B 組。 | 📝 記錄（context 注入） |
 | `skill-deploy-drift-guard.sh` | 如果「全機真正在用的 skill」跟「repo 裡版控的正本」內容對不上，就在開場講出來——避免用著一份沒人知道已經跟正本分家的舊拷貝。 | 📝 記錄 |
+| `duplicate-hook-registration-guard.sh` | 如果這個專案自己的 `.claude/settings.json` 還登記著跟 ISEP plugin 同名的舊 hook，就在開場點名是哪幾支——**同一個動作跑兩次**，多數閘只是白跑，但帶「蓋一次戳記只放行一次」語意的閘會被第一份吃光，第二份永遠看到空戳記、恆擋（`inkstone/ISEP#122` 就是這樣，2026-09-01 撞了三次才被抓到）。判準是「有沒有真的註冊」，不是「檔案存不存在」。 | 📝 記錄（context 注入） |
 
 ## F. AI 想結束這一輪、要收工的時候（Stop）
 
@@ -259,7 +345,9 @@
 | `delivery-police.sh` | AI 宣稱「這件事做完了」，卻看不到任何實測證據（畫面截圖、指令輸出、HTTP 狀態碼…）就擋下。 | 🛑 擋 |
 | `wiki-first-police.sh` | AI 做完事卻沒有把結論寫回 wiki 就想收工，就擋下——下次（或別的 AI）查 wiki 會查不到這次做過什麼。 | 🛑 擋 |
 | `unpushed-police.sh` | AI 改好的東西還留在本機、沒有真的推送出去給別人用，卻想收工，就擋下——「改對了但沒送到」跟沒改是一樣的。 | 🛑 擋 |
-| `queue-drain-guard.sh` | **在接票的 session（跑過 `ticket pick／claim／handback`，或環境設了 `ISEP_DRAIN=1`），池子裡還有現在就能抓的票，就不准收工**——它自己跑一次 `ticket pick`，有票就把票號和認領指令交回去。這是 ISEP 唯一一支看「佇列」而不是看「這回合寫了什麼」的收工閘（`inkstone/ISEP#33`：雲端三趟 run 都是做完一件、還有票就停）。做不了的票要把理由寫回票、改欄位，pick 就不再回它。跟 leo 聊天的 session 不會被咬；同一張連續指名 3 次、讀不到佇列 3 次、或一個 session 擋滿 40 次就放行並留痕，不會鎖死。 | 🛑 擋（有上限） |
+| `unreleased-police.sh` | 這個 session 改過的 repo，收工那一刻還沒**出貨**（沒有一個 release tag 收進 HEAD），就擋一次，並點名是哪個 repo、最後 commit 與最新 release 差幾筆。「改過」認的是**這個 session 期間新長出來的 commit**（不是工作區髒、不是 push），跟「出貨」用同一個單位（commit）才數得出差多少。**只在收工問一次，不是每次 commit 都吼**（leo 明說可以累積）。三種不擋：①只改了 wiki／docs（知識就地被讀，不需出版本）②repo 根目錄放了 `.isep-release-exempt`（產物／模板 repo 自己帶理由排除，不是中央手列清單）③在 `.claude/release-holds.md` 寫一行「這次先不出，因為 X」（放行且留痕，出貨後刪掉那行）。只掛 `Stop` 不掛 `SubagentStop`——subagent 交回分支、release 由總管出，在 subagent 收工逼它出貨純屬誤攔。 | 🛑 擋（至多攔一次） |
+| `queue-drain-guard.sh` | **在接票的 session（跑過 `ticket pick／claim／handback`，或環境設了 `ISEP_DRAIN=1`），池子裡還有現在就能抓的票，就不准收工**——它自己跑一次 `ticket pick`，有票就把票號和認領指令交回去。「池子」多大看環境：設了 `ISEP_DRAIN=1`（雲端工人）時 pick 會看到整個 open 票池的 `s/todo`／`s/backlog`；本機沒設時只看主線與逾期里程碑，所以總管跑過 `handback` 也不會被叫去抓票池（`inkstone/ISEP#130`）。雲端環境下可做的都抓盡、還有沒 s/* 的票時，pick 回一張待分診的，本閘照那一列印 `ticket triage …` 而不是 claim（`inkstone/ISEP#159`）。這是 ISEP 唯一一支看「佇列」而不是看「這回合寫了什麼」的收工閘（`inkstone/ISEP#33`：雲端三趟 run 都是做完一件、還有票就停）。做不了的票要把理由寫回票、改欄位，pick 就不再回它。跟 leo 聊天的 session 不會被咬；同一張連續指名 3 次、讀不到佇列 3 次、或一個 session 擋滿 40 次就放行並留痕，不會鎖死。 | 🛑 擋（有上限） |
+| `baton-handback-guard.sh` | **背景派出去的工人交件時**（主對話收到完工通知），檢查那張工單票有沒有把棒子交回來（指派／標籤／下一步三格），缺就擋一次要 AI 補。工人還在跑的時候一聲都不出（`inkstone/ISEP#153`）。同一條線只點名一次；補完三格就不再出現。前景派工的那一半在下面 H 組。 | 🛑 擋（每條線至多一次） |
 
 > 🔴 **`claim-verify-police.sh` 已於 `inkstone/ISEP#60` 移除**（連同下面原本的 G 組 `subagent-claim-worksheet.sh`）。
 > 這一對是自造的「待驗單」機制（一張沒有狀態、沒有持有人的 markdown），違反 D58：
@@ -279,7 +367,7 @@
 | `kbdb-asked-stamp.sh` | AI 真的查過 KBDB 之後，留一個時間戳——給前面 `history-first-guard.sh` 判斷「這輪有沒有先查過」用。 | 📝 記錄 |
 | `subagent-first-stamp.sh` | AI 真的派過工之後，留一個時間戳——給 `subagent-first-guard.sh` 判斷用。 | 📝 記錄 |
 | `issue-status-autoflip.sh` | AI 一派工出去，就自動把對應的 Gitea 票改成「進行中（s/doing）」，不必等人手動改標籤。 | 📝 記錄（自動改票） |
-| `baton-handback-guard.sh` | 一條派工線做完了，就去看它那張票有沒有**指派給人／標籤有沒有說它卡在哪／有沒有寫下一步**，缺哪一格就當場說出來。你關心的是：不會再有票做完了卻沒人接手，躺在那裡沒人發現。 | 📝 記錄（提醒，不擋） |
+| `baton-handback-guard.sh` | 一條派工線做完了，就去看它那張票有沒有**指派給人／標籤有沒有說它卡在哪／有沒有寫下一步**，缺哪一格就當場說出來。你關心的是：不會再有票做完了卻沒人接手，躺在那裡沒人發現。**只管前景派工**：背景派工送出的那一刻工人才剛出發，這裡不出聲，等它交件時由 F 組的 Stop 那半查（`inkstone/ISEP#153`）。 | 📝 記錄（提醒，不擋） |
 | `kbdb-evidence-stamp.sh` | AI 每次去知識庫拿資料，就記一筆「這是**搜尋**搜到的，還是**走正規檢索路徑**拿到的」。你關心的是：它等一下要拿這筆資料下結論時，有東西可以對照它走的是哪條路。 | 📝 記錄 |
 | `investigate-first-stamp.sh` | 你真的**派人去查某張票**之後，按「session ＋ 票號」留一個時間戳——給 `diagnosis-evidence-guard.sh` 判斷「這件事有沒有人查過」用。按票分而不是按 session 分：早上派人查了 A 票，不該等於解鎖了 B 票的診斷。 | 📝 記錄 |
 ## I. 你會撞到但跟「派工／收工」無關的一支（Edit·MultiEdit）
@@ -401,6 +489,7 @@ A1 缺人話、A2 表格有幽靈、C 全頁有幽靈。
 | `micromanage-guard.sh` / `irreversible-dispatch-guard.sh` / `no-ticket-no-dispatch.sh` | 各 2 次 | 各自同時掛在 `Task` 與 `Agent` 兩個矩比對名稱上——這兩個名稱應該是同一種派工動作的新舊叫法，兩個都掛保證不漏接 |
 | `worklist-guard.sh` / `self-drive-police.sh` / `self-drive-judge.sh` / `delivery-police.sh` / `wiki-first-police.sh` / `unpushed-police.sh` | 各 2 次 | 一次守「總管自己想收工」（Stop），一次守「subagent 交回工作」（SubagentStop）——同一套判準用在兩種角色身上 |
 | `search-is-not-proof-guard.sh` | 3 次 | 拿搜尋結果當證據的那個動作，可能是「貼進票裡」（Bash），也可能是「寫進派工單發包出去」（`Task`／`Agent` 兩個名稱各掛一次），三種都要接住 |
+| `baton-handback-guard.sh` | 2 次 | 同一件事的兩種收工時機：前景派工 tool 回來就是交件（PostToolUse），背景派工要等完工通知進主對話（Stop） |
 
 ❓ **這裡有一件我看不出來是刻意還是遺留、需要人判斷**：`micromanage-guard.sh`／`irreversible-dispatch-guard.sh`／`no-ticket-no-dispatch.sh`
 三支都**同時**掛在 `Task` 跟 `Agent` 這兩個矩比對名稱上。如果這兩個名稱在目前版本的 Claude Code 裡指的是「同一種派工工具呼叫」，

hooks/baton-handback-guard.sh

@@ -1,9 +1,12 @@
 #!/usr/bin/env bash
 # 管什麼: 一條派工線收工時，檢查它的工單票有沒有把棒子交回來——指派（誰該動）＋ tag（卡在哪）＋ 下一步（做什麼）三格。
 # 為什麼: 2026-08-26 那次交回寫在 comment 裡，票沒指派、tag 沒動 ⇒ 沒有任何欄位在說「這張票在等你」，棒子躺了 14 小時。撈一次看得到的只有欄位，不是留言。
-# 誤觸時怎麼關: 這條線不對應任何票 → 派工單本來就不該少了【工單】那行（no-ticket-no-dispatch.sh 管那個）；真要放行在指令裡留 `baton-ok: <理由>`（本閘只提醒不阻擋，不會擋住任何動作）。
+# 誤觸時怎麼關: 這條線不對應任何票 → 派工單本來就不該少了【工單】那行（no-ticket-no-dispatch.sh 管那個）；背景工人交件後同一條線只點名一次，補完三格就不再出現。
 #
-# baton-handback-guard.sh — 收工＝把棒子交回去（PostToolUse: Agent|Task）
+# baton-handback-guard.sh — 收工＝把棒子交回去
+#   同一件事的兩種收工時機，掛兩個事件：
+#     PostToolUse(Agent|Task)  前景派工：tool 回來＝工人交件了 ⇒ 當場查
+#     Stop                     背景派工：主對話收到 <task-notification> completed ⇒ 回合結束時查
 #
 # ── leo 2026-08-27 的原話（本閘的規格）────────────────────────────────
 #   「它把事情做完後如果要檢查後續，就要把任務指定給你並改 tag，
@@ -15,73 +18,161 @@
 #   tag  s/*        它卡在哪一段？      缺了它 → 撈得到票，但要重讀整串
 #   下一步（留言）  收下的人要做什麼？  缺了它 → 撿起棒子的人得自己重建脈絡
 #
-# ── 為什麼掛在 PostToolUse(Agent) 而不是 SubagentStop ──────────────
-#   工單票號寫在**派工單**裡（`【工單】owner/repo#N`），而派工單就是 Agent 的 tool_input。
-#   SubagentStop 拿到的 transcript 是主對話，票號要繞一圈才找得回來
-#   （見 subagent-claim-worksheet.sh 檔頭那段實撞紀錄）。
-#   同一個位置 issue-status-autoflip.sh 已經在用，形狀是驗過的。
+# ── 背景派工為什麼改到 Stop 查（inkstone/ISEP#153，09-13 兩次實撞）──────────
+#   PostToolUse:Agent 對背景派工是**送出後幾秒**就觸發（parallel-lines-cap-guard.sh 檔頭有實測時間線），
+#   那時 tool_response 是 launch ack：{"isAsync": true, "status": "async_launched", ...}
+#   （同一份物件寫在 transcript 的 toolUseResult，2026-08-24 實跡）。
+#   舊版在這一刻就查票 ⇒ 對 ISEP#150、arcrun-rag#14 各念一次「收工了但棒子沒交回來」，
+#   而兩個工人之後各跑了 17 分鐘才交件。這會教總管在工人動手前去改票（假交棒），或學會忽略本閘。
 #
-# ── 只提醒，不阻擋 ────────────────────────────────────────────────
-#   工作已經做完了，擋在這裡沒有任何東西可以被挽救；能做的是**讓總管在當下就看到缺哪一格**。
-#   同 unpushed-police.sh 的定位：exit 2 讓訊息進到模型眼前，不是 blocker。
+#   真正的交件是主 transcript 裡的 <task-notification>（<status>completed</status>），
+#   它帶著 <tool-use-id> ——**拿這個唯一識別碼回頭對上當初那一則 Agent tool_use**，
+#   從它的 prompt 取【工單】。判準是結構比對（哪一則派工），不是讀文字猜。
+#   不掛 SubagentStop：parallel-lines-cap-guard.sh 檔頭實測過它在主 session 一次都沒觸發。
+#
+# ── 只點名一次 ────────────────────────────────────────────────────
+#   Stop 回 exit 2 會讓總管多走一個回合（去補三格）。查過的 tool-use-id 記在狀態檔，之後不再查
+#   ⇒ 補完了自然安靜，沒補也不會鬼打牆。狀態檔在 ${ISEP_BATON_STATE_DIR:-${TMPDIR:-/tmp}}。
+#   前景 PostToolUse 同 unpushed-police.sh 的定位：exit 2 讓訊息進到模型眼前，不擋任何動作。
 set -uo pipefail
 
 INPUT=$(cat)
+# 訊息裡的出路一律印絕對路徑：總管的 cwd 常是 InkStoneCo，那裡的 scripts/ticket 是舊複本，
+# `grep -c handback` → 0（2026-09-13 實查）⇒ 印相對路徑＝教一條走不通的路（同 comment-carries-task-guard ⑮）。
+PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)}"
+TICKET="$PLUGIN_ROOT/scripts/ticket"
+STATE_DIR="${ISEP_BATON_STATE_DIR:-${TMPDIR:-/tmp}}"
+export ISEP_BATON_STATE_DIR="${STATE_DIR%/}"
+
+# ── 找出這一次要查的票（每行一張：owner repo num）──────────────────────
+SPECS=$(printf '%s' "$INPUT" | python3 -c '
+import sys, json, re, os
+
+TICKET = re.compile(r"([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)#(\d+)")
+
+def spec_of(prompt):
+    for line in (prompt or "").splitlines():
+        if "【工單】" not in line:
+            continue
+        m = TICKET.search(line)
+        if m:
+            return "%s %s %s" % m.groups()
+    return None
+
+def is_async_ack(resp):
+    # launch ack 兩種長相都認：結構化物件（isAsync／status），或只剩文字的 content 陣列
+    if isinstance(resp, dict) and (resp.get("isAsync") is True or resp.get("status") == "async_launched"):
+        return True
+    try:
+        return "Async agent launched" in json.dumps(resp, ensure_ascii=False)
+    except Exception:
+        return False
 
-SPEC=$(printf '%s' "$INPUT" | python3 -c '
-import sys, json, re
 try:
     d = json.load(sys.stdin)
 except Exception:
     raise SystemExit
-p = (d.get("tool_input") or {}).get("prompt") or ""
-for line in p.splitlines():
-    if "【工單】" not in line:
-        continue
-    m = re.search(r"([A-Za-z0-9_.-]+)/([A-Za-z0-9_.-]+)#(\d+)", line)
-    if m:
-        print(f"{m.group(1)} {m.group(2)} {m.group(3)}")
-        break
+
+if d.get("hook_event_name") != "Stop":
+    if is_async_ack(d.get("tool_response")):
+        raise SystemExit                  # 工人才剛出發，還沒有「收工」可言；交件時由 Stop 那半查
+    s = spec_of((d.get("tool_input") or {}).get("prompt"))
+    if s:
+        print(s)
+    raise SystemExit
+
+# ── Stop：有沒有背景工人交件 ─────────────────────────────────────────
+tp = d.get("transcript_path") or ""
+if not tp or not os.path.isfile(tp):
+    raise SystemExit
+sid = re.sub(r"[^A-Za-z0-9_.-]", "_", d.get("session_id") or "nosid")[:64]
+state = os.path.join(os.environ["ISEP_BATON_STATE_DIR"], "baton-handback-seen-%s" % sid)
+try:
+    seen = set(open(state, encoding="utf-8").read().split())
+except OSError:
+    seen = set()
+
+NOTE = re.compile(r"<tool-use-id>(toolu_[A-Za-z0-9_-]+)</tool-use-id>.*?<status>([a-z_]+)</status>", re.S)
+completed = []                             # 保留出現順序
+dispatch = {}                              # tool_use id → 帶【工單】的派工單
+try:
+    with open(tp, encoding="utf-8", errors="replace") as f:
+        for line in f:
+            if "<task-notification>" in line:
+                # 同一則通知會以 enqueue／attachment／remove 出現多次，用 id 去重
+                for tuid, st in NOTE.findall(line.replace("\\n", "\n")):
+                    if st == "completed" and tuid not in completed:
+                        completed.append(tuid)
+            if "【工單】" in line and "tool_use" in line:
+                try:
+                    e = json.loads(line)
+                except Exception:
+                    continue
+                msg = e.get("message")
+                if not isinstance(msg, dict) or msg.get("role") != "assistant":
+                    continue
+                for b in msg.get("content") or []:
+                    if (isinstance(b, dict) and b.get("type") == "tool_use"
+                            and b.get("name") in ("Agent", "Task")):
+                        p = (b.get("input") or {}).get("prompt")
+                        if isinstance(p, str) and "【工單】" in p:
+                            dispatch[b.get("id")] = p
+except OSError:
+    raise SystemExit
+
+todo = [t for t in completed if t in dispatch and t not in seen]
+if not todo:
+    raise SystemExit
+try:
+    os.makedirs(os.path.dirname(state), exist_ok=True)
+    with open(state, "a", encoding="utf-8") as f:
+        f.write("\n".join(todo) + "\n")
+except OSError:
+    pass                                   # 記不下來頂多再念一次，不擋
+out = []
+for t in todo:
+    s = spec_of(dispatch[t])
+    if s and s not in out:
+        out.append(s)
+print("\n".join(out))
 ' 2>/dev/null || true)
 
-[ -n "${SPEC:-}" ] || exit 0
-# shellcheck disable=SC2086
-set -- $SPEC
-OWNER="$1"; REPO="$2"; NUM="$3"
+[ -n "${SPECS:-}" ] || exit 0
 
-# ── 測試縫（唯一目的：讓判斷邏輯測得起來，不必每跑一次測試就在票池留一張票）──
-#   BATON_GUARD_FIXTURE=<目錄> ⇒ 讀 issue.json / comments.json，不打網路。
-#   正式執行時這個變數不存在，一行都不會走到。
-if [ -n "${BATON_GUARD_FIXTURE:-}" ]; then
-  J=$(cat "$BATON_GUARD_FIXTURE/issue.json")
-  C=$(cat "$BATON_GUARD_FIXTURE/comments.json")
-else
-# token：掃已知的 checkout 找第一個帶憑證、指向本站的 remote（同 scripts/ticket 的做法）
-ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}"
-URL=""
-for d in "$ROOT" "$ROOT/products/$REPO" "$ROOT/matrix/$REPO" "$ROOT/polaris/$REPO"; do
-  [ -e "$d/.git" ] || continue
-  U=$(git -C "$d" remote -v 2>/dev/null | grep -m1 'git\.uncle6\.me' | grep '@' | awk '{print $2}') || true
-  [ -n "${U:-}" ] && { URL="$U"; break; }
-done
-[ -n "$URL" ] || exit 0
-TOKEN=$(printf '%s' "$URL" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
-[ "$TOKEN" != "$URL" ] || exit 0
+# ── 查一張票：缺哪一格就寫到 stderr 並回 2，齊了回 0 ─────────────────────
+check_one(){ # $1 owner $2 repo $3 num
+  local OWNER="$1" REPO="$2" NUM="$3" J C REPORT BODY NOW_A NOW_L
+  # ── 測試縫（唯一目的：讓判斷邏輯測得起來，不必每跑一次測試就在票池留一張票）──
+  #   BATON_GUARD_FIXTURE=<目錄> ⇒ 讀 issue.json / comments.json，不打網路。
+  #   正式執行時這個變數不存在，一行都不會走到。
+  if [ -n "${BATON_GUARD_FIXTURE:-}" ]; then
+    J=$(cat "$BATON_GUARD_FIXTURE/issue.json")
+    C=$(cat "$BATON_GUARD_FIXTURE/comments.json")
+  else
+    # token：來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡）
+    local TOKEN _GT_LIB
+    _GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+    command -v gitea_token >/dev/null 2>&1 || return 0
+    TOKEN=$(gitea_token) || return 0
+    [ -n "$TOKEN" ] || return 0
+    J=$(curl -s --max-time 12 -H "Authorization: token $TOKEN" \
+          "https://git.uncle6.me/api/v1/repos/$OWNER/$REPO/issues/$NUM" 2>/dev/null) || return 0
+    C=$(curl -s --max-time 12 -H "Authorization: token $TOKEN" \
+          "https://git.uncle6.me/api/v1/repos/$OWNER/$REPO/issues/$NUM/comments?limit=100" 2>/dev/null) || C='[]'
+  fi
 
-J=$(curl -s --max-time 12 -H "Authorization: token $TOKEN" \
-      "https://git.uncle6.me/api/v1/repos/$OWNER/$REPO/issues/$NUM" 2>/dev/null) || exit 0
-C=$(curl -s --max-time 12 -H "Authorization: token $TOKEN" \
-      "https://git.uncle6.me/api/v1/repos/$OWNER/$REPO/issues/$NUM/comments?limit=100" 2>/dev/null) || C='[]'
-fi
-
-REPORT=$(python3 - "$J" "$C" <<'PY' 2>/dev/null
+  REPORT=$(python3 - "$J" "$C" <<'PY' 2>/dev/null
 import json, sys
 try:
     it = json.loads(sys.argv[1]); cs = json.loads(sys.argv[2])
 except Exception:
     raise SystemExit
+if not isinstance(it, dict) or "state" not in it:
+    raise SystemExit                      # 讀不到票（404／錯誤回應）⇒ 不瞎報
 if it.get("state") == "closed":
     raise SystemExit                      # 已經關了 ＝ 棒子到終點了，沒有下一手
+if not isinstance(cs, list):
+    cs = []
 miss = []
 if not (it.get("assignees") or []):
     miss.append("指派：沒有人被指到這張票 ⇒ 撈 assignee 撈不到它，等於棒子躺在地上")
@@ -100,37 +191,51 @@ print("\n".join("  ❌ " + m for m in miss))
 print("__ASSIGNEES__" + ",".join(a["login"] for a in (it.get("assignees") or [])))
 print("__LABELS__" + ",".join(labs))
 PY
-) || exit 0
+) || return 0
+  [ -n "${REPORT:-}" ] || return 0
 
-[ -n "${REPORT:-}" ] || exit 0
+  BODY=$(printf '%s' "$REPORT" | grep -v '^__')
+  NOW_A=$(printf '%s' "$REPORT" | sed -n 's/^__ASSIGNEES__//p')
+  NOW_L=$(printf '%s' "$REPORT" | sed -n 's/^__LABELS__//p')
 
-BODY=$(printf '%s' "$REPORT" | grep -v '^__')
-NOW_A=$(printf '%s' "$REPORT" | sed -n 's/^__ASSIGNEES__//p')
-NOW_L=$(printf '%s' "$REPORT" | sed -n 's/^__LABELS__//p')
-
-cat >&2 <<EOF
+  cat >&2 <<EOF
 🏃 交棒警察：$OWNER/$REPO#$NUM 這條線收工了，但**棒子沒有交回來**。
 
 現在票上：指派＝[${NOW_A:-（空）}]　標籤＝[${NOW_L:-（空）}]
 
 $BODY
 
-【leo 2026-08-27】「**每個任務結束必須要指派回總管**，要說明下一步怎麼做，
-  直到最後交出正確 deliverable 並且驗證」
-
-🔴 **關鍵在「指派」是欄位，不是文字。** 撈一次就看得到，不必讀 comment——
-   leo 自己就是用 Gitea 原生的「指派給您的」在看。
-
 【一個動作把三格補齊】
-  scripts/ticket handback $OWNER/$REPO#$NUM \\
+  "$TICKET" handback $OWNER/$REPO#$NUM \\
       --to claude-code \\
       --next "<收下的人第一件事要做什麼，一句話>" \\
       --label <s/review｜s/stage｜s/pending｜s/todo> \\
       --evidence "<實測輸出或 PR 連結>"
 
   要 leo 親手做的 → --to Leo（會自動加 Human 標籤）
-  已經真的做完且驗過了 → scripts/ticket close $OWNER/$REPO#$NUM --deliverable <URL>
+  已經真的做完且驗過了 → "$TICKET" close $OWNER/$REPO#$NUM --deliverable <URL>
 
-【撈一次看棒子在誰手上】 scripts/ticket mine
+EOF
+  return 2
+}
+
+HIT=0
+while read -r OWNER REPO NUM; do
+  [ -n "${NUM:-}" ] || continue
+  check_one "$OWNER" "$REPO" "$NUM" </dev/null
+  [ $? -eq 2 ] && HIT=1
+done <<< "$SPECS"
+
+[ "$HIT" = 1 ] || exit 0
+
+cat >&2 <<EOF
+【leo 2026-08-27】「**每個任務結束必須要指派回總管**，要說明下一步怎麼做，
+  直到最後交出正確 deliverable 並且驗證」
+
+🔴 **關鍵在「指派」是欄位，不是文字。** 撈一次就看得到，不必讀 comment——
+   leo 自己就是用 Gitea 原生的「指派給您的」在看。
+
+【撈一次看棒子在誰手上】 "$TICKET" mine
+（背景工人交件後，同一條線只點名這一次；補完三格就不會再出現。）
 EOF
 exit 2

hooks/dispatch-format-guard.sh

@@ -83,6 +83,10 @@ set -u
 
 INPUT="$(cat)"
 HERE="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+# 訊息裡的出路一律印絕對路徑：收工方的 cwd 常是 InkStoneCo，那裡的 scripts/ticket 是
+# 2026-08-27 之前的舊複本，照著相對路徑貼會叫到它（同 comment-carries-task-guard ⑮、
+# baton-handback-guard；inkstone/ISEP#112／#113）。
+TICKET="${CLAUDE_PLUGIN_ROOT:-$(cd "$HERE/.." && pwd)}/scripts/ticket"
 
 FACTS="$(printf '%s' "$INPUT" | python3 "$HERE/lib/dispatch_parse.py" dispatch 2>/dev/null)"
 [ -n "$FACTS" ] || exit 0   # parser 掛了 → fail-open（回到「沒有這支閘」的狀態）
@@ -151,7 +155,7 @@ __CARRY__
              **本閘每次派工都會自動注入給收工方**，你不必寫、也不會漏。
 
   只有這次 ⇒ **寫進那張票**（main 是哪顆、今天撞過什麼、另一條線在動什麼）
-             `scripts/ticket say <owner/repo#N> -F <檔>`
+             `"__TICKET__" say <owner/repo#N> -F <檔>`
              然後派工單寫 `【工單】<owner/repo#N> → comment <剛拿到的號碼>`
 
   🔴 **「票上還沒有」不是把它寫進 prompt 的理由——它就是「去把它寫上票」的指令。**
@@ -207,13 +211,14 @@ if t:
   fi
 
   DFG_MSG="$MSG" DFG_VIOL="$VIOL_TEXT" DFG_SESSION="$SESSION" \
-  DFG_HEAD="$HEADLINE" DFG_CARRY="$CARRY_TEXT" python3 -c '
+  DFG_HEAD="$HEADLINE" DFG_CARRY="$CARRY_TEXT" DFG_TICKET="$TICKET" python3 -c '
 import os, sys
 sys.stderr.write(
     os.environ["DFG_MSG"]
       .replace("__HEADLINE__", os.environ.get("DFG_HEAD", ""))
       .replace("__VIOLATIONS__", os.environ.get("DFG_VIOL", ""))
       .replace("__CARRY__", os.environ.get("DFG_CARRY", ""))
+      .replace("__TICKET__", os.environ.get("DFG_TICKET", "") or "scripts/ticket")
       .replace("__SESSION__", os.environ.get("DFG_SESSION", "") or "<session_id>")
     + "\n"
 )

hooks/duplicate-hook-registration-guard.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# duplicate-hook-registration-guard.sh — SessionStart：這個專案自己的 .claude/settings.json
+# 是不是還在登記一支跟 ISEP plugin 同名的舊 hook（inkstone/ISEP#122）
+#
+# 為什麼存在（2026-09-01 實撞）：
+#   總管三次要部署 uncle6.me，三次被 prod-write-guard.sh 擋。leo 問「你沒有權限？」
+#   ——不是沒權限，是 InkStoneCo/.claude/settings.json 裡還留著 ISEP 立 plugin 之前
+#   的舊登記，跟 plugin 自己的 hooks.json 同時掛在同一個事件上，於是每個 PreToolUse
+#   都跑了**兩次**：一次由專案版、一次由 plugin。多數閘只是白跑一次沒感覺，
+#   但**帶「蓋一次戳記只放行一次」語意的閘會被第一份吃光**——第二份永遠看到空的戳記，
+#   於是恆擋。查證見 ISEP#122：37 支專案版登記裡，34 支跟 plugin 完全同名同用途、
+#   3 支是已經退役的機制（`claim-verify-police.sh`／`subagent-claim-worksheet.sh`／
+#   `sdd-guard.sh`），全部清掉；剩下 1 支（`kv-write-guard.sh`）是專案版有、plugin
+#   當時沒有的真閘，已原樣搬進本 repo（同一輪 commit）。
+#
+# 🔑 這支 hook 的用途不是清除，是**讓「又長出重複掛載」這件事有人立刻知道**。
+#    上一次它能存活 13 天沒被發現，就是因為除了「戳記莫名其妙失效」以外沒有任何
+#    訊號會指出來——一支天天在跑的閘，跟一支不存在的閘，行為長得一模一樣。
+#
+# 三條設計約束（跟 skill-deploy-drift-guard.sh 同一個形狀）：
+#   1. 沒事不出聲——乾淨時完全靜音。
+#   2. 從不擋人——SessionStart 一律 exit 0，這是通知，不是閘。
+#   3. 判準是「登記在不在」，不是關鍵字——比對的是 hooks.json／settings.json
+#      裡實際出現的檔名，不是靠猜或列黑名單（isep-hand 紅線：不准用關鍵字黑名單）。
+
+set -uo pipefail
+
+ROOT="${CLAUDE_PLUGIN_ROOT:-}"
+[ -n "$ROOT" ] || exit 0
+[ -f "$ROOT/hooks/hooks.json" ] || exit 0
+
+PROJ="${CLAUDE_PROJECT_DIR:-}"
+[ -n "$PROJ" ] || exit 0
+SETTINGS="$PROJ/.claude/settings.json"
+[ -f "$SETTINGS" ] || exit 0
+
+# ISEP plugin 自己「真的註冊了」的 hook 檔名（不是目錄列表——目錄裡可能有沒掛的樣板）
+PLUGIN_NAMES="$(grep -oE 'hooks/[a-zA-Z0-9._-]+\.sh' "$ROOT/hooks/hooks.json" 2>/dev/null \
+  | sed 's|.*/||' | sort -u)"
+[ -n "$PLUGIN_NAMES" ] || exit 0
+
+# 這個專案自己的 settings.json 裡，指向 .claude/hooks/ 底下的登記
+PROJECT_NAMES="$(grep -oE '\.claude/hooks/[a-zA-Z0-9_.-]+\.sh' "$SETTINGS" 2>/dev/null \
+  | sed 's|.*/||' | sort -u)"
+[ -n "$PROJECT_NAMES" ] || exit 0
+
+DUPES="$(comm -12 <(printf '%s\n' "$PLUGIN_NAMES") <(printf '%s\n' "$PROJECT_NAMES") 2>/dev/null || true)"
+[ -n "$DUPES" ] || exit 0
+
+N=$(printf '%s\n' "$DUPES" | grep -c .)
+LIST="$(printf '%s\n' "$DUPES" | sed 's/^/   • /')"
+
+cat <<EOF
+🔁 重複掛載警報：\`$SETTINGS\` 還登記著 ${N} 支跟 ISEP plugin 同名的舊 hook。
+
+$LIST
+
+⇒ 每個對應的動作都會**跑兩次**——一次由這份專案版複本、一次由 plugin。
+   多數閘只是白跑一次；**帶「蓋一次戳記只放行一次」語意的閘會被第一份吃光**，
+   第二份永遠看到空戳記，於是恆擋——這正是 inkstone/ISEP#122 那次的形狀。
+
+出路（二選一，不是「留著沒關係」）：
+  ① 這幾支 plugin 已經覆蓋 → 從 \`$SETTINGS\` 的 hooks 區段刪掉這幾條登記。
+  ② 專案版身上還有 plugin 沒有的邏輯 → 先把那段邏輯併進 ISEP（開票、比照
+     kv-write-guard.sh 那次的搬法），plugin 升版裝上之後再刪專案版登記。
+  **不要讓兩份同時掛著**——那正是這支閘存在的理由。
+EOF
+exit 0

hooks/factory-idle-guard.sh

@@ -82,6 +82,10 @@
 set -eu
 
 PROJ="${CLAUDE_PROJECT_DIR:-$(pwd)}"
+# 訊息裡的出路一律印絕對路徑：收工方的 cwd 常是 InkStoneCo，那裡的 scripts/ticket 是
+# 2026-08-27 之前的舊複本，照著相對路徑貼會叫到它（同 comment-carries-task-guard ⑮、
+# baton-handback-guard；inkstone/ISEP#112／#113）。$0 是本檔路徑，往上一層就是 plugin 根。
+TICKET="${CLAUDE_PLUGIN_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}/scripts/ticket"
 PAYLOAD=$(cat 2>/dev/null || echo '{}')
 
 # ── 主閘：宣告了下一步，有沒有交出派工憑證？────────────────────────
@@ -263,8 +267,8 @@ leo 2026-08-16（本閘的規格）：
 
 ━━ 現在怎麼過這道閘（四條，程式碼裡都真的有對應的分支）━━━━━━━━━
   ① **現在就按 trigger**：這個回合直接呼叫 Agent／Task 派出去。
-     沒有票 → 先 \`scripts/ticket where <關鍵字>\` 搜該掛哪張，
-     再 \`ticket say <owner/repo#N> -F <檔>\`，然後帶【工單】派工。
+     沒有票 → 先 \`"$TICKET" where <關鍵字>\` 搜該掛哪張，
+     再 \`"$TICKET" say <owner/repo#N> -F <檔>\`，然後帶【工單】派工。
   ② **它已經在別人手上**：把票號寫進這段收尾文字（例：「已派給 inkstone/ISEP#30」）。
      有 \`#數字\` 就放行——那不是「我等下做」，是「已經有人在做」。
   ③ **它其實不該現在做**：寫一行說明它在等什麼，格式就是這一個標記——
@@ -294,7 +298,10 @@ for d in /private/tmp/claude-501/*/*/tasks; do
 done
 [ "$RUNNING" -gt 0 ] && exit 0
 
-TOKEN=$(git -C "$PROJ" remote get-url gitea 2>/dev/null | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|') || TOKEN=""
+# token 來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡）
+_GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+command -v gitea_token >/dev/null 2>&1 || exit 0
+TOKEN=$(gitea_token) || TOKEN=""
 [ -z "$TOKEN" ] && exit 0
 
 # 🔴 org 是 inkstone，不是 Leo（2026-08-13 搬遷；舊值讓本閘靜默失效到 08-16）
@@ -318,7 +325,7 @@ leo 2026-08-10：「你的任務是**維護 loop**，你要去拿任務派任務
   **全工廠停工你要發現，這是警訊**。」
 
 【現在該做的，不是回報，是派工】
-  1. 撈池子當場撈：\`scripts/ticket where <關鍵字>\`（或 labels=s/todo）
+  1. 撈池子當場撈：\`"$TICKET" where <關鍵字>\`（或 labels=s/todo）
   2. 照 CP 排序：\`system-dev/docs/3-specs/critical-paths/ship.md\` 是有序的六步
   3. 一次派 2–4 件平行跑；同一個 repo 不要塞兩條（會搶工作區）
   4. agent 死於環境錯誤（SSL／API）⇒ **那是要重派的訊號，不是完工**

hooks/hooks.json

@@ -126,6 +126,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/wiki-size-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/kv-write-guard.sh"
           }
         ]
       },
@@ -292,6 +296,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/wiki-size-guard.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/duplicate-hook-registration-guard.sh"
           }
         ]
       }
@@ -369,6 +377,14 @@
           }
         ]
       },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/unreleased-police.sh"
+          }
+        ]
+      },
       {
         "hooks": [
           {
@@ -377,6 +393,15 @@
             "timeout": 180
           }
         ]
+      },
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/baton-handback-guard.sh",
+            "timeout": 60
+          }
+        ]
       }
     ],
     "SubagentStop": [

hooks/issue-status-autoflip.sh

@@ -43,17 +43,12 @@ for line in p.splitlines():
 set -- $SPEC
 OWNER="$1"; REPO="$2"; NUM="$3"
 
-# token 從該 repo 的 gitea remote 取；取不到就安靜結束（不影響派工）
-for d in "$CLAUDE_PROJECT_DIR/products/$REPO" "$CLAUDE_PROJECT_DIR/matrix/$REPO" "$CLAUDE_PROJECT_DIR"; do
-  [ -d "$d/.git" ] || continue
-  URL=$(git -C "$d" remote get-url gitea 2>/dev/null) || continue
-  case "$URL" in *@*) break ;; esac
-done
-[ -n "${URL:-}" ] || exit 0
-
-TOKEN=$(printf '%s' "$URL" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
-HOST=$(printf '%s' "$URL" | sed -E 's|.*@([^/]+)/.*|\1|')
-[ "$TOKEN" != "$URL" ] || exit 0
+# token 來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽；取不到就安靜結束（不影響派工）
+_GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+command -v gitea_token >/dev/null 2>&1 || exit 0
+TOKEN=$(gitea_token) || exit 0
+[ -n "$TOKEN" ] || exit 0
+HOST="git.uncle6.me"
 
 curl -s -o /dev/null --max-time 8 \
   -X POST -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \

hooks/kv-write-guard.sh

@@ -0,0 +1,115 @@
+#!/bin/bash
+# PreToolUse hook（Write|Edit|MultiEdit）— 長效資料不准寫進 KV，一律走 KBDB API
+#
+# 【portage 記錄，inkstone/ISEP#122】本檔 2026-08-25 立於
+# `InkStoneCo/.claude/hooks/kv-write-guard.sh`（那時 ISEP 還沒吸收它），
+# 2026-09-02 原樣搬進 ISEP——它是那次盤點揪出來的**唯一一支**「專案版有、
+# plugin 沒有」的真閘（另外 3 支同名殘骸是已退役機制，直接刪掉，不搬）。
+# 搬完之後 `InkStoneCo/.claude/hooks/kv-write-guard.sh` 就是廢棄複本，
+# 待這裡升版、`/plugin update` 裝上之後即可從專案版與 settings.json 一併移除。
+#
+# 【leo 2026-08-25 立】原話（三句，一句比一句尖）：
+#   「已經禁止寫入 KV 了，這是太貴的資源，應該都去寫入 KBDB，到底寫入 KV 做什麼？」
+#   「上次刪掉一堆東西，現在又寫入，**你沒有規範嗎**」
+#   「**我強制禁止寫 SQL，要用 KBDB API，你就讓它繞過寫 KV 代替？**」
+#
+# ── 為什麼存在（2026-08-25 實查，這是本閘的正身）─────────────────────────
+# 規則早就在：`system-dev/wiki/decisions-summary.md:133`
+#     「**KV ＝暫存（cache / transient），不是長期真相源。**」
+# 而且打過一場「KV 退休戰」（同檔 254 行，SUBMISSIONS_KV 併入那一役）。
+#
+# 🔴 **但 `.claude/hooks/` 底下跟 KV 有關的閘：0 支。**
+#    ⇒ 規則被讀到了，卻沒有任何機制驗證有沒有照做——與 2026-08-25 一整天挖出來的
+#      四層 migration 缺陷、以及 08-10 抓到的 history-first／KBDB-first／stage-first
+#      **完全同一個形狀**。
+#
+# 🔴 **更糟的是 leo 指出的因果**（總管用 git 查證屬實）：
+#      禁 SQL 的牆        2026-08-07
+#      app-system.ts 誕生 2026-08-24  ← 17 天之後，**從第一行就在寫 KV**
+#    而 `kbdbFetch()` 裡的 KV 字樣是 **0** ⇒ 走 KBDB API 根本不碰 KV
+#    ⇒ 那些 KV 寫入**每一處都是繞過**，沒有一處經過知識庫。
+#    **牆立起來了，水從旁邊流走了。**
+#
+# ── 判準（封動作，不封措辭）──────────────────────────────────────────
+#   新增一行「往 KV 寫入」的程式碼  ⇒ 擋一次，要求說明它為什麼不是長效資料
+#   只是讀（.get／.list）           ⇒ 放行
+#   刪除既有的 KV 寫入（退休戰）    ⇒ 放行（那正是我們要的方向）
+#
+# ── 豁免（留痕，不是後門）────────────────────────────────────────────
+#   那一行尾端加 `kv-ok: <理由>`。
+#   合法的理由只有一種形狀：**這筆資料本來就是短命的**（session、一次性 nonce、
+#   有 TTL 的快取）。寫「暫時先這樣」「之後再搬」都不算——
+#   那是把債留給下一個人，而 2026-08-25 證明了沒人會回來還。
+set -uo pipefail
+
+payload=$(cat)
+read -r tool content file <<<"$(printf '%s' "$payload" | python3 -c "
+import json,sys
+try:
+    d=json.load(sys.stdin); ti=d.get('tool_input') or {}
+    # Write 用 content；Edit 用 new_string；MultiEdit 把每筆 new_string 串起來
+    parts=[ti.get('content') or '', ti.get('new_string') or '']
+    for e in (ti.get('edits') or []): parts.append(e.get('new_string') or '')
+    body='\n'.join(p for p in parts if p)
+    print(d.get('tool_name','') or 'x', len(body), ti.get('file_path','') or 'x')
+    sys.stderr.write(body)
+except Exception:
+    print('x 0 x')
+" 2>/tmp/.kv-guard-body)" || exit 0
+
+body=$(cat /tmp/.kv-guard-body 2>/dev/null)
+rm -f /tmp/.kv-guard-body
+[ -z "$body" ] && exit 0
+
+# 只管程式碼檔；文件、設定、測試裡提到 KV 不算違規
+case "$file" in
+  *.ts|*.js|*.mjs|*.tsx|*.jsx) ;;
+  *) exit 0 ;;
+esac
+# 閘自己、與退休戰的測試檔放行（否則永遠改不動它）
+case "$file" in
+  *kv-write-guard*|*.test.*|*/tests/*) exit 0 ;;
+esac
+
+# 命中的行：往 KV 綁定寫入，且**該行沒有 kv-ok 豁免**
+# 判準是形狀不是名字：**全大寫的 binding 後面接 .put(／.delete(**。
+# 為什麼不列名字清單（第一版就是這樣寫壞的）：名字會長出新的（下一個 KV 綁定叫什麼沒人知道），
+# 而清單只認得已知的那幾個 ⇒ 新的 KV 從清單的縫隙走過去，本閘就變成裝飾。
+# 全大寫識別字 ＋ .put/.delete 這個形狀，在 Workers 裡就是 KV（D1 沒有 .put，JS 物件用 .set）。
+hits=$(printf '%s' "$body" | grep -nE '\b[A-Z][A-Z0-9_]{1,}\.(put|delete)\(' \
+        | grep -v 'kv-ok' || true)
+[ -z "$hits" ] && exit 0
+
+cat >&2 <<EOF
+🚫 長效資料不准寫進 KV——一律走 KBDB API（leo 2026-08-25 立）
+
+leo 原話：
+「**我強制禁止寫 SQL，要用 KBDB API，你就讓它繞過寫 KV 代替？**」
+「上次刪掉一堆東西，現在又寫入，**你沒有規範嗎**」
+
+━━ 你這次要寫的 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+$(printf '%s' "$hits" | head -6 | sed 's/^/   /')
+
+━━ 為什麼擋 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+規則早就在（\`system-dev/wiki/decisions-summary.md:133\`）：
+   **KV ＝暫存（cache / transient），不是長期真相源。**
+而 2026-08-25 實查：\`.claude/hooks/\` 底下跟 KV 有關的閘 **0 支**
+⇒ 規則被讀到了，卻沒有機制驗證有沒有照做。本閘就是補那一格。
+
+🔴 **並且**：\`kbdbFetch()\` 裡的 KV 字樣是 **0**——走 KBDB API 根本不碰 KV。
+   所以「寫 KV」在這個系統裡**必定意味著繞過知識庫**，不是一種實作選擇。
+   禁 SQL 的牆 2026-08-07 立，而 app-system 2026-08-24 誕生就在寫 KV
+   ——**牆立起來了，水從旁邊流走了。**
+
+━━ 怎麼過 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  ① **本來就該走 KBDB**（絕大多數）→ 改成 KBDB API。
+     新資料類型＝seed 一列 template，資料展開成完整 record，
+     **不准打包進 metadata_json**（D91／D93）。讀 \`arcrun-kbdb-guardrails\` skill。
+  ② **這筆資料真的是短命的**（session／一次性 nonce／有 TTL 的快取）
+     → 那一行尾端加 \`kv-ok: <為什麼它是短命的>\`，留痕放行。
+  ③ **你在做的是退休戰（刪掉 KV 寫入）** → 本閘不擋刪除，只擋新增。
+
+🔴 \`kv-ok: 暫時先這樣\` / \`之後再搬\` **不算理由**——那是把債留給下一個人，
+   而 2026-08-25 已經證明了沒人會回來還。
+EOF
+exit 2

hooks/lib/gitea_token.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""gitea_token.py — 解出 Gitea 憑證（GITEA_TOKEN_CLAUDE_CODE）的唯一 Python 來源。
+
+為什麼存在（inkstone/ISEP#47）：舊法用 `git remote -v` ＋
+  `re.search(r"//[^:/]+:([^@]+)@")` 從 remote URL 抽 token ⇒ token 必須明文嵌在
+  URL 裡 ⇒ 任何印出 remote URL 的訊息（git-lfs 的 locksverify 那行）都會把它洩進
+  transcript／log。來源統一到這裡後，remote URL 才能改乾淨。
+
+這是 `scripts/lib/gitea-token.sh` 的 Python 對照——**順序刻意一致**，讓 shell 與
+Python 兩邊解出來的是同一把（兩份必然漂移，所以只留一條路：先 env、再 .env）。
+
+解析順序（先環境、後檔案——雲端只有 env、本機有 .env，兩邊都涵蓋）：
+  1) 環境變數 GITEA_TOKEN_CLAUDE_CODE，再退 GITEA_TOKEN（本機 source .env 後也在）
+  2) $CLAUDE_PROJECT_DIR/.env 的 GITEA_TOKEN_CLAUDE_CODE=
+  3) git 根目錄的 .env 的 GITEA_TOKEN_CLAUDE_CODE=
+  讀不到 → 回 None（呼叫者自己判空，不能把 None 當成功）。
+
+🔴 只回值、不印別的——絕不把 token 印進 log。
+🔴 不從 remote URL 抽 token——那正是 ISEP#47 要根除的洩漏源。
+"""
+import os
+import subprocess
+
+
+def _from_file(path):
+    """從一個 .env 檔抓 GITEA_TOKEN_CLAUDE_CODE=，去掉外圍引號。抓不到回 None。"""
+    try:
+        with open(path, encoding="utf-8", errors="replace") as f:
+            for line in f:
+                if line.startswith("GITEA_TOKEN_CLAUDE_CODE="):
+                    v = line.split("=", 1)[1].strip()
+                    if len(v) >= 2 and v[0] == v[-1] and v[0] in ("'", '"'):
+                        v = v[1:-1]
+                    return v or None
+    except OSError:
+        pass
+    return None
+
+
+def _git_root():
+    """git rev-parse --show-toplevel（跟 shell 版同一把尺）。拿不到回 None。"""
+    try:
+        out = subprocess.run(["git", "rev-parse", "--show-toplevel"],
+                             capture_output=True, text=True, timeout=20)
+        root = (out.stdout or "").strip()
+        return root or None
+    except Exception:
+        return None
+
+
+def gitea_token():
+    """回 Gitea token 字串，或 None（拿不到）。順序見模組 docstring。"""
+    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
+        v = os.environ.get(env)
+        if v:
+            return v
+    pd = os.environ.get("CLAUDE_PROJECT_DIR")
+    if pd:
+        v = _from_file(os.path.join(pd, ".env"))
+        if v:
+            return v
+    root = _git_root()
+    if root:
+        v = _from_file(os.path.join(root, ".env"))
+        if v:
+            return v
+    return None

hooks/lib/mainline.py

@@ -364,18 +364,42 @@ def collect_members(api, ms, cap=MEMBER_WALK_CAP):
     回 (members, info)：
       members  排好序的 `owner/repo#N` 清單（含已關的——進度與 `has` 都要看得到它們）
       info     {"milestone": [...], "via_deps": [...], "hub_ticket": ref|None,
-                "reached": bool, "capped": bool}
+                "reached": bool, "capped": bool, "unread": [...], "complete": bool}
     🔴 `reached=False` ＝ 連 hub 里程碑那一頁都讀不到 ⇒ 呼叫端**不要拿空清單蓋掉舊快取**
       （讀不到 ≠ 沒有成員）。
+    🔴 `unread` ＝ 讀不到 `/dependencies` 的票（重讀過仍失敗）。**只要有一張，名單就不完整**：
+      那張底下的前置全部沒收到（inkstone/ISEP#130 c6973：Gitea 握手逾時，hub 票底下三張全漏，
+      `set` 卻印 ✅）。`complete`＝reached 且沒有 unread 且沒被上限截斷——呼叫端只准在它為真時
+      把名單當成完整的寫出去。
     判準只有兩個 Gitea 事實：票的 `milestone.id` 等於錨的 id、以及相依邊。標題只拿來查詢。
     """
+    import time
     import urllib.parse
+    try:
+        retries = max(0, int(os.environ.get("ISEP_MEMBER_RETRIES", "2")))
+    except ValueError:
+        retries = 2
+    try:
+        backoff = max(0.0, float(os.environ.get("ISEP_MEMBER_BACKOFF", "2")))
+    except ValueError:
+        backoff = 2.0
+
+    def read_list(path):
+        """讀一頁清單；拿不到 list 就重讀（握手逾時常常下一次就好）。仍拿不到回 None。"""
+        for n in range(retries + 1):
+            got = api(path)
+            if isinstance(got, list):
+                return got
+            if n < retries and backoff:
+                time.sleep(backoff * (n + 1))
+        return None
+
     owner, repo, mid = ms.get("owner"), ms.get("repo"), ms.get("id")
     title = ms.get("title") or ""
     info = {"milestone": [], "via_deps": [], "hub_ticket": hub_ticket(ms),
-            "reached": False, "capped": False}
+            "reached": False, "capped": False, "unread": [], "complete": False}
     q = urllib.parse.urlencode({"state": "all", "type": "issues", "milestones": title, "limit": 100})
-    rows = api("/repos/%s/%s/issues?%s" % (owner, repo, q))
+    rows = read_list("/repos/%s/%s/issues?%s" % (owner, repo, q))
     if not isinstance(rows, list):
         return [], info
     info["reached"] = True
@@ -400,9 +424,10 @@ def collect_members(api, ms, cap=MEMBER_WALK_CAP):
         parts = split_ref(cur)
         if not parts:
             continue
-        deps = api("/repos/%s/%s/issues/%d/dependencies?limit=100" % parts)
+        deps = read_list("/repos/%s/%s/issues/%d/dependencies?limit=100" % parts)
         if not isinstance(deps, list):
-            continue                                  # 這一張讀不到：跳過它，不當成「沒有相依」以外的事
+            info["unread"].append(cur)                # 讀不到 ≠ 沒有相依：記下來，名單就不算完整
+            continue
         for d in deps:
             r = issue_ref(d)
             if not r or r in seen:
@@ -412,6 +437,7 @@ def collect_members(api, ms, cap=MEMBER_WALK_CAP):
                 break
             seen.add(r); out.append(r); queue.append(r)
             info["via_deps"].append(r)
+    info["complete"] = not info["unread"] and not info["capped"]
     return sorted(set(out)), info
 
 

hooks/lib/release_chain.py

@@ -25,9 +25,16 @@ import json
 import os
 import re
 import subprocess
+import sys
 import urllib.error
 import urllib.request
 
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+try:
+    from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
+except Exception:      # 旁邊沒有 gitea_token.py（部分部署）也要能載入——讀 tag／release 一律匿名，不靠 token
+    _gitea_token = None
+
 DEFAULT_HOST = "https://git.uncle6.me"
 DEFAULT_REPO = "inkstone/ISEP"
 MANIFEST_PATH = ".claude-plugin/plugin.json"
@@ -58,23 +65,16 @@ def tagname(v):
 
 
 def token_from_env_or_remote(host, root=None):
-    """建 release 才用得到。環境變數優先；沒有就從 remote URL 裡撈（bootstrap 會帶）。"""
+    """建 release（POST）才用得到。來源＝env／.env（ISEP#47），**不再從 remote URL 抽**——
+    那會逼 token 明文嵌在 URL 裡，任何印出 remote 的訊息都會洩一次。解析順序見
+    hooks/lib/gitea_token.py（先 env、再 $CLAUDE_PROJECT_DIR/.env、最後 git 根的 .env）。
+    `host`／`root` 參數保留給呼叫端相容，現已不參與解析。拿不到回 ""（呼叫者自己判空）。"""
+    if _gitea_token is not None:
+        return _gitea_token() or ""
+    # 退路：gitea_token.py 不在旁邊——只讀 env（仍不碰 remote URL，不重現 #47 的洩漏源）
     for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
         if os.environ.get(env):
             return os.environ[env]
-    if not root:
-        return ""
-    h = host.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if h in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
     return ""
 
 

hooks/lib/roster.py

@@ -46,7 +46,18 @@ _NAME_RE = re.compile(r"^name:\s*(.+?)\s*$", re.M)
 _DESC_RE = re.compile(r"^description:\s*(.+?)\s*$", re.M)
 # 「**負責 repo**：inkstone/ISEP」——粗體記號與全形冒號都當可選，
 # 免得改一次排版就讓名單讀不到 repo（那會靜默失效，比擋錯更難發現）。
-_REPO_RE = re.compile(r"\*{0,2}負責\s*repo\*{0,2}\s*[：:]\s*([^\s（(]+)")
+# 一個工人可以管**幾個同一件事的 repo**（inkstone/ISEP#118：課程工人同時管課件內容
+# `ax-courses`、引擎 `course_gen`、學員範本 `llm-wiki-template`）——用「、」或逗號隔開。
+# 抓到行尾或第一個括號為止，再切開；只收長得像 `owner/repo` 的片段。
+_REPO_RE = re.compile(r"\*{0,2}負責\s*repo\*{0,2}\s*[：:]\s*([^\n（(]+)")
+_REPO_SPLIT = re.compile(r"[、,，\s]+")
+
+
+def _parse_repos(body):
+    m = _REPO_RE.search(body)
+    if not m:
+        return []
+    return [p for p in _REPO_SPLIT.split(m.group(1).strip()) if "/" in p]
 
 
 def roster_dir():
@@ -81,11 +92,13 @@ def load(directory=None):
         if not m:
             continue
         dm = _DESC_RE.search(head)
-        rm = _REPO_RE.search(body)
+        repos = _parse_repos(body)
         out.append({
             "name": m.group(1).strip(),
             "description": (dm.group(1).strip() if dm else ""),
-            "repo": (rm.group(1).strip() if rm else ""),
+            # `repo` 維持字串（閘的注入、【身份】欄、one_liner 都吃它）；比對一律用 `repos`
+            "repo": "、".join(repos),
+            "repos": repos,
             "path": path,
             "body": body.strip(),
         })
@@ -113,6 +126,43 @@ def find(name, directory=None):
     return None
 
 
+def which(repo, directory=None, workers=None):
+    """這個 `owner/repo` 該派給誰 ⇒ 回工人清單（可能是空的）。大小寫不分。"""
+    want = (repo or "").strip().lower()
+    if not want:
+        return []
+    ws = workers if workers is not None else load(directory)
+    return [w for w in ws if want in (r.lower() for r in w.get("repos") or [])]
+
+
+def uncovered(repo_rows, directory=None):
+    """給 Gitea `/orgs/{org}/repos` 回來的列 ⇒ 回「**有開著的票、卻沒有工人**」的 repo。
+
+    inkstone/ISEP#118：新 repo 的工人從來沒有人負責加——建 repo 的那一刻沒有任何東西提醒，
+    要等到第一次派工撞上 roster-guard 才發現，而那時最省事的出路是開例外閘繞過去。
+
+    判準只看兩個事實，不看名字長相：
+      · 名單上**沒有**任何工人的 `負責 repo` 包含它（唯一識別碼比對，方向是放行）
+      · 它**有開著的票**（`open_issues_count > 0`，Gitea 這個數字不含 PR）
+        ⇒ 沒票的 repo（封存、投影用、還沒開張的）不叫：沒有工可派，就不是缺人
+    封存的 repo 不叫。名單讀不到 ⇒ 回 None（**不是**「全部都缺人」——那是最貴的假情報）。
+    """
+    ws = load(directory)
+    if not ws:
+        return None
+    out = []
+    for r in repo_rows or []:
+        full = (r or {}).get("full_name") or ""
+        if not full or r.get("archived"):
+            continue
+        n = int(r.get("open_issues_count") or 0)
+        if n <= 0 or which(full, workers=ws):
+            continue
+        out.append({"repo": full, "open": n})
+    out.sort(key=lambda x: (-x["open"], x["repo"]))
+    return out
+
+
 def one_liner(w):
     repo = w.get("repo") or "（跨 repo）"
     return "%-18s %-26s %s" % (w["name"], repo, w.get("description", ""))

hooks/no-ticket-no-dispatch.sh

@@ -79,10 +79,12 @@ set -- $REF
 OWNER="$1"; REPO="$2"; NUM="$3"
 
 # 拿 token（拿不到就放行——這是本地環境問題，不是派工者的錯）
-URL=$(git -C "${CLAUDE_PROJECT_DIR:-.}" remote get-url gitea 2>/dev/null || true)
-case "${URL:-}" in *@*) ;; *) exit 0 ;; esac
-TOKEN=$(printf '%s' "$URL" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
-HOST=$(printf '%s' "$URL" | sed -E 's|.*@([^/]+)/.*|\1|')
+# token 來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡）
+_GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+command -v gitea_token >/dev/null 2>&1 || exit 0
+TOKEN=$(gitea_token) || exit 0
+[ -n "$TOKEN" ] || exit 0
+HOST="git.uncle6.me"
 
 RESP=$(curl -s --max-time 15 -H "Authorization: token $TOKEN" \
   "https://$HOST/api/v1/repos/$OWNER/$REPO/issues/$NUM" 2>/dev/null || true)

hooks/pr-verdict-guard.sh

@@ -62,17 +62,12 @@ set -u
 PROJ="${CLAUDE_PROJECT_DIR:-$(pwd)}"
 PAYLOAD=$(cat 2>/dev/null || echo '{}')
 
-# ── token：同 scripts/ticket 的做法（掃 remote 找帶憑證的，再退到環境變數）──
+# ── token：來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽 ──
+# （舊法掃各 repo 的 remote 找帶憑證的網址，代表 token 得明文嵌在 URL 裡 → 會洩進 log）
 TOKEN=""
 if [ -z "${PR_VERDICT_FIXTURE:-}" ]; then
-  for d in "$PROJ" "$PROJ/products"/* "$PROJ/matrix"/* "$PROJ/polaris"/*; do
-    [ -e "$d/.git" ] || continue
-    U=$(git -C "$d" remote -v 2>/dev/null | grep -m1 'git\.uncle6\.me' | grep '@' | awk '{print $2}') || true
-    if [ -n "${U:-}" ]; then
-      T=$(printf '%s' "$U" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
-      [ "$T" != "$U" ] && { TOKEN="$T"; break; }
-    fi
-  done
+  _GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+  command -v gitea_token >/dev/null 2>&1 && TOKEN=$(gitea_token) || TOKEN=""
   [ -n "$TOKEN" ] || TOKEN="${GITEA_TOKEN_CLAUDE_CODE:-${GITEA_TOKEN:-}}"
 fi
 

hooks/queue-drain-guard.sh

@@ -33,6 +33,9 @@
 # 不用 $CLAUDE_PROJECT_DIR：雲端沒有它，21 支閘的 log 因此靜默寫進 /.claude/hooks/（ISEP#130 c6873）。
 # 狀態與 log 一律寫 ${ISEP_DRAIN_STATE_DIR:-${TMPDIR:-/tmp}}，那裡在哪台都寫得進去。
 #
+#   「池子」多大由 pick 決定：環境 ISEP_DRAIN=1 時 pick 會往下看到整個 open 票池（inkstone/ISEP#130）；
+#   本機沒設時只看主線與逾期——總管跑過 handback 不會因此被叫去抓票池。
+#
 # 迴歸測試：hooks/tests/queue-drain-guard.test.sh
 set -u
 
@@ -138,6 +141,7 @@ miss = 0
 try:
     row = json.loads(out)
     ref, title = row.get("ref"), (row.get("title") or "")[:80]
+    nxt = (row.get("next") or "").replace("\t", " ").replace("\n", " ")
 except Exception:
     save("ALLOW:unparsable")
 if not ref:
@@ -149,19 +153,21 @@ if same > MAX_SAME:
 if blocks >= MAX_BLOCKS:
     save("ALLOW:max-blocks")
 blocks += 1
-save("BLOCK:%s\t%s\t%d" % (ref, title, same))
+save("BLOCK:%s\t%s\t%d\t%s" % (ref, title, same, nxt))
 ' 2>/dev/null) || VERDICT="ALLOW:crash"
 
 case "$VERDICT" in
   BLOCK:*)
     body="${VERDICT#BLOCK:}"
-    REF=$(printf '%s' "$body" | cut -f1); TITLE=$(printf '%s' "$body" | cut -f2); N=$(printf '%s' "$body" | cut -f3)
+    REF=$(printf '%s' "$body" | cut -f1); TITLE=$(printf '%s' "$body" | cut -f2); N=$(printf '%s' "$body" | cut -f3); NEXT=$(printf '%s' "$body" | cut -f4)
+    # pick 的每一列自帶下一步（inkstone/ISEP#159）：待分診的票下一步是 triage 不是 claim——照它印，不自己猜
+    [ -z "$NEXT" ] && NEXT="python3 \"$PLUGIN_ROOT/scripts/ticket\" claim $REF --name <你的名字>"
     note "⛔ 擋下" "池子還有 $REF（第 $N 次指名）"
     cat >&2 <<MSG
 🔁 佇列警察：**這個 session 在接票，而池子裡還有一張現在就能抓的票——還不是收工的時候。**
 
   下一張：$REF　$TITLE
-  認領：python3 "$PLUGIN_ROOT/scripts/ticket" claim $REF --name <你的名字>
+  下一步：$NEXT
 
 leo 2026-09-13：「任務完成自己去拿下一個任務，幫我消化任務」。
 回報寫在票上就好，**不必在這裡寫收工摘要**——摘要等 pick 抓盡再寫一次。

hooks/tests/dispatch-format-guard.test.sh

@@ -35,7 +35,10 @@ PY
 # reply_payload <tool_name> <裝話的欄位名> <內容> [額外欄位 JSON]
 #   ISEP#88：通往 subagent 的路不只 Task／Agent 一條，每一條裝話的欄位還不一樣。
 reply_payload() {
-  python3 - "$1" "$2" "$3" "${4:-{\}}" <<'RP'
+  # 第 4 個參數沒給時要傳合法的 JSON「{}」。原本寫成 "${4:-{\}}"，bash 把它展開成字面上的 {\}
+  # （反斜線留著）⇒ json.loads 當場炸、payload 變空字串 ⇒ E 群 ㉔–㉘ 五條其實從沒送出 payload（09-19 查到）
+  local extra="${4:-}"; [ -n "$extra" ] || extra='{}'
+  python3 - "$1" "$2" "$3" "$extra" <<'RP'
 import json, sys
 tool, key, text, extra = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
 ti = {key: text}
@@ -127,6 +130,21 @@ else
   FAIL=$((FAIL+1))
 fi
 
+# 注入：§2 第 10 條的「試寫判權限＋掛住／被拒／找不到」要真的被送出去
+#       （inkstone/ISEP#120：閘教的出路本身就是這條規則，收工方沒讀文件也要拿到）
+N=$((N+1))
+if printf '%s' "$inj" | python3 -c '
+import sys, json
+c = json.load(sys.stdin)["hookSpecificOutput"]["additionalContext"]
+assert "--dry-run" in c, "沒有試寫探測法"
+assert "permissions" in c, "沒有點名那個會說謊的欄位"
+assert "掛住" in c and "被拒" in c and "找不到" in c, "三種失敗的形狀沒齊"
+' 2>/dev/null; then
+  printf '  ✅ ⑦b 注入內容帶「試寫判寫入權限＋掛住／被拒／找不到」（inkstone/ISEP#120）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ⑦b §2 第 10 條沒被注入，或三種失敗形狀缺一（收工方就拿不到那條判準）\n'; FAIL=$((FAIL+1))
+fi
+
 clean
 touch /tmp/.dispatch-ok-S-TEST
 t 0 "⑧ 明示豁免戳記在 → 放行一次" \
@@ -216,13 +234,19 @@ fi
 
 # 迴歸：訊息裡的反引號一度在別支閘被 shell 當成命令替換執行掉
 #   （2026-08-26 ask-user-question-guard：閘照擋，但**它教人怎麼解的那兩行變成空白**）
+# ⑰ 兩件事一起驗（都會讓「照著貼」失敗）：
+#   ① 反引號沒被 shell 當命令替換執行掉（出路那兩行沒變空白）——原本這條的用意
+#   ② 出路印的是**絕對路徑**的 ticket，不是相對的 `scripts/ticket`（inkstone/ISEP#113）：
+#      收工方 cwd 常是 InkStoneCo，那裡的 scripts/ticket 是舊複本（`grep -c subtask` → 0）
+#      ⇒ 相對路徑貼過去會叫到舊的、什麼都不會發生（同 comment-carries ⑮、baton 那條）
 N=$((N+1))
-if printf '%s' "$msg" | grep -q 'scripts/ticket say' \
+if printf '%s' "$msg" | grep -qE '/scripts/ticket" say' \
+   && ! printf '%s' "$msg" | grep -qE '`scripts/ticket' \
    && printf '%s' "$msg" | grep -q 'touch /tmp/.dispatch-ok-S-TEST' \
    && ! printf '%s' "$msg" | grep -qi 'is a directory\|command not found'; then
-  printf '  ✅ ⑰ 訊息原文照印：反引號沒被當命令執行，出路那兩行沒有變空白\n'; PASS=$((PASS+1))
+  printf '  ✅ ⑰ 訊息原文照印（反引號沒被執行）＋出路的 ticket 是絕對路徑，沒有相對的 scripts/ticket（ISEP#113）\n'; PASS=$((PASS+1))
 else
-  printf '  ❌ ⑰ 訊息被 shell 展開了（指令消失，或冒出 shell 錯誤）\n'
+  printf '  ❌ ⑰ 訊息被 shell 展開，或出路又印回相對路徑的 scripts/ticket（InkStoneCo 那份是舊複本）\n'
   printf '%s\n' "$msg" | sed -n '1,20p' | sed 's/^/     /'
   FAIL=$((FAIL+1))
 fi

hooks/tests/duplicate-hook-registration-guard.test.sh

@@ -0,0 +1,111 @@
+#!/usr/bin/env bash
+# duplicate-hook-registration-guard.sh 的迴歸測試（inkstone/ISEP#122）
+#
+# 這支閘的價值是「不吵的時候真的不吵，該吵的時候真的吵得出正確清單」——
+# 兩邊都要驗，而且全程用假的 plugin root／專案目錄，不碰真正的
+# InkStoneCo/.claude/ 或這台機器裝著的 ISEP plugin。
+set -u
+HOOK="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/duplicate-hook-registration-guard.sh}"
+PASS=0; FAIL=0; N=0
+
+check() { # check <說明> <輸出> <exit碼> <該出現|!不該出現>...
+  desc="$1"; out="$2"; code="$3"; shift 3; N=$((N+1)); ok=1; why=""
+  if [ "$code" != "0" ]; then ok=0; why="exit 應該是 0（這支從不擋人），實際是 $code"; fi
+  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
+}
+
+# mkroot <名字...> → 造一份假 plugin root，hooks.json 裡真的註冊這些檔名
+mkroot() {
+  d="$TMP/root-$RANDOM"; mkdir -p "$d/hooks"
+  {
+    printf '{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":['
+    first=1
+    for n in "$@"; do
+      [ "$first" = 1 ] || printf ','
+      printf '{"type":"command","command":"${CLAUDE_PLUGIN_ROOT}/hooks/%s"}' "$n"
+      first=0
+    done
+    printf ']}]}}\n'
+  } > "$d/hooks/hooks.json"
+  printf '%s\n' "$d"
+}
+
+# mkproj <名字...> → 造一份假專案目錄，settings.json 裡登記這些檔名
+mkproj() {
+  d="$TMP/proj-$RANDOM"; mkdir -p "$d/.claude"
+  {
+    printf '{"hooks":{"PreToolUse":[{"matcher":"Bash","hooks":['
+    first=1
+    for n in "$@"; do
+      [ "$first" = 1 ] || printf ','
+      printf '{"type":"command","command":"$CLAUDE_PROJECT_DIR/.claude/hooks/%s"}' "$n"
+      first=0
+    done
+    printf ']}]}}\n'
+  } > "$d/.claude/settings.json"
+  printf '%s\n' "$d"
+}
+
+run() { # run <root> <proj>
+  out=$(CLAUDE_PLUGIN_ROOT="$1" CLAUDE_PROJECT_DIR="$2" bash "$HOOK" 2>&1)
+  code=$?
+  printf '%s\x1e%s' "$out" "$code"
+}
+
+TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
+
+echo "── 該吵 ──────────────────────────────────────────────────────"
+
+R=$(mkroot prod-write-guard.sh github-contact-guard.sh)
+P=$(mkproj prod-write-guard.sh other-thing.sh)
+o=$(run "$R" "$P"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "① 專案版跟 plugin 同名一支 → 點名那一支" "$out" "$code" \
+  "重複掛載警報" "1 支" "prod-write-guard.sh" "!github-contact-guard.sh" "!other-thing.sh"
+
+R=$(mkroot a.sh b.sh c.sh)
+P=$(mkproj a.sh b.sh c.sh)
+o=$(run "$R" "$P"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "② 全部同名 → 三支都點名" "$out" "$code" "3 支" "a.sh" "b.sh" "c.sh"
+
+echo "── 不該吵（誤攔比漏擋嚴重）───────────────────────────────────"
+
+R=$(mkroot a.sh)
+P=$(mkproj z.sh)
+o=$(run "$R" "$P"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "③ 完全不重疊 → 靜音" "$out" "$code" "!重複掛載"
+
+R=$(mkroot a.sh)
+d="$TMP/proj-empty-$RANDOM"; mkdir -p "$d/.claude"; echo '{"hooks":{}}' > "$d/.claude/settings.json"
+o=$(run "$R" "$d"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "④ 專案沒登記任何 .claude/hooks/*.sh → 靜音" "$out" "$code" "!重複掛載"
+
+d="$TMP/proj-nosettings-$RANDOM"; mkdir -p "$d/.claude"
+o=$(run "$R" "$d"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "⑤ 專案根本沒有 settings.json → 靜音" "$out" "$code" "!重複掛載"
+
+o=$(CLAUDE_PROJECT_DIR="$(mkproj a.sh)" bash "$HOOK" 2>&1); code=$?
+check "⑥ 沒有 CLAUDE_PLUGIN_ROOT（不是 plugin 環境）→ 靜音" "$o" "$code" "!重複掛載"
+
+d="$TMP/root-nohooksjson-$RANDOM"; mkdir -p "$d/hooks"
+o=$(CLAUDE_PLUGIN_ROOT="$d" CLAUDE_PROJECT_DIR="$(mkproj a.sh)" bash "$HOOK" 2>&1); code=$?
+check "⑦ plugin root 沒有 hooks.json（環境不完整）→ 靜音" "$o" "$code" "!重複掛載"
+
+echo "── 判準是「登記」不是「檔案存在」──────────────────────────────"
+
+R=$(mkroot pre-write-guard.template.sh)  # 有這個檔但 hooks.json 沒收（樣板慣例）
+d="$TMP/root-unreg-$RANDOM"; mkdir -p "$d/hooks"; echo '{"hooks":{}}' > "$d/hooks/hooks.json"
+touch "$d/hooks/pre-write-guard.template.sh"
+P=$(mkproj pre-write-guard.template.sh)
+o=$(run "$d" "$P"); out="${o%$'\x1e'*}"; code="${o##*$'\x1e'}"
+check "⑧ plugin 有這個檔但沒真的註冊 → 不算重複，靜音" "$out" "$code" "!重複掛載"
+
+echo ""
+echo "── 結果：$PASS 通過 / $FAIL 失敗（共 $N）──"
+[ "$FAIL" -eq 0 ]

hooks/tests/factory-idle-guard.test.sh

@@ -181,6 +181,35 @@ echo "── 出路③ 的反面：沒寫標記就照樣擋（不准靠刪掉那
 t 2 "同一句話拿掉 ⏸ 等： 標記 ⇒ 擋" \
   'T:那批 workflow 要重打 bundle。我等你確認，這件事我不自己動。'
 
+echo
+echo "── 出路裡的 ticket 是絕對路徑，不是相對的 scripts/ticket（inkstone/ISEP#113）─"
+# 收工方的 cwd 常是 InkStoneCo，那裡的 scripts/ticket 是 2026-08-27 之前的舊複本
+# （`grep -c subtask` → 0）⇒ 相對路徑貼過去會叫到它、什麼都不會發生（同 comment-carries ⑮、
+# baton-handback）。這兩條分別驗「主閘印出來的那塊」與「整支閘的訊息裡再也沒有相對路徑」。
+N=$((N+1))
+mk "$TMP/tr-path.jsonl" 'T:我看完了。下一步我去把那支閘的誤攔補上。'
+pmsg=$(printf '{"transcript_path":"%s"}' "$TMP/tr-path.jsonl" \
+       | CLAUDE_PROJECT_DIR="$TMP" sh "$HOOK" 2>&1)
+if printf '%s' "$pmsg" | grep -qE '/scripts/ticket" where' \
+   && ! printf '%s' "$pmsg" | grep -qE '`scripts/ticket'; then
+  printf '  ✅ 主閘出路的 ticket 印絕對路徑，沒有相對的 scripts/ticket\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ 主閘出路又印回相對的 scripts/ticket ⇒ 在 InkStoneCo cwd 貼上去會叫到舊複本\n'
+  printf '%s\n' "$pmsg" | grep -n 'ticket' | sed 's/^/     /'
+  FAIL=$((FAIL+1))
+fi
+
+# 副閘（全廠停工那塊）在離線測試裡拿不到 gitea token、走不到，所以直接掃這支閘的原始碼：
+# 印出來的每一處 ticket 指令都不准是相對路徑（backtick 直接接 scripts/ticket）。
+N=$((N+1))
+if grep -n '`scripts/ticket' "$HOOK" >/dev/null 2>&1; then
+  printf '  ❌ 這支閘的訊息裡還有相對路徑的 scripts/ticket（副閘那塊漏改了）\n'
+  grep -n '`scripts/ticket' "$HOOK" | sed 's/^/     /'
+  FAIL=$((FAIL+1))
+else
+  printf '  ✅ 整支閘的訊息裡沒有任何相對路徑的 scripts/ticket（主閘＋副閘都改了）\n'; PASS=$((PASS+1))
+fi
+
 echo
 echo "── 壞輸入不准亂擋（fail-open）────────────────────────────────"
 

hooks/tests/gitea-arm-check.test.sh

@@ -180,6 +180,30 @@ grep -qE "票號.*純數字|純數字票號" /tmp/gitea-arm-test-out.$$ \
   && { echo "  ✅ 錯誤訊息點名是票號格式問題"; PASS=$((PASS+1)); } \
   || { echo "  ❌ 沒看到預期訊息："; cat /tmp/gitea-arm-test-out.$$; FAIL=$((FAIL+1)); }
 
+# ── 🔴 inkstone/ISEP#123：請求留言第一行就有人閘記號 👤 ＋「要 leo 做什麼」──
+#   leo 一天只看兩眼，他要在一長串留言裡一眼認出「這則在等我動手」。舊版第一行是
+#   `🔐 ARM 請求`（機器術語）沒有 👤 ⇒ 他認不出來。這一組離線印內文（ISEP_ARM_PRINT_BODY=1：
+#   不打網路、不讀 token、不寫本地狀態）驗第一行，不必真的等 leo、也不留任何測試票。
+echo "── 🔴 inkstone/ISEP#123：請求留言第一行有 👤 ＋「要 leo 做什麼」，nonce 仍單獨成行 ──"
+BODY_OUT=$(CLAUDE_PROJECT_DIR="$TMPPROJ" ISEP_ARM_PRINT_BODY=1 "$REQ" 41 "出 prod：demo" 30 2>/dev/null)
+FIRST=$(printf '%s\n' "$BODY_OUT" | head -1)
+case "$FIRST" in
+  "👤"*) echo "  ✅ 第一行以 👤 開頭（等 leo 動手一眼認得出）：$FIRST"; PASS=$((PASS+1)) ;;
+  *)     echo "  ❌ 第一行沒有 👤（leo 認不出這則在等他）：$FIRST"; FAIL=$((FAIL+1)) ;;
+esac
+if printf '%s' "$FIRST" | grep -qE "貼|放行|解鎖"; then
+  echo "  ✅ 第一行講得出「要 leo 做什麼」（不是只有記號與機器術語）"; PASS=$((PASS+1))
+else
+  echo "  ❌ 第一行只有記號、沒說要做什麼：$FIRST"; FAIL=$((FAIL+1))
+fi
+# 🔴 nonce 仍要單獨成行：gitea-arm-check 靠「leo 回覆的留言含這組 nonce」比對，
+#    把 nonce 併進句子裡不會壞比對，但單獨成行是 leo 複製貼上最不會出錯的形狀。
+if printf '%s\n' "$BODY_OUT" | grep -qE '^ARM-[0-9a-f]+$'; then
+  echo "  ✅ nonce 仍單獨成行（arm-check 比對照舊）"; PASS=$((PASS+1))
+else
+  echo "  ❌ nonce 不再單獨成行："; printf '%s\n' "$BODY_OUT"; FAIL=$((FAIL+1))
+fi
+
 # ── 🔴 2026-08-16 新增：repo 可指定，但 owner 絕不可 ──────────────────
 echo "── 🔴 gitea-arm-common：repo 可由參數指定，owner 是安全邊界不給指定 ──"
 ( . "$PROJ/scripts/lib/gitea-arm-common.sh" >/dev/null 2>&1

hooks/tests/gitea-arm-to-github-armed.test.sh

@@ -0,0 +1,127 @@
+#!/usr/bin/env bash
+# gitea-arm-to-github-armed.sh 的迴歸測試——**保險寫在哪，讀的人就要在哪讀得到**。
+#
+# 🔴 它在守什麼（inkstone/ISEP#156，2026-09-17 實撞，inkstone/arcrun-rag#202）：
+#   ISEP 以 plugin 形式裝在 `~/.claude/plugins/cache/inkstone/isep/<ver>/`，
+#   舊版用 `ROOT=$(dirname $0)/..` 決定 `.github-armed` 寫在哪
+#   ⇒ 保險被寫進 **plugin 快取資料夾**；而出貨線（ship.mjs → d20-guard.mjs）
+#     與每一支讀它的閘（main-and-prod-push-guard／github-contact-guard／stage-before-prod-guard）
+#     讀的都是**專案根**（`${CLAUDE_PROJECT_DIR:-$(pwd)}`）
+#   ⇒ leo 在票上回了碼、腳本印「✅ 保險已解」，出貨照樣卡住。
+#   **比單純失敗更糟：它對 leo 說謊。**
+#
+# 判準是「要求某個東西在場」：保險檔必須出現在讀的人會讀的那個位置，
+# 並且**真的被那些讀的人認得**（不是只驗檔案存在）。
+#
+# 全程離線：`gitea-arm-check.sh` 的核准本身（Leo 真的回覆）必須打真的 Gitea，
+# 那部分由 gitea-arm-check.test.sh 與 inkstone/InkStoneCo#34 的人工實測負責。
+# 這裡把「核准成功」換成 stub，**只驗核准之後保險落在哪、被不被認得**；
+# fail-closed 那條則用**真的** check（無待核請求 → 本地就擋，不碰網路）。
+#
+# 用法：bash hooks/tests/gitea-arm-to-github-armed.test.sh .
+set -u
+REPO="$(cd "${1:?用法: $0 <ISEP repo 根目錄>}" && pwd)"
+SRC="$REPO/scripts/gitea-arm-to-github-armed.sh"
+[ -f "$SRC" ] || { echo "❌ 找不到 $SRC（參數要傳 ISEP repo 根目錄）"; exit 1; }
+
+T=$(mktemp -d)
+trap '[ -n "${KEEP:-}" ] && echo "保留 $T" || rm -rf "$T"' EXIT
+
+# ── 造一個長得像 plugin 快取的安裝位置，與一個長得像 InkStoneCo 的專案根 ──
+PLUG="$T/.claude/plugins/cache/inkstone/isep/9.9.9"
+PROJ="$T/InkStoneCo"
+mkdir -p "$PLUG/scripts/lib" "$PROJ" "$T/elsewhere"
+cp "$SRC" "$PLUG/scripts/"
+cp "$REPO/scripts/lib/gitea-arm-common.sh" "$PLUG/scripts/lib/"
+cp "$REPO/scripts/gitea-arm-request.sh" "$PLUG/scripts/" 2>/dev/null
+# stub：扮演「leo 已在票上核准」——輸出格式照 gitea-arm-check.sh 成功時的 `ARMED: <mission>`
+cat > "$PLUG/scripts/gitea-arm-check.sh" <<'STUB'
+#!/bin/sh
+[ "${1:-}" = "--consume" ] || { echo "stub: 應該帶 --consume" >&2; exit 1; }
+echo "ARMED: 測試出貨 ISEP#156"
+STUB
+chmod +x "$PLUG/scripts/"*.sh
+
+PASS=0; FAIL=0
+ok(){ echo "  ✅ $1"; PASS=$((PASS+1)); }
+ng(){ echo "  ❌ $1"; FAIL=$((FAIL+1)); }
+chk(){ if eval "$2"; then ok "$1"; else ng "$1"; fi; }
+
+echo "── ① 從 plugin 路徑執行，CLAUDE_PROJECT_DIR 指向專案根（總管 session 的實際形狀）──"
+( cd "$T/elsewhere" && CLAUDE_PROJECT_DIR="$PROJ" sh "$PLUG/scripts/gitea-arm-to-github-armed.sh" ) >"$T/out1" 2>&1
+rc=$?
+chk "離開碼 0" '[ $rc -eq 0 ]'
+chk "★ 專案根出現 .github-armed" '[ -f "$PROJ/.github-armed" ]'
+chk "★ plugin 快取資料夾裡沒有 .github-armed（09-17 實撞的位置）" '[ ! -e "$PLUG/.github-armed" ]'
+chk "cwd 也沒有被寫（不是靠碰巧站對位置）" '[ ! -e "$T/elsewhere/.github-armed" ]'
+chk "印出的「提前上保險」路徑就是真正寫下的那份" 'grep -qF "rm $PROJ/.github-armed" "$T/out1"'
+chk "第 1 行是未來的到期 epoch" '[ "$(sed -n 1p "$PROJ/.github-armed")" -gt "$(date +%s)" ]'
+chk "第 2 行帶任務說明" '[ "$(sed -n 2p "$PROJ/.github-armed")" = "測試出貨 ISEP#156" ]'
+
+echo "── ② 讀的人真的認得這份保險（不是只驗檔案存在）──"
+# ②a 出貨線：ship.mjs 的 prod --confirm preflight 呼叫的就是 d20-guard.mjs 的 checkArmed(INKSTONE_ROOT)
+D20=""
+for c in "${INKSTONE_ROOT:-}" "$REPO/../InkStoneCo" "$REPO/../../InkStoneCo" "$HOME/Documents/tech_projects/InkStoneCo"; do
+  [ -n "$c" ] && [ -f "$c/products/arcrun-rag/installer/scripts/d20-guard.mjs" ] \
+    && { D20="$(cd "$c" && pwd)/products/arcrun-rag/installer/scripts/d20-guard.mjs"; break; }
+done
+if [ -n "$D20" ] && command -v node >/dev/null 2>&1; then
+  node --input-type=module -e "
+    const { checkArmed } = await import(process.argv[1]);
+    const r = checkArmed(process.argv[2]);
+    console.log('checkArmed OK mission=' + r.mission);
+  " "$D20" "$PROJ" >"$T/out2" 2>&1
+  rc=$?
+  chk "★ ship.mjs 的 checkArmed(專案根) 認得（$(head -1 "$T/out2")）" '[ $rc -eq 0 ]'
+  node --input-type=module -e "
+    const { checkArmed } = await import(process.argv[1]);
+    checkArmed(process.argv[2]);
+  " "$D20" "$PLUG" >/dev/null 2>&1
+  rc=$?
+  chk "對照：checkArmed(plugin 快取) 讀不到 ⇒ 上一條有鑑別力" '[ $rc -ne 0 ]'
+else
+  echo "  ⏭️ SKIP 找不到 arcrun-rag 的 d20-guard.mjs 或 node（不算失敗，也不算驗過）"
+fi
+
+# ②b 閘：同一個位置（`${CLAUDE_PROJECT_DIR:-$(pwd)}/.github-armed`）
+mk(){ python3 -c "import json,sys;print(json.dumps({'tool_name':'Bash','tool_input':{'command':sys.argv[1]},'cwd':sys.argv[2]}))" "$1" "$T/elsewhere"; }
+gate(){ # gate <hook> <cmd> <CLAUDE_PROJECT_DIR> → 回 hook 離開碼
+  mk "$2" | ( cd "$T/elsewhere" && env -u CLAUDE_CODE_CHILD_SESSION CLAUDE_PROJECT_DIR="$3" bash "$1" ) >/dev/null 2>&1
+}
+# 閘會寫 github-contact-log／狀態目錄——一律寫進暫存的專案根，不碰真的 InkStoneCo
+mkdir -p "$PROJ/system-dev/docs/3-specs/autonomy-dispatch" "$T/empty/system-dev/docs/3-specs/autonomy-dispatch"
+WR="npx wrangler deploy"
+GH="git push https://github.com/example/example.git main"
+gate "$REPO/hooks/main-and-prod-push-guard.sh" "$WR" "$PROJ"; rc=$?
+chk "★ main-and-prod-push-guard：保險在專案根 ⇒ wrangler deploy 放行" '[ $rc -ne 2 ]'
+gate "$REPO/hooks/main-and-prod-push-guard.sh" "$WR" "$T/empty"; rc=$?
+chk "對照：沒有保險 ⇒ 同一條被擋" '[ $rc -eq 2 ]'
+gate "$REPO/hooks/github-contact-guard.sh" "$GH" "$PROJ"; rc=$?
+chk "★ github-contact-guard：保險在專案根 ⇒ push github 放行" '[ $rc -ne 2 ]'
+gate "$REPO/hooks/github-contact-guard.sh" "$GH" "$T/empty"; rc=$?
+chk "對照：沒有保險 ⇒ 同一條被擋" '[ $rc -eq 2 ]'
+
+echo "── ③ 沒設 CLAUDE_PROJECT_DIR（leo 在終端機）⇒ 跟閘一樣退回 cwd ──"
+rm -f "$PROJ/.github-armed"
+( cd "$PROJ" && env -u CLAUDE_PROJECT_DIR sh "$PLUG/scripts/gitea-arm-to-github-armed.sh" ) >"$T/out3" 2>&1
+rc=$?
+chk "離開碼 0" '[ $rc -eq 0 ]'
+chk "寫在 cwd（專案根），不在 plugin 快取" '[ -f "$PROJ/.github-armed" ] && [ ! -e "$PLUG/.github-armed" ]'
+
+echo "── ④ fail-closed：沒拿到核准就一個檔都不寫（用真的 check，不碰網路）──"
+rm -f "$PROJ/.github-armed" "$PLUG/.github-armed"
+cp "$REPO/scripts/gitea-arm-check.sh" "$PLUG/scripts/gitea-arm-check.sh"
+printf 'GITEA_TOKEN_CLAUDE_CODE=test-token-not-real\n' > "$PROJ/.env"
+( cd "$T/elsewhere" && CLAUDE_PROJECT_DIR="$PROJ" sh "$PLUG/scripts/gitea-arm-to-github-armed.sh" ) >"$T/out4" 2>&1
+rc=$?
+chk "沒有待核請求 ⇒ 離開碼非 0" '[ $rc -ne 0 ]'
+chk "專案根與 plugin 快取都沒有 .github-armed" '[ ! -e "$PROJ/.github-armed" ] && [ ! -e "$PLUG/.github-armed" ]'
+# 出路要走得通：訊息印的那支 request 腳本必須是真的存在的絕對路徑
+# （相對的 `scripts/…` 會對貼上那個人的 cwd 解析，站在 InkStoneCo 會叫到舊複本——ISEP#112 同一個病）
+# 取「本檔自己印的」那一行（⛔ 之後）；中文冒號不是空白，所以用「⛔ 之後第一個以 / 開頭的 token」
+REQ=$(sed -n '/⛔/,$p' "$T/out4" | grep -oE '[^[:space:]：]*gitea-arm-request\.sh' | grep '^/' | head -1)
+chk "★ 出路印的是存在的絕對路徑（印出：${REQ:-無}）" '[ -n "$REQ" ] && [ -f "$REQ" ]'
+
+echo
+echo "通過 $PASS 條，失敗 $FAIL 條"
+[ "$FAIL" -eq 0 ]

hooks/tests/isep-presence-beacon.test.sh

@@ -25,6 +25,8 @@ mkplugin() {
   cp "$HOOK" "$d/hooks/$(basename "$HOOK")"
   cp "$REAL_HOOKS/lib/beacon_report.py" "$d/hooks/lib/beacon_report.py"
   cp "$REAL_HOOKS/lib/release_chain.py" "$d/hooks/lib/release_chain.py"
+  # release_chain 現在會 import gitea_token（ISEP#47 唯一 token 來源）；一起造出來才是真實的 plugin 樣子
+  cp "$REAL_HOOKS/lib/gitea_token.py" "$d/hooks/lib/gitea_token.py"
   printf '#!/bin/sh\necho real\n' > "$d/scripts/ticket"
   # inkstone/ISEP#122：會自動載入的東西（skill／command／agent）也要造得出來
   mkdir -p "$d/skills/demo" "$d/commands" "$d/agents" "$d/docs"

hooks/tests/kv-write-guard.test.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# kv-write-guard.sh 的迴歸測試（inkstone/ISEP#122 搬進 ISEP 時補上——
+# 原檔 2026-08-25 立於 InkStoneCo 專案版，搬過來之前沒有自動化測試）。
+set -u
+HOOK="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/kv-write-guard.sh}"
+PASS=0; FAIL=0; N=0
+
+# run <tool> <file_path> <content>  → 送一個 Write 事件的 payload
+run() {
+  python3 -c '
+import json,sys
+tool, fp, content = sys.argv[1], sys.argv[2], sys.argv[3]
+print(json.dumps({"tool_name": tool, "tool_input": {"file_path": fp, "content": content}}))
+' "$1" "$2" "$3" | bash "$HOOK" 2>&1
+  echo "EXIT:$?"
+}
+
+check() { # check <說明> <輸出+EXIT行> <該擋(2)|該放行(0)> <該出現|!不該出現>...
+  desc="$1"; out="$2"; want="$3"; shift 3
+  code="$(printf '%s\n' "$out" | grep -oE 'EXIT:[0-9]+' | tail -1 | cut -d: -f2)"
+  N=$((N+1)); ok=1; why=""
+  if [ "$code" != "$want" ]; then ok=0; why="要 exit $want，實際 $code"; fi
+  for w in "$@"; do
+    case "$w" in
+      "!"*) if printf '%s' "$out" | grep -qF -- "${w#!}"; then ok=0; why="$why 不該出現卻出現：${w#!}"; fi ;;
+      *)    if ! printf '%s' "$out" | grep -qF -- "$w"; then ok=0; why="$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 "── 該擋：往 KV binding 寫入 ──────────────────────────────────"
+out=$(run "Write" "src/app-system.ts" $'export async function save() {\n  await MY_KV.put("k", "v");\n}')
+check "① 全大寫 binding.put( → 擋" "$out" 2 "長效資料不准寫進 KV" "MY_KV"
+
+out=$(run "Edit" "src/app-system.ts" $'const x = 1;\nSESSION_KV.delete(id);')
+check "② .delete( 一樣擋" "$out" 2 "長效資料不准寫進 KV"
+
+echo "── 不該擋（誤攔比漏擋嚴重）───────────────────────────────────"
+
+out=$(run "Write" "src/app-system.ts" 'const v = await MY_KV.get("k");')
+check "③ 只是讀（.get）→ 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+out=$(run "Write" "src/app-system.ts" 'MY_KV.put("k", v); // kv-ok: session nonce，有 TTL')
+check "④ 加了 kv-ok 豁免留痕的那行 → 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+out=$(run "Write" "README.md" 'MY_KV.put("k", "v")')
+check "⑤ 非程式碼檔（.md）→ 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+out=$(run "Write" "src/kv-write-guard.test.ts" 'MY_KV.put("k", "v")')
+check "⑥ 閘自己的測試檔 → 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+out=$(run "Write" "src/app-system.ts" 'const config = { retries: 3 };')
+check "⑦ 完全不提 KV 的一般程式碼 → 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+out=$(run "Write" "src/app-system.ts" 'this.myKv.put("k", "v"); // 小寫 binding，不是本閘要的形狀')
+check "⑧ 小寫變數名（不是「全大寫識別字」形狀）→ 放行" "$out" 0 "!長效資料不准寫進 KV"
+
+echo ""
+echo "── 結果：$PASS 通過 / $FAIL 失敗（共 $N）──"
+[ "$FAIL" -eq 0 ]

hooks/tests/mainline-members-by-dependency.test.sh

@@ -95,7 +95,14 @@ class H(BaseHTTPRequestHandler):
             r = "%s/%s#%s" % m.groups()[:3]
             if r not in w["issues"]: return self._send(404, {"message": "not found"})
             if not m.group(4): return self._send(200, issue_obj(w, r))
-            if m.group(4) == "/dependencies": return self._send(200, [issue_obj(w, c) for c in w["deps"].get(r, [])])
+            if m.group(4) == "/dependencies":
+                # inkstone/ISEP#130 c6973：Gitea 握手逾時時，票本身讀得到、它的 /dependencies 讀不到
+                fo = os.path.join(TMP, "depsfail-once"); ff = os.path.join(TMP, "depsfail")
+                if os.path.exists(fo) and r in open(fo).read().split():
+                    os.remove(fo); return self._send(500, {"message": "handshake timed out (test, once)"})
+                if os.path.exists(ff) and r in open(ff).read().split():
+                    return self._send(500, {"message": "handshake timed out (test)"})
+                return self._send(200, [issue_obj(w, c) for c in w["deps"].get(r, [])])
             return self._send(200, [issue_obj(w, pr) for pr, cs in w["deps"].items() if r in cs])
         return self._send(404, {"message": "not found", "path": p})
     def do_POST(self):
@@ -299,6 +306,38 @@ OUT=$(ml refresh --members); RC=$?
 [ "$RC" = 0 ] && [ "$(members)" = "$BEFORE" ] && ok "㊻ Gitea 回 500 ⇒ refresh --members 不炸、成員一張不少（讀不到 ≠ 沒有成員）" || no "㊻ 成員被清掉或炸了" "$RC $OUT / $(members)"
 rm -f "$TMP/down"
 
+echo "── F. 讀不到任何一條 /dependencies ⇒ 不准寫出一份看起來完整的名單（inkstone/ISEP#130 → c6973）──"
+jget(){ python3 -c "import json,sys; d=json.load(open(sys.argv[1])); v=d.get(sys.argv[2]); print(v if not isinstance(v,list) else ' '.join(v))" "$ISEP_COUNTDOWN_STATE_DIR/mainline.json" "$1"; }
+export ISEP_MEMBER_BACKOFF=0
+printf 'inkstone/InkStoneCo#44\n' > "$TMP/depsfail"
+OUT=$(ml set inkstone/Arcrun#48 --hub inkstone/InkStoneCo#44); RC=$?
+[ "$RC" != 0 ] && ok "F1 hub 票的 /dependencies 讀不到 ⇒ set 離開碼非 0（實際 $RC）" || no "F1 set 當成成功" "$RC $OUT"
+printf '%s' "$OUT" | grep -q '✅' && no "F2 名單不完整卻印 ✅（c6973 重現的就是這個）" "$OUT" || ok "F2 名單不完整時不印 ✅"
+case "$OUT" in *"成員不完整"*"inkstone/InkStoneCo#44"*) ok "F3 訊息講出「成員不完整」並點名讀不到的是哪一張" ;; *) no "F3 沒講不完整／沒點名" "$OUT" ;; esac
+[ "$(jget members_complete)" = "False" ] && ok "F4 寫出去的主線檔標 members_complete=false（讀檔的人也看得出）" || no "F4 檔案沒標不完整" "$(cat "$ISEP_COUNTDOWN_STATE_DIR/mainline.json")"
+case " $(jget members_unread) " in *" inkstone/InkStoneCo#44 "*) ok "F5 members_unread 列出讀不到的票" ;; *) no "F5 沒列" "$(jget members_unread)" ;; esac
+[ "$(jget ref)" = "inkstone/Arcrun#48" ] && ok "F6 主線本身照樣標定（壞的只有成員那一格）" || no "F6 主線沒標上" "$(jget ref)"
+OUT=$(python3 "$TICKET" pick --mainline "$ISEP_COUNTDOWN_STATE_DIR/mainline.json" 2>&1); RC=$?
+[ "$RC" != 1 ] && ok "F7 同樣讀不到時 ticket pick 不回離開碼 1（不會讓 queue-drain-guard 當成抓盡；實際 $RC）" || no "F7 pick 回了「抓盡」" "$OUT"
+rm -f "$TMP/depsfail"
+
+printf 'inkstone/InkStoneCo#44\n' > "$TMP/depsfail-once"
+OUT=$(ml set inkstone/Arcrun#48 --hub inkstone/InkStoneCo#44); RC=$?
+[ "$RC" = 0 ] && printf '%s' "$OUT" | grep -q '✅' && ok "F8 只逾時一次 ⇒ 重讀一次就完整，set 照常 ✅" || no "F8 沒重試" "$RC $OUT"
+case " $(members) " in *" inkstone/arcrun-rag#104 "*) ok "F9 重讀後 hub 票底下的 arcrun-rag#104 收到了" ;; *) no "F9 還是漏收" "$(members)" ;; esac
+[ "$(jget members_complete)" = "True" ] && ok "F10 完整時 members_complete=true" || no "F10 完整卻沒標" "$(jget members_complete)"
+
+OUT=$(ml refresh --members); RC=$?
+case "$OUT" in *"成員"*"張"*) ok "F11 refresh --members 讀得到時會印出成員張數（c6973：原本零輸出）" ;; *) no "F11 refresh --members 還是零輸出" "$OUT" ;; esac
+BEFORE=$(members)
+printf 'inkstone/InkStoneCo#44\n' > "$TMP/depsfail"
+OUT=$(ml refresh --members); RC=$?
+[ "$RC" = 0 ] && ok "F12 refresh --members 讀不到也不炸（SessionStart 那條不准炸）" || no "F12 炸了" "$RC $OUT"
+[ "$(members)" = "$BEFORE" ] && ok "F13 不完整時保留舊快取，不拿殘缺名單蓋掉" || no "F13 快取被蓋掉" "$BEFORE → $(members)"
+case "$OUT" in *"成員不完整"*) ok "F14 refresh --members 講出成員不完整" ;; *) no "F14 靜默" "$OUT" ;; esac
+rm -f "$TMP/depsfail"
+unset ISEP_MEMBER_BACKOFF
+
 echo "── E. milestone-account 的帳本落在會被 clone 走的地方（票上驗法第 3 條）──"
 OUT=$(CLAUDE_PROJECT_DIR="$SHELL_ROOT" python3 "$ACCOUNT" ledger-path 2>&1)
 [ "$OUT" = "$HUB/system-dev/estimates/ledger.jsonl" ] && ok "㊼ 雲端薄殼形狀（\$CLAUDE_PROJECT_DIR 是薄殼根、真身在 InkStoneCo/）⇒ 帳本在 InkStoneCo/system-dev/estimates/" || no "㊼ 帳本路徑不對" "$OUT"
@@ -306,7 +345,7 @@ OUT=$(cd "$HUB" && env -u CLAUDE_PROJECT_DIR python3 "$ACCOUNT" ledger-path 2>&1
 [ "$OUT" = "$HUB/system-dev/estimates/ledger.jsonl" ] && ok "㊽ cwd 就是 InkStoneCo ⇒ 同一個地方" || no "㊽ cwd 形狀不對" "$OUT"
 # plugin 快取的形狀：原始碼被複製到一個沒有 .git 的目錄（claude plugin update 會整個換掉）
 CACHE="$TMP/plugins/cache/inkstone/isep/9.9.9"; mkdir -p "$CACHE/scripts" "$CACHE/hooks/lib" "$CACHE/system-dev"
-cp "$ACCOUNT" "$CACHE/scripts/"; cp "$ROOT/lib/mainline.py" "$CACHE/hooks/lib/"
+cp "$ACCOUNT" "$CACHE/scripts/"; cp "$ROOT/lib/mainline.py" "$ROOT/lib/gitea_token.py" "$CACHE/hooks/lib/"
 EMPTY="$TMP/shell-empty"; mkdir -p "$EMPTY"
 OUT=$(cd "$EMPTY" && CLAUDE_PROJECT_DIR="$EMPTY" python3 "$CACHE/scripts/milestone-account" ledger-path 2>&1)
 case "$OUT" in "$CACHE"*) no "㊾ 帳本落進 plugin 快取（下一版就不見）" "$OUT" ;; "$HOME/.claude/isep-estimates/ledger.jsonl") ok "㊾ 專案裡沒有 system-dev、原始碼又在沒 .git 的快取 ⇒ 帳本退到家目錄，**不落快取**" ;; *) no "㊾ 路徑不明" "$OUT" ;; esac

hooks/tests/overdue-nag.test.sh

@@ -206,6 +206,55 @@ CH=$(printf '%s' "$IN" | CLAUDE_CODE_CHILD_SESSION=1 bash "$HOOK" 2>/dev/null)
 [ -z "$CH" ] && ok "㉟ 子 session 不叫（subagent 開工不是 leo 開工）" \
   || no "㉟ 子 session 不叫" "實得：$CH"
 
+echo "── G 群：有票卻沒有工人的 repo（inkstone/ISEP#118）──────────────────"
+# 假名單：只有一位管 acme/staffed 的工人，不碰真的 agents/
+mkdir -p "$TMP/roster"
+cat > "$TMP/roster/staffed.md" <<'MD'
+---
+name: staffed-hand
+description: 測試用
+---
+**負責 repo**：acme/staffed、acme/also-staffed
+## 開工前先讀
+## 紅線
+MD
+cat > "$TMP/gap.json" <<'JSON'
+{"milestones": [], "issues": [],
+ "repos": [
+  {"full_name":"acme/staffed","open_issues_count":4},
+  {"full_name":"acme/also-staffed","open_issues_count":1},
+  {"full_name":"acme/new-course","open_issues_count":5},
+  {"full_name":"acme/quiet","open_issues_count":0},
+  {"full_name":"acme/frozen","open_issues_count":3,"archived":true}
+ ]}
+JSON
+GR=$(ISEP_ROSTER_DIR="$TMP/roster" python3 "$NAG" --fixture "$TMP/gap.json" --now "$NOW" 2>&1)
+GS=$(ISEP_ROSTER_DIR="$TMP/roster" python3 "$NAG" --fixture "$TMP/gap.json" --now "$NOW" --short 2>&1)
+GJ=$(ISEP_ROSTER_DIR="$TMP/roster" python3 "$NAG" --fixture "$TMP/gap.json" --now "$NOW" --json 2>&1)
+has "$GR" "有票卻沒有工人的 repo（1 個）" && has "$GR" "acme/new-course（5 張票開著）" \
+  && ok "㊱ 新開、有票、名單上沒人的 repo 被點名（連同幾張票）" \
+  || no "㊱ 點名缺工人的 repo" "實得：$(printf '%s' "$GR" | tr '\n' ' ' | head -c 300)"
+has "$GR" "agents/" && ok "㊲ 講得出出路：去 agents/ 補工人（不是開例外閘）" || no "㊲ 出路" "沒講"
+if has "$GR" "acme/staffed（" || has "$GR" "acme/also-staffed" || has "$GR" "acme/quiet" || has "$GR" "acme/frozen"; then
+  no "㊳ 不該叫的不要叫" "有人的／沒票的／封存的被點名了"
+else
+  ok "㊳ 有工人的（含多 repo 的第二個）、沒票的、封存的都不叫"
+fi
+has "$GS" "查過了，沒有" && ! has "$GS" "工人" \
+  && ok "㊴ Telegram 短版不提工人（派工是總管的事，不吵 leo）" \
+  || no "㊴ 短版不提工人" "實得：$GS"
+printf '%s' "$GJ" | python3 -c '
+import json,sys
+assert json.load(sys.stdin)["findings"]["repos_without_worker"] == [{"repo":"acme/new-course","open":5}]
+' 2>/dev/null && ok "㊵ --json 帶得出同一份清單" || no "㊵ --json" "$(printf '%s' "$GJ" | head -c 200)"
+GN=$(ISEP_ROSTER_DIR="$TMP/沒有這個目錄" python3 "$NAG" --fixture "$TMP/gap.json" --now "$NOW" 2>&1)
+has "$GN" "沒查到" && ! has "$GN" "acme/staffed（" \
+  && ok "㊶ 名單讀不到 ⇒ 講「沒查到」，不把每個 repo 都說成缺人" \
+  || no "㊶ 名單讀不到" "實得：$(printf '%s' "$GN" | tr '\n' ' ' | head -c 300)"
+GO=$(python3 "$NAG" --fixture "$TMP/full.json" --now "$NOW" 2>&1)
+has "$GO" "沒查到" && ok "㊷ 舊格式 fixture（沒有 repos）⇒ 講「沒查到」，前三類照舊" \
+  || no "㊷ 舊格式相容" "實得：$(printf '%s' "$GO" | tail -3 | tr '\n' ' ')"
+
 echo
 printf '通過 %d 條，失敗 %d 條\n' "$PASS" "$FAIL"
 [ "$FAIL" = 0 ]

hooks/tests/queue-drain-guard.test.sh

@@ -61,6 +61,11 @@ run "★ stop_hook_active=true 仍擋（別的閘擋過一次就讓路，正是
 ISEP_DRAIN=1 run "ISEP_DRAIN=1：還沒跑過任何 ticket 指令也擋" 2 s4 chat.jsonl
 check "log 寫在狀態目錄（不靠 CLAUDE_PROJECT_DIR）" "grep -q '擋下' '$TMP/state-s4/queue-drain-guard.log'"
 
+stub 0 '{"ref":"inkstone/mira#21","title":"沒人看過的票","group":"待分診","next":"python3 /x/scripts/ticket triage inkstone/mira#21 --to <s/backlog|s/triage|s/pending> --why \"<一句理由>\""}'
+run "★ 可做的都抓盡、還有待分診的票 → 擋（ISEP#159：沒驗傷的票不會自己消失）" 2 s9 worker.jsonl
+check "訊息照 pick 那一列的 next 印 triage，不印 claim（待分診的票認領不了）" \
+  "grep -q 'triage inkstone/mira#21' '$TMP/stderr' && ! grep -q 'claim inkstone/mira#21' '$TMP/stderr'"
+
 echo
 echo "── ② 不該擋 ──"
 stub 0 "$TICKET"

hooks/tests/reply-identity.test.sh

@@ -62,10 +62,16 @@ h 0 "⑦ 只是在講這件事（把端點寫進文件）而沒有 POST → 不
 echo
 echo "── 正門（scripts/ticket）───────────────────────────────────────"
 
+# 🔴 正門的案例一律指到連不上的主機（跟 test-baton-handback-guard 等同一個寫法）。
+#   ⑪ 是「合規內文通過身份閘」——通過之後 scripts/ticket 會真的往下打 API。
+#   舊版假設「離線環境打不出去」，但在有 token 的機器上（本機 .env、雲端 env）它真的打得出去：
+#   2026-08-27 到 09-19 在 inkstone/ISEP#30 留下 69 則「【身份】subagent／…／feat/x 做完了」。
+OFF_ENV=(env TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN_CLAUDE_CODE=fake ISEP_API_RETRIES=0)
+
 g() {  # g <期望 exit> <說明> <內文>
   want="$1"; desc="$2"; content="$3"
   printf '%s' "$content" > "$TMP/body.md"
-  err=$(python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/body.md" 2>&1 >/dev/null); rc=$?
+  err=$("${OFF_ENV[@]}" python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/body.md" 2>&1 >/dev/null); rc=$?
   if [ "$rc" -eq "$want" ]; then ok "$desc"; else
     bad "$desc —— 期望 exit=$want，實得 exit=$rc" "$err"; fi
 }
@@ -87,7 +93,7 @@ g 2 "⑩ 身份欄不在第一行 → 擋（要一眼看得到，不是藏在中
 printf '%s' '【身份】subagent／inkstone/ISEP／feat/x
 
 做完了' > "$TMP/ok.md"
-err=$(python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/ok.md" 2>&1 >/dev/null || true)
+err=$("${OFF_ENV[@]}" python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/ok.md" 2>&1 >/dev/null || true)
 if printf '%s' "$err" | grep -q '第一行要表明身份'; then
   bad "⑪ 合規的內文被身份閘擋掉了（誤攔）" "$err"
 else

hooks/tests/roster-guard.test.sh

@@ -200,6 +200,84 @@ else
   printf '  ❌ ⑲ 真實的 subagent_type（isep:isep-hand）認不出來——就是這個造成 8/28 的死鎖\n'; FAIL=$((FAIL+1))
 fi
 
+echo "── 驗收 5：課程工人（inkstone/ISEP#118）：一個工人管三個 repo ──────────"
+
+for r in inkstone/ax-courses inkstone/course_gen inkstone/llm-wiki-template; do
+  N=$((N+1))
+  if [ "$(python3 "$ROOT/scripts/roster" which "$r" 2>/dev/null)" = "course-hand" ]; then
+    printf '  ✅ ⑳ `roster which %s` ⇒ course-hand\n' "$r"; PASS=$((PASS+1))
+  else
+    printf '  ❌ ⑳ `roster which %s` 沒回 course-hand（下一次派工又要開例外閘）\n' "$r"; FAIL=$((FAIL+1))
+  fi
+done
+
+# 真實派工的形狀：plugin 前綴 ＋ 只有一行【工單】
+t 0 "㉑ 派 isep:course-hand 去 inkstone/ax-courses#6 ⇒ 放行（09-14 實撞開例外閘的那一張）" \
+  "$(payload '【工單】inkstone/ax-courses#6' 'isep:course-hand' 'Agent')"
+
+N=$((N+1))
+inj3=$(printf '%s' "$(payload '【工單】inkstone/ax-courses#6' 'isep:course-hand' 'Agent')" | bash "$HOOK" 2>/dev/null)
+if printf '%s' "$inj3" | python3 -c '
+import sys, json
+c = json.load(sys.stdin)["hookSpecificOutput"]["additionalContext"]
+for want in ("course-hand", "inkstone/ax-courses", "inkstone/course_gen", "pdftoppm", "## 紅線"):
+    assert want in c, want
+' 2>/dev/null; then
+  printf '  ✅ ㉒ 注入的卡片帶著它管的三個 repo 與課件驗收紅線（pdftoppm）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ㉒ 課程工人的注入缺東西\n'; FAIL=$((FAIL+1))
+fi
+
+echo "── 驗收 6：多 repo 解析與「有票卻沒工人」的判準（離線假名單）────────"
+
+mkdir -p "$TMP/r6"
+cat > "$TMP/r6/multi.md" <<'MD'
+---
+name: multi-hand
+description: 測試用
+---
+**負責 repo**：acme/a、acme/b, acme/c（括號後面不算 acme/zzz）
+## 開工前先讀
+## 紅線
+MD
+cat > "$TMP/r6/single.md" <<'MD'
+---
+name: single-hand
+description: 測試用
+---
+**負責 repo**：acme/solo
+## 開工前先讀
+## 紅線
+MD
+
+N=$((N+1))
+if python3 - "$ROOT" "$TMP/r6" <<'PY' 2>/dev/null
+import sys, os
+sys.path.insert(0, os.path.join(sys.argv[1], "hooks", "lib"))
+import roster
+d = sys.argv[2]
+assert [w["name"] for w in roster.which("acme/b", d)] == ["multi-hand"], "頓號後面的 repo 認不出來"
+assert [w["name"] for w in roster.which("acme/c", d)] == ["multi-hand"], "逗號後面的 repo 認不出來"
+assert [w["name"] for w in roster.which("ACME/SOLO", d)] == ["single-hand"], "大小寫不分壞了"
+assert roster.which("acme/zzz", d) == [], "括號裡的字被當成 repo"
+assert roster.which("acme/nobody", d) == [], "不存在的 repo 被認領了"
+rows = [
+    {"full_name": "acme/a", "open_issues_count": 3},            # 有人 ⇒ 不叫
+    {"full_name": "acme/lonely", "open_issues_count": 2},       # 沒人、有票 ⇒ 叫
+    {"full_name": "acme/idle", "open_issues_count": 0},         # 沒人、沒票 ⇒ 不叫
+    {"full_name": "acme/old", "open_issues_count": 9, "archived": True},  # 封存 ⇒ 不叫
+    {"full_name": "acme/busy", "open_issues_count": 5},         # 沒人、有票 ⇒ 叫，排前面
+]
+got = roster.uncovered(rows, d)
+assert got == [{"repo": "acme/busy", "open": 5}, {"repo": "acme/lonely", "open": 2}], got
+assert roster.uncovered(rows, os.path.join(d, "不存在")) is None, "名單讀不到時沒有回 None"
+PY
+then
+  printf '  ✅ ㉓ 頓號／逗號都認得、括號後不算；只叫「沒人又有票」、不叫封存與沒票；名單讀不到回 None\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ ㉓ 多 repo 解析或 uncovered 判準壞了\n'; FAIL=$((FAIL+1))
+fi
+
 echo
 printf '結果：%s 通過 / %s 失敗（共 %s 條）\n' "$PASS" "$FAIL" "$N"
 [ "$FAIL" -eq 0 ] || exit 1

hooks/tests/wiki-compress.test.sh

@@ -132,38 +132,51 @@ echo "── E 群：閘——大幅刪減要擋，正常編輯不准擋 ──
 mk(){ printf '{"hook_event_name":"PreToolUse","session_id":"wctest%s","tool_name":"%s","tool_input":%s}' "$1" "$2" "$3"; }
 run(){ rm -f /tmp/.wiki-size-guard-wctest*; out=$(printf '%s' "$1" | bash "$HOOK" 2>&1); printf '%s|%s' "$?" "$(printf '%s' "$out" | tr '\n' ' ')"; }
 
+# 🔴 這兩支輔助函式的存在理由（inkstone/ISEP#161）：舊版把 $BIG／$SMALL 直接嵌進
+# `python3 -c "..."` 的原始碼字串裡，而外層又套了三層 "$(...)"。當中一層雙引號
+# 提早收口，讓 `{'file_path':...}` 這段在 bash 眼裡變成「未加引號」，觸發**大括號展開**
+# （逗號分隔 → 拆成三條各自獨立的 python3 -c 呼叫，`{`／`}` 本身被吃掉）——
+# 症狀就是 payload 少了 dict 的大括號、且 python 噴三次 SyntaxError。
+# 改用環境變數把內容傳給 python：內容永遠不會被當成 bash 原始碼解析，
+# 也不必再猜三層引號怎麼配對。
+json_edit(){ # file_path old_string new_string
+  PL_FILE="$1" PL_OLD="$2" PL_NEW="$3" python3 -c '
+import json, os
+print(json.dumps({
+    "file_path": os.environ["PL_FILE"],
+    "old_string": os.environ["PL_OLD"],
+    "new_string": os.environ["PL_NEW"],
+}, ensure_ascii=False))'
+}
+json_write(){ # file_path content
+  PL_FILE="$1" PL_CONTENT="$2" python3 -c '
+import json, os
+print(json.dumps({
+    "file_path": os.environ["PL_FILE"],
+    "content": os.environ["PL_CONTENT"],
+}, ensure_ascii=False))'
+}
+
 BIG=$(python3 -c 'print("這是一段很長的舊內容。" * 200)')
 SMALL="剩這一句。"
-R=$(run "$(mk 1 Edit "$(python3 -c "
-import json,sys
-print(json.dumps({'file_path':'$W/mistakes.md','old_string':'''$BIG''','new_string':'$SMALL'}, ensure_ascii=False))")")")
+R=$(run "$(mk 1 Edit "$(json_edit "$W/mistakes.md" "$BIG" "$SMALL")")")
 case "$R" in 2\|*) ok "⑯ 砍掉一大段 wiki ⇒ 擋一次" ;; *) no "⑯ 該擋" "實得 $R" ;; esac
 has "$R" "只搬不改" && ok "⑰ 擋的訊息說得出出路（三步指令）" || no "⑰ 出路" "$R"
 
-R=$(run "$(mk 2 Edit "$(python3 -c "
-import json
-print(json.dumps({'file_path':'$W/mistakes.md','old_string':'這是一句舊的話，長度普通。','new_string':'這是一句新的話，長度也普通，改了幾個字。'}, ensure_ascii=False))")")")
+R=$(run "$(mk 2 Edit "$(json_edit "$W/mistakes.md" "這是一句舊的話，長度普通。" "這是一句新的話，長度也普通，改了幾個字。")")")
 case "$R" in 0\|*) ok "⑱ 一般編輯不擋（誤攔比漏擋更該修）" ;; *) no "⑱ 不該擋" "實得 $R" ;; esac
 
-R=$(run "$(mk 3 Edit "$(python3 -c "
-import json
-print(json.dumps({'file_path':'/somewhere/src/app.ts','old_string':'x'*3000,'new_string':'y'}, ensure_ascii=False))")")")
+R=$(run "$(mk 3 Edit "$(json_edit "/somewhere/src/app.ts" "$(python3 -c "print('x' * 3000)")" "y")")")
 case "$R" in 0\|*) ok "⑲ 不是 wiki 的檔不管（別的檔縮水是它們自己的事）" ;; *) no "⑲ 非 wiki" "實得 $R" ;; esac
 
-R=$(run "$(mk 4 Edit "$(python3 -c "
-import json,sys
-print(json.dumps({'file_path':'$W/mistakes.md','old_string':'''$BIG''','new_string':'剩這一句。 wiki-compress-ok'}, ensure_ascii=False))")")")
+R=$(run "$(mk 4 Edit "$(json_edit "$W/mistakes.md" "$BIG" "剩這一句。 wiki-compress-ok")")")
 case "$R" in 0\|*) ok "⑳ wiki-compress-ok 留痕式豁免走得通" ;; *) no "⑳ 豁免" "實得 $R" ;; esac
 
-R=$(run "$(mk 5 Write "$(python3 -c "
-import json
-print(json.dumps({'file_path':'$W/從來沒有過的新檔.md','content':'新檔案的一點內容'}, ensure_ascii=False))")")")
+R=$(run "$(mk 5 Write "$(json_write "$W/從來沒有過的新檔.md" "新檔案的一點內容")")")
 case "$R" in 0\|*) ok "㉑ 新建檔案不算壓縮" ;; *) no "㉑ 新檔" "實得 $R" ;; esac
 
 # 至多擋一次：同一個 session 連兩次，第二次要放行（不然會卡死）
-PAY=$(mk 6 Edit "$(python3 -c "
-import json
-print(json.dumps({'file_path':'$W/mistakes.md','old_string':'''$BIG''','new_string':'剩這一句。'}, ensure_ascii=False))")")
+PAY=$(mk 6 Edit "$(json_edit "$W/mistakes.md" "$BIG" "剩這一句。")")
 rm -f /tmp/.wiki-size-guard-wctest6
 printf '%s' "$PAY" | bash "$HOOK" >/dev/null 2>&1; first=$?
 printf '%s' "$PAY" | bash "$HOOK" >/dev/null 2>&1; second=$?

hooks/ticket-api-bypass-guard.sh

@@ -116,10 +116,10 @@ fi
 # 不影響「擋下來」這個判斷本身。
 HITS=""
 if [ "$RESOURCE" = "issues" ]; then
-  REMOTES=$(git -C "${CLAUDE_PROJECT_DIR:-.}" remote -v 2>/dev/null || true)
-  CRED_LINE=$(printf '%s' "$REMOTES" | grep -m1 'git\.uncle6\.me' | grep -m1 '@' || true)
-  if [ -n "$CRED_LINE" ]; then
-    TOKEN=$(printf '%s' "$CRED_LINE" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
+  # token 來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡）
+  _GT_LIB="$(dirname -- "$0")/../scripts/lib/gitea-token.sh"; [ -f "$_GT_LIB" ] && . "$_GT_LIB"
+  TOKEN=""; command -v gitea_token >/dev/null 2>&1 && TOKEN=$(gitea_token) || TOKEN=""
+  if [ -n "$TOKEN" ]; then
     # 只認雙引號的 "title": "..."（curl -d／json.dumps 輸出的實際格式，也是
     # 2026-08-27 那 13 張票真實用的寫法，見 scripts/test-ticket-api-bypass-guard.sh
     # 既有的模擬指令）。刻意不支援單引號版本——這段 python 要塞進 bash 單引號

hooks/unreleased-police.sh

@@ -0,0 +1,241 @@
+#!/usr/bin/env bash
+# unreleased-police.sh — 未出貨警察（Stop hook）  inkstone/ISEP#68
+#
+# 🔴 本機 LC_ALL 未固定時，把變數（repo 名／數字）串進含全形標點的字串會吃掉字元
+#   （unpushed-police.sh 檔頭第 4 行記過同一課）。固定 locale，別讓報告被環境吃掉。
+export LC_ALL=C
+#
+# ── leo 2026-08-27 的規格（原話就是判準，inkstone/ISEP#68）────────────────
+#   「每個 repo 只要有改動就要出貨」
+#   「這個警察很簡單，這個 session 有改但要結束沒出貨就抓，
+#     你可以久一點再出貨累積幾個 PR，但最後一定要出貨」
+#   「版本出去之前都只是內部測試」
+#
+#     掛點   Stop（session 要結束的那一刻）—— 不是每次 commit，只在收工問一次
+#     條件   這個 session 改過的 repo
+#     檢查   有沒有出貨（新的 release）
+#     寬容   可以累積幾個 PR 再一起出（「先不出」要留痕）
+#     底線   session 結束前一定要出
+#
+# ── 為什麼是 Stop、不是 SubagentStop（誤攔第一防線）────────────────────
+#   leo 規則三點七：subagent 交 deliverable（分支上的 commit），**總管**把它們
+#   收斂成一個 release。subagent 交回分支、天生不出 release ⇒ 在 SubagentStop
+#   要它出貨＝逼它做一件它不該做的事＝純誤攔。所以本閘只掛 Stop。
+#
+# ── 四個判準，每一個都寫得出理由（票要求我自己判，不照抄總管）──────────
+#
+# ① 「改過」＝ 這個 session 期間 HEAD 前進了新的 commit（不是「工作區髒」、不是「push」）。
+#    · 出貨（release/tag）的單位是 commit；leo 的「累積幾個 PR」也是累積 commit。
+#      「改過」要和「出貨」用同一個單位對齊，才數得出「差多少」。
+#    · 「工作區髒」還沒落地，且已被 unpushed-police 管——用它會重疊、又會逼暫存檔出貨（誤攔）。
+#    · 「push」是 D20 開閘的動作、又是 release 的上游，用它當「改過」太晚。
+#    session 起點 ＝ transcript 第一列的時間戳（同 countdown.py 的基準：一段對話＝一個 release）。
+#
+# ② 「該不該出貨」＝ 這個 session 的 commit 有沒有動到**知識以外**的檔案。
+#    principles.md：環境（hooks／commands／skills／scripts／plugin）要升版才到得了人手上；
+#    知識（wiki／docs／_archive）改了就地被讀到，不需要出版本。
+#    ⇒ 只改 wiki／docs 的 commit **不算要出貨的改動**（票驗收 4「只改了 wiki 不該擋」）。
+#    判準是「有沒有任何一個改到的檔在知識目錄之外」，不是維護一張「哪些算 code」的清單。
+#    方向：把 docs 誤判成「不用出貨」是漏擋（安全方向）；把 wiki 判成「要出貨」是誤攔（要避免）。
+#
+# ③ 「哪些 repo 不適用」＝ repo 根目錄有 `.isep-release-exempt` 這個檔（裡面寫一行理由）。
+#    · 判準是「檔在不在」，不是一張會過期的中央手列清單，也不是名字黑名單。
+#    · **預設納管**：新 repo 進來自動被管（沒人需要記得加），只有產物 repo／模板 repo
+#      這種真的不出版的才放一個 marker——而且它自己帶著「為什麼不適用」的理由。
+#    （票明說 arcrun-rag-bundles-staging 是產物、system-dev-template 是模板；它們各放一個 marker 即可。）
+#
+# ④ 「這次先不出」＝ $CLAUDE_PROJECT_DIR/.claude/release-holds.md 裡有一行提到這個 repo（+理由）。
+#    · 形狀跟 unpushed-police 的 branch-holds.md 一樣：**要求某個東西在場**（leo 認可的兩種閘形狀之一），
+#      不是去 transcript 裡撈「先不出因為」這種字（文字層封路已被證偽：8 次誤攔 0 次命中）。
+#    · 「明說先不出」寫進一個檔＝同時滿足「放行」與「留痕」（票驗收 5）。
+#    · 出貨了就把那一行刪掉——訊息會這樣講。
+#
+# ── 「出貨」怎麼認 ──────────────────────────────────────────────────────
+#   shipped ⟺ `git tag --contains HEAD` 非空（HEAD 這顆已經被某個 release tag 收進去）。
+#   Gitea 的 release 就是 tag；tag 打在哪顆 commit 上是本機答得準的事實，不必打網路。
+#   沒被收進去 ⇒ 用 `git describe` 找出「最新 release」、數出 HEAD 領先它幾筆——
+#   那就是「最後 commit 與最新 release 差多少」（票驗收 1 要訊息點得出來）。
+#
+# ── fail-open：Stop 閘擋下內部錯誤會鎖死 session，誤攔是本 repo 第一級缺陷 ──
+#   拿不到 transcript 起點／不是 git repo／git 問不出來 ⇒ 一律放行。
+#
+# 迴歸測試：scripts/test-unreleased-police.sh（含「不該擋」與「出路走得通」兩組）
+
+input="$(cat 2>/dev/null || echo '{}')"
+
+# ── 防無限迴圈：已被別的 Stop 閘擋出來這一輪 ⇒ 不再擋 ──
+stop_active="$(printf '%s' "$input" | python3 -c '
+import sys, json
+try: print(json.load(sys.stdin).get("stop_hook_active", False))
+except Exception: print(False)
+' 2>/dev/null)"
+[ "$stop_active" = "True" ] && exit 0
+
+# ── 一次取出 transcript 路徑與 session 起點（epoch）──
+# 起點的算法跟 hooks/lib/countdown.py transcript_start 同源：transcript 第一列的時間戳。
+LIBDIR="$(dirname "$0")/lib"
+read -r START_EPOCH TRANSCRIPT <<EOF2
+$(printf '%s' "$input" | LIBDIR="$LIBDIR" python3 -c '
+import sys, json, os
+sys.path.insert(0, os.environ.get("LIBDIR", ""))
+start = ""
+tp = ""
+try:
+    d = json.load(sys.stdin)
+    tp = d.get("transcript_path") or ""
+except Exception:
+    d = {}
+try:
+    from countdown import transcript_start
+    dt = transcript_start(tp)
+    if dt: start = str(int(dt.timestamp()))
+except Exception:
+    # lib 不在時就地補：讀第一列時間戳
+    try:
+        from datetime import datetime, timezone
+        with open(tp) as f:
+            for line in f:
+                line = line.strip()
+                if not line: continue
+                try: row = json.loads(line)
+                except Exception: continue
+                raw = row.get("timestamp")
+                if isinstance(raw, str) and raw.strip():
+                    s = raw.strip().replace("Z", "+00:00")
+                    try:
+                        dt = datetime.fromisoformat(s)
+                        if not dt.tzinfo: dt = dt.replace(tzinfo=timezone.utc)
+                        start = str(int(dt.timestamp())); break
+                    except Exception: pass
+    except Exception: pass
+print(start or "-", tp or "-")
+' 2>/dev/null)
+EOF2
+
+# 拿不到起點 ⇒ 無從界定「這個 session 改了什麼」⇒ 放行（誤攔比漏擋嚴重）
+case "$START_EPOCH" in ''|'-'|*[!0-9]*) exit 0 ;; esac
+
+TOP="${CLAUDE_PROJECT_DIR:-$(cd "$(dirname "$0")/../.." && pwd)}"
+
+# 掃描對象：頂層 ＋ 已知子 repo（存在才掃），與 unpushed-police 同一份排法。
+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"
+
+HOLDS="$TOP/.claude/release-holds.md"
+
+problems=""
+held_note=""
+exempt_note=""
+
+for r in $REPOS; do
+  [ -d "$r/.git" ] || [ -f "$r/.git" ] || continue
+  name="${r#$TOP/}"; [ "$name" = "$r" ] && name="$(basename "$r")"
+  [ "$r" = "$TOP" ] && name="(頂層) $(basename "$r")"
+  base="$(basename "$r")"
+
+  # ── ① 這個 session 有沒有新 commit（reachable from HEAD, committer-date >= 起點）──
+  files="$(git -C "$r" -c core.quotepath=off log HEAD --since="@$START_EPOCH" --name-only --format= 2>/dev/null \
+             | grep -v '^$' | sort -u)"
+  [ -z "$files" ] && continue   # 這個 session 沒動這個 repo → 放行（票驗收 3／4「只讀不寫」）
+
+  # ── ② 有沒有動到「知識以外」的檔（要出貨的改動）──
+  #   知識目錄：路徑含 /wiki/、/docs/、/_archive/，或以它們開頭。
+  nonknow="$(printf '%s\n' "$files" | grep -vE '(^|/)(wiki|docs|_archive)(/|$)' | head -1)"
+  [ -z "$nonknow" ] && continue   # 只改了知識（wiki／docs）→ 不需出貨（票驗收 4）
+
+  # ── ③ 這個 repo 是不是 marker 排除（產物／模板）──
+  if [ -f "$r/.isep-release-exempt" ]; then
+    _why="$(head -1 "$r/.isep-release-exempt" 2>/dev/null)"
+    exempt_note="$exempt_note
+     - $name（.isep-release-exempt：${_why:-未寫理由}）"
+    continue
+  fi
+
+  # ── 已經出貨了嗎？HEAD 被某個 tag 收進去 ⇒ 出過貨，放行（票驗收 2）──
+  if [ -n "$(git -C "$r" tag --contains HEAD 2>/dev/null | head -1)" ]; then
+    continue
+  fi
+
+  # ── 到這裡：這個 session 動過、要出貨、卻還沒出貨 ──
+  # 「最後 commit 與最新 release 差多少」
+  base_tag="$(git -C "$r" describe --tags --abbrev=0 HEAD 2>/dev/null || true)"
+  if [ -n "$base_tag" ]; then
+    n="$(git -C "$r" rev-list --count "$base_tag"..HEAD 2>/dev/null || echo '?')"
+    detail="最新 release $base_tag ，HEAD 領先它 $n 筆（其中有環境／code 改動未出貨）"
+  else
+    n="$(git -C "$r" rev-list --count HEAD 2>/dev/null || echo '?')"
+    detail="從未出過版（一個 release tag 都沒有），HEAD 共 $n 筆 commit 未出貨"
+  fi
+  short_top="$(printf '%s\n' "$files" | grep -vE '(^|/)(wiki|docs|_archive)(/|$)' | head -3 \
+                | sed 's/^/         · /')"
+
+  # ── ④ 這次先不出（release-holds.md 有提到這個 repo）⇒ 放行 ＋ 留痕 ──
+  if [ -f "$HOLDS" ] && grep -qF "$base" "$HOLDS" 2>/dev/null; then
+    _line="$(grep -F "$base" "$HOLDS" 2>/dev/null | head -1)"
+    held_note="$held_note
+     - $name（先不出，理由在 .claude/release-holds.md）：$_line"
+    continue
+  fi
+
+  problems="$problems
+  📦 $name ：$detail
+     這個 session 動到、需要出貨的檔（節錄）：
+$short_top"
+done
+
+# 沒有任何「改了卻沒出貨」的 repo ⇒ 放行
+if [ -z "$problems" ]; then
+  # 有 hold／exempt 但沒有真問題時安靜放行——不無事生非（票紅線）
+  exit 0
+fi
+
+REPLACE_HOLDS="$HOLDS"
+
+printf '%s\n' "🚢 未出貨警察：這個 session 改過的 repo，收工前還沒出貨。" >&2
+# 靜態訊息用 quoted heredoc（mistakes.md：unquoted heredoc 會把反引號當命令執行）；
+# 動態內容用 printf '%s' 分開印，變數與全形標點之間都留空白（避免 locale 吃字元）。
+cat >&2 <<'EOF'
+
+【leo 2026-08-27（原話就是判準）】
+  「每個 repo 只要有改動就要出貨」「版本出去之前都只是內部測試」
+  「你可以久一點再出貨累積幾個 PR，但最後一定要出貨」
+【判準】改對了、commit 了 ≠ 送到人手上。release 出去之前都只是內部測試。
+EOF
+
+printf '%s\n' "$problems" >&2
+
+if [ -n "$held_note" ]; then
+  printf '%s\n' "" >&2
+  printf '%s\n' "⏸️ 這次先不出（已留痕，不擋）：$held_note" >&2
+fi
+if [ -n "$exempt_note" ]; then
+  printf '%s\n' "" >&2
+  printf '%s\n' "⊘ 排除（.isep-release-exempt）：$exempt_note" >&2
+fi
+
+cat >&2 <<'EOF'
+
+━━ 收工前擇一，都走得通 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  1. 該出貨就出貨：升版（改了會被載入的東西＝plugin／worker／bundle 就升版）
+     ＋ 打 release tag。ISEP 自己：bash scripts/check-version-consistency.sh 先對齊，
+     版本三處一致後由總管打 tag。
+  2. 這次先不出（累積、或交回分支由總管出）：在下面這個檔寫一行理由——
+     寫完再收工就放行，而且留了痕，總管看得到有東西在路上：
+EOF
+
+printf '%s\n' "        $REPLACE_HOLDS" >&2
+printf '%s\n' "        一行格式： <repo 名>: <為什麼這次先不出>" >&2
+printf '%s\n' "        （repo 名就是上面每個 📦 後面那個名字的最後一段，例如 ISEP／mira）" >&2
+
+cat >&2 <<'EOF'
+  3. 是產物 repo／模板 repo（本來就不出版）：在該 repo 根目錄放一個
+     .isep-release-exempt，第一行寫理由。之後這支閘就不再管它。
+
+🔴 本閘只在收工那一刻問一次，不是每次 commit 都吼（leo 明說可以累積）。
+   出貨之後記得把 release-holds.md 裡對應那一行刪掉，否則下次它會以為你還在累積。
+EOF
+exit 2

scripts/debt-worklist

@@ -51,6 +51,7 @@ try:
     import mainline as ML
 except Exception:      # 拿不到共用零件就退回舊行為（fail-open），不讓還債線整個癱掉
     ML = None
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
 
 # 等 leo 的票不進「可領清單」——不是它們不重要，是**沒有人能替他領**：
 #   Human／human/exec ＝ 要他親手批示或動手
@@ -67,28 +68,17 @@ def die(msg, code=2):
     sys.exit(code)
 
 
-# ── 連線（跟 scripts/ticket 同一套：先找帶憑證的 remote，再退環境變數）────────
+# ── 連線（跟 scripts/ticket 同一套 token 來源：env／.env，不碰 remote URL；ISEP#47）────────
 def token():
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
+    tok = _gitea_token()
+    if tok:
+        return tok
     host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        if os.environ.get(env):
-            return os.environ[env]
     die(f"""🔴 拿不到 {host} 的 token
 
 擇一：
-  • 讓某個 remote 帶憑證（多數 repo 的 gitea/origin 本來就有）
-  • 或設環境變數 GITEA_TOKEN_CLAUDE_CODE""")
+  • 設環境變數 GITEA_TOKEN_CLAUDE_CODE
+  • 或在 $CLAUDE_PROJECT_DIR/.env（或 git 根的 .env）放 GITEA_TOKEN_CLAUDE_CODE=""")
 
 
 def api(path):

scripts/git-credential-gitea.sh

@@ -0,0 +1,26 @@
+#!/bin/sh
+# git-credential-gitea.sh — git credential helper：把 Gitea 憑證從 env／.env 餵給 git，
+#   讓 remote URL 不必嵌 token（inkstone/ISEP#47）。URL 乾淨 ⇒ git 把它印出來也不洩 token。
+#
+# 安裝（gitea-bootstrap.sh 會自動設好，這裡是手動法）：
+#   git config credential.helper "$(git rev-parse --show-toplevel)/scripts/git-credential-gitea.sh"
+# 只對 git.uncle6.me 的 get 供憑證；store／erase 不做事（token 不由 git 保管）。
+DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+. "$DIR/lib/gitea-token.sh"
+
+[ "${1:-}" = "get" ] || exit 0
+
+HOST=""
+while IFS='=' read -r k v; do
+  [ -z "$k" ] && break
+  [ "$k" = "host" ] && HOST="$v"
+done
+case "$HOST" in
+  git.uncle6.me|"") : ;;
+  *) exit 0 ;;
+esac
+
+TOK=$(gitea_token) || exit 0
+[ -n "$TOK" ] || exit 0
+printf 'username=claude-code\n'
+printf 'password=%s\n' "$TOK"

scripts/gitea-arm-request.sh

@@ -46,33 +46,47 @@ esac
 [ "$MINUTES" -le 60 ] || MINUTES=60
 [ "$MINUTES" -ge 1 ] || MINUTES=1
 
-TOKEN=$(gitea_arm_token) || { echo "❌ 讀不到 GITEA_TOKEN_CLAUDE_CODE（頂層 .env）" >&2; exit 1; }
-
 NONCE="ARM-$(python3 -c 'import secrets; print(secrets.token_hex(4))')"
 NOW=$(date +%s)
 EXPIRES=$((NOW + MINUTES * 60))
 EXPIRES_HUMAN=$(date -r "$EXPIRES" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || date -d "@$EXPIRES" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "$EXPIRES")
 
-STATE_DIR=$(gitea_arm_state_dir)
-PENDING_FILE="$STATE_DIR/pending/${NONCE}.json"
-
-# ── 貼留言到呼叫端指定的那張票 ─────────────────────────────────────────
+# ── 留言內文 ───────────────────────────────────────────────────────────
+# 🔴 inkstone/ISEP#123：**第一行就是人閘記號 `👤` ＋「要 leo 做什麼」**——
+#   leo 一天只看兩眼，他要在一長串留言裡一眼認出「這則是在等我動手的」。
+#   舊版第一行是 `🔐 ARM 請求`（機器術語），沒有 `👤` ⇒ 他掃過去認不出來，
+#   而他手寫的交棒都以 `👤 Leo：` 開頭。這正是「規範在人身上、不在機器上」的形狀。
+#   （`👤` 是留言記號，跟「不准用 `👤 裁決題：` 當**票名**前綴」是兩件事，見 scripts/ticket 的標題閘。）
 COMMENT_BODY=$(MISSION="$MISSION" NONCE="$NONCE" EXPIRES_HUMAN="$EXPIRES_HUMAN" MINUTES="$MINUTES" python3 -c '
 import os
 mission = os.environ["MISSION"]
 nonce = os.environ["NONCE"]
 expires_human = os.environ["EXPIRES_HUMAN"]
 minutes = os.environ["MINUTES"]
-print(f"""🔐 ARM 請求
+print(f"""👤 Leo：回這則、貼下面那組碼，就放行這一次 —— {mission}
 
-任務：{mission}
+🔐 ARM 請求
 有效時限：{minutes} 分鐘內（{expires_human} 前）
 
-📱 回這則、貼上下面這串就解鎖這一次（用完就失效，別的請求不能借用）：
+📱 貼上下面這串就解鎖這一次（用完就失效，別的請求不能借用）：
 {nonce}
 """)
 ')
 
+# ── 印出內文就退場（測試用，不打網路、不讀 token、不寫本地狀態）──────────
+#   離線驗「第一行有 👤」不必碰 Gitea，也不必真的等 leo（inkstone/ISEP#123 驗收 3）。
+if [ "${ISEP_ARM_PRINT_BODY:-}" = "1" ]; then
+  printf '%s\n' "$COMMENT_BODY"
+  exit 0
+fi
+
+TOKEN=$(gitea_arm_token) || { echo "❌ 讀不到 GITEA_TOKEN_CLAUDE_CODE（頂層 .env）" >&2; exit 1; }
+
+STATE_DIR=$(gitea_arm_state_dir)
+PENDING_FILE="$STATE_DIR/pending/${NONCE}.json"
+
+# ── 貼留言到呼叫端指定的那張票 ─────────────────────────────────────────
+
 REQUEST_JSON=$(jq -n --arg body "$COMMENT_BODY" '{body: $body}')
 
 RESP=$(curl -s -w '\n%{http_code}' -X POST \

scripts/gitea-arm-to-github-armed.sh

@@ -21,17 +21,36 @@
 #   ⇒ 拿掉那個條件，這支就變成「AI 自己批准自己發佈」——**那正是 D20 要擋的事**。
 set -eu
 
-ROOT=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
-ARMED="$ROOT/.github-armed"
+SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+# shellcheck source=lib/gitea-arm-common.sh
+. "$SCRIPT_DIR/lib/gitea-arm-common.sh"
+
+# ── 保險寫在哪：**讀的人在哪讀，就寫在哪**（inkstone/ISEP#156，2026-09-17 實撞）──────
+#
+# 🔴 舊版寫 `ROOT=$(dirname $0)/..`（腳本自己的上一層）。ISEP 還住在 InkStoneCo 裡時兩者剛好
+#   同一個位置；**改成 plugin 發佈後，腳本住在 `~/.claude/plugins/cache/inkstone/isep/<ver>/`**
+#   ⇒ 保險被寫進 plugin 快取資料夾，印「✅ 保險已解」，而出貨線與每一道閘都讀不到
+#   ⇒ leo 回了碼、出貨照樣卡住，總管手動把檔案搬過去才通（inkstone/arcrun-rag#202 c7598）。
+#   **一句「已解」卻沒解，比單純失敗更糟——它讓 leo 以為自己的動作生效了。**
+#
+# ⇒ 改用 `gitea_arm_proj_dir`（＝`${CLAUDE_PROJECT_DIR:-$(pwd)}`），理由是**跟讀的人對齊**：
+#   · main-and-prod-push-guard.sh／github-contact-guard.sh／stage-before-prod-guard.sh
+#     全部讀 `${CLAUDE_PROJECT_DIR:-$(pwd)}/.github-armed`
+#   · ship.mjs 讀 `InkStoneCo/.github-armed`（總管 session 的 CLAUDE_PROJECT_DIR 就是它）
+#   · 本檔自己的核准來源（`gitea-arm-check.sh` 讀的 token 與待核請求）本來就住在這裡
+#     ⇒ 專案根猜錯時 check 會先因為讀不到 `.env`／待核請求而 fail-closed，**不會寫到錯的地方**
+#   不要再改回「腳本的位置」：腳本住哪是安裝方式決定的，保險住哪是讀的人決定的，兩者無關。
+ARMED="$(gitea_arm_proj_dir)/.github-armed"
 
 # ── 唯一的授權來源：leo 在 Gitea 票上的回覆 ────────────────────────────
 # 不捕捉、不吞錯——check 失敗就讓它把原因印到 stderr 並中止本支。
 # 🔴 `--consume` 是必要的（2026-08-16 起 check 預設唯讀）：本檔會**寫出保險**，
 #   那就是「放行」本身 ⇒ 這一次核准必須當場作廢，否則同一組碼能重複解保險。
-OUT=$("$ROOT/scripts/gitea-arm-check.sh" --consume) || {
+OUT=$("$SCRIPT_DIR/gitea-arm-check.sh" --consume) || {
   echo "" >&2
   echo "⛔ 沒有取得 leo 的核准 ⇒ 不寫保險（fail-closed）" >&2
-  echo "   先跑：scripts/gitea-arm-request.sh <票號> \"<要做什麼>\"，把代碼給 leo 回在那張票上。" >&2
+  # 印絕對路徑：相對的 `scripts/…` 會對貼上那個人的 cwd 解析，站在 InkStoneCo 會叫到舊複本（ISEP#112 同病）
+  echo "   先跑：$SCRIPT_DIR/gitea-arm-request.sh <票號> \"<要做什麼>\"，把代碼給 leo 回在那張票上。" >&2
   exit 1
 }
 
@@ -50,6 +69,7 @@ printf '%s\n%s\n%s\n' \
   > "$ARMED"
 
 echo "✅ 保險已解（來源：leo 在 Gitea 票上的核准）"
+echo "   寫在：$ARMED"
 echo "   任務：$MISSION"
 echo "   有效至：$(date -r "$EXPIRY" '+%Y-%m-%d %H:%M:%S' 2>/dev/null || echo "$EXPIRY")"
 echo "   提前上保險：rm $ARMED"

scripts/gitea-bootstrap.sh

@@ -16,14 +16,29 @@ set -eu
 REPO=""
 [ "${1:-}" = "-r" ] && { REPO="${2:?-r 後面要接 owner/repo}"; }
 
-REMOTE=$(git remote get-url gitea 2>/dev/null) || {
-  echo "✗ 當前目錄沒有名為 gitea 的 remote。請 cd 到目標 repo，或先加 remote。" >&2; exit 1; }
+# 取當前 repo 的 remote（雲端叫 origin、本機慣例叫 gitea）
+REMOTE_NAME=$(git remote get-url gitea >/dev/null 2>&1 && echo gitea || (git remote get-url origin >/dev/null 2>&1 && echo origin))
+[ -n "$REMOTE_NAME" ] || { echo "✗ 當前目錄沒有 gitea/origin remote。請 cd 到目標 repo，或先加 remote。" >&2; exit 1; }
+REMOTE=$(git remote get-url "$REMOTE_NAME" 2>/dev/null)
+# 去掉網址裡可能嵌著的憑證 → 乾淨 URL（inkstone/ISEP#47：token 不進 remote URL）
+REMOTE=$(printf '%s' "$REMOTE" | sed -E 's#//[^/@]*@#//#')
 
-TOKEN=$(printf '%s' "$REMOTE" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
-[ "$TOKEN" = "$REMOTE" ] && { echo "✗ gitea remote URL 裡沒有 token，無法取得認證。" >&2; exit 1; }
-HOST=$(printf '%s' "$REMOTE" | sed -E 's|.*@([^/]+)/.*|\1|')
+# token 來源＝env／.env（不從 remote URL 抽——那會逼 token 明文嵌在 URL 裡 → 洩進 log）
+_GT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+[ -f "$_GT_DIR/lib/gitea-token.sh" ] && . "$_GT_DIR/lib/gitea-token.sh"
+TOKEN=""; command -v gitea_token >/dev/null 2>&1 && TOKEN=$(gitea_token || true)
+[ -n "$TOKEN" ] || { echo "✗ 取不到 Gitea token（設 GITEA_TOKEN_CLAUDE_CODE，或在 .env 放 GITEA_TOKEN_CLAUDE_CODE=）。" >&2; exit 1; }
+HOST=$(printf '%s' "$REMOTE" | sed -E 's|.*://([^/]+)/.*|\1|')
 [ -n "$REPO" ] || REPO=$(printf '%s' "$REMOTE" | sed -E 's|.*://[^/]+/(.+)\.git$|\1|')
 
+# 設定乾淨 remote URL + credential helper（冪等）：URL 不含 token，認證改由 helper 從 env／.env 供
+# ⇒ git 把 remote URL 印出來（git-lfs 的 locksverify 那行）也不會洩 token（inkstone/ISEP#47）。
+if [ -f "$_GT_DIR/git-credential-gitea.sh" ]; then
+  CUR=$(git remote get-url "$REMOTE_NAME" 2>/dev/null || true)
+  case "$CUR" in *@*) git remote set-url "$REMOTE_NAME" "$REMOTE" && echo "  ✓ remote $REMOTE_NAME 已清乾淨（移除嵌入的 token）" ;; esac
+  git config credential.helper "$_GT_DIR/git-credential-gitea.sh"
+fi
+
 echo "→ repo: $REPO　host: $HOST"
 
 # 狀態機（互斥 scope label）。順序＝出貨流程：

scripts/gitea-labels-sync.sh

@@ -30,16 +30,15 @@ if [[ ! -f "$LABELS_YAML" ]]; then
   exit 1
 fi
 
-# --- token：跟 InkStoneCo 頂層 gitea remote 拿同一把（不落地檔案、不印出來） ---
+# --- token：來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡） ---
 TOKEN="${GITEA_TOKEN:-}"
 if [[ -z "$TOKEN" ]]; then
-  INKSTONE_TOP="${INKSTONE_TOP:-$HOME/Documents/tech_projects/InkStoneCo}"
-  if [[ -d "$INKSTONE_TOP/.git" ]]; then
-    TOKEN="$(git -C "$INKSTONE_TOP" remote get-url gitea 2>/dev/null | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')"
-  fi
+  _GT_LIB="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)/lib/gitea-token.sh"
+  [[ -f "$_GT_LIB" ]] && . "$_GT_LIB"
+  command -v gitea_token >/dev/null 2>&1 && TOKEN="$(gitea_token || true)"
 fi
 if [[ -z "$TOKEN" ]]; then
-  echo "拿不到 Gitea token——設 GITEA_TOKEN 環境變數，或確認 $INKSTONE_TOP 的 gitea remote 存在" >&2
+  echo "拿不到 Gitea token——設 GITEA_TOKEN_CLAUDE_CODE 環境變數，或在 .env／頂層 .env 放 GITEA_TOKEN_CLAUDE_CODE=" >&2
   exit 1
 fi
 

scripts/isep-doctor

@@ -0,0 +1,152 @@
+#!/usr/bin/env python3
+"""isep-doctor — 這台機器上每一個 Claude Code，到底有沒有把 ISEP 載進來（inkstone/ISEP#150）
+
+為什麼要有這支：
+  plugin 載入失敗時，ISEP 的閘**一支都不會跑**，而且**沒有任何閘能講出來**——
+  講話的 isep-presence-beacon 本身就在那個沒載入的 plugin 裡。
+
+為什麼一台機器要分開問（09-13 總管複驗 c6991 推翻了第一版）：
+  同一台 Mac 上有**不只一個** Claude Code：CLI（例：/opt/homebrew/bin/claude 2.1.220）
+  與 Claude Desktop 內建的那一份（~/Library/Application Support/Claude/claude-code/<版本>/…，例：2.1.266）。
+  它們讀同一份 ~/.claude，**卻不一定得出同一個結論**：
+    settings.json 的 extraKnownMarketplaces.inkstone.source 多了 path 時——
+      2.1.266：整個 marketplace 被忽略 ⇒ isep@inkstone 報 "Marketplace inkstone not found"
+      2.1.220：照常載入
+  第一版只看「設定長得像會出事」就對整台機器判 ❌，在 2.1.220 上是假陽性。
+
+判準（實際狀態，不是設定長相）：
+  對每一個找得到的 Claude Code 各跑一次 `plugin list --json`，看它**自己**回報的 isep@inkstone：
+    沒有這一筆      ⇒ ❌ 沒安裝
+    帶 errors      ⇒ ❌ 沒載入（照實轉述；若 settings 比已安裝的 marketplace 多了抓取欄位，附上原因與修法）
+    沒有 errors    ⇒ ✅（即使設定裡有 path——那台實際載得進來就是載得進來）
+    跑不動／看不懂 ⇒ ◐ 查不了（讀不到不等於沒載入，也不等於有）
+  設定比對**只當解釋**，永遠不單獨判 ❌。
+
+離開碼：0 全部 ✅｜1 至少一個 ❌｜2 沒有 ❌、但至少一個查不了（或一個 Claude Code 都找不到）
+
+測試用環境變數：
+  ISEP_DOCTOR_CLAUDE_BINS  用這份清單取代自動尋找；以 os.pathsep 分隔，每項 `名稱=可執行檔路徑`
+  ISEP_DOCTOR_CLAUDE_HOME  代替 ~/.claude
+迴歸測試：scripts/test-isep-doctor.sh（離線）／scripts/test-isep-doctor-live.sh（真的 Claude Code、隔離 HOME）
+"""
+import glob
+import json
+import os
+import re
+import shutil
+import subprocess
+import sys
+
+PLUGIN_ID = "isep@inkstone"
+MARKET = "inkstone"
+FETCH_FIELDS = ("path", "ref", "headers", "sparsePaths")
+DESKTOP_GLOB = "~/Library/Application Support/Claude/claude-code/*/claude.app/Contents/MacOS/claude"
+
+home = os.environ.get("ISEP_DOCTOR_CLAUDE_HOME") or os.path.expanduser("~/.claude")
+
+
+def _ver_key(path):
+    m = re.search(r"/claude-code/([0-9][0-9.]*)/", path)
+    return tuple(int(x) for x in m.group(1).split(".") if x) if m else ()
+
+
+def find_claudes():
+    """回傳 [(名稱, 路徑)]。Desktop 只取最新版本那一份（它啟動的就是那一份；舊資料夾可能殘留）。"""
+    env = os.environ.get("ISEP_DOCTOR_CLAUDE_BINS")
+    if env is not None:
+        out = []
+        for item in env.split(os.pathsep):
+            if "=" in item:
+                name, path = item.split("=", 1)
+                out.append((name, path))
+        return out
+    out = []
+    cli = shutil.which("claude")
+    if cli:
+        out.append(("CLI", cli))
+    desk = sorted(glob.glob(os.path.expanduser(DESKTOP_GLOB)), key=_ver_key)  # 數字排序：2.1.99 < 2.1.266
+    if desk:
+        out.append(("Desktop", desk[-1]))
+    return out
+
+
+def version_of(exe):
+    try:
+        r = subprocess.run([exe, "--version"], capture_output=True, text=True, timeout=30)
+        return (r.stdout.strip().split() or ["?"])[0]
+    except Exception:  # noqa: BLE001
+        return "?"
+
+
+def ask(exe):
+    """回傳 (狀態, 內容)。狀態：'list' 內容＝plugin list 陣列；'err' 內容＝查不了的原因。"""
+    try:
+        r = subprocess.run([exe, "plugin", "list", "--json"], capture_output=True, text=True, timeout=90)
+    except Exception as e:  # noqa: BLE001
+        return "err", f"執行失敗（{e}）"
+    try:
+        data = json.loads(r.stdout)
+        if not isinstance(data, list):
+            raise ValueError("不是陣列")
+        return "list", data
+    except Exception:  # noqa: BLE001
+        tail = (r.stdout or r.stderr or "").strip().splitlines()[-1:] or ["（沒有輸出）"]
+        return "err", f"plugin list --json 看不懂（exit={r.returncode}：{tail[0][:200]}）"
+
+
+def load(p):
+    try:
+        return json.load(open(p))
+    except Exception:  # noqa: BLE001
+        return {}
+
+
+declared = (load(os.path.join(home, "settings.json")).get("extraKnownMarketplaces") or {}).get(MARKET, {}).get("source")
+known = (load(os.path.join(home, "plugins", "known_marketplaces.json")).get(MARKET) or {}).get("source")
+extra = []
+if isinstance(declared, dict):
+    extra = [k for k in FETCH_FIELDS if k in declared and (not isinstance(known, dict) or declared.get(k) != known.get(k))]
+
+claudes = find_claudes()
+if not claudes:
+    print("◐ 查不了：這台找不到任何 Claude Code 可執行檔（CLI 與 Desktop 都沒有）")
+    sys.exit(2)
+
+bad, unknown, extra_hit = [], [], False
+for name, exe in claudes:
+    label = f"{name} {version_of(exe)}"
+    state, data = ask(exe)
+    if state == "err":
+        unknown.append(name)
+        print(f"◐ {label}：查不了——{data}（讀不到不等於沒載入）")
+        print(f"   {exe}")
+        continue
+    entry = next((p for p in data if p.get("id") == PLUGIN_ID), None)
+    if entry is None:
+        bad.append(name)
+        print(f"❌ {label}：{PLUGIN_ID} 沒有安裝——用這個 Claude Code 開的 session 一支 ISEP 閘都沒有")
+        print("   修法：claude plugin marketplace add https://git.uncle6.me/inkstone/ISEP.git && claude plugin install isep@inkstone")
+        continue
+    errors = entry.get("errors") or []
+    if not errors:
+        print(f"✅ {label}：{PLUGIN_ID} {entry.get('version')} 已載入（enabled={entry.get('enabled')}）")
+        continue
+    bad.append(name)
+    print(f"❌ {label}：{PLUGIN_ID} {entry.get('version')} 沒有載入——用這個 Claude Code 開的 session 一支 ISEP 閘都沒有")
+    for e in errors:
+        print(f"   Claude Code 回報：{e}")
+    if extra:
+        extra_hit = True
+        print(f"   可能原因：~/.claude/settings.json 的 extraKnownMarketplaces.{MARKET}.source 多了 {', '.join(extra)}，"
+              "這一版把它當 git 抓取欄位，跟已安裝的 marketplace 對不上，整個 marketplace 被忽略")
+
+if extra_hit:
+    fields = ", ".join(repr(k) for k in extra)
+    print("修法（一行，只拿掉上面點名的欄位；改完完全關掉 Claude Desktop／重開 CLI session 再跑一次本指令）：")
+    print(f"   python3 -c \"import json,os;p=os.path.expanduser('~/.claude/settings.json');d=json.load(open(p));"
+          f"s=d['extraKnownMarketplaces']['{MARKET}']['source'];[s.pop(k,None) for k in ({fields},)];"
+          "json.dump(d,open(p,'w'),ensure_ascii=False,indent=2)\"")
+
+if bad:
+    sys.exit(1)
+sys.exit(2 if unknown else 0)

scripts/isep-nag

@@ -20,10 +20,15 @@ leo 整天上課，一天看兩眼。**不叫，就等於這件事不會發生
 （機器帳號 `claude-code` 在 `bots` 團隊，`/orgs/…/hooks` 回 403，裝不了）。
 **但腳本版本身是完整可用的，不是半成品。**
 
-━━ 撈三種東西 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+━━ 撈四種東西 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
   ① 逾期的 milestone      期限過了、票還沒關 ⇒ 那個版本交不出來了
   ② 掛著等 leo 的票        `Human` 或指派給 leo，**標等了幾天**
   ③ 棒子掉在地上的票        `s/doing`／`s/review` 卻很多天沒動 ⇒ 沒有人在做
+  ④ 有票卻沒有工人的 repo   名單（`agents/`）上沒人負責、卻有開著的票
+                           ⇒ 派工一定撞 roster-guard（inkstone/ISEP#118）
+     **只進長版**（開場給總管看），不進 Telegram 短版——補工人是總管的事，不吵 leo。
+     它回答的是「新 repo 的工人誰在什麼時候加」：建 repo 之後的**第一個 session 開場**，
+     由這支點名；在那之前沒有任何東西會提醒。
 
 每一條都用白話寫（`CLAUDE.md` 規則五）：一眼看懂、代號附一句人話、
 講「這對你意味什麼」而不是系統內部狀態。
@@ -69,6 +74,8 @@ HOST = os.environ.get("TICKET_HOST") or "https://git.uncle6.me"
 ORG = os.environ.get("ISEP_NAG_ORG") or "inkstone"
 STALE_DAYS = int(os.environ.get("ISEP_NAG_STALE_DAYS") or 3)
 HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "hooks", "lib"))
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
 
 # 「等 leo」的兩個訊號：掛 Human 標籤，或指派給他本人。
 HUMAN_LABEL = "Human"
@@ -78,23 +85,8 @@ BATON_LABELS = {"s/doing", "s/review"}
 
 
 def token():
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        v = os.environ.get(env)
-        if v:
-            return v
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
-    host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    return None
+    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 None（呼叫者自己判空）。
+    return _gitea_token()
 
 
 def api(path, tok):
@@ -133,10 +125,12 @@ def collect(fixture=None):
         return {"milestones": [], "issues": [], "error":
                 "拿不到 Gitea token（GITEA_TOKEN_CLAUDE_CODE 沒設，remote 也沒帶憑證）"}
 
+    # org 的 repo 清單**一律撈一次**：④「有票卻沒工人」要看整個 org，
+    # 而且這一通本來就要打（沒設 ISEP_NAG_REPOS 時），不多花 API。
+    org_rows = api("/orgs/%s/repos?limit=50" % ORG, tok) or []
     repos = os.environ.get("ISEP_NAG_REPOS", "").split()
     if not repos:
-        rows = api("/orgs/%s/repos?limit=50" % ORG, tok) or []
-        repos = [r.get("full_name") for r in rows if r.get("full_name")]
+        repos = [r.get("full_name") for r in org_rows if r.get("full_name")]
 
     # 🔴 平行撈，因為這支掛在 SessionStart 上——那是 leo 每次開工的關鍵路徑。
     #    循序版實測 16 秒（16 個 repo ＋ 5 頁票），**開場等 16 秒沒有人會忍受它，
@@ -175,7 +169,7 @@ def collect(fixture=None):
         issues.extend(rows)
         if len(rows) < 50:
             break
-    return {"milestones": milestones, "issues": issues}
+    return {"milestones": milestones, "issues": issues, "repos": org_rows}
 
 
 # ══ 二、找出「該叫的事」═══════════════════════════════════════════════════
@@ -227,7 +221,25 @@ def findings(data, now):
     waiting.sort(key=lambda x: -x["quiet_days"])
     dropped.sort(key=lambda x: -x["quiet_days"])
     return {"overdue_milestones": over, "waiting_on_leo": waiting,
-            "dropped_batons": dropped}
+            "dropped_batons": dropped,
+            "repos_without_worker": no_worker(data)}
+
+
+def no_worker(data):
+    """④ 有票卻沒有工人的 repo（inkstone/ISEP#118）。
+
+    回 list（可能是空的）；**名單讀不到或 org 清單沒撈到 ⇒ 回 None**，
+    報告裡講「沒查到」，不講成「每個 repo 都缺人」或「都有人」。
+    """
+    rows = data.get("repos")
+    if not rows:
+        return None
+    try:
+        sys.path.insert(0, os.path.join(HERE, "..", "hooks", "lib"))
+        import roster
+    except Exception:
+        return None
+    return roster.uncovered(rows)
 
 
 # ══ 三、講出來（白話）═════════════════════════════════════════════════════
@@ -260,12 +272,13 @@ def full_report(f, now, err=None):
                 "   ⇒ **這不等於「沒有事情逾期」**，這是「我沒查到」。兩件事不要講成同一句。"]
         return "\n".join(out)
 
-    n = sum(len(v) for v in f.values())
+    n = sum(len(f[k]) for k in ("overdue_milestones", "waiting_on_leo", "dropped_batons"))
     if n == 0:
         out += ["", "✅ **查過了，沒有。** 三類都乾淨：",
                 "   · 沒有逾期還開著票的 milestone",
                 "   · 沒有掛著等你的票",
                 "   · 沒有超過 %d 天沒動的 s/doing／s/review" % STALE_DAYS]
+        out += worker_section(f)
         return "\n".join(out)
 
     if f["overdue_milestones"]:
@@ -295,9 +308,30 @@ def full_report(f, now, err=None):
                           _clip(i["title"], 38)))
         out += _tail(f["dropped_batons"], MAX_ROWS)
         out.append("   ⇒ 對你意味著：這些不是在做，是沒人接。要嘛派人，要嘛改回 s/todo。")
+    out += worker_section(f)
     return "\n".join(out)
 
 
+def worker_section(f):
+    """④ 只進長版（開場注入給總管看的那份），**不進 Telegram 短版**：
+    派工是總管的事，不是 leo 的事——拿它去吵 leo 就是把總管的活推給他。"""
+    rows = f.get("repos_without_worker")
+    if rows is None:
+        return ["", "👷 有票卻沒有工人的 repo：**沒查到**（org 清單或工人名單讀不到）"
+                    "——這不等於「每個 repo 都有人」。"]
+    if not rows:
+        return ["", "👷 每個有開著票的 repo，名單上都有工人。"]
+    out = ["", "👷 **有票卻沒有工人的 repo（%d 個）**——派工到這裡會被 roster-guard 擋，"
+               "只剩開例外閘繞過去：" % len(rows)]
+    for r in rows[:MAX_ROWS]:
+        out.append("   · %s（%d 張票開著）" % (r["repo"], r["open"]))
+    out += _tail(rows, MAX_ROWS)
+    out.append("   ⇒ 對總管意味著：**先補工人再派工**——在 ISEP `agents/` 加一個 `.md`"
+               "（規約 docs/governance/worker-roster.md），或把它寫進既有工人的 `負責 repo`。"
+               "不要開 `/tmp/.roster-ok-*` 了事，那樣下一次還是會撞。")
+    return out
+
+
 def short_report(f, now, err=None):
     """Telegram 版：leo 在手機上一眼掃完、回一個詞。**寧短勿長。**"""
     if err:

scripts/isep-notify

@@ -72,6 +72,9 @@ GITEA_HOST = os.environ.get("TICKET_HOST") or "https://git.uncle6.me"
 PROD_STAMP = "/tmp/.prod-write-ok"
 GATE_FACT = "gate-verdict.json"
 
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "hooks", "lib"))
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
+
 
 # ══ 一、這個 session 的閘是哪一份、哪一版 ═══════════════════════════════
 #
@@ -302,23 +305,8 @@ def send_bot_api(text):
 
 # ══ 三、退路：貼回票上 ═══════════════════════════════════════════════════
 def gitea_token():
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        v = os.environ.get(env)
-        if v:
-            return v
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
-    host = GITEA_HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    return None
+    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 None（呼叫者自己判空）。
+    return _gitea_token()
 
 
 def fallback_body(text, gate_fact, why=None):

scripts/lib/gitea-token.sh

@@ -0,0 +1,44 @@
+#!/bin/sh
+# gitea-token.sh — 解出 Gitea 憑證（GITEA_TOKEN_CLAUDE_CODE）。source 它、呼叫 gitea_token()。
+#
+# 為什麼存在（inkstone/ISEP#47）：舊法用 `git remote get-url gitea | sed` 從 remote URL
+#   抽 token ⇒ token 必須明文嵌在 URL 裡 ⇒ 任何印出 remote URL 的訊息（git-lfs 的
+#   locksverify 那行）都會把它洩進 transcript／log。來源統一到這裡後，remote URL 才能改乾淨。
+#
+# 解析順序（先環境、後檔案——雲端只有 env、本機有 .env，兩邊都涵蓋）：
+#   1) 環境變數 $GITEA_TOKEN_CLAUDE_CODE（雲端 make-cloud-env 注入；本機 source .env 後也在）
+#   2) .env 的 GITEA_TOKEN_CLAUDE_CODE=（先找 $CLAUDE_PROJECT_DIR/.env，再找 git 根的 .env）
+#      —— 與既有 gitea_arm_token()（scripts/lib/gitea-arm-common.sh）同一條路，照既有寫法走。
+#   讀不到 → 印空字串、回非 0（呼叫者必須自己判空，不能把空字串當成功）。
+#
+# 🔴 只回值、不印別的——絕不 echo 出 token 以外的東西（避免洩進 log）。
+
+# 內部：從一個 .env 檔抓 GITEA_TOKEN_CLAUDE_CODE=，去掉外圍引號。
+_gitea_token_from_file() {
+  [ -f "$1" ] || return 1
+  _gt_val=$(grep '^GITEA_TOKEN_CLAUDE_CODE=' "$1" 2>/dev/null | head -1 | cut -d= -f2-)
+  _gt_val=${_gt_val%\"}; _gt_val=${_gt_val#\"}
+  _gt_val=${_gt_val%\'}; _gt_val=${_gt_val#\'}
+  [ -n "$_gt_val" ] || return 1
+  printf '%s' "$_gt_val"
+  return 0
+}
+
+gitea_token() {
+  # 1) 環境變數優先
+  if [ -n "${GITEA_TOKEN_CLAUDE_CODE:-}" ]; then
+    printf '%s' "$GITEA_TOKEN_CLAUDE_CODE"
+    return 0
+  fi
+  # 2) $CLAUDE_PROJECT_DIR/.env
+  if [ -n "${CLAUDE_PROJECT_DIR:-}" ] && _gitea_token_from_file "$CLAUDE_PROJECT_DIR/.env"; then
+    return 0
+  fi
+  # 3) git 根的 .env
+  _gt_root=$(git rev-parse --show-toplevel 2>/dev/null || true)
+  if [ -n "${_gt_root:-}" ] && _gitea_token_from_file "$_gt_root/.env"; then
+    return 0
+  fi
+  printf ''
+  return 1
+}

scripts/mainline

@@ -252,21 +252,50 @@ def cmd_set(argv):
         "members": [],
     }
     refs, info = collect_members(ms)
+    complete = bool(info.get("reached") and info.get("complete"))
+    if not complete:
+        # 名單不完整：同一條線重標時，舊快取裡有的成員先留著（讀不到 ≠ 沒有）
+        prev = ML.load() or {}
+        if prev.get("ref") == ms["ref"]:
+            refs = sorted(set(refs) | set(prev.get("members") or []))
     ms["members"] = refs
+    ms["members_complete"] = complete
+    ms["members_unread"] = incomplete_what(info)
     now = datetime.now(timezone.utc).astimezone().strftime("%Y-%m-%d %H:%M")
     ms["set_at"] = ms["refreshed_at"] = now
     if not ML.save(ms, mirror=True):
         die("🔴 寫不進 %s——主線沒有被標上。" % ML.path())
-    print("✅ 主線已標定：%s/%s#%d「%s」" % (owner, repo, mid, title))
+    # 🔴 inkstone/ISEP#130 c6973：名單不完整時不准印 ✅——雲端工人靠這份名單抓票，
+    #    漏收＝以為抓盡＝收工。主線本身照樣標定，壞的只有成員那一格，所以講清楚是哪一格。
+    print("%s 主線已標定：%s/%s#%d「%s」%s" % (
+        "✅" if complete else "⚠️", owner, repo, mid, title, "" if complete else "（🔴 成員不完整）"))
     if hub:
         print("   hub 票：%s" % hub)
     print(members_line(refs, info) if info.get("reached")
           else "   ⚠️ 讀不到 hub 里程碑裡的票，成員先留空（讀不到 ≠ 沒有）")
-    if info.get("capped"):
-        print("   ⚠️ 相依走到 %d 張就停了（上限），剩下的沒收" % ML.MEMBER_WALK_CAP)
+    if not complete:
+        print(incomplete_line(info))
     print(mirror_line())
     print()
     cmd_show([])
+    if not complete:
+        sys.exit(3)
+
+
+def incomplete_what(info):
+    """名單不完整的原因，寫進主線檔（讀檔的人不必重跑也看得出）。完整時回 []。"""
+    what = list(info.get("unread") or [])
+    if not info.get("reached"):
+        what.insert(0, "（hub 里程碑那一頁）")
+    if info.get("capped"):
+        what.append("（相依走到 %d 張上限）" % ML.MEMBER_WALK_CAP)
+    return what
+
+
+def incomplete_line(info):
+    return ("   🔴 成員不完整：讀不到 %s——那底下的前置沒收到。\n"
+            "      雲端工人靠這份名單抓票；Gitea 恢復後重跑 `mainline refresh --members`（或同一行 set）補齊。"
+            % "、".join(incomplete_what(info)))
 
 
 def mirror_line():
@@ -328,6 +357,9 @@ def cmd_refresh(argv):
     except SystemExit:
         return                      # 拿不到 token：主線已經在了，進度晚點再更新，不炸
     if not isinstance(d, dict) or not d.get("title"):
+        if "--members" in argv:     # 明講要成員的人要看得到結果（c6973：原本零輸出）
+            print("   ⚠️ 讀不到主線里程碑 %s——成員沒更新，沿用舊快取 %d 張"
+                  % (ML.ref_of(ms), len(ms.get("members") or [])))
         return                      # 讀不到 ≠ 主線不存在
     ms.update({
         "title": d.get("title") or ms["title"],
@@ -342,12 +374,19 @@ def cmd_refresh(argv):
         # 真 Gitea 實測 25 張成員要 19 秒 ⇒ SessionStart 那條不帶 --members（成本不變）；
         # `set`／`adopt` 會重收，`pick`／`has`／focus guard 本來就每次現問 Gitea，快取只餵 `show`。
         # 讀不到（reached=False）就保留舊快取——寧可資料舊，不要把成員弄丟。
+        # 🔴 inkstone/ISEP#130 c6973：只有**完整**的名單才准蓋掉快取；不完整就留舊的並講出來。
         try:
             refs, info = collect_members(ms)
         except SystemExit:
             refs, info = [], {"reached": False}
-        if info.get("reached"):
+        if info.get("reached") and info.get("complete"):
             ms["members"] = refs
+            ms["members_complete"], ms["members_unread"] = True, []
+            print(members_line(refs, info))
+        else:
+            ms["members_complete"], ms["members_unread"] = False, incomplete_what(info)
+            print("   ⚠️ 成員不完整，沿用舊快取 %d 張（沒有拿殘缺名單蓋掉）" % len(ms.get("members") or []))
+            print(incomplete_line(info))
     ML.save(ms)
 
 
@@ -391,13 +430,18 @@ hub 里程碑裡現在有：%s
         T.add_dependency(vparts, (owner, repo, num))
         how = "成為 hub 票 %s 的相依（%s/%s 沒有多出任何里程碑）" % (via, owner, repo)
     refs, info = collect_members(ms)
-    if info.get("reached"):
+    complete = bool(info.get("reached") and info.get("complete"))
+    if complete:
         ms["members"] = sorted(set(refs) | {ref})
     else:
-        ms["members"] = sorted(set(ms.get("members") or []) | {ref})
+        # 不完整（c6973）：新收到的與舊快取取聯集，不拿殘缺名單蓋掉
+        ms["members"] = sorted(set(ms.get("members") or []) | set(refs) | {ref})
+    ms["members_complete"], ms["members_unread"] = complete, incomplete_what(info)
     ML.save(ms, mirror=True)
     print("✅ 補收：%s → %s" % (ref, how))
-    print(members_line(ms["members"], info) if info.get("reached") else "   （成員清單沿用舊快取＋這一張）")
+    print(members_line(ms["members"], info) if complete else "   （成員清單＝舊快取＋這次讀得到的＋這一張）")
+    if not complete:
+        print(incomplete_line(info))
     print(mirror_line())
 
 

scripts/make-cloud-env.sh

@@ -5,7 +5,7 @@
 # 誤觸時怎麼關: 這支不擋任何東西。不想產生就別跑；產物在版控外，刪掉即可。
 #
 # 用法：bash scripts/make-cloud-env.sh
-# 產物：~/.claude/cloud-env/<日期>.txt（權限 600，**不在任何 repo 裡**）
+# 產物：~/Desktop/cloud-env-<版本>-<日期>.txt（權限 600，**不在任何 repo 裡**）；版本紀錄 docs/cloud-env-versions.tsv
 # 本腳本只寫「變數名字」，值在執行當下才從既有 .env 讀出來寫進產物 —— 值不進版控、不進對話。
 set -euo pipefail
 
@@ -44,6 +44,28 @@ NEEDED=(
   #    只有 namespace 是機敏 ⇒ 走環境變數。原本只住在 ~/.arcrun/config.yaml 的 api_key，
   #    那個檔在家目錄、不隨 clone 走 ⇒ 雲端永遠拿不到。
   ARCRUN_NS_YOULIN                       # youlin 實例的 namespace（X-Arcrun-API-Key）
+  ARCRUN_NS_UNCLE6                       # uncle6 實例的 namespace：出貨第 1、19、20 站派給 uncle6 工作流（inkstone/InkStoneCo#98 → comment 7739）
+
+  # ── prod 出貨把產物推上 GitHub 鏡像（第 14、21、22 站）──
+  #    🔴 名字進清單 ≠ 雲端可以自由寫 GitHub：`github-contact-guard.sh` 照樣擋，
+  #       寫入仍要 D20 開閘（保險檔落在哪由 inkstone/ISEP#157 處理）。
+  #       進清單是因為「拿不到這兩個名字」會讓 prod 那半在雲端**連開閘之後都走不下去**。
+  GITHUB_MIRROR_TOKEN                    # GitHub 鏡像 repo 的寫入 token（走標頭，不進網址）
+  GITHUB_ACCOUNT_NAME                    # 上面那把的帳號名（組鏡像 repo 路徑用，不是機密）
+
+  # ── 雲端工人的通知出口（v7，2026-09-18：leo 貼出現行雲端環境才發現 v1–v6 漏收）──
+  #    雲端走 Bot API 直送（`scripts/isep-notify`；leo21c 的 notify_leo 已於 08-14 消失，InkStoneCo#110）
+  TELEGRAM_CHAT_ID                       # 收訊的 chat id（不是機密）
+  TELEGRAM_BOT_TOKEN                     # 通知 bot 的 token
+)
+
+# 🔓 例外：值只住在 polaris/mira/.env、但**不是**打得到 leo21c 的憑證——點名放行，其他照擋（B8）
+#    Telegram 兩把是通知 bot，不碰任何 CF 帳號；雲端 09-18 前就已手動設了同樣的值。
+MIRA_ALLOWED=(TELEGRAM_CHAT_ID TELEGRAM_BOT_TOKEN)
+
+# ── 固定值（不是金鑰，產生器直接寫）──
+FIXED=(
+  "ISEP_DRAIN=1"                         # 雲端工人＝接票環境：ticket pick 自帶 --pool、佇列閘不准有票就收工（ISEP#130）
 )
 #
 # 🔴 這份清單的邊界——加一把之前先問「這把打得到哪個實例」，不是「這把方便嗎」
@@ -91,23 +113,42 @@ lookup() {  # $1=變數名 → 印出值（找不到就空）
   return 1
 }
 
-# 預設丟 ~/.claude/cloud-env（權限 700）。要放別的地方＝ OUT_DIR=~/Desktop bash scripts/make-cloud-env.sh
-OUT_DIR="${OUT_DIR:-$HOME/.claude/cloud-env}"
+# ── 版本（leo 2026-09-18：「你要有版本，因為這件事做了很多次，但你都沒記錄版本」）──
+# 真相源＝docs/cloud-env-versions.tsv（只記 key，不記值）。最後一列＝現行版。
+# 🔴 NEEDED 跟最後一列的 key 不一致 ⇒ 拒絕產生：改了清單就必須在 tsv 加一版。
+VERSIONS="$(cd "$(dirname "$0")/.." && pwd)/docs/cloud-env-versions.tsv"
+[ -f "$VERSIONS" ] || { echo "🔴 找不到 $VERSIONS" >&2; exit 1; }
+CUR_LINE=$(grep -v '^#' "$VERSIONS" | grep -v '^[[:space:]]*$' | tail -1)
+PREV_LINE=$(grep -v '^#' "$VERSIONS" | grep -v '^[[:space:]]*$' | tail -2 | head -1)
+VER=$(printf '%s' "$CUR_LINE" | cut -f1); VER_DATE=$(printf '%s' "$CUR_LINE" | cut -f2)
+VER_KEYS=$(printf '%s' "$CUR_LINE" | cut -f3); VER_WHY=$(printf '%s' "$CUR_LINE" | cut -f4)
+PREV_VER=$(printf '%s' "$PREV_LINE" | cut -f1); PREV_KEYS=$(printf '%s' "$PREV_LINE" | cut -f3)
+FIXED_NAMES=(); for kv in "${FIXED[@]}"; do FIXED_NAMES+=("${kv%%=*}"); done
+NEEDED_JOINED=$(IFS=,; printf '%s' "${NEEDED[*]} ${FIXED_NAMES[*]}" | tr ' ' ',')
+if [ "$NEEDED_JOINED" != "$VER_KEYS" ]; then
+  echo "🔴 NEEDED 與 $VERSIONS 最後一版（$VER）的 key 不一致——改了清單就要在 tsv 加一列新版本再跑。" >&2
+  echo "   NEEDED：$NEEDED_JOINED" >&2
+  echo "   $VER ：$VER_KEYS" >&2
+  exit 2
+fi
+ADDED=$(comm -13 <(tr , '\n' <<<"$PREV_KEYS" | sort) <(tr , '\n' <<<"$VER_KEYS" | sort) | paste -sd, -)
+REMOVED=$(comm -23 <(tr , '\n' <<<"$PREV_KEYS" | sort) <(tr , '\n' <<<"$VER_KEYS" | sort) | paste -sd, -)
+
+# 預設丟桌面（leo 2026-09-18 指定）。要放別的地方＝ OUT_DIR=<目錄> bash scripts/make-cloud-env.sh
+OUT_DIR="${OUT_DIR:-$HOME/Desktop}"
 mkdir -p "$OUT_DIR"
-# 只在「這個目錄是我們自己造的預設位置」時才收緊權限——
-# OUT_DIR 可被覆寫，不該對使用者指定的既有目錄（例如 ~/Desktop）動權限。
-[ "$OUT_DIR" = "$HOME/.claude/cloud-env" ] && chmod 700 "$OUT_DIR"
-OUT="$OUT_DIR/$(date +%Y%m%d-%H%M%S).txt"
+OUT="$OUT_DIR/cloud-env-${VER}-$(date +%Y%m%d-%H%M).txt"
 
 SETUP="$(cd "$(dirname "$0")/.." && pwd)/docs/cloud-setup-script.sh"
 [ -f "$SETUP" ] || { echo "🔴 找不到 $SETUP" >&2; exit 1; }
 
 MISSING=()
+# 🔴 兩個檔分開產（2026-09-18 實撞）：原本兩段放同一檔、中間用「════」分隔，
+#    leo 把分隔線一起貼進 Setup script 欄 ⇒ 雲端開機 exit 127「'════…': command not found」，
+#    每一趟 cloud-worker 在開機就死。⇒ 變數一個檔（只有 KEY=VALUE）、開機腳本一個檔（逐位元組＝cloud-setup-script.sh），
+#    **兩個檔都整份貼**，沒有任何要人自己裁切的地方。
+SETUP_OUT="${OUT%.txt}-setup-script.sh"
 {
-  echo "claude.ai → Cloud environments → 你的環境。下面兩塊各自貼進對應欄位。"
-  echo "產生時間：$(date '+%Y-%m-%d %H:%M')"
-  echo
-  echo "════════ ① Environment variables（一行一個，名字與值分開填）════════"
   for n in "${NEEDED[@]}"; do
     if v=$(lookup "$n"); then
       echo "$n=$v"
@@ -116,12 +157,20 @@ MISSING=()
       MISSING+=("$n")
     fi
   done
-  echo
-  echo "════════ ② Setup script（整段貼，一字不改）════════"
-  cat "$SETUP"
+  for kv in "${FIXED[@]}"; do echo "$kv"; done
 } > "$OUT"
-chmod 600 "$OUT"
+cp "$SETUP" "$SETUP_OUT"
+chmod 600 "$OUT" "$SETUP_OUT"
+{
+  echo "claude.ai → Cloud environments → 你的環境（${VER}，${VER_DATE}：${VER_WHY}）"
+  echo "比 ${PREV_VER} 多：${ADDED:-（無）}｜少：${REMOVED:-（無）}"
+  echo "① Environment variables 欄：整份貼 $(basename "$OUT")"
+  echo "② Setup script 欄：整份貼 $(basename "$SETUP_OUT")（一字不改，不要加任何東西）"
+  echo "貼完刪掉這三個檔。"
+} > "${OUT%.txt}-README.txt"
 
 echo "✅ 產生完成：$OUT"
+echo "   版本：${VER}（比 ${PREV_VER} 多：${ADDED:-無}｜少：${REMOVED:-無}）"
 echo "   變數 ${#NEEDED[@]} 個｜找不到值的 ${#MISSING[@]} 個 ${MISSING[*]:-}"
-echo "   🔴 這個檔含金鑰真身：貼完就刪（rm '$OUT'），它刻意不在任何 repo 裡。"
+echo "   開機腳本：$SETUP_OUT"
+echo "   🔴 含金鑰真身：貼完就刪（rm '${OUT%.txt}'*），它刻意不在任何 repo 裡。"

scripts/milestone-account

@@ -41,6 +41,8 @@ import urllib.request
 HOST = os.environ.get("MILESTONE_ACCOUNT_HOST", "https://git.uncle6.me")
 HERE = os.path.dirname(os.path.abspath(__file__))
 ROOT = os.path.dirname(HERE)
+sys.path.insert(0, os.path.join(HERE, "..", "hooks", "lib"))
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
 def _project_roots():
     """跟 `hooks/lib/mainline.py::project_roots()` 同一把尺（那裡是唯一定義；載不到才退回同形狀的內建）。"""
     try:
@@ -112,22 +114,8 @@ def die(msg, code=2):
 
 
 def token():
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or HERE
-    host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        if os.environ.get(env):
-            return os.environ[env]
-    return ""
+    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 ""（呼叫者自己判空）。
+    return _gitea_token() or ""
 
 
 _FX = None

scripts/pr-verdict

@@ -31,6 +31,9 @@ import urllib.request
 HOST = os.environ.get("PR_VERDICT_HOST", "https://git.uncle6.me")
 DRY = False
 
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "hooks", "lib"))
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
+
 
 def die(msg, code=2):
     print(msg, file=sys.stderr)
@@ -38,22 +41,12 @@ def die(msg, code=2):
 
 
 def token():
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
+    # 來源＝env／.env（ISEP#47），不碰 remote URL。解析順序見 hooks/lib/gitea_token.py。
+    tok = _gitea_token()
+    if tok:
+        return tok
     host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        if os.environ.get(env):
-            return os.environ[env]
-    die(f"🔴 拿不到 {host} 的 token（remote 沒帶憑證，也沒有 GITEA_TOKEN_CLAUDE_CODE）")
+    die(f"🔴 拿不到 {host} 的 token（沒有 GITEA_TOKEN_CLAUDE_CODE，.env 裡也沒有）")
 
 
 def api(path, payload=None, method=None, soft=False):

scripts/release-manifest

@@ -41,6 +41,8 @@ import urllib.request
 
 HOST = os.environ.get("RELEASE_MANIFEST_HOST", "https://git.uncle6.me")
 HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "hooks", "lib"))
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
 def _resolve_dir():
     """清單住哪裡。
 
@@ -74,22 +76,8 @@ def die(msg, code=2):
 
 
 def token():
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or HERE
-    host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host in line:
-            m = re.search(r"//[^:/]+:([^@]+)@", line)
-            if m:
-                return m.group(1)
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        if os.environ.get(env):
-            return os.environ[env]
-    return ""
+    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 ""（呼叫者自己判空）。
+    return _gitea_token() or ""
 
 
 def _fixture():

scripts/roster

@@ -53,7 +53,7 @@ def cmd_show(name):
 
 
 def cmd_which(repo):
-    hits = [w for w in R.load() if w["repo"].lower() == (repo or "").strip().lower()]
+    hits = R.which(repo)      # 一個工人可以管好幾個 repo（inkstone/ISEP#118）
     if not hits:
         print("🚫 名單上沒有負責「%s」的人。現有的是：" % repo, file=sys.stderr)
         for w in R.load():

scripts/test-baton-handback-guard.sh

@@ -1,11 +1,14 @@
 #!/bin/bash
 # 交棒警察的測試——三格（指派／tag／下一步）各自缺漏時要被抓到
-# 判準：5 種該報、5 種不該報
+# 判準：前景 5 種該報、5 種不該報；背景派工（inkstone/ISEP#153）送出時不報、交件時才報、只報一次；
+#       訊息印的出路照著貼真的跑得完。
 # 用 fixture 跑，不打網路、不在票池留下任何一張測試票。
 cd "$(dirname "$0")/.." || exit 1
+ROOT=$(pwd)
 H=hooks/baton-handback-guard.sh
 PASS=0; FAIL=0
-FX=$(mktemp -d); trap 'rm -rf "$FX"' EXIT
+FX=$(mktemp -d); ST=$(mktemp -d); trap 'rm -rf "$FX" "$ST"' EXIT
+export CLAUDE_PLUGIN_ROOT="$ROOT" ISEP_BATON_STATE_DIR="$ST"
 
 mkfx(){ # $1=state $2=assignees(csv) $3=labels(csv) $4=有沒有交棒留言(y/n)
   python3 - "$FX" "$1" "$2" "$3" "$4" <<'PY'
@@ -22,12 +25,15 @@ json.dump(comments, open(os.path.join(d, "comments.json"), "w"))
 PY
 }
 
+judge(){ # $1=want $2=got $3=說明
+  if [ "$2" = "$1" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
+  printf 'want=%s got=%s  %s\n' "$1" "$2" "$3"
+}
+
 run(){ # $1=want $2=說明  （fixture 已備好）
   printf '%s' '{"tool_name":"Agent","tool_input":{"prompt":"【工單】inkstone/arcrun-rag#136\n做點事"}}' \
     | BATON_GUARD_FIXTURE="$FX" bash "$H" >/dev/null 2>&1
-  got=$?
-  if [ "$got" = "$1" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-  printf 'want=%s got=%s  %s\n' "$1" "$got" "$2"
+  judge "$1" "$?" "$2"
 }
 
 echo "── 該報：三格有缺 ──"
@@ -46,9 +52,98 @@ mkfx closed ""            ""                  n ; run 0 "票已關＝棒子到
 echo "── 派工單裡沒有【工單】那行 ⇒ 不歸這支管 ──"
 printf '%s' '{"tool_name":"Agent","tool_input":{"prompt":"隨便做點事"}}' \
   | BATON_GUARD_FIXTURE="$FX" bash "$H" >/dev/null 2>&1
-got=$?
-if [ "$got" = 0 ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-printf 'want=0 got=%s  沒有票號的派工單\n' "$got"
+judge 0 "$?" "沒有票號的派工單"
+
+# ═══ inkstone/ISEP#153：背景派工 ═══════════════════════════════════════
+post(){ # $1=tool_response JSON  → 離開碼
+  printf '{"hook_event_name":"PostToolUse","tool_name":"Agent","tool_input":{"prompt":"【工單】inkstone/arcrun-rag#136\\n做點事","run_in_background":true},"tool_response":%s}' "$1" \
+    | BATON_GUARD_FIXTURE="$FX" bash "$H" >/dev/null 2>&1
+}
+
+echo "── 驗收 1：背景派工送出的那一刻不報（票上三格全缺也一樣）──"
+mkfx open "" "s/doing" n
+post '{"isAsync":true,"status":"async_launched","agentId":"a93f7dc98c50fc671","description":"x"}'
+judge 0 "$?" "launch ack（toolUseResult 真跡的形狀：isAsync／async_launched）"
+post '[{"type":"text","text":"Async agent launched successfully. (This tool result is internal metadata)\nagentId: a1"}]'
+judge 0 "$?" "launch ack 只剩文字 content 陣列時也認得"
+post '{"status":"completed","content":[{"type":"text","text":"工作做完了"}]}'
+judge 2 "$?" "驗收 3 對照：前景派工回來（不是 launch ack）照舊要報"
+
+# 假 transcript：派工 tool_use ＋ launch ack ＋（可選）完工通知
+TP="$ST/main.jsonl"
+mktx(){ # $1=通知對到哪個 tool-use-id（空＝還沒交件） $2=通知 status  $3=派工單第一行
+  python3 - "$TP" "$1" "$2" "$3" <<'PY'
+import json, sys
+tp, note_id, status, first = sys.argv[1:5]
+L = []
+def add(o): L.append(json.dumps(o, ensure_ascii=False))
+for tid, line in (("toolu_AAA", first), ("toolu_BBB", "【工單】inkstone/ISEP#999")):
+    add({"type": "assistant", "message": {"role": "assistant", "content": [
+        {"type": "tool_use", "id": tid, "name": "Agent",
+         "input": {"prompt": line + "\n做點事", "run_in_background": True}}]}})
+    add({"type": "user", "message": {"role": "user", "content": [
+        {"type": "tool_result", "tool_use_id": tid,
+         "content": [{"type": "text", "text": "Async agent launched successfully."}]}]},
+         "toolUseResult": {"isAsync": True, "status": "async_launched"}})
+if note_id:
+    n = ("<task-notification>\n<task-id>a1</task-id>\n<tool-use-id>%s</tool-use-id>\n"
+         "<status>%s</status>\n<summary>Agent finished</summary>\n<result>好了</result>\n"
+         "</task-notification>") % (note_id, status)
+    # 真跡裡同一則通知出現三次：enqueue／attachment／remove
+    add({"type": "queue-operation", "operation": "enqueue", "content": n})
+    add({"type": "attachment", "attachment": {"type": "queued_command", "prompt": n}})
+    add({"type": "queue-operation", "operation": "remove", "content": n})
+open(tp, "w").write("\n".join(L) + "\n")
+PY
+}
+stop(){ # $1=session id → 離開碼；stderr 存到 $ST/err
+  printf '{"hook_event_name":"Stop","session_id":"%s","transcript_path":"%s","stop_hook_active":false}' "$1" "$TP" \
+    | BATON_GUARD_FIXTURE="$FX" bash "$H" >/dev/null 2>"$ST/err"
+}
+
+echo "── 驗收 2：背景工人真的交件時才報 ──"
+mkfx open "" "s/doing" n
+mktx "" "" "【工單】inkstone/arcrun-rag#136"
+stop s1; judge 0 "$?" "工人還在跑（沒有完工通知）⇒ 不報"
+mktx toolu_AAA completed "【工單】inkstone/arcrun-rag#136"
+stop s1; got=$?; judge 2 "$got" "完工通知 completed ＋ 票上三格全缺 ⇒ 報"
+if grep -q 'inkstone/arcrun-rag#136' "$ST/err" && ! grep -q 'ISEP#999' "$ST/err"; then got=ok; else got=bad; fi
+judge ok "$got" "只點名那一則通知對到的票（tool-use-id 比對；另一條還在跑的 #999 不點）"
+cp "$ST/err" "$ST/msg"
+stop s1; judge 0 "$?" "同一則通知第二次 Stop ⇒ 不鬼打牆（只點名一次）"
+mktx toolu_AAA killed "【工單】inkstone/arcrun-rag#136"
+stop s2; judge 0 "$?" "通知不是 completed（killed）⇒ 不當成交件"
+mkfx open "claude-code" "s/review" y
+mktx toolu_AAA completed "【工單】inkstone/arcrun-rag#136"
+stop s3; judge 0 "$?" "交件時三格已經補齊 ⇒ 安靜（出路：補完就不再出現）"
+mkfx open "" "s/doing" n
+mktx toolu_AAA completed "隨便做點事，沒有工單"
+stop s4; judge 0 "$?" "交件的那條派工單沒有【工單】⇒ 不歸這支管"
+printf '{"hook_event_name":"Stop","session_id":"s5","transcript_path":"/nonexistent"}' \
+  | BATON_GUARD_FIXTURE="$FX" bash "$H" >/dev/null 2>&1
+judge 0 "$?" "讀不到 transcript ⇒ 放行"
+
+echo "── 出路：訊息印的那塊指令照著貼真的跑得完 ──"
+BLK=$(python3 - "$ST/msg" <<'PY'
+import sys, re
+t = open(sys.argv[1], encoding="utf-8").read()
+m = re.search(r'^\s*("[^"\n]*/scripts/ticket" handback .*?--evidence "[^"\n]*")', t, re.S | re.M)
+if not m:
+    raise SystemExit
+b = m.group(1)
+b = b.replace("<收下的人第一件事要做什麼，一句話>", "去複驗")
+b = re.sub(r"<s/review｜[^>]*>", "s/review", b)
+b = b.replace("<實測輸出或 PR 連結>", "測試")
+print(b)
+PY
+)
+case "$BLK" in /*|\"/*) got=abs ;; *) got="${BLK:0:30}" ;; esac
+judge abs "$got" "出路印的是絕對路徑（InkStoneCo/scripts/ticket 是舊複本，沒有 handback）"
+OFF="TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN_CLAUDE_CODE=fake ISEP_API_RETRIES=0"
+env $OFF bash -c "$BLK" >/dev/null 2>&1
+judge 1 "$?" "★ 原樣貼上只填三格 ⇒ 參數全過、走到網路才停（離開碼 1；2＝被自己的用法擋下）"
+env $OFF bash -c "${BLK/--next/--nope}" >/dev/null 2>&1
+judge 2 "$?" "對照組：拿掉 --next ⇒ 確實跑不完（上一條才有鑑別力）"
 
 echo
 echo "$PASS/$((PASS+FAIL)) 通過"

scripts/test-gitea-token.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# Gitea token 解析器的測試（inkstone/ISEP#47）——鎖住「token 只從 env／.env 來，
+# 絕不從 remote URL 抽」這條規約。一支解析器兩份實作（Python：hooks/lib/gitea_token.py；
+# shell：scripts/lib/gitea-token.sh），兩份必須解出同一把、順序一致，所以一起測。
+#
+# 全程離線：造暫存的 .env 與乾淨／髒的 git remote，**不打 Gitea、不碰 $HOME、不留測試票**。
+#
+# 為什麼要有這支：ISEP#47 的洩漏源是「token 明文嵌在 remote URL 裡」。
+#   c9128 複驗指出雲端那次只改了 6 支、漏了 8 支 Python，且雲端有環境變數所以測不出
+#   本機（只有 .env）的壞法。這支把那個壞法變成一條會紅的測試——
+#   remote 髒、但 token 只在 URL 裡時，解析器**必須解不出**（否則洩漏源還在）。
+cd "$(dirname "$0")/.." || exit 1
+REPO=$PWD                                  # ISEP 樹根：子 shell cd 進暫存目錄後仍要指得回來
+PYLIB=hooks/lib/gitea_token.py
+SHLIB=scripts/lib/gitea-token.sh
+PASS=0; FAIL=0
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
+TOK=deadbeefdeadbeefdeadbeefdeadbeef00001111   # 假 token，40 字，長得像真的
+
+ok(){ # $1=條件 $2=說明
+  if eval "$1"; then PASS=$((PASS+1)); printf '  ✅ %s\n' "$2"
+  else FAIL=$((FAIL+1)); printf '  ❌ %s\n     判準：%s\n' "$2" "$1"; fi
+}
+
+# 造一個 git repo，remote 可選乾淨或髒（把 token 嵌進 URL＝重現舊洩漏源）
+mkrepo(){ # $1=repo 目錄 $2=dirty|clean $3=有沒有 .env(env|noenv)
+  d="$T/$1"; mkdir -p "$d"; ( cd "$d" && git init -q )
+  if [ "$2" = "dirty" ]; then
+    ( cd "$d" && git remote add origin "https://claude-code:${TOK}@git.uncle6.me/inkstone/ISEP.git" )
+  else
+    ( cd "$d" && git remote add origin "https://git.uncle6.me/inkstone/ISEP.git" )
+  fi
+  [ "$3" = "env" ] && printf 'FOO=x\nGITEA_TOKEN_CLAUDE_CODE=%s\nBAR=y\n' "$TOK" > "$d/.env"
+  echo "$d"
+}
+
+# 解析器跑一次：清掉環境變數（除非 $WITHENV），回傳解出的值到 $GOT
+resolve_py(){ # $1=cwd $2=CLAUDE_PROJECT_DIR(空=不設) $3=setenv|noenv
+  local envargs="-u GITEA_TOKEN_CLAUDE_CODE -u GITEA_TOKEN"
+  [ "$3" = "setenv" ] && envargs="GITEA_TOKEN_CLAUDE_CODE=$TOK"
+  # 空＝真的不設：CC session 會繼承一個 CLAUDE_PROJECT_DIR，不 -u 掉就會解到真的 token（09-19 在本機實撞）。
+  # env 的 -u 一定要排在 NAME=VALUE 前面，所以「要設」時放在最後、「不設」時併進 -u 那串。
+  local pd=""; if [ -n "$2" ]; then pd="CLAUDE_PROJECT_DIR=$2"; else envargs="-u CLAUDE_PROJECT_DIR $envargs"; fi
+  GOT=$( cd "$1" && env $envargs $pd python3 -c "
+import sys; sys.path.insert(0,'$REPO/hooks/lib')
+from gitea_token import gitea_token
+print(gitea_token() or '')" 2>/dev/null )
+}
+resolve_sh(){ # 同上，走 shell 版
+  local envargs="-u GITEA_TOKEN_CLAUDE_CODE -u GITEA_TOKEN"
+  [ "$3" = "setenv" ] && envargs="GITEA_TOKEN_CLAUDE_CODE=$TOK"
+  # 空＝真的不設：CC session 會繼承一個 CLAUDE_PROJECT_DIR，不 -u 掉就會解到真的 token（09-19 在本機實撞）。
+  # env 的 -u 一定要排在 NAME=VALUE 前面，所以「要設」時放在最後、「不設」時併進 -u 那串。
+  local pd=""; if [ -n "$2" ]; then pd="CLAUDE_PROJECT_DIR=$2"; else envargs="-u CLAUDE_PROJECT_DIR $envargs"; fi
+  GOT=$( cd "$1" && env $envargs $pd sh -c ". $REPO/$SHLIB; gitea_token" 2>/dev/null )
+}
+
+echo "── 解析順序：先 env、再 \$CLAUDE_PROJECT_DIR/.env、最後 git 根的 .env ──"
+
+# ① 環境變數優先（就算 .env 沒有也拿得到）
+R=$(mkrepo r1 clean noenv)
+resolve_py "$R" "" setenv;  ok '[ "$GOT" = "$TOK" ]' 'Py ① 環境變數在 → 解得出'
+resolve_sh "$R" "" setenv;  ok '[ "$GOT" = "$TOK" ]' 'sh ① 環境變數在 → 解得出'
+
+# ② 沒有環境變數，token 在 $CLAUDE_PROJECT_DIR/.env（＝本機 Mac 的實況）
+R=$(mkrepo r2 clean env)
+resolve_py "$R" "$R" noenv; ok '[ "$GOT" = "$TOK" ]' 'Py ② 無 env、CLAUDE_PROJECT_DIR/.env 有 → 解得出（c9128 的壞法，這條要綠）'
+resolve_sh "$R" "$R" noenv; ok '[ "$GOT" = "$TOK" ]' 'sh ② 無 env、CLAUDE_PROJECT_DIR/.env 有 → 解得出'
+
+# ③ 沒有環境變數、沒設 CLAUDE_PROJECT_DIR，token 在 git 根的 .env
+R=$(mkrepo r3 clean env)
+resolve_py "$R" "" noenv;   ok '[ "$GOT" = "$TOK" ]' 'Py ③ 退到 git 根的 .env → 解得出'
+resolve_sh "$R" "" noenv;   ok '[ "$GOT" = "$TOK" ]' 'sh ③ 退到 git 根的 .env → 解得出'
+
+echo "── 洩漏源必須斷：token 只在 remote URL 裡時，解析器不准解出它 ──"
+
+# ④ remote 髒（URL 嵌 token）、但沒有 env、沒有 .env ⇒ 必須解不出（否則 ISEP#47 沒修好）
+R=$(mkrepo r4 dirty noenv)
+resolve_py "$R" "" noenv;   ok '[ -z "$GOT" ]' 'Py ④ 只有髒 remote → 解不出（不再從 URL 抽 token）'
+resolve_sh "$R" "" noenv;   ok '[ -z "$GOT" ]' 'sh ④ 只有髒 remote → 解不出'
+
+# ⑤ 什麼都沒有 ⇒ 空
+R=$(mkrepo r5 clean noenv)
+resolve_py "$R" "" noenv;   ok '[ -z "$GOT" ]' 'Py ⑤ 什麼都沒有 → 空'
+resolve_sh "$R" "" noenv;   ok '[ -z "$GOT" ]' 'sh ⑤ 什麼都沒有 → 空'
+
+echo "── 八支腳本在「本機實況」下都拿得到 token（無 env＋乾淨 remote＋.env 有）──"
+# 走到 token 之後就打不通的 host，區分：印「拿不到 token」＝死在 token 步；連線失敗＝已過 token 步。
+R=$(mkrepo r6 clean env)
+past_token(){ # $1=說明 其餘=命令
+  local desc="$1"; shift
+  local out; out=$( cd "$R" && env -u GITEA_TOKEN_CLAUDE_CODE -u GITEA_TOKEN CLAUDE_PROJECT_DIR="$R" \
+        TICKET_HOST="http://127.0.0.1:9" MILESTONE_ACCOUNT_HOST="http://127.0.0.1:9" \
+        PR_VERDICT_HOST="http://127.0.0.1:9" RELEASE_MANIFEST_HOST="http://127.0.0.1:9" \
+        "$@" 2>&1 )
+  if echo "$out" | grep -q "拿不到.*token"; then ok 'false' "$desc（死在 token 步）"
+  else ok 'true' "$desc"; fi
+}
+past_token 'ticket mine 過 token'        python3 "$PWD/scripts/ticket" mine
+past_token 'isep-nag 過 token'           python3 "$PWD/scripts/isep-nag"
+past_token 'isep-notify 過 token'        python3 "$PWD/scripts/isep-notify" --text probe --ticket inkstone/ISEP#47
+past_token 'milestone-account 過 token'  python3 "$PWD/scripts/milestone-account"
+past_token 'pr-verdict 過 token'         python3 "$PWD/scripts/pr-verdict" --pr inkstone/ISEP#1
+past_token 'debt-worklist 過 token'      python3 "$PWD/scripts/debt-worklist"
+
+echo ""
+echo "通過 $PASS 條，失敗 $FAIL 條（共 $((PASS+FAIL)) 條）"
+[ "$FAIL" -eq 0 ]

scripts/test-github-contact-guard.sh

@@ -71,6 +71,34 @@ runc 0 "$W/body/sub" 'git push origin x'
 runc 0 "$W/shell" "cd $W && git -C body push origin x"
 runc 0 "$W/body"  "(cd $W/shell && true); git push origin x"
 
+echo "── subagent 走同一條判斷：payload 帶 agent_id/agent_type 拿到跟總管一模一樣的判決（inkstone/ISEP#119）──"
+# 為什麼這群非有不可（inkstone/ISEP#119）：2026-09-01 一個 subagent 把分支推上 GitHub
+# 沒經過解保險，同時總管這端擋得住——表面像「subagent 端失效」。但官方文件講明：
+# subagent 的 tool 呼叫照樣觸發同一批 PreToolUse hook，只是 input 多帶 agent_id/agent_type
+# （https://code.claude.com/docs/en/hooks）。這支閘從頭到尾不讀那兩個欄位 ⇒ 它**無從**
+# 只擋總管或只擋 subagent。當天真正的洞是同一族的 cwd 病（上面 ISEP#109 那組）：
+# subagent 站在薄殼、靠 cd/-C 推它自己那顆 origin＝github 的 repo，舊版在錯的目錄解 origin
+# ⇒ 放行。這群把「帶 agent_id 的 payload 判決 == 不帶的判決」釘死，證明沒有 subagent 專屬破口。
+runsub(){ # $1=want $2=cwd $3=cmd —— 同一條指令跑兩次：帶 agent_id（subagent）與不帶（總管），
+          # 兩次都必須等於 want，才算「subagent 與總管走同一條判斷、拿同一個結果」。
+  local want="$1" cwd="$2" cmd="$3" a b
+  a=$(printf '%s' "{\"tool_name\":\"Bash\",\"cwd\":$(python3 -c 'import json,sys;print(json.dumps(sys.argv[1]))' "$cwd"),\"agent_id\":\"agt_119\",\"agent_type\":\"isep-hand\",\"tool_input\":{\"command\":$(python3 -c 'import json,sys;print(json.dumps(sys.argv[1]))' "$cmd")}}" \
+    | bash "$H" >/dev/null 2>&1; echo $?)
+  b=$(printf '%s' "{\"tool_name\":\"Bash\",\"cwd\":$(python3 -c 'import json,sys;print(json.dumps(sys.argv[1]))' "$cwd"),\"tool_input\":{\"command\":$(python3 -c 'import json,sys;print(json.dumps(sys.argv[1]))' "$cmd")}}" \
+    | bash "$H" >/dev/null 2>&1; echo $?)
+  if [ "$a" = "$want" ] && [ "$b" = "$want" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
+  printf 'want=%s subagent=%s 總管=%s  cwd=%s  %.48s\n' "$want" "$a" "$b" "${cwd#$W/}" "$cmd"
+}
+echo "  · subagent 推 GitHub（含 09-01 的 cd/-C 原形狀）→ 擋，且與總管同判"
+runsub 2 "$W/shell" 'git push origin x'
+runsub 2 "$W/body"  "cd $W/shell && git push origin x"
+runsub 2 "$W/body"  "git -C $W/shell push origin x"
+runsub 2 "$W/shell" 'gh api repos/example/example/issues'
+echo "  · subagent 推 Gitea／讀取 → 放行，且與總管同判（沒有為了擋 subagent 而擋過頭）"
+runsub 0 "$W/body"  'git push origin x'
+runsub 0 "$W/shell" "git -C $W/body push origin x"
+runsub 0 "$W/shell" 'git clone https://github.com/example/example.git'
+
 echo
 echo "$PASS/$((PASS+FAIL)) 通過"
 [ "$FAIL" -eq 0 ]

scripts/test-isep-doctor-live.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+# 實測：scripts/isep-doctor 對**真的** Claude Code（這台的 CLI 與 Desktop 內建那一份）判得對不對（inkstone/ISEP#150）
+#
+# 不動 ~/.claude：把 inkstone marketplace 與 isep 安裝紀錄複製到 mktemp 的隔離 HOME，
+# 分別放「有 path」「沒有 path」兩份 settings.json，用真的可執行檔跑 doctor。
+# 會打網路：只有 Claude Code 自己可能匿名讀 git.uncle6.me（Gitea），不碰 GitHub、不寫任何遠端。
+#
+# 期望（09-13 在 CLI 2.1.220／Desktop 2.1.266 上實測過的行為）：
+#   沒有 path             ⇒ 兩個都 ✅，離開碼 0                          （真陰性）
+#   有 path、Desktop 2.1.266 ⇒ ❌ 並點名 path                             （真陽性）
+#   有 path、CLI 2.1.220     ⇒ ✅，不因設定長相被判 ❌                      （舊版 doctor 的假陽性）
+# 版本不是這兩個時，該版本那一格印 SKIP（行為可能不同，不假裝驗過）。
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+R="$HOME/.claude/plugins"
+[ -d "$R/cache/inkstone" ] && [ -d "$R/marketplaces/inkstone" ] || { echo "SKIP：這台沒有安裝 isep@inkstone，無從複製"; exit 0; }
+
+CLI=$(command -v claude || true)
+DESK=$(ls -d "$HOME/Library/Application Support/Claude/claude-code/"*/claude.app/Contents/MacOS/claude 2>/dev/null \
+       | python3 -c 'import sys,re;L=[l.strip() for l in sys.stdin if l.strip()];k=lambda p:tuple(int(x) for x in re.search(r"/claude-code/([0-9.]+)/",p).group(1).split(".") if x);print(sorted(L,key=k)[-1] if L else "")')
+BINS=""; [ -n "$CLI" ] && BINS="CLI=$CLI"; [ -n "$DESK" ] && BINS="${BINS:+$BINS:}Desktop=$DESK"
+[ -n "$BINS" ] || { echo "SKIP：找不到任何 Claude Code"; exit 0; }
+vcli=$([ -n "$CLI" ] && "$CLI" --version | awk '{print $1}'); vdesk=$([ -n "$DESK" ] && "$DESK" --version | awk '{print $1}')
+echo "CLI=${CLI:-無} ${vcli:-}｜Desktop=${DESK:-無} ${vdesk:-}"
+
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
+C="$T/home/.claude"; mkdir -p "$C/plugins/cache" "$C/plugins/marketplaces"
+cp -R "$R/cache/inkstone" "$C/plugins/cache/" && cp -R "$R/marketplaces/inkstone" "$C/plugins/marketplaces/"
+python3 - "$R" "$C" <<'EOF'
+import json, sys
+R, C = sys.argv[1], sys.argv[2]
+km = json.load(open(R + "/known_marketplaces.json"))
+json.dump({"inkstone": json.loads(json.dumps(km["inkstone"]).replace(R, C + "/plugins"))}, open(C + "/plugins/known_marketplaces.json", "w"))
+ip = json.load(open(R + "/installed_plugins.json"))
+ip["plugins"] = {"isep@inkstone": ip["plugins"]["isep@inkstone"]}
+json.dump(json.loads(json.dumps(ip).replace(R, C + "/plugins")), open(C + "/plugins/installed_plugins.json", "w"))
+src = {"source": "git", "url": "https://git.uncle6.me/inkstone/ISEP.git"}
+json.dump({"enabledPlugins": {"isep@inkstone": True}, "extraKnownMarketplaces": {"inkstone": {"source": src}}}, open(C + "/settings.nopath.json", "w"))
+src["path"] = "/Users/youlinhsieh/Documents/tech_projects/ISEP"
+json.dump({"enabledPlugins": {"isep@inkstone": True}, "extraKnownMarketplaces": {"inkstone": {"source": src}}}, open(C + "/settings.path.json", "w"))
+EOF
+cp -R "$C" "$T/pristine"
+
+pass=0; fail=0; skip=0
+doctor() { # settings 變體
+  rm -rf "$C" && cp -R "$T/pristine" "$C" && cp "$C/settings.$1.json" "$C/settings.json"
+  OUT=$(cd "$T" && env -u CLAUDE_CODE_CHILD_SESSION HOME="$T/home" ISEP_DOCTOR_CLAUDE_BINS="$BINS" python3 "$HERE/isep-doctor" 2>&1); CODE=$?
+  echo "── settings=$1（exit=$CODE）"; printf '%s\n' "$OUT" | sed 's/^/   /'
+}
+has() { printf '%s' "$OUT" | grep -q -- "$1"; }
+judge() { if eval "$2"; then pass=$((pass+1)); echo "ok   $1"; else fail=$((fail+1)); echo "FAIL $1"; fi; }
+
+doctor nopath
+judge "真陰性：沒有 path → 離開碼 0、沒有 ❌" '[ "$CODE" = 0 ] && ! has "❌"'
+
+doctor path
+if [ "$vdesk" = 2.1.266 ]; then
+  judge "真陽性：Desktop 2.1.266 有 path → ❌ 並點名 path、離開碼 1" '[ "$CODE" = 1 ] && has "❌ Desktop 2.1.266" && has "多了 path"'
+else skip=$((skip+1)); echo "SKIP 真陽性：Desktop 是 ${vdesk:-無}，不是 2.1.266"; fi
+if [ "$vcli" = 2.1.220 ]; then
+  judge "假陽性：CLI 2.1.220 有 path 但實際載入 → ✅" 'has "✅ CLI 2.1.220"'
+else skip=$((skip+1)); echo "SKIP 假陽性：CLI 是 ${vcli:-無}，不是 2.1.220"; fi
+
+echo "pass=$pass fail=$fail skip=$skip"; [ "$fail" = 0 ]

scripts/test-isep-doctor.sh

@@ -0,0 +1,95 @@
+#!/usr/bin/env bash
+# 迴歸測試：scripts/isep-doctor（inkstone/ISEP#150）——全離線
+# 用假的 claude 可執行檔（shell 腳本）代替真的 CLI／Desktop，走的是 doctor 真正的 subprocess 那條路。
+# 真的 Claude Code 版本的實測在 scripts/test-isep-doctor-live.sh。
+set -u
+HERE="$(cd "$(dirname "$0")" && pwd)"
+T=$(mktemp -d); trap 'rm -rf "$T"' EXIT
+pass=0; fail=0
+URL=https://git.uncle6.me/inkstone/ISEP.git
+
+mkfake() { # 路徑 版本 plugin-list 輸出（原樣印出）
+  mkdir -p "$(dirname "$1")"
+  printf '%s' "$3" > "$1.out"
+  cat > "$1" <<EOF
+#!/bin/sh
+if [ "\$1" = "--version" ]; then echo "$2 (Claude Code)"; exit 0; fi
+cat "$1.out"
+EOF
+  chmod +x "$1"
+}
+run() { OUT=$(ISEP_DOCTOR_CLAUDE_HOME="$T/home" python3 "$HERE/isep-doctor" 2>&1); CODE=$?; }
+ok()  { pass=$((pass+1)); echo "ok   $1"; }
+bad() { fail=$((fail+1)); echo "FAIL $1 (exit=$CODE)"; printf '%s\n' "$OUT" | sed 's/^/     /'; }
+expect() { # 名稱 離開碼 要有的樣式（| 分隔，可空） 不准有的樣式（可空）
+  local p miss=""
+  [ "$CODE" = "$2" ] || miss="exit"
+  local IFS='|'
+  for p in $3; do printf '%s' "$OUT" | grep -q -- "$p" || miss="$miss 缺[$p]"; done
+  if [ -n "${4:-}" ] && printf '%s' "$OUT" | grep -q -- "$4"; then miss="$miss 多了[$4]"; fi
+  [ -z "$miss" ] && ok "$1" || { bad "$1 →$miss"; }
+}
+
+mkdir -p "$T/home/plugins"
+echo "{\"inkstone\":{\"source\":{\"source\":\"git\",\"url\":\"$URL\"}}}" > "$T/home/plugins/known_marketplaces.json"
+SET_PATH="{\"extraKnownMarketplaces\":{\"inkstone\":{\"source\":{\"source\":\"git\",\"url\":\"$URL\",\"path\":\"/Users/x/ISEP\"}}},\"model\":\"keep\"}"
+SET_CLEAN="{\"extraKnownMarketplaces\":{\"inkstone\":{\"source\":{\"source\":\"git\",\"url\":\"$URL\"}}}}"
+LOADED='[{"id":"isep@inkstone","version":"0.30.1","enabled":true}]'
+NOTFOUND='[{"id":"isep@inkstone","version":"0.30.1","enabled":true,"errors":["Marketplace inkstone not found"]}]'
+
+# ① 假陽性（c6991）：設定有 path，但這個 Claude Code 自己回報載入正常 → ✅、不准點名 path
+echo "$SET_PATH" > "$T/home/settings.json"
+mkfake "$T/b/cli" 2.1.220 "$LOADED"
+export ISEP_DOCTOR_CLAUDE_BINS="CLI=$T/b/cli"; run
+expect "① 有 path 但實際載入（2.1.220 形狀）→ ✅ 不點名 path" 0 "✅ CLI 2.1.220" "path"
+
+# ② 真陽性（c6990）：同一份設定，CLI 載得進、Desktop 載不進 → 1；兩邊各講各的；點名 path；給修法
+mkfake "$T/b/desk" 2.1.266 "$NOTFOUND"
+export ISEP_DOCTOR_CLAUDE_BINS="CLI=$T/b/cli:Desktop=$T/b/desk"; run
+expect "② CLI 載得進、Desktop 載不進 → 1，逐一講、點名 path" 1 "✅ CLI 2.1.220|❌ Desktop 2.1.266|Marketplace inkstone not found|多了 path|^   python3 "
+printf '%s' "$OUT" | grep -q "CLI 與 Desktop 都一樣" && bad "② 不准再說 CLI 與 Desktop 都一樣" || ok "② 沒有把整台機器講成同一個結論"
+
+# ③ 真陰性：拿掉 path，兩邊都載入 → 0
+echo "$SET_CLEAN" > "$T/home/settings.json"
+mkfake "$T/b/desk" 2.1.266 "$LOADED"; run
+expect "③ 沒有 path、兩邊都載入 → 0" 0 "✅ CLI 2.1.220|✅ Desktop 2.1.266" "❌"
+
+# ④ 別的原因失敗（設定沒有多餘欄位）→ 1，照實轉述，不編原因、不給 path 修法
+mkfake "$T/b/desk" 2.1.266 '[{"id":"isep@inkstone","version":"0.30.1","enabled":true,"errors":["Plugin directory missing"]}]'; run
+expect "④ 其他錯誤照實轉述、不編原因" 1 "❌ Desktop|Plugin directory missing" "修法（一行"
+
+# ⑤ 沒安裝 → 1
+mkfake "$T/b/desk" 2.1.266 '[]'; run
+expect "⑤ 沒安裝 → 1" 1 "❌ Desktop 2.1.266：isep@inkstone 沒有安裝"
+
+# ⑥ 查不了（輸出不是 JSON）＋另一個正常 → 2，◐，不准講成 ❌ 或 ✅
+mkfake "$T/b/desk" 2.1.266 'Error: something broke'; run
+expect "⑥ 一個查不了、一個正常 → 2" 2 "◐ Desktop|讀不到不等於沒載入|✅ CLI" "❌"
+
+# ⑦ 一個 Claude Code 都找不到 → 2
+export ISEP_DOCTOR_CLAUDE_BINS=""; run
+expect "⑦ 找不到任何 Claude Code → 2" 2 "◐ 查不了"
+
+# ⑧ 修法那一行真的修得好（在假 HOME 上原封不動執行印給 leo 的那一行）
+echo "$SET_PATH" > "$T/home/settings.json"
+mkfake "$T/b/desk" 2.1.266 "$NOTFOUND"
+export ISEP_DOCTOR_CLAUDE_BINS="Desktop=$T/b/desk"; run
+fixline=$(printf '%s\n' "$OUT" | grep '^   python3 ' | sed 's/^   //')
+mkdir -p "$T/fake/.claude" && cp "$T/home/settings.json" "$T/fake/.claude/settings.json"
+HOME="$T/fake" bash -c "$fixline"
+if [ -n "$fixline" ] && python3 -c "import json,sys;d=json.load(open('$T/fake/.claude/settings.json'));s=d['extraKnownMarketplaces']['inkstone']['source'];sys.exit(0 if 'path' not in s and d['model']=='keep' and s['url'].endswith('ISEP.git') else 1)"; then
+  ok "⑧ 修法一行拿掉 path、其他設定不動"
+else fail=$((fail+1)); echo "FAIL ⑧ 修法一行"; cat "$T/fake/.claude/settings.json"; fi
+# ⑧b 修完再問一次（Desktop 改回報正常）→ 0：出路走得通
+cp "$T/fake/.claude/settings.json" "$T/home/settings.json"; mkfake "$T/b/desk" 2.1.266 "$LOADED"; run
+expect "⑧b 照修法修完再跑 → ✅" 0 "✅ Desktop" "多了 path"
+
+# ⑨ 自動尋找：Desktop 取數字上最新的那一份（2.1.99 < 2.1.266，字串排序會選錯）
+unset ISEP_DOCTOR_CLAUDE_BINS
+D="$T/h9/Library/Application Support/Claude/claude-code"
+mkfake "$D/2.1.99/claude.app/Contents/MacOS/claude" 2.1.99 "$NOTFOUND"
+mkfake "$D/2.1.266/claude.app/Contents/MacOS/claude" 2.1.266 "$LOADED"
+OUT=$(HOME="$T/h9" PATH="/usr/bin:/bin" ISEP_DOCTOR_CLAUDE_HOME="$T/home" /usr/bin/env python3 "$HERE/isep-doctor" 2>&1); CODE=$?
+expect "⑨ Desktop 取最新版本（數字排序）" 0 "✅ Desktop 2.1.266" "2.1.99"
+
+echo "pass=$pass fail=$fail"; [ "$fail" = 0 ]

scripts/test-make-cloud-env.sh

@@ -35,6 +35,7 @@ NEEDED=()
 while IFS= read -r l; do NEEDED+=("$l"); done < <(
   sed -n '/^NEEDED=(/,/^)/p' "$S" | sed -E '1d;$d; s/[[:space:]]*#.*$//; s/[[:space:]]//g' | grep -v '^$')
 [ "${#NEEDED[@]}" -gt 0 ] || { echo "🔴 從 $S 讀不出 NEEDED，測試本身壞了"; exit 1; }
+MIRA_ALLOWED=($(sed -n 's/^MIRA_ALLOWED=(\(.*\))/\1/p' "$S"))
 echo "清單（只有名字）：${NEEDED[*]}"
 echo
 
@@ -59,6 +60,19 @@ chk 0 "$miss" "A3 每個名字都帶著值出現在 ① 區塊"
 printf '%s\n' "$OUT_LINE" | grep -q "找不到值的 0 個" \
   && ok "A4 收尾那行說「找不到值的 0 個」" || bad "A4 收尾計數不對：$OUT_LINE"
 
+# 版本（leo 2026-09-18）：產物檔頭帶現行版本號；清單改了沒升版要拒絕
+grep -q "（v[0-9]" "${F%.txt}-README.txt" && ok "V1 README 寫著版本號" || bad "V1 README 沒有版本號"
+# 2026-09-18 實撞：兩段同檔、分隔線被貼進 Setup script 欄 ⇒ 雲端開機 exit 127。分檔後兩件事要守住：
+bad_lines=$(grep -cvE '^[A-Z][A-Z0-9_]*=' "$F")
+chk 0 "$bad_lines" "V3 變數檔每一行都是 KEY=VALUE（沒有分隔線、說明文字）"
+cmp -s "${F%.txt}-setup-script.sh" "$(cd "$(dirname "$S")/.." && pwd)/docs/cloud-setup-script.sh" \
+  && ok "V4 開機腳本檔與 docs/cloud-setup-script.sh 逐位元組相同" || bad "V4 開機腳本檔被加料了"
+VT="$(cd "$(dirname "$S")/.." && pwd)/docs/cloud-env-versions.tsv"; VB="$VT.bak-test"
+cp "$VT" "$VB"; printf 'v999\t2099-01-01\tNOPE_ONLY\t測試用\n' >> "$VT"
+INKSTONE_ROOT="$FAKE" OUT_DIR="$OUTD" bash "$S" >/dev/null 2>&1; rc=$?
+mv "$VB" "$VT"
+chk 2 "$rc" "V2 清單與最後一版 key 不一致時拒絕產生（離開碼 2）"
+
 # 缺值時不准假綠：拿掉第一個，它要變成 <🔴 …> 且計數變 1
 grep -v "^${NEEDED[0]}=" "$FAKE/.env" > "$FAKE/.env.tmp" && mv "$FAKE/.env.tmp" "$FAKE/.env"
 OUT2=$(INKSTONE_ROOT="$FAKE" OUT_DIR="$OUTD" bash "$S" 2>&1)
@@ -104,7 +118,7 @@ else
     if r=$(real_src "$n"); then
       len="${r%% *}"; src="${r#* }"
       printf '     %-38s → 找得到（長度 %s）來自 %s\n' "$n" "$len" "${src#$BASE/}"
-      case "$src" in */polaris/mira/.env) prod=$((prod+1)); echo "     🔴 ↑ 這是 leo21c 現役正式環境那份 .env";; esac
+      case "$src" in */polaris/mira/.env) if printf '%s\n' "${MIRA_ALLOWED[@]}" | grep -qx "$n"; then echo "     🔓 ↑ 點名放行（MIRA_ALLOWED：通知 bot，不碰 CF）"; else prod=$((prod+1)); echo "     🔴 ↑ 這是 leo21c 現役正式環境那份 .env"; fi;; esac
     else
       printf '     %-38s → 🔴 這台拿不到\n' "$n"; gone=$((gone+1))
     fi

scripts/test-milestone-account.sh

@@ -125,10 +125,15 @@ else
   printf '  ❌ ⑯ REPORT.md 內容不對\n'; FAIL=$((FAIL+1))
 fi
 N=$((N+1))
-if [ "$(wc -l < "$TMP/led/ledger.jsonl")" = "4" ]; then
+# 🔴 inkstone/ISEP#161：macOS/BSD 的 `wc -l` 會在數字前墊空白（GNU coreutils 不會），
+# 直接拿去跟 "4" 比較永遠是 "       4" != "4" ⇒ 這格從一開始就沒真的比對過筆數，
+# 不是帳本筆數漂了，是這支測試在 macOS 上的比對方式本身有 bug。
+# 用 tr -d ' ' 去掉墊白後才是真的整數比較（同款修法見 inkstone/ISEP#161 對 test-stage.sh 的處理）。
+LEDGER_LINES=$(wc -l < "$TMP/led/ledger.jsonl" 2>/dev/null | tr -d ' ')
+if [ "$LEDGER_LINES" = "4" ]; then
   printf '  ✅ ⑰ 帳本剛好四筆（沒有被擋下的那幾次也記進去）\n'; PASS=$((PASS+1))
 else
-  printf '  ❌ ⑰ 帳本筆數不對：%s\n' "$(wc -l < "$TMP/led/ledger.jsonl" 2>/dev/null)"
+  printf '  ❌ ⑰ 帳本筆數不對：%s\n' "$LEDGER_LINES"
   FAIL=$((FAIL+1))
 fi
 

scripts/test-stage.sh

@@ -107,16 +107,16 @@ no_value(){ ! printf '%s' "$OUT" | grep -qF "$STAGE_TEST_VALUE"; }
 
 echo "── A. 本工具自己拒絕的：離開碼 2，而且沒打網路 ──"
 reset; run secret put --worker w --secret X --from-env STAGE_TEST_VALUE --token-env TOK_STAGE --account 58309bb90fd93ad6d0fe0aae99170e9d
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q "$STAGE" && printf '%s' "$OUT" | grep -q '交回地端' && [ "$(wc -l < "$LOG")" = 0 ] \
-  && ok "A1 --account 給非 stage（uncle6 的 ID）⇒ 拒絕、講出 stage 是誰、出路是交回地端、一個請求都沒發" || bad "A1 rc=$RC hits=$(wc -l < "$LOG") $OUT"
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q "$STAGE" && printf '%s' "$OUT" | grep -q '交回地端' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] \
+  && ok "A1 --account 給非 stage（uncle6 的 ID）⇒ 拒絕、講出 stage 是誰、出路是交回地端、一個請求都沒發" || bad "A1 rc=$RC hits=$(wc -l < "$LOG" | tr -d " ") $OUT"
 reset; run secret put --worker w --secret X --from-env STAGE_TEST_VALUE --token-env NOPE_TOKEN_VAR
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_TOKEN_VAR' && [ "$(wc -l < "$LOG")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_TOKEN_VAR' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] \
   && ok "A2 token 的環境變數沒值 ⇒ 拒絕、點名那個變數、沒打網路" || bad "A2 rc=$RC $OUT"
 reset; run secret put --worker w --secret X --from-env NOPE_VALUE_VAR --token-env TOK_STAGE
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_VALUE_VAR' && printf '%s' "$OUT" | grep -q '紅線' && [ "$(wc -l < "$LOG")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_VALUE_VAR' && printf '%s' "$OUT" | grep -q '紅線' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] \
   && ok "A3 值的環境變數沒值 ⇒ 拒絕、點名變數、明講不准改寫進指令列、沒打網路" || bad "A3 rc=$RC $OUT"
 reset; run secret put --worker w --secret X --value "$STAGE_TEST_VALUE" --token-env TOK_STAGE
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--value' && no_value && [ "$(wc -l < "$LOG")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--value' && no_value && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] \
   && ok "A4 --value（值在指令列）⇒ 拒收，而且拒絕訊息裡不回顯那個值" || bad "A4 rc=$RC $OUT"
 reset; run secret put --secret X --from-env STAGE_TEST_VALUE --token-env TOK_STAGE
 [ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--worker' && ok "A5 缺 --worker ⇒ 拒絕、講缺哪個" || bad "A5 rc=$RC $OUT"
@@ -169,14 +169,14 @@ reset leo21c; run secret delete --worker w --secret X --token-env TOK_STAGE
 
 echo "── D. api：主機只會是 stage、標頭值從環境變數來、body 三種來源 ──"
 reset; run api POST https://arcrun-cypher-executor.leo21c.workers.dev/kbdb/entries --json '{}'
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'leo21c.workers.dev' && printf '%s' "$OUT" | grep -q 'arcrun-yuga3bse' && [ "$(wc -l < "$LOG")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'leo21c.workers.dev' && printf '%s' "$OUT" | grep -q 'arcrun-yuga3bse' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] \
   && ok "D1 完整網址指到 leo21c ⇒ 拒絕、講出 stage 主機是什麼、沒打網路" || bad "D1 rc=$RC $OUT"
 reset; run api POST https://arcrun-kbdb.youlin-hsieh-dev.workers.dev/records --json '{}'
-[ "$RC" = 2 ] && [ "$(wc -l < "$LOG")" = 0 ] && ok "D2 09-02 已死的舊子網域 youlin-hsieh-dev 也拒絕（不是 stage 的識別碼）" || bad "D2 rc=$RC $OUT"
+[ "$RC" = 2 ] && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] && ok "D2 09-02 已死的舊子網域 youlin-hsieh-dev 也拒絕（不是 stage 的識別碼）" || bad "D2 rc=$RC $OUT"
 reset; run api POST arcrun-kbdb/records --bearer 'Bearer xyz' --json '{}'
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--bearer' && [ "$(wc -l < "$LOG")" = 0 ] && ok "D3 --bearer／--header（值在指令列）⇒ 拒收" || bad "D3 rc=$RC $OUT"
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--bearer' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] && ok "D3 --bearer／--header（值在指令列）⇒ 拒收" || bad "D3 rc=$RC $OUT"
 reset; run api POST arcrun-kbdb/records --bearer-env NOPE_KBDB --json '{}'
-[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_KBDB' && [ "$(wc -l < "$LOG")" = 0 ] && ok "D4 --bearer-env 指的變數沒值 ⇒ 拒絕、點名" || bad "D4 rc=$RC $OUT"
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_KBDB' && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] && ok "D4 --bearer-env 指的變數沒值 ⇒ 拒絕、點名" || bad "D4 rc=$RC $OUT"
 reset; run api POST 'arcrun-kbdb/map/recompute?library=rt-lib&owner_id=yuga3bse' --bearer-env KBDB_TOK_TEST
 [ "$RC" = 0 ] && grep -q '"method": "POST", "path": "/arcrun-kbdb/map/recompute?library=rt-lib&owner_id=yuga3bse", "auth": "Bearer kbdb-' "$LOG" \
   && printf '%s' "$OUT" | grep -q '^HTTP 200' && ok "D5 POST <worker>/<path>?query：主機由工具補、query 原樣、Bearer 從環境變數來、印 HTTP 200、離開碼 0" || bad "D5 rc=$RC $OUT $(cat "$LOG")"
@@ -198,7 +198,7 @@ grep -q '"xkey": "kbdb-' "$LOG" && ok "D12 --header-env Name=VAR：任意標頭
 reset; run api POST https://arcrun-kbdb.arcrun-yuga3bse.workers.dev/records --bearer-env KBDB_TOK_TEST --json '{}'
 [ "$RC" = 0 ] && grep -q '"path": "/arcrun-kbdb/records"' "$LOG" && ok "D13 完整網址但主機就是 stage ⇒ 收" || bad "D13 rc=$RC $OUT"
 reset; run api POST 'arcrun-kbdb/records' --bearer-env KBDB_TOK_TEST --json '{}' --data-file x
-[ "$RC" = 2 ] && [ "$(wc -l < "$LOG")" = 0 ] && ok "D14 --json 與 --data-file 同時給 ⇒ 拒絕" || bad "D14 rc=$RC"
+[ "$RC" = 2 ] && [ "$(wc -l < "$LOG" | tr -d " ")" = 0 ] && ok "D14 --json 與 --data-file 同時給 ⇒ 拒絕" || bad "D14 rc=$RC"
 reset; run api FROB arcrun-kbdb/records
 [ "$RC" = 2 ] && ok "D15 不認得的 METHOD ⇒ 拒絕" || bad "D15 rc=$RC"
 reset; STAGE_API_BASE_OVERRIDE="http://127.0.0.1:1" run api GET arcrun-cypher-executor/health

scripts/test-ticket-api-bypass-guard.sh

@@ -68,7 +68,10 @@ echo "   裸引號的 python dict 寫法，跟 2026-08-27 那 13 張票實際的
 echo "   curl -d 那種「JSON 被跳脫成字串塞進另一層引號」的寫法，本閘的猜題功能"
 echo "   刻意不支援，見 hook 檔頭「只認雙引號」那段註解，訊息裡不會列候選舊票，"
 echo "   但擋下來這件事不受影響，另有獨立案例覆蓋。）"
-if git remote -v 2>/dev/null | grep 'git\.uncle6\.me' | grep -q '@'; then
+# 能不能打網路：看 token 解不解得出來（inkstone/ISEP#47 之後 remote URL 乾淨、不再帶憑證，
+# 舊判準「remote 有沒有 @」會讓這條在每台機器上永遠 SKIP ⇒ 等於沒有這條測試）
+_GT_TOK=""; . "$(dirname "$0")/lib/gitea-token.sh" 2>/dev/null && _GT_TOK=$(gitea_token 2>/dev/null || true)
+if [ -n "$_GT_TOK" ]; then
   OUT=$(printf '%s' "{\"tool_name\":\"Bash\",\"tool_input\":{\"command\":$(python3 -c 'import json,sys;print(json.dumps(sys.argv[1]))' 'req("POST", f"{API}/repos/{REPO}/issues", {"title":"總圖說我一條關聯都沒有，三元組 graph 全部消失"})')}}" \
     | bash "$H" 2>&1 >/dev/null)
   RC=$?
@@ -79,7 +82,7 @@ if git remote -v 2>/dev/null | grep 'git\.uncle6\.me' | grep -q '@'; then
     printf '%s\n' "$OUT"
   fi
 else
-  echo "  ⏭️  SKIP（這台機器的 git remote 沒帶 git.uncle6.me 的憑證，連不上就不算數）"
+  echo "  ⏭️  SKIP（解不出 Gitea token：沒有 \$GITEA_TOKEN_CLAUDE_CODE、\$CLAUDE_PROJECT_DIR/.env 也沒有，連不上就不算數）"
 fi
 
 [ -n "$SAVED" ] && printf '%s' "$SAVED" > /tmp/.ticket-where-ok

scripts/test-ticket-handoff-writeback.sh

@@ -269,6 +269,21 @@ b "labels.yaml 沒有的旅程名 → 擋下來（要求標籤在場，不是猜
 b "擋下來時直接指回 labels.yaml（不叫人自己猜怎麼修）" "True" \
   "'labels.yaml' in buf" "${A_BASE[@]}" --journey 沒這條旅程
 
+echo
+echo "── ⑨ inkstone/ISEP#123：交棒留言的人閘記號（純函式 handback_comment_lines）──"
+echo "     --to Leo ＝要 leo 親手做 ⇒ 第一行掛 👤，他掃一長串留言一眼認得出在等他；"
+echo "     🏃 那一塊照舊留著（baton-handback-guard 靠它判斷交棒了沒）。"
+p "★ --to Leo → 第一行以 👤 開頭（等 leo 動手一眼認得出）" "True" \
+  "m.handback_comment_lines('Leo','貼一組碼放行出貨')[0].startswith('👤')"
+p "★ --to Leo → 🏃 仍在留言裡（拔掉它 baton-handback-guard 會漏擋）" "True" \
+  "any('🏃' in x for x in m.handback_comment_lines('Leo','貼一組碼放行出貨'))"
+p "--to Leo → 第一行講得出「要做什麼」（下一步就在 👤 那一行）" "True" \
+  "'貼一組碼放行出貨' in m.handback_comment_lines('Leo','貼一組碼放行出貨')[0]"
+p "--to claude-code（交回總管）→ 第一行仍是 🏃，不掛 👤（那不是等 leo 的）" "True" \
+  "m.handback_comment_lines('claude-code','去驗那一格')[0].startswith('🏃') and not any('👤' in x for x in m.handback_comment_lines('claude-code','去驗那一格'))"
+p "證據與未關相依照舊接在後面（沒被人閘記號擠掉）" "True" \
+  "any('證據' in x for x in m.handback_comment_lines('Leo','n',ev='http://x')) and any('未關的相依' in x for x in m.handback_comment_lines('Leo','n',openn=[{'repository':{'full_name':'inkstone/ISEP'},'number':9,'title':'t'}]))"
+
 echo
 echo "通過 $PASS 條，失敗 $FAIL 條"
 [ "$FAIL" = 0 ] || exit 1

scripts/test-ticket-pick.sh

@@ -21,7 +21,7 @@ PASS=0; FAIL=0
 export TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN=x
 export ISEP_COUNTDOWN_STATE_DIR="$TMP/state"; mkdir -p "$ISEP_COUNTDOWN_STATE_DIR"
 export ISEP_COUNTDOWN_NOW=$(python3 -c 'import datetime as d;print(int(d.datetime(2026,9,7,0,0,tzinfo=d.timezone.utc).timestamp()))')
-unset ISEP_MAINLINE_FILE ISEP_IDENTITY CLAUDE_PROJECT_DIR
+unset ISEP_MAINLINE_FILE ISEP_IDENTITY CLAUDE_PROJECT_DIR ISEP_DRAIN ISEP_WORKER_LOGIN
 
 MAIN="$TMP/mainline.json"
 cat > "$MAIN" <<'JSON'
@@ -57,9 +57,21 @@ POOL = {
   "Arcrun": [I("Arcrun", 6, ["s/todo", "p/high"], "main", created="2026-08-27T00:00:00Z"),  # ★ 主線裡最優先
              I("Arcrun", 7, ["s/todo"], "late"),                               # 逾期里程碑：主線抓盡才輪到
              I("Arcrun", 8, ["s/todo"], "future")],                            # 不是主線也沒逾期：永遠不抓
-  "mira": [I("mira", 9, ["s/todo", "s/doing"], "main")],                       # 09-07 實查 mira#6 的形狀：有人在做
+  "mira": [I("mira", 9, ["s/todo", "s/doing"], "main"),                       # 09-07 實查 mira#6 的形狀：有人在做
+           # ── 票池那一層才看得到的（inkstone/ISEP#130）：都沒有里程碑 ──
+           I("mira", 20, ["s/triage"], None),                                  # 還沒決定要不要做：不抓
+           I("mira", 21, [], None),                                            # 沒有 s/*（還沒驗傷）：不抓，但要被點名
+           I("mira", 22, ["s/todo"], None, assignees=("Leo",)),                # 指派 Leo：不抓
+           I("mira", 23, ["s/backlog", "Human"], None),                        # Human：不抓
+           I("mira", 24, ["s/review"], None),                                  # 等總管：不抓
+           I("mira", 25, ["s/backlog", "p/high"], None, created="2026-09-05T00:00:00Z"),  # ★ 票池裡最優先
+           I("mira", 26, ["s/todo", "hub"], None),                             # hub：容器不是任務
+           I("mira", 27, ["Human"], None)],                                    # 沒 s/* 但掛 Human：不抓、也不分診（ISEP#159）
+  # 分頁：伺服器每頁上限 30（比 pick 要的 50 小）——只看「不滿一頁」就停的寫法會漏掉第 31 張之後的
+  "big": [I("big", n, [], None) for n in range(1, 31)] + [I("big", 31, ["s/backlog"], None)],
 }
 MSN = {"ISEP": ["main", "late", "future"], "Arcrun": ["main", "late", "future"], "mira": ["main"]}
+SERVER_PAGE_MAX = 30
 # 相依邊（inkstone/ISEP#133）：主線錨在 Arcrun#48，Arcrun#6 把 ISEP#1 當相依 ⇒ ISEP#1 在主線上；
 # ISEP#13 掛在 ISEP 的同名里程碑但沒有任何邊 ⇒ 不在主線上。mira#9 同理（同名、沒邊）。
 DEPS = {"Arcrun#6": ["ISEP#1"]}
@@ -84,9 +96,13 @@ def fake_api(path, payload=None, method=None):
         repo = path.split("/")[3]
         import urllib.parse
         q = urllib.parse.parse_qs(path.split("?", 1)[1])
-        want = q.get("milestones", [""])[0]
-        return [i for i in POOL[repo] if (i["milestone"] or {}).get("title") == want
-                and f"{repo}#{i['number']}" not in DROP]
+        rows = [i for i in POOL[repo] if f"{repo}#{i['number']}" not in DROP]
+        if "milestones" in q:
+            want = q["milestones"][0]
+            return [i for i in rows if (i["milestone"] or {}).get("title") == want]
+        # 不帶里程碑＝整個 repo 的 open 票（票池那一層），照 Gitea 的分頁
+        page = int(q.get("page", ["1"])[0]); per = min(int(q.get("limit", ["50"])[0]), SERVER_PAGE_MAX)
+        return rows[(page - 1) * per: page * per]
     if path.endswith("/labels?limit=100"):
         return [{"name": n, "id": k} for k, n in
                 enumerate(["s/todo", "s/doing", "s/review", "p/high", "Human"], 1)]
@@ -182,7 +198,10 @@ export DROP='["Arcrun#6","ISEP#1"]'
 p "★ 主線兩張都被拿走後 → 回逾期里程碑的 Arcrun#7" "True" "'inkstone/Arcrun#7' in out and rc is None" "$ARGS"
 export DROP='["Arcrun#6","ISEP#1","Arcrun#7"]'
 p "★ 主線與逾期都抓盡 → 離開碼 1（真的沒有，不是故障）" "1" "rc" "$ARGS"
-p "訊息明講「不要去抓 backlog」（出路是收工回報，不是換規則）" "True" "'backlog' in out and '收工' in out" "$ARGS"
+p "沒帶 --pool 時訊息明講「這一趟沒有看票池」並給出 --pool 這條路（ISEP#130：不再說成正常收工）" "True" \
+  "'沒有看票池' in out and '--pool' in out and '不是故障' not in out" "$ARGS"
+p "沒帶 --pool、主線與逾期都抓盡 → 票池一通都沒讀（本機總管不會因此被點名去抓票池）" "False" \
+  "any('page=' in p for _,p,_ in rec)" "$ARGS"
 p "抓盡時**沒有**回 Arcrun#8（未來里程碑）" "False" "'Arcrun#8' in out" "$ARGS"
 unset DROP
 
@@ -236,6 +255,63 @@ p "擋下時訊息講得出理由與出路（pick）" "True" "'Human' in out and
 p "身份名不在名單上 → 在打任何 API 之前就擋（一通都沒打）" "True" "rc==2 and len(rec)==0" \
   "[\"cmd_claim\",\"inkstone/Arcrun#6\",\"--mainline\",\"$MAIN\",\"--name\",\"路人\"]"
 
+echo
+echo "── ⑤ 票池那一層（inkstone/ISEP#130 c7801：幾百張 open 票，工人卻回「沒事做」）──"
+POOLA="[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--pool\"]"
+POOLALL="[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--pool\",\"--all\",\"--json\"]"
+p "pickable：s/backlog 在票池那一層可抓" "True" "m.pickable(I('ISEP',4,['s/backlog'],None),None,None,m.POOL_STATUSES)[0]"
+p "pickable：s/triage 在票池那一層仍不可抓（要不要做還沒決定）" "False" "m.pickable(I('x',1,['s/triage'],None),None,None,m.POOL_STATUSES)[0]"
+p "pickable：沒有 s/* 仍不可抓，理由講得出「沒有 s/*」" "True" "'沒有 s/*' in m.pickable(I('x',1,[],None),None,None,m.POOL_STATUSES)[1]"
+p "pickable：票池裡的 backlog 掛 Human → 不可抓（不該碰的一格都沒放寬）" "False" "m.pickable(I('x',1,['s/backlog','Human'],None),None,None,m.POOL_STATUSES)[0]"
+p "pickable：票池裡指派給 Leo → 不可抓" "False" "m.pickable(I('x',1,['s/todo'],None,assignees=('Leo',)),None,'claude-code',m.POOL_STATUSES)[0]"
+p "順序：同優先序 s/todo 先於 s/backlog" "True" \
+  "m.pick_order(I('a',9,['s/todo'],None)) < m.pick_order(I('a',1,['s/backlog'],None))"
+p "主線有票時帶 --pool 也照樣先回主線的 Arcrun#6，票池一通都沒讀（能省就省）" "True" \
+  "'inkstone/Arcrun#6' in out and not any('page=' in p for _,p,_ in rec)" "$POOLA"
+export DROP='["Arcrun#6","ISEP#1","Arcrun#7"]'
+p "★ 主線與逾期都抓盡、帶 --pool → 回票池裡最優先的 mira#25（p/high 的 backlog）" "True" \
+  "'inkstone/mira#25' in out and rc is None" "$POOLA"
+p "★ --all：票池可抓的恰好是這幾張，照 p/high → s/todo → s/backlog 排（Human／指派 Leo／triage／沒 s/*／review／s/doing／hub／PR 都不在）" \
+  "['inkstone/mira#25', 'inkstone/ISEP#5', 'inkstone/Arcrun#8', 'inkstone/ISEP#13', 'inkstone/ISEP#4', 'inkstone/big#31']" \
+  "[r['ref'] for r in json.loads(out) if r['group']=='票池']" "$POOLALL"
+p "★ 分頁：伺服器每頁只給 30 張時，第 31 張（big#31）照樣讀得到" "True" "'inkstone/big#31' in out" "$POOLALL"
+p "票池那一層也只讀不寫" "True" "all(mm=='GET' for mm,_,_ in rec)" "$POOLALL"
+export ISEP_DRAIN=1
+p "★ 環境 ISEP_DRAIN=1（雲端工人的環境）＝ 帶 --pool，指令不必改" "True" \
+  "'inkstone/mira#25' in out and rc==0" "[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--json\"]"
+unset ISEP_DRAIN
+unset DROP
+export DROP='["Arcrun#6","ISEP#1","Arcrun#7","mira#25","Arcrun#8","ISEP#13","ISEP#5","ISEP#4","big#31"]'
+p "★ 票池抓盡、但還有沒 s/* 的票 → 回一張待分診的（同一天開的，票號序第一的 big#1），下一步是 triage 不是 claim（ISEP#159）" "True" \
+  "rc is None and 'inkstone/big#1' in out and ' triage inkstone/big#1 ' in out and 'claim inkstone/big#1' not in out" "$POOLA"
+p "--json：待分診那一列帶 group=待分診 與貼了就能跑的 next（佇列閘照它印）" "True" \
+  "(lambda r: r['group']=='待分診' and ' triage ' in r['next'])(json.loads(out))" \
+  "[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--pool\",\"--json\"]"
+p "待分診那一層不回掛 Human 的 mira#27（沒 s/* 也不碰）" "False" "'mira#27' in out" "$POOLALL"
+p "pick --claim 遇到待分診的票 → 不認領（沒有任何寫入）" "True" \
+  "not any(mm in ('PATCH','PUT','POST') for mm,_,_ in rec)" \
+  "[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--pool\",\"--claim\"]"
+export DROP='["Arcrun#6","ISEP#1","Arcrun#7","mira#25","Arcrun#8","ISEP#13","ISEP#5","ISEP#4","big#31","mira#21"'"$(python3 -c 'print("".join(",\"big#%d\"" % n for n in range(1,31)))')"']'
+p "★ 票池與待分診都抓盡 → 離開碼 1" "1" "rc" "$POOLA"
+p "★ 可抓 0 張時列出池子大小與「不能抓的理由」各幾張（沒 s/* 又掛 Human 的被點名），而且不說成「正常／不是故障」" "True" \
+  "'open 票池' in out and '沒有 s/*' in out and '不是故障' not in out and '正常' not in out" "$POOLA"
+p "--json 抓盡時同一張理由表寫到 stderr（stdout 仍是 null，佇列閘照舊解析得動）" "True" \
+  "out.startswith('null') and '不能抓' not in out.split(chr(10))[0] and '沒有 s/*' in out" \
+  "[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--pool\",\"--json\"]"
+unset DROP
+
+echo
+echo "   （認領票池裡的票）"
+CLP="[\"cmd_claim\",\"inkstone/ISEP#4\",\"--mainline\",\"$MAIN\",\"--name\",\"isep-hand\",\"--pool\"]"
+p "★ --pool 認領 backlog 的 ISEP#4 → 過，s/backlog 換成 s/doing" "True" \
+  "rc is None and [sorted(pl['labels']) for mm,p,pl in rec if mm=='PUT' and p.endswith('/issues/4/labels')]==[[2]]" "$CLP"
+p "認領留言寫明是從 open 票池抓的、狀態從 s/backlog 變 s/doing" "True" \
+  "any('open 票池' in pl['body'] and 's/backlog → s/doing' in pl['body'] for mm,p,pl in rec if mm=='POST' and p.endswith('/comments'))" "$CLP"
+blocked "--pool 也擋掛 Human 的 mira#23" inkstone/mira#23 --pool
+blocked "--pool 也擋指派 Leo 的 mira#22" inkstone/mira#22 --pool
+blocked "--pool 也擋 s/triage 的 mira#20" inkstone/mira#20 --pool
+blocked "--pool 也擋沒有 s/* 的 mira#21" inkstone/mira#21 --pool
+
 echo
 echo "── ④ 動詞接得上（不帶假池子，走到網路才炸）──"
 out=$(python3 "$T" pick --mainline "$MAIN" 2>&1); got=$?

scripts/test-ticket-triage.sh

@@ -0,0 +1,300 @@
+#!/bin/bash
+# 雲端工人「分診＋組里程碑」的測試（inkstone/ISEP#159）
+#
+# 票上的驗收：
+#   1. 沒狀態的票數下降，每張被動過的票上都有一則說明（分到哪、為什麼；重複的指向哪張）
+#   2. 提出新里程碑：載體票在 InkStoneCo、執行票掛成前置、名字不是版本號、有期限、deliverable＝版本
+#   3. 不碰 Human、不碰指派給 Leo 的票
+#   4. 組了之後照里程碑往下做（pick --pool 先回它的前置票）
+#
+# 全程離線：api() 換成錄音機餵假池子；TICKET_HOST 指到連不上的位址，漏接一條會當場炸，不會假綠。
+cd "$(dirname "$0")/.." || exit 1
+T=scripts/ticket
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+PASS=0; FAIL=0
+export TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN=x ISEP_MEMBER_BACKOFF=0
+export ISEP_COUNTDOWN_STATE_DIR="$TMP/state"; mkdir -p "$ISEP_COUNTDOWN_STATE_DIR"
+# 時鐘定在 2026-09-18 00:00 UTC
+export ISEP_COUNTDOWN_NOW=$(python3 -c 'import datetime as d;print(int(d.datetime(2026,9,18,0,0,tzinfo=d.timezone.utc).timestamp()))')
+unset ISEP_MAINLINE_FILE ISEP_IDENTITY CLAUDE_PROJECT_DIR ISEP_DRAIN
+export ISEP_WORKER_LOGIN=claude-code   # 抓票者自己是誰（真跑時問 /user；離線測試不打網路）
+
+MAIN="$TMP/mainline.json"
+cat > "$MAIN" <<'JSON'
+{"ref":"inkstone/InkStoneCo#65","owner":"inkstone","repo":"InkStoneCo","id":65,
+ "title":"主線 M","due_on":"2026-09-25T23:59:59Z","members":[]}
+JSON
+
+cat > "$TMP/pool.py" <<'PY'
+import json, os, re, urllib.parse
+MS = {"main": {"id": 65, "title": "主線 M", "due_on": "2026-09-25T23:59:59Z", "state": "open"},
+      "mine": {"id": 70, "title": "組好的 M", "due_on": "2026-09-30T23:59:59Z", "state": "open"},
+      "sub": {"id": 9, "title": "子 repo 的舊里程碑", "due_on": "2026-10-30T23:59:59Z", "state": "open"}}
+def I(repo, n, labels, ms=None, assignees=(), created="2026-09-01T00:00:00Z", pr=False, state="open", title=None):
+    d = {"number": n, "title": title or f"票 {repo}#{n}", "state": state,
+         "labels": [{"name": l} for l in labels],
+         "assignees": [{"login": a} for a in assignees],
+         "milestone": MS[ms] if ms else None, "created_at": created,
+         "repository": {"full_name": f"inkstone/{repo}"}}
+    if pr: d["pull_request"] = {"merged": False}
+    return d
+POOL = {
+  "InkStoneCo": [I("InkStoneCo", 55, [], None, title="身為一天只看兩眼的人…"),       # ★ 載體候選：沒里程碑、沒人
+                 I("InkStoneCo", 132, ["Human", "s/pending"], "main", assignees=("Leo",)),  # 主線載體（Leo 的）
+                 I("InkStoneCo", 80, ["s/backlog"], "mine"),                       # 組好的 M 的載體（有 s/* 也不是任務）
+                 I("InkStoneCo", 81, ["Human"], None),                             # 掛 Human 的載體候選
+                 I("InkStoneCo", 82, [], "main"),
+                 I("InkStoneCo", 83, [], None, assignees=("Leo",)),                 # 指派 Leo 的載體候選
+                 I("InkStoneCo", 84, ["s/backlog"], None)],                        # 已是「組好的 M」載體的前置——不能再當載體                                 # 已掛在主線里程碑的載體候選
+  "ISEP": [I("ISEP", 1, [], None, created="2026-08-01T00:00:00Z"),                # ★ 待分診（最舊）
+           I("ISEP", 2, [], None),                                                 # 待分診
+           I("ISEP", 3, ["Human"], None),                                          # 沒 s/*、掛 Human：不碰
+           I("ISEP", 4, [], None, assignees=("Leo",)),                             # 沒 s/*、指派 Leo：不碰
+           I("ISEP", 5, ["s/backlog", "type/bug"], None),                          # ★ 已分診：可組進里程碑
+           I("ISEP", 6, ["s/triage"], None),                                       # 還沒決定：不可組
+           I("ISEP", 7, ["s/backlog"], None),                                      # 已是組好的 M 的前置
+           I("ISEP", 8, ["s/backlog"], "sub"),                                     # 掛著子 repo 里程碑
+           I("ISEP", 9, [], None, pr=True),                                        # PR
+           I("ISEP", 10, [], None, assignees=("claude-code",))],                   # 只指派給自己：可分診
+  "Arcrun": [I("Arcrun", 20, ["s/todo"], None),                                    # ★ 已分診：可組進里程碑
+             I("Arcrun", 21, ["s/todo"], None),                                    # 組好的 M 的前置（pick 用）
+             I("Arcrun", 22, ["s/backlog", "Human"], None),                        # Human 前置：不碰
+             I("Arcrun", 23, ["s/backlog"], None, assignees=("Leo",))],            # 指派 Leo 的前置：不碰                       # Human 前置：不碰
+}
+MSN = {"InkStoneCo": ["main", "mine"], "ISEP": ["sub"]}
+DEPS = {"InkStoneCo#80": ["ISEP#7", "Arcrun#21", "InkStoneCo#84"]}
+def _by_ref(ref):
+    repo, n = ref.split("#")
+    return next(i for i in POOL[repo] if i["number"] == int(n))
+BLOCKS = {}
+for _p, _cs in DEPS.items():
+    for _c in _cs:
+        BLOCKS.setdefault(_c, []).append(_p)
+LABELS = ["s/triage", "s/backlog", "s/todo", "s/doing", "s/review", "s/pending", "close/duplicate",
+          "Human", "type/bug", "p/high"]
+DROP = set(json.loads(os.environ.get("DROP", "[]")))
+rec = []
+def fake_api(path, payload=None, method=None):
+    verb = method or ("POST" if payload is not None else "GET")
+    rec.append((verb, path, payload))
+    if path.startswith("/orgs/inkstone/repos"):
+        return [{"name": r} for r in POOL]
+    if path == "/user":
+        return {"login": "claude-code"}
+    if path.endswith("/labels?limit=100"):
+        return [{"name": n, "id": k} for k, n in enumerate(LABELS, 1)]
+    if "/milestones" in path:
+        repo = path.split("/")[3]
+        if verb == "POST":
+            return {"id": 71, "title": payload["title"]}
+        return [MS[k] for k in MSN.get(repo, [])]
+    if "/issues?" in path:
+        repo = path.split("/")[3]
+        q = urllib.parse.parse_qs(path.split("?", 1)[1])
+        rows = [i for i in POOL[repo] if f"{repo}#{i['number']}" not in DROP]
+        if "milestones" in q:
+            want = q["milestones"][0]
+            return [i for i in rows if (i["milestone"] or {}).get("title") == want]
+        rows = [i for i in rows if i["state"] == "open"]
+        page = int(q.get("page", ["1"])[0]); per = int(q.get("limit", ["50"])[0])
+        return rows[(page - 1) * per: page * per]
+    m = re.match(r"/repos/inkstone/([\w-]+)/issues/(\d+)/(dependencies|blocks)(\?.*)?$", path)
+    if m:
+        if verb == "POST":
+            return {}
+        table = DEPS if m.group(3) == "dependencies" else BLOCKS
+        return [_by_ref(r) for r in table.get(f"{m.group(1)}#{m.group(2)}", [])]
+    m = re.match(r"/repos/inkstone/([\w-]+)/issues/(\d+)$", path)
+    if m and verb == "GET":
+        return _by_ref(f"{m.group(1)}#{m.group(2)}")
+    return {}
+PY
+export POOL_PY="$TMP/pool.py"
+
+probe() {
+  python3 - "$1" "$2" <<'PY'
+import sys, os, json, io, contextlib, 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)
+ns = {}
+exec(open(os.environ["POOL_PY"]).read(), ns)
+m.api = ns["fake_api"]; rec = ns["rec"]
+argv = json.loads(sys.argv[2]) if sys.argv[2] else None
+buf = io.StringIO(); rc = None
+if argv is not None:
+    with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
+        try:
+            getattr(m, argv[0])(argv[1:])
+        except SystemExit as e:
+            rc = e.code
+W = [(mm, p, pl) for mm, p, pl in rec if mm in ("POST", "PATCH", "PUT", "DELETE")]
+print(eval(sys.argv[1], {"m": m, "rec": rec, "W": W, "rc": rc, "out": buf.getvalue(), "I": ns["I"], "json": json}))
+PY
+}
+p() { # p <說明> <want> <python 片段> [argv json]
+  got=$(probe "$3" "${4:-}" 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"
+}
+j() { python3 -c 'import json,sys;print(json.dumps(sys.argv[1:],ensure_ascii=False))' "$@"; }
+
+echo "── ① 規則本體（純函式）──"
+p "沒 s/*、沒人、沒 Human → 待分診" "True" "m.triageable(I('ISEP',1,[]),'claude-code')[0]"
+p "★ 掛 Human → 不碰（驗收 3）" "False" "m.triageable(I('ISEP',3,['Human']),'claude-code')[0]"
+p "human/exec 同組 → 不碰" "False" "m.triageable(I('ISEP',3,['human/exec']),'claude-code')[0]"
+p "★ 指派給 Leo → 不碰（驗收 3）" "False" "m.triageable(I('ISEP',4,[],assignees=('Leo',)),'claude-code')[0]"
+p "只指派給自己 → 可分診" "True" "m.triageable(I('ISEP',10,[],assignees=('claude-code',)),'claude-code')[0]"
+p "不知道自己是誰、票有指派 → 不碰（不猜）" "False" "m.triageable(I('ISEP',10,[],assignees=('claude-code',)),None)[0]"
+p "已經有 s/*（連 s/triage 也算）→ 不是待分診" "False" "m.triageable(I('ISEP',6,['s/triage']),'claude-code')[0]"
+p "PR → 不是票" "False" "m.triageable(I('ISEP',9,[],pr=True),'claude-code')[0]"
+p "已關 → 不碰" "False" "m.triageable(I('ISEP',1,[],state='closed'),'claude-code')[0]"
+p "InkStoneCo 裡掛在 open 里程碑的票（載體）→ 不是待分診（它是容器）" "False" "m.triageable(I('InkStoneCo',82,[],'main'),'claude-code')[0]"
+p "別的 repo 掛著里程碑、沒 s/* → 照樣待分診（載體只認 InkStoneCo）" "True" "m.triageable(I('ISEP',8,[],'sub'),'claude-code')[0]"
+p "名字以版本號開頭（1.4.52 雲端零件包）→ 算版本號名字" "True" "m._version_like('1.4.52 雲端零件包')"
+p "v 開頭也算" "True" "m._version_like('v0.30 什麼')"
+p "名字裡提到版本但不是開頭（封測不再斷，含 1.4 修正）→ 不算（誤攔比漏擋嚴重）" "False" "m._version_like('封測不再斷，含 1.4 修正')"
+
+echo
+echo "── ② triage：一個動作＝說明＋欄位（驗收 1）──"
+TR=$(j cmd_triage inkstone/ISEP#1 --to s/backlog --why "還在用、要修" --name isep-hand)
+p "★ 先留說明、再改標籤：寫入恰好是 [留言, 改標籤]" "[('POST', '/repos/inkstone/ISEP/issues/1/comments'), ('PUT', '/repos/inkstone/ISEP/issues/1/labels')]" \
+  "[(mm,p) for mm,p,_ in W]" "$TR"
+p "★ 說明第一行是【身份】，內文講得出分到哪、為什麼" "True" \
+  "(lambda b: b.split(chr(10))[0]=='【身份】isep-hand／inkstone/ISEP／-' and 's/backlog' in b and '還在用、要修' in b)(W[0][2]['body'])" "$TR"
+p "標籤換成 s/backlog（id 2）" "[2]" "W[1][2]['labels']" "$TR"
+p "離開碼 0" "None" "rc" "$TR"
+TD=$(j cmd_triage inkstone/ISEP#2 --dup-of inkstone/ISEP#5 --why "同一件事" --name isep-hand)
+p "★ 重複：留說明→標 close/duplicate→關→在留下的那張留一則指回來" \
+  "[('POST', '/repos/inkstone/ISEP/issues/2/comments'), ('PUT', '/repos/inkstone/ISEP/issues/2/labels'), ('PATCH', '/repos/inkstone/ISEP/issues/2'), ('POST', '/repos/inkstone/ISEP/issues/5/comments')]" \
+  "[(mm,p) for mm,p,_ in W]" "$TD"
+p "★ 重複那則說明指向留下的那張（驗收 1：重複的指向哪張）" "True" "'inkstone/ISEP#5' in W[0][2]['body']" "$TD"
+p "關的是 state=closed、標的是 close/duplicate（id 7）" "True" "W[2][2]=={'state':'closed'} and W[1][2]['labels']==[7]" "$TD"
+TDL=$(j cmd_triage inkstone/ISEP#2 --dup-of inkstone/InkStoneCo#132 --why "同一件事")
+p "★ 重複的對象是 Leo 的票 → 這張照關，但**不在 Leo 的票上寫任何字**（驗收 3）" "True" \
+  "rc is None and not any('/InkStoneCo/' in p for _,p,_ in W) and '沒在' in out" "$TDL"
+p "只指派給自己的 ISEP#10 → 分診得了" "None" "rc" "$(j cmd_triage inkstone/ISEP#10 --to s/triage --why 要總管看)"
+
+echo
+echo "   （該擋的：擋下時一筆都沒寫）"
+nb() { # nb <說明> <argv json> [要在訊息裡看到的字]
+  p "$1 → 離開碼 2、零寫入${3:+、訊息有「$3」}" "True" "rc==2 and not W${3:+ and '$3' in out}" "$2"
+}
+nb "★ 掛 Human 的 ISEP#3（驗收 3）" "$(j cmd_triage inkstone/ISEP#3 --to s/backlog --why x)" "掛著 Human"
+nb "★ 指派給 Leo 的 ISEP#4（驗收 3）" "$(j cmd_triage inkstone/ISEP#4 --to s/backlog --why x)" "指派給 Leo"
+nb "已分診過的 ISEP#6" "$(j cmd_triage inkstone/ISEP#6 --to s/backlog --why x)" "已經分診過"
+nb "PR" "$(j cmd_triage inkstone/ISEP#9 --to s/backlog --why x)"
+p "triage --sign cloud-worker ⇒ 說明內文署 [cloud-worker]" "True" "'[cloud-worker]' in W[0][2]['body']" \
+  "$(j cmd_triage inkstone/ISEP#1 --to s/backlog --why x --sign cloud-worker)"
+nb "沒寫 --why（說明是驗收 1 的本體）" "$(j cmd_triage inkstone/ISEP#1 --to s/backlog)" "--why"
+nb "--to s/todo（要經 compose 排進里程碑才給）" "$(j cmd_triage inkstone/ISEP#1 --to s/todo --why x)" "compose"
+nb "--to 與 --dup-of 都給" "$(j cmd_triage inkstone/ISEP#1 --to s/backlog --dup-of inkstone/ISEP#5 --why x)"
+nb "--dup-of 指到自己" "$(j cmd_triage inkstone/ISEP#1 --dup-of inkstone/ISEP#1 --why x)"
+p "參數錯（沒 --why）→ 一通 API 都沒打" "0" "len(rec)" "$(j cmd_triage inkstone/ISEP#1 --to s/backlog)"
+p "身份名不在名單上 → 一通 API 都沒打" "True" "rc==2 and len(rec)==0" "$(j cmd_triage inkstone/ISEP#1 --to s/backlog --why x --name 路人)"
+
+echo
+echo "   （--list：工人拿什麼來判斷）"
+p "★ --list 列出待分診的票（InkStoneCo 還沒分診的也算），不列 Human／Leo／已分診／PR" \
+  "['inkstone/ISEP#1', 'inkstone/ISEP#10', 'inkstone/ISEP#2', 'inkstone/InkStoneCo#55']" \
+  "[r['ref'] for r in json.loads(out)]" "$(j cmd_triage --list --json)"
+p "--list --all 連已分診的 open 票也列（找重複要看全部），並標出哪些可分診" "True" \
+  "(lambda rows: len(rows)>10 and {r['ref'] for r in rows if r['triageable']}=={'inkstone/ISEP#1','inkstone/ISEP#2','inkstone/ISEP#10','inkstone/InkStoneCo#55'})(json.loads(out))" \
+  "$(j cmd_triage --list --all --json)"
+p "--list 文字版講得出「不碰」的有幾張，並給出下一步那一行" "True" \
+  "'不碰' in out and ' triage inkstone/ISEP#1 ' in out" "$(j cmd_triage --list)"
+p "--list 只讀不寫" "True" "not W" "$(j cmd_triage --list)"
+
+echo
+echo "── ③ compose：組里程碑（驗收 2）──"
+CP=$(j cmd_compose --title "雲端自己把票池消化成版本" --goal "leo 不必一張張叫它做" --due 2026-10-01 \
+       --carrier inkstone/InkStoneCo#55 inkstone/ISEP#5 inkstone/Arcrun#20 --name isep-hand)
+p "★ 里程碑建在 inkstone/InkStoneCo（開工規約第 7 條）" "True" \
+  "[p for mm,p,_ in W if mm=='POST' and p.endswith('/milestones')]==['/repos/inkstone/InkStoneCo/milestones']" "$CP"
+p "★ 有期限（23:59:59Z），不是 9999" "2026-10-01T23:59:59Z" \
+  "[pl['due_on'] for mm,p,pl in W if p.endswith('/milestones')][0]" "$CP"
+p "★ 描述寫明這一輪要讓什麼變成真的、deliverable＝總管驗過的新版本、載體與前置" "True" \
+  "(lambda d: '這一輪要讓什麼變成真的：leo 不必' in d and 'deliverable＝' in d and '新版本' in d and 'inkstone/InkStoneCo#55' in d and 'inkstone/ISEP#5' in d)([pl['description'] for mm,p,pl in W if p.endswith('/milestones')][0])" "$CP"
+p "★ 載體票掛上新里程碑（id 71）" "True" \
+  "('PATCH','/repos/inkstone/InkStoneCo/issues/55',{'milestone':71}) in W" "$CP"
+p "★ 兩張執行票都掛成載體票的前置（/dependencies）" "True" \
+  "[pl for mm,p,pl in W if mm=='POST' and p=='/repos/inkstone/InkStoneCo/issues/55/dependencies']==[{'owner':'inkstone','repo':'ISEP','index':5},{'owner':'inkstone','repo':'Arcrun','index':20}]" "$CP"
+p "★ s/backlog → s/todo（已排進里程碑，等人領票），type/bug 留著" "[3, 9]" \
+  "sorted([pl['labels'] for mm,p,pl in W if mm=='PUT' and p=='/repos/inkstone/ISEP/issues/5/labels'][0])" "$CP"
+p "本來就 s/todo 的 Arcrun#20 不重貼標籤" "False" "any(p.endswith('/Arcrun/issues/20/labels') for _,p,_ in W)" "$CP"
+p "每張前置與載體都留了一則說明（第一行【身份】）" "True" \
+  "sorted(p for mm,p,pl in W if mm=='POST' and p.endswith('/comments') and pl['body'].startswith('【身份】'))==['/repos/inkstone/Arcrun/issues/20/comments','/repos/inkstone/ISEP/issues/5/comments','/repos/inkstone/InkStoneCo/issues/55/comments']" "$CP"
+p "★ 不開任何新票（開工規約第 2 條）" "False" \
+  "any(mm=='POST' and p.endswith('/issues') for mm,p,_ in W)" "$CP"
+p "離開碼 0，印出里程碑網址" "True" "rc is None and '/inkstone/InkStoneCo/milestone/71' in out" "$CP"
+CPS=$(j cmd_compose --title "雲端自己把票池消化成版本" --goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#55 inkstone/ISEP#5 --sign cloud-worker)
+p "--sign cloud-worker ⇒ 每則留言內文都署 [cloud-worker]；--sign 的值不會被當成前置票" "True" \
+  "rc is None and all('[cloud-worker]' in pl['body'] for mm,p,pl in W if p.endswith('/comments')) and not any('cloud-worker' in str(pl) for mm,p,pl in W if p.endswith('/dependencies'))" "$CPS"
+p "沒給 --sign ⇒ 不署一個寫死的名字（誰跑的就署誰）" "False" \
+  "any('[cloud-worker]' in pl['body'] for mm,p,pl in W if p.endswith('/comments'))" "$CP"
+
+echo
+echo "   （該擋的：先全部驗過才寫——擋下時一筆都沒寫，而且理由一次列齊）"
+cb() { # cb <說明> <要在訊息裡看到的字> <argv...>
+  what=$1; want=$2; shift 2
+  p "$what → 離開碼 2、零寫入、訊息有「$want」" "True" "rc==2 and not W and '$want' in out" "$(j cmd_compose "$@")"
+}
+OK=(--goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#55)
+cb "★ 名字是版本號（開工規約第 5 條）" "版本號" --title "1.4.52 雲端零件包" "${OK[@]}" inkstone/ISEP#5
+cb "沒名字" "--title" "${OK[@]}" inkstone/ISEP#5
+cb "★ 沒期限（開工規約第 6 條）" "--due" --title 好名字 --goal g --carrier inkstone/InkStoneCo#55 inkstone/ISEP#5
+cb "期限 9999" "天內" --title 好名字 --goal g --due 9999-01-01 --carrier inkstone/InkStoneCo#55 inkstone/ISEP#5
+cb "期限在過去" "天內" --title 好名字 --goal g --due 2026-09-01 --carrier inkstone/InkStoneCo#55 inkstone/ISEP#5
+cb "載體不在 InkStoneCo（不准在子 repo 建里程碑）" "InkStoneCo" --title 好名字 --goal g --due 2026-10-01 --carrier inkstone/ISEP#1 inkstone/ISEP#5
+cb "沒有前置" "前置" --title 好名字 "${OK[@]}"
+cb "★ 載體掛 Human（驗收 3）" "載體 inkstone/InkStoneCo#81：掛著 Human" --title 好名字 --goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#81 inkstone/ISEP#5
+cb "★ 載體指派給 Leo（驗收 3）" "載體 inkstone/InkStoneCo#83：指派給 Leo" --title 好名字 --goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#83 inkstone/ISEP#5
+cb "載體本身是別的 open 里程碑載體的前置（那一輪還在跑）" "那一輪還在跑" --title 好名字 --goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#84 inkstone/ISEP#5
+cb "載體已在別的 open 里程碑" "已經掛在里程碑" --title 好名字 --goal g --due 2026-10-01 --carrier inkstone/InkStoneCo#82 inkstone/ISEP#5
+cb "同名 open 里程碑已在" "同名" --title "組好的 M" "${OK[@]}" inkstone/ISEP#5
+cb "★ 前置掛 Human（驗收 3）" "前置 inkstone/Arcrun#22：掛著 Human" --title 好名字 "${OK[@]}" inkstone/Arcrun#22
+cb "★ 前置指派給 Leo（驗收 3）" "前置 inkstone/Arcrun#23：指派給 Leo" --title 好名字 "${OK[@]}" inkstone/Arcrun#23
+cb "前置還沒分診（沒 s/*）" "還沒分診" --title 好名字 "${OK[@]}" inkstone/ISEP#1
+cb "前置是 s/triage（要不要做還沒決定）" "還沒分診" --title 好名字 "${OK[@]}" inkstone/ISEP#6
+cb "前置已經是別的里程碑載體的前置（一張票同時只排一輪）" "只排一輪" --title 好名字 "${OK[@]}" inkstone/ISEP#7
+cb "前置掛著子 repo 的里程碑" "已經掛在里程碑" --title 好名字 "${OK[@]}" inkstone/ISEP#8
+p "★ 好幾格不對時一次列齊（Human 前置＋沒分診前置，兩個理由都在）" "True" \
+  "rc==2 and not W and 'Arcrun#22：掛著 Human' in out and 'ISEP#1 還沒分診' in out" \
+  "$(j cmd_compose --title 好名字 "${OK[@]}" inkstone/Arcrun#22 inkstone/ISEP#1)"
+p "參數層的錯（版本號名字）在打任何 API 之前就擋" "0" "len(rec)" \
+  "$(j cmd_compose --title 1.2.3 "${OK[@]}" inkstone/ISEP#5)"
+
+echo
+echo "── ④ 組了之後照里程碑往下做（驗收：再照里程碑往下做）──"
+POOLA=$(j cmd_pick --mainline "$MAIN" --pool --all --json)
+p "★ --pool：還沒到期的 InkStoneCo 里程碑「組好的 M」一組，成員是載體的前置（ISEP#7 的 s/backlog 不抓，Arcrun#21 s/todo 可抓）" \
+  "['inkstone/Arcrun#21']" "[r['ref'] for r in json.loads(out) if r['group']=='里程碑']" "$POOLA"
+p "★ 載體票本身（InkStoneCo#80，s/backlog）不當成可做的票——里程碑那組與票池那組都沒有它" "False" \
+  "any(r['ref']=='inkstone/InkStoneCo#80' for r in json.loads(out))" "$POOLA"
+p "里程碑那一組排在票池之前（先照里程碑做，再撿散票）" "True" \
+  "(lambda g: g.index('里程碑') < g.index('票池'))([r['group'] for r in json.loads(out)])" "$POOLA"
+p "★ 待分診那一組最舊的先（ISEP#1 08-01 開），不含 Human／Leo" \
+  "['inkstone/ISEP#1', 'inkstone/ISEP#10', 'inkstone/ISEP#2', 'inkstone/InkStoneCo#55']" \
+  "[r['ref'] for r in json.loads(out) if r['group']=='待分診']" "$POOLA"
+p "每一列都帶下一步（里程碑那一列是 claim、待分診那一列是 triage）" "True" \
+  "all((' triage ' in r['next']) == (r['group']=='待分診') for r in json.loads(out))" "$POOLA"
+p "沒帶 --pool（本機總管）→ 不看還沒到期的里程碑、也不回待分診（誤攔比漏擋嚴重）" "True" \
+  "rc==1 and '里程碑「組好的' not in out and '待分診' not in out" "$(j cmd_pick --mainline "$MAIN")"
+p "pick 只讀不寫" "True" "not W" "$POOLA"
+
+echo
+echo "── ⑤ 動詞接得上 ──"
+out=$(python3 "$T" usage triage 2>&1); got=$?
+if [ "$got" = 0 ] && printf '%s' "$out" | grep -q -- '--dup-of'; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
+printf 'ticket usage triage 印得出用法\n'
+out=$(python3 "$T" usage compose 2>&1); got=$?
+if [ "$got" = 0 ] && printf '%s' "$out" | grep -q -- '--carrier'; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
+printf 'ticket usage compose 印得出用法\n'
+out=$(python3 "$T" triage inkstone/ISEP#1 --to s/backlog --why x 2>&1); got=$?
+if [ "$got" != 0 ] && ! printf '%s' "$out" | grep -q '✅'; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
+printf 'triage 連不上 Gitea → 非零離開、不印成功（got=%s）\n' "$got"
+
+echo
+echo "通過 $PASS 條，失敗 $FAIL 條"
+[ "$FAIL" = 0 ] || exit 1

scripts/test-unreleased-police.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# unreleased-police.sh 的迴歸測試（inkstone/ISEP#68，docs/TESTING.md A27）
+#
+# 兩個方向都要有證據（本 repo 心法：誤攔比漏擋嚴重）：
+#   A 群「該擋」   —— session 改了 code 卻沒出貨（含「從未出過版」與「領先最新 release N 筆」）
+#   B 群「不該擋」 —— 只讀不寫／只改 wiki／已出貨（tag 收進 HEAD）／排除 marker／這次先不出／stop_hook_active
+#   C 群「出路走得通」—— 照擋下訊息教的「寫 release-holds.md 一行」做，再送一次就放行（ISEP#112 的課）
+#   D 群「鑑別力」 —— 拿掉 marker 同一個 repo 就會擋（證明放行是 marker 造成的，不是偵測壞了）
+#
+# 🔴 全程在乾淨的 TMP 底下造假 repo／假 transcript，跑完自己清；不碰任何真 repo、不打網路。
+set -u
+HOOK="${1:-$(cd "$(dirname "$0")/.." && pwd)/hooks/unreleased-police.sh}"
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"' EXIT
+
+# session 起點固定成 2026-01-01T00:00:00Z（transcript 第一列的時間戳）。
+# 「這個 session 的 commit」＝committer-date 晚於這一刻。
+T0="2026-01-01T00:00:00Z"
+TR="$TMP/transcript.jsonl"
+printf '{"timestamp":"%s","type":"user","message":{"content":[{"type":"text","text":"開工"}]}}\n' "$T0" > "$TR"
+AFTER="2026-06-01T00:00:00Z"    # 晚於起點 ＝ 這個 session 改的
+BEFORE="2025-06-01T00:00:00Z"   # 早於起點 ＝ 不是這個 session 改的
+
+PASS=0; FAIL=0; N=0
+
+mkrepo() { git init -q "$1"; git -C "$1" config user.email t@t; git -C "$1" config user.name t; }
+# commit <repo> <date> <相對路徑> <訊息>
+commit() {
+  mkdir -p "$(dirname "$1/$3")"; echo x >> "$1/$3"; git -C "$1" add -A
+  GIT_AUTHOR_DATE="$2" GIT_COMMITTER_DATE="$2" git -C "$1" commit -qm "$4"
+}
+
+# fire <說明> <期望exit> <repo目錄> [extra-json] [--grep <字串>]
+fire() {
+  desc="$1"; want="$2"; repo="$3"; extra="${4:-}"; needle="${6:-}"
+  N=$((N+1))
+  payload=$(printf '{"session_id":"s%s","transcript_path":"%s"%s}' "$N" "$TR" "$extra")
+  out=$(printf '%s' "$payload" | CLAUDE_PROJECT_DIR="$repo" bash "$HOOK" 2>&1); rc=$?
+  ok=1
+  [ "$rc" = "$want" ] || ok=0
+  if [ -n "$needle" ] && ! printf '%s' "$out" | grep -qF "$needle"; then ok=0; fi
+  if [ "$ok" = 1 ]; then
+    printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 期望 exit=%s，實得 exit=%s' "$desc" "$want" "$rc"
+    [ -n "$needle" ] && printf '（找 "%s"）' "$needle"
+    printf '\n'
+    printf '%s\n' "$out" | sed -n '1,10p' | sed 's/^/     /'
+    FAIL=$((FAIL+1))
+  fi
+}
+
+echo "── A 群：該擋（改了 code 卻沒出貨）──"
+mkrepo "$TMP/a1"; commit "$TMP/a1" "$AFTER" hooks/foo.sh "加一支 hook"
+fire "改了 hook、從未出過版 → 擋，且點名 repo＋筆數" 2 "$TMP/a1" "" --grep "從未出過版"
+
+mkrepo "$TMP/a2"; commit "$TMP/a2" "$BEFORE" hooks/a.sh a; git -C "$TMP/a2" tag v1
+commit "$TMP/a2" "$AFTER" hooks/b.sh b
+fire "有舊 release、新 commit 未收進 → 擋，訊息說『領先它 N 筆』" 2 "$TMP/a2" "" --grep "領先它 1 筆"
+
+mkrepo "$TMP/a3"; commit "$TMP/a3" "$AFTER" scripts/x.sh x; commit "$TMP/a3" "$AFTER" system-dev/wiki/n.md n
+fire "同一 session 改了 code＋wiki → 擋（只要有一個非知識檔）" 2 "$TMP/a3" "" --grep "未出貨"
+
+echo "── B 群：不該擋 ──"
+mkrepo "$TMP/b1"; commit "$TMP/b1" "$BEFORE" hooks/foo.sh old
+fire "這個 session 什麼都沒 commit（只讀不寫）→ 放行" 0 "$TMP/b1"
+
+mkrepo "$TMP/b2"; commit "$TMP/b2" "$AFTER" system-dev/wiki/note.md "只改 wiki"
+fire "這個 session 只改了 wiki → 放行" 0 "$TMP/b2"
+
+mkrepo "$TMP/b2b"; commit "$TMP/b2b" "$AFTER" docs/hooks-inventory.md "只改 docs"
+fire "這個 session 只改了 docs → 放行" 0 "$TMP/b2b"
+
+mkrepo "$TMP/b3"; commit "$TMP/b3" "$AFTER" hooks/foo.sh code; git -C "$TMP/b3" tag v9
+fire "改了 code 而且已出貨（tag 收進 HEAD）→ 放行" 0 "$TMP/b3"
+
+mkrepo "$TMP/b4"; commit "$TMP/b4" "$AFTER" hooks/foo.sh code
+printf '產物 repo，管線產出，不出版\n' > "$TMP/b4/.isep-release-exempt"
+fire "改了 code 但有 .isep-release-exempt marker → 放行" 0 "$TMP/b4"
+
+mkrepo "$TMP/b5"; commit "$TMP/b5" "$AFTER" hooks/foo.sh code
+mkdir -p "$TMP/b5/.claude"; printf 'b5: 交回分支，release 由總管出\n' > "$TMP/b5/.claude/release-holds.md"
+fire "改了 code 沒出貨、但 release-holds.md 有這個 repo（先不出）→ 放行且留痕" 0 "$TMP/b5"
+
+mkrepo "$TMP/b6"; commit "$TMP/b6" "$AFTER" hooks/foo.sh code
+fire "已被別的 Stop 閘擋過這一輪（stop_hook_active）→ 放行" 0 "$TMP/b6" ',"stop_hook_active":true'
+
+echo "── C 群：擋下訊息教的出路，照做真的走得通 ──"
+mkrepo "$TMP/c1"; commit "$TMP/c1" "$AFTER" hooks/foo.sh code
+fire "先擋一次" 2 "$TMP/c1" "" --grep "release-holds.md"
+# 照訊息說的：在 .claude/release-holds.md 寫「<repo 名>: <理由>」
+mkdir -p "$TMP/c1/.claude"; printf 'c1: 這次累積，下個 session 一起出\n' > "$TMP/c1/.claude/release-holds.md"
+fire "照訊息寫了 release-holds.md 那一行，再送 → 放行" 0 "$TMP/c1"
+
+echo "── D 群：鑑別力（放行是 marker/hold 造成的，不是偵測壞了）──"
+# b4 若拿掉 marker，同一個 repo 就會擋 → 證明偵測本身是會亮的
+rm -f "$TMP/b4/.isep-release-exempt"
+fire "把 b4 的 marker 拿掉 → 同一個 repo 就擋（偵測真的會亮）" 2 "$TMP/b4"
+
+echo
+echo "$PASS/$N 通過"
+[ "$FAIL" -eq 0 ]

scripts/ticket

@@ -30,10 +30,19 @@ leo 2026-08-16 三句話，本工具就是它們的機械化：
 
 雲端工人抓票（inkstone/ISEP#131，規則機械可判，不靠 prompt 叮嚀）：
 
-    ticket pick [--mainline <主線檔>] [--all] [--json]   回一張現在可以抓的票（主線抓盡才抓逾期）
+    ticket pick [--mainline <主線檔>] [--all] [--json] [--pool]
+                                                          回一張現在可以抓的票（主線 → 逾期里程碑 → --pool 時 open 票池）
     ticket claim <票> [--as <登入名>] [--name <身份>]    認領＝指派＋s/doing＋【身份】留言，一個動作
     ticket pick --claim …                                 上面兩件連著做
 
+雲端工人分診＋組里程碑（inkstone/ISEP#159：不只撿票，還要組票）：
+
+    ticket triage --list [--all] [--json]                 還沒有 s/* 的票（--all 連已分診的一起列，找重複用）
+    ticket triage <票> --to <s/backlog|s/triage|s/pending> --why <一句>   給狀態＋票上一則說明，一個動作
+    ticket triage <票> --dup-of <留下的票> --why <一句>   重複：說明＋close/duplicate＋關＋指回去
+    ticket compose --title … --goal … --due YYYY-MM-DD --carrier inkstone/InkStoneCo#N <前置…>
+                                                          組一個 InkStoneCo 里程碑（先全部驗過才寫，不開新票）
+
 票的寫法：`owner/repo#N`，例：`inkstone/InkStoneCo#44`
 """
 import json
@@ -57,6 +66,7 @@ try:
     from dispatch_parse import parse_identity, IDENTITY_ROLES
 except Exception:      # 拿不到共用零件就不擋（fail-open）——開票的路不該被一個 import 卡死
     parse_identity, IDENTITY_ROLES = None, ("總管", "subagent", "leo")
+from gitea_token import gitea_token as _gitea_token   # 唯一 token 來源（ISEP#47）：env→.env，不碰 remote URL
 
 
 def check_identity(body, what):
@@ -100,36 +110,17 @@ def die(msg, code=2):
 
 
 def token():
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
-    # 掃這個 repo 的**所有** remote，找第一個指向本站、且帶憑證的。
-    # 原本寫死只認名叫 "gitea" 的 remote —— 2026-08-20 實撞：
-    # ISEP 這個新 repo 的 remote 叫 origin，於是這支腳本在那裡整個跑不起來，
-    # 「開票前先搜」那道閘在新 repo 等於不存在。閘不該綁在某個 remote 的名字上。
+    # 來源＝env／.env（ISEP#47），不再從 remote URL 抽——那會逼 token 明文嵌在 URL 裡，
+    # 任何印出 remote 的訊息（git-lfs locksverify）都會洩一次。解析順序見 hooks/lib/gitea_token.py。
+    tok = _gitea_token()
+    if tok:
+        return tok
     host = HOST.split("//")[-1].rstrip("/")
-    try:
-        out = subprocess.run(["git", "-C", root, "remote", "-v"],
-                             capture_output=True, text=True, timeout=20).stdout
-    except Exception:
-        out = ""
-    for line in out.splitlines():
-        if host not in line:
-            continue
-        m = re.search(r"//[^:/]+:([^@]+)@", line)
-        if m:
-            return m.group(1)
-    # 退而求其次：環境變數（雲端／CI 沒有帶憑證的 remote 時走這條）
-    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
-        v = os.environ.get(env)
-        if v:
-            return v
     die(f"""🔴 拿不到 {host} 的 token
 
-這個 repo 的 remote 裡沒有一個帶憑證且指向 {host}：
-{out.strip() or "（沒有任何 remote）"}
-
 擇一：
-  • 讓某個 remote 帶憑證（多數 repo 的 gitea/origin 本來就有）
-  • 或設環境變數 GITEA_TOKEN_CLAUDE_CODE""")
+  • 設環境變數 GITEA_TOKEN_CLAUDE_CODE
+  • 或在 $CLAUDE_PROJECT_DIR/.env（或 git 根的 .env）放 GITEA_TOKEN_CLAUDE_CODE=""")
 
 
 _TOLERATE = ()          # 這一次呼叫可以吞掉的 HTTP 狀態碼（見 add_dependency）
@@ -670,6 +661,30 @@ BATON_MARK = "🏃 **棒子交回**"
 HANDBACK_TO = os.environ.get("ISEP_HANDBACK_TO") or "claude-code"
 
 
+def handback_comment_lines(to, nxt, ev=None, openn=None):
+    """交棒留言的內文（純函式，好離線驗）。
+
+    inkstone/ISEP#123：`--to Leo` ＝「要 leo 親手做」⇒ **第一行掛人閘記號 `👤`**，
+    leo 一天只看兩眼，他要在一長串留言裡一眼認出「這則在等我動手」。他手寫的交棒
+    都以 `👤 Leo：` 開頭，機器貼的這則本來反而沒有——這正是本票要補的那個記號。
+
+    🔴 **🏃 那一塊照舊留著，不是可有可無**：baton-handback-guard.sh 用「這張票的留言
+    裡有沒有 🏃」判斷這條線交棒了沒（`any("🏃" in body)`），拔掉它 ＝ 漏擋。
+    交回總管（claude-code）維持第一行 🏃、不掛 👤——那不是等 leo 動手的留言。
+    """
+    lines = []
+    if to == "Leo":
+        lines += [f"👤 Leo：{nxt}", ""]
+    lines += [f"{BATON_MARK}　→ `{to}`", "",
+              f"**下一步**：{nxt}"]
+    if ev:
+        lines += ["", f"**證據**：{ev}"]
+    if openn:
+        lines += ["", "**未關的相依**（它們全關之前這張票關不掉）："]
+        lines += [f"- {i['repository']['full_name']}#{i['number']}　{i['title'][:60]}" for i in openn]
+    return lines
+
+
 def _labels_of(owner, repo):
     return {l["name"]: l["id"] for l in api(f"/repos/{owner}/{repo}/labels?limit=100")}
 
@@ -894,17 +909,36 @@ def subtask_example(parent=None, draft=None):
 #    用法裡寫死 `ticket` 或 `scripts/ticket`，讀的人照著貼就又踩回這張票的坑。
 USAGE = {
     "pick":
-        "用法：{bin} pick [--mainline <主線 json 檔>] [--all] [--json] [--claim [--as <登入名>] [--name <身份>]]\n"
-        "      回**一張**現在可以抓的票（主線抓盡才輪到逾期里程碑；不抓 backlog）。主線的成員＝hub 里程碑裡的票＋\n"
+        "用法：{bin} pick [--mainline <主線 json 檔>] [--all] [--json] [--pool] [--claim [--as <登入名>] [--name <身份>]]\n"
+        "      回**一張**現在可以抓的票：主線 → 主線抓盡才輪到逾期里程碑 → 帶 --pool（或環境 ISEP_DRAIN=1）時\n"
+        "      再輪到整個 open 票池的 s/todo／s/backlog（不限里程碑；Human、指派給別人、hub 照樣不抓，inkstone/ISEP#130）。\n"
+        "      可抓 0 張時列出池子裡每種「不能抓的理由」各幾張。主線的成員＝hub 里程碑裡的票＋\n"
         "      hub 票＋它們的相依（跨 repo）——別 repo 的同名里程碑不算主線（inkstone/ISEP#133）\n"
         "      --mainline 不給時依序找：$ISEP_MAINLINE_FILE → ~/.claude/isep-countdown/mainline.json"
         " → $CLAUDE_PROJECT_DIR/system-dev/mainline.json\n"
         "      離開碼：0 ＝ 有票（印在 stdout）；1 ＝ 真的沒有可抓的票；2 ＝ 讀不到（讀不到 ≠ 沒有）",
     "claim":
         "用法：{bin} claim <owner/repo#N> [--as <登入名，預設本 token 的使用者>] [--name <身份名，預設 subagent>]"
-        " [--mainline <主線 json 檔>]\n"
+        " [--mainline <主線 json 檔>] [--pool]\n"
         "      認領＝指派給自己 ＋ 換成 s/doing ＋ 第一行【身份】的留言，**一個動作**。\n"
-        "      抓票規則在這裡再驗一次：不是 s/todo、已有人、掛 Human、不在主線也不逾期 ⇒ 擋下（離開碼 2）",
+        "      抓票規則在這裡再驗一次：不是 s/todo、已有人、掛 Human、不在主線也不逾期 ⇒ 擋下（離開碼 2）；\n"
+        "      帶 --pool（或 ISEP_DRAIN=1）時 open 票池裡的 s/todo／s/backlog 也認領得了",
+    "triage":
+        "用法：{bin} triage --list [--json] [--all]\n"
+        "      {bin} triage <owner/repo#N> --to <s/backlog|s/triage|s/pending> --why \"<一句理由>\" [--name <身份>] [--sign <署名>]\n"
+        "      {bin} triage <owner/repo#N> --dup-of <owner/repo#M> --why \"<一句理由>\" [--name <身份>] [--sign <署名>]\n"
+        "      分診**還沒有 s/* 的票**（inkstone/ISEP#159）：給它一個狀態＋在票上留一則說明，一個動作；\n"
+        "      重複的關掉並指向留下的那張（close/duplicate，留下的那張也留一則指回來）。\n"
+        "      --list 列出現在待分診的票；--all 連已分診的 open 票一起列（找重複用）。\n"
+        "      掛 Human／human/*、指派給別人（含 Leo）的票一律不碰；s/todo 要經 compose 排進里程碑才給。",
+    "compose":
+        "用法：{bin} compose --title \"<這一輪要讓什麼變成真的>\" --goal \"<一段話>\" --due YYYY-MM-DD\n"
+        "      --carrier inkstone/InkStoneCo#N <前置票 owner/repo#M ...> [--name <身份>] [--sign <署名，例 cloud-worker>]\n"
+        "      把已分診的票組成一個里程碑（inkstone/ISEP#159，CLAUDE.md 開工規約 1–7 條）：\n"
+        "      里程碑建在 inkstone/InkStoneCo、掛在既有的載體票上；前置票掛成載體票的相依，s/backlog → s/todo；\n"
+        "      deliverable＝一個總管在 stage 驗過的新版本（版本號由總管定）。**不開任何新票。**\n"
+        "      先全部驗過才寫：名字像版本號、期限不在 1–60 天內、同名里程碑已在、載體或前置掛 Human／指派別人、\n"
+        "      前置還沒分診或已在別的 open 里程碑裡 ⇒ 一次列出全部理由，一筆都不寫（離開碼 2）。",
     "subtask":
         "用法：{bin} subtask <母票 owner/repo#N> --title \"<User Story>\" -F <內文檔>\n"
         "      [--repo <收件 repo，預設跟母票同一個>] [--label <s/xxx，預設 s/todo>]\n"
@@ -1095,13 +1129,7 @@ def cmd_handback(argv):
     deps = _deps(owner, repo, num)
     openn = [i for i in deps if i["state"] == "open"]
 
-    lines = [f"{BATON_MARK}　→ `{to}`", "",
-             f"**下一步**：{nxt}"]
-    if ev:
-        lines += ["", f"**證據**：{ev}"]
-    if openn:
-        lines += ["", "**未關的相依**（它們全關之前這張票關不掉）："]
-        lines += [f"- {i['repository']['full_name']}#{i['number']}　{i['title'][:60]}" for i in openn]
+    lines = handback_comment_lines(to, nxt, ev, openn)
     api(f"/repos/{owner}/{repo}/issues/{num}/comments", {"body": "\n".join(lines)})
 
     api(f"/repos/{owner}/{repo}/issues/{num}", {"assignees": [to]}, method="PATCH")
@@ -1270,7 +1298,12 @@ def cmd_loose(argv):
 #
 # 規則（全部是 Gitea 欄位，沒有一格在猜文字）：
 #   可抓  s/* 狀態恰好是 {s/todo} ＋ 沒有 assignee ＋ 沒有 Human／human/* ＋ 不是 hub ＋ 有里程碑
-#         且里程碑 ＝ 主線；主線抓盡才抓「逾期的 open 里程碑」；backlog／沒里程碑一律不抓
+#         且里程碑 ＝ 主線；主線抓盡才抓「逾期的 open 里程碑」
+#         ⇒ 兩層都抓盡、且是接票的環境（--pool／ISEP_DRAIN=1）⇒ 第三層：整個 open 票池裡
+#           s/* 恰好是 s/todo 或 s/backlog 的（不限里程碑），其他格一格不放寬（inkstone/ISEP#130 c7801）
+#   🔴 2026-09-18 實量：org 299 張 open、254 張沒掛里程碑；舊規則只看主線成員與逾期里程碑，
+#      實跑可抓 0 張 ⇒ 09-18 六趟 run 全部「可接 0 張、正常收工」。加上票池這一層，同一刻可抓 101 張。
+#      主線／逾期是**先抓誰**，不是**只抓誰**。
 #   認領  指派 ＋ s/doing ＋【身份】留言，一個動作（`claim`）
 #   完成  分支 ＋ 證據 ＋ s/review ＋ `handback`——那半本來就有，不重做
 #
@@ -1326,7 +1359,25 @@ def human_gated(labels):
     return any(n == "Human" or n.startswith("human/") for n in labels)
 
 
-def pickable(issue, milestone_title, me=None):
+# 票池那一層接受的狀態（inkstone/ISEP#130 c7801）：labels.yaml 裡「決定要做、沒人在做」的只有這兩個。
+#   s/todo    已排進 milestone，等人領票
+#   s/backlog 驗過了、確定要做，但還沒排進任何 sprint
+# 其他狀態都有人或有事在管：s/triage＝還沒決定要不要做（總管／leo 的事）、s/doing＝有人在做、
+# s/review／s/stage＝等總管或 leo、s/pending＝在等外部。**沒有 s/* 的票**＝還沒被驗傷，一樣不抓，
+# 但會被點名計數（見 pool_candidates），不再沉默地消失在「可抓 0 張」後面。
+MAINLINE_STATUSES = ("s/todo",)
+POOL_STATUSES = ("s/todo", "s/backlog")
+
+
+def pool_mode(argv=()):
+    """要不要往下看到整個 open 票池。`--pool` 或環境 `ISEP_DRAIN=1`（雲端工人的環境本來就設它）。
+
+    為什麼不是預設全開：`queue-drain-guard` 在本機只要總管跑過 `ticket handback` 就會問 pick——
+    票池永遠有票，總管每次收工都會被點名去抓票，那是誤攔。接票的環境自己宣告，不靠猜。"""
+    return "--pool" in argv or os.environ.get("ISEP_DRAIN") == "1"
+
+
+def pickable(issue, milestone_title, me=None, statuses=MAINLINE_STATUSES):
     """這張票現在能不能被雲端工人抓走。回 (ok, 理由)。**純函式，不打網路。**
 
     `milestone_title`＝要求它掛在哪個里程碑底下（主線，或輪到的那個逾期里程碑）。
@@ -1336,14 +1387,15 @@ def pickable(issue, milestone_title, me=None):
       指派 `claude-code` ⇒ 舊規則說「已經指派給 claude-code」⇒ **工人把自己當成別人**，
       09-11 那趟 run（Arcrun#86 c6917）就是用這條理由判定「主線沒有可抓的票」然後收工。
       `s/todo` 的意思本來就是「沒人在做」；有人在做的形狀是 `s/doing`，那格照擋。
+    `statuses`＝接受哪些 s/*（主線／逾期只收 s/todo；票池另收 s/backlog，見 POOL_STATUSES）。
     理由是給人看的：`pick --all` 與 `claim` 擋下時都印它，一張票為什麼不能抓要說得出來。
     """
     if issue.get("pull_request"):
         return False, "這是 PR，不是票"
     labels = _label_names(issue)
     st = sorted(n for n in labels if n.startswith("s/"))
-    if st != ["s/todo"]:
-        return False, "狀態不是單一的 s/todo（現在是 %s）" % (st or "沒有 s/*")
+    if len(st) != 1 or st[0] not in statuses:
+        return False, "狀態不是單一的 %s（現在是 %s）" % ("／".join(statuses), st or "沒有 s/*")
     if issue.get("assignees") or issue.get("assignee"):
         who = [a.get("login") for a in (issue.get("assignees") or []) if isinstance(a, dict)] \
             or [(issue.get("assignee") or {}).get("login")]
@@ -1371,11 +1423,12 @@ def pickable(issue, milestone_title, me=None):
 
 
 def pick_order(issue):
-    """同一個里程碑裡先抓誰：p/high → 沒標 → p/low；再看開票時間（舊的先）；最後票號。
-    結果要**可重現**——同一個池子問兩次要拿到同一張。"""
+    """同一組裡先抓誰：p/high → 沒標 → p/low；同優先序 s/todo 先於 s/backlog（排進 sprint 的先）；
+    再看開票時間（舊的先）；最後票號。結果要**可重現**——同一個池子問兩次要拿到同一張。"""
     labels = _label_names(issue)
     prio = 0 if "p/high" in labels else (2 if "p/low" in labels else 1)
-    return (prio, issue.get("created_at") or "", issue.get("number") or 0)
+    status = 1 if "s/backlog" in labels else 0
+    return (prio, status, issue.get("created_at") or "", issue.get("number") or 0)
 
 
 def _ref_of(issue, owner=None, repo=None):
@@ -1463,13 +1516,109 @@ def _fetch_issue(ref):
     return it
 
 
+def _open_issues(owner, repo):
+    """一個 repo 的全部 open 票（分頁讀完；Gitea 每頁上限 50，只讀一頁會漏）。"""
+    out, page = [], 1
+    while page <= 40:
+        q = urllib.parse.urlencode({"state": "open", "type": "issues", "limit": 50, "page": page})
+        rows = [it for it in (api("/repos/%s/%s/issues?%s" % (owner, repo, q)) or []) if isinstance(it, dict)]
+        for it in rows:
+            it.setdefault("repository", {"full_name": "%s/%s" % (owner, repo)})
+        if not rows:          # 讀到空頁才停：伺服器的每頁上限可能比 50 小，看「不滿一頁」會提早收手
+            break
+        out += rows
+        page += 1
+    return out
+
+
+def pool_issues(owner):
+    """整個 org 的 open 票（不含 PR）——**全局票池的唯一讀法**，pick 的票池層與 triage 共用這一份。
+
+    🔌 接口留給 inkstone/ISEP#154：全局票池是 Arcrun 工作流 `global_index`（tickets 庫），
+    寫卡驗完之前先用這裡直打 Gitea。要換成讀 #154 那份時**只換這一個函式**——
+    呼叫端拿到的形狀不變（Gitea issue dict，帶 `repository.full_name`），不另寫第三套撈法。"""
+    out = []
+    for r in _repos(owner):
+        out += [it for it in _open_issues(owner, r) if not it.get("pull_request")]
+    return out
+
+
+def pool_candidates(owner, me, seen=(), issues=None):
+    """第三層：整個 org 的 open 票池（inkstone/ISEP#130 c7801）。回 (可抓的票…, 池子大小, {不能抓的理由: 張數})。
+
+    leo 09-18：「我看到 Gitea 有 446 張票，要它自己領工作就是持續消化工作，它說沒事做？」
+    ⇒ 主線與逾期里程碑只是**先抓誰**，不是**只抓誰**。它們抓盡之後，池子裡「決定要做、沒人在做」的票
+    （POOL_STATUSES）照樣可抓。不該碰的一格都沒放寬：Human／human/*、指派給別人（含 Leo）、hub、PR。
+    「要 Mac／要 prod」沒有欄位可判——那是工人讀票後走 cloud-worker.md「做不了的票」：寫回票＋改欄位，
+    pick 下一輪就不再回它（改的是 s/*，不是猜文字）。
+
+    `seen`＝前兩層已經列過的票號，不重複。理由表一併回傳：**可抓 0 張時要說得出池子去哪了**。"""
+    found, why_count, total = [], {}, 0
+    for it in (pool_issues(owner) if issues is None else issues):
+        if it.get("pull_request"):
+            continue
+        total += 1
+        ref = _ref_of(it)
+        if ref in seen:
+            continue
+        if _is_carrier(it):
+            # 開工規約第 7 條：InkStoneCo 里程碑裡的票是載體（容器），做的是它的前置（inkstone/ISEP#159）
+            why = "是里程碑「%s」的載體票（容器，做的是它的前置）" % it["milestone"].get("title")
+            why_count[why] = why_count.get(why, 0) + 1
+            continue
+        ok, why = pickable(it, None, me, POOL_STATUSES)
+        if ok:
+            found.append(it)
+        else:
+            why_count[why] = why_count.get(why, 0) + 1
+    return sorted(found, key=pick_order), total, why_count
+
+
+def _me():
+    """抓票者自己是誰：只指派給自己的 s/todo 票算可抓（inkstone/ISEP#33，見 pickable）
+    問不到（舊 token、測試替身沒有 /user）⇒ None ⇒ 照舊規則，不因為這一格讓 pick 整個死掉"""
+    return os.environ.get("ISEP_WORKER_LOGIN") or ((api_soft("/user") or {}).get("login"))
+
+
 def mainline_members(ms):
     """主線的成員（inkstone/ISEP#133）：hub 里程碑裡的票＋hub 票＋它們的相依（跨 repo）。
     判準在 `hooks/lib/mainline.py::collect_members`，這裡只是把本檔的 `api` 遞進去。"""
     return _mainline_lib().collect_members(api, ms)
 
 
-def pick_candidates(ms, now=None):
+# 里程碑一律住在這個 repo（CLAUDE.md 開工規約第 7 條，leo 2026-09-13）：
+# 裡面只放載體票，別 repo 的執行票是載體票的**前置**（/dependencies）。
+CARRIER_REPO = "InkStoneCo"
+
+
+def carrier_members(owner, m):
+    """InkStoneCo 里程碑的**執行票**＝載體票沿相依收下去的票，不含載體票本身（載體是容器不是任務）。
+    判準同主線（`hooks/lib/mainline.py::collect_members`，inkstone/ISEP#133），不另寫一份。"""
+    refs, info = _mainline_lib().collect_members(
+        api, {"owner": owner, "repo": CARRIER_REPO, "id": m.get("id"), "title": m.get("title")})
+    roots = set(info.get("milestone") or [])
+    return [r for r in refs if r not in roots]
+
+
+def _milestone_group(owner, r, m, me):
+    """一個里程碑底下現在可抓的票。InkStoneCo 的里程碑看相依邊；別的 repo 照舊看票上的里程碑欄。"""
+    found = []
+    if r == CARRIER_REPO:
+        for ref in carrier_members(owner, m):
+            it = _fetch_issue(ref)
+            if it and (it.get("state") or "open") == "open" and pickable(it, None, me)[0]:
+                found.append(it)
+        return sorted(found, key=pick_order)
+    for it in _issues_in(owner, r, m.get("title")):
+        if str((it.get("milestone") or {}).get("id")) != str(m.get("id")):
+            continue
+        ok, _ = pickable(it, m.get("title"), me)
+        if ok:
+            found.append(it)
+    return sorted(found, key=pick_order)
+
+
+def pick_candidates(ms, now=None, pool=False):
     """依序回 [(組名, 里程碑標題, [可抓的票…])]：第一組是主線，之後是逾期的 open 里程碑
     （最逾期的先）。**每一組裡都已經照 pick_order 排好。**
 
@@ -1481,9 +1630,7 @@ def pick_candidates(ms, now=None):
     owner = ms.get("owner") or ORG
     anchor = "%s/%s#%s" % (ms.get("owner"), ms.get("repo"), ms.get("id"))
 
-    # 抓票者自己是誰：只指派給自己的 s/todo 票算可抓（inkstone/ISEP#33，見 pickable）
-    #   問不到（舊 token、測試替身沒有 /user）⇒ me=None ⇒ 照舊規則，不因為這一格讓 pick 整個死掉
-    me = os.environ.get("ISEP_WORKER_LOGIN") or ((api_soft("/user") or {}).get("login"))
+    me = _me()
 
     refs, info = mainline_members(ms)
     found = []
@@ -1497,23 +1644,26 @@ def pick_candidates(ms, now=None):
     groups = [("主線", ms["title"], sorted(found, key=pick_order))]
 
     repos = _repos(owner)
-    overdue = []
+    overdue, upcoming = [], []
     for r, m in _open_milestones(owner, repos):
         if "%s/%s#%s" % (owner, r, m.get("id")) == anchor:
             continue
         due = ML.due_of(m)
         if due and due < now:
             overdue.append((due, r, m))
+        elif r == CARRIER_REPO:
+            upcoming.append((due, r, m))
     for due, r, m in sorted(overdue, key=lambda x: x[0]):
-        found = []
-        for it in _issues_in(owner, r, m.get("title")):
-            if str((it.get("milestone") or {}).get("id")) != str(m.get("id")):
-                continue
-            ok, _ = pickable(it, m.get("title"), me)
-            if ok:
-                found.append(it)
         groups.append(("逾期里程碑", "%s（%s/%s#%s）" % (m.get("title"), owner, r, m.get("id")),
-                       sorted(found, key=pick_order)))
+                       _milestone_group(owner, r, m, me)))
+    if pool:
+        # 第三層（inkstone/ISEP#159）：還沒到期的 InkStoneCo 里程碑——雲端工人自己組的里程碑就在這裡，
+        # 「組了之後照里程碑往下做」靠這一層：它的前置票先於票池裡散的票。期限近的先。
+        # 只在接票的環境（--pool／ISEP_DRAIN=1）看：本機總管收工時不會因此被點名。
+        far = now.replace(year=now.year + 100)
+        for due, r, m in sorted(upcoming, key=lambda x: x[0] or far):
+            groups.append(("里程碑", "%s（%s/%s#%s）" % (m.get("title"), owner, r, m.get("id")),
+                           _milestone_group(owner, r, m, me)))
     return groups
 
 
@@ -1524,28 +1674,42 @@ def cmd_pick(argv):
     ms, src = load_mainline(argv)
     as_json = "--json" in argv
     show_all = "--all" in argv
+    pool = pool_mode(argv)
+    pool_total, pool_why = None, {}
     try:
-        groups = pick_candidates(ms)
+        groups = pick_candidates(ms, pool=pool)
+        # 票池那一層只在前面都抓盡（或要看全部）時才讀——它要翻整個 org，能省就省
+        if pool and (show_all or not any(its for _, _, its in groups)):
+            seen = {_ref_of(it) for _, _, its in groups for it in its}
+            me = _me()
+            issues = pool_issues(ms.get("owner") or ORG)
+            found, pool_total, pool_why = pool_candidates(ms.get("owner") or ORG, me, seen, issues)
+            groups.append(("票池", "open 票池（%s，不限里程碑）" % "／".join(POOL_STATUSES), found))
+            # 最後一層（inkstone/ISEP#159）：沒有可做的票時，還沒驗傷的票就是下一件事——
+            # 回一張待分診的票，下一步是 `triage` 不是 `claim`（佇列閘照 row 的 next 印）。
+            if show_all or not found:
+                groups.append(("待分診", "還沒有 s/* 的 open 票", triage_candidates(issues, me)))
     except (urllib.error.URLError, OSError) as e:
         die("🔴 拿不到 Gitea（%s）。讀不到 ≠ 沒有可抓的票——先修連線，不要空轉也不要抓別的。" % e)
 
     flat = [(g, t, it) for g, t, its in groups for it in its]
     if as_json:
         rows = [{"ref": _ref_of(it), "title": it.get("title"), "group": g, "milestone": t,
-                 "labels": _label_names(it), "created_at": it.get("created_at")}
+                 "labels": _label_names(it), "created_at": it.get("created_at"),
+                 "next": _next_cmd(g, _ref_of(it))}
                 for g, t, it in flat]
         print(json.dumps(rows if show_all else (rows[0] if rows else None), ensure_ascii=False, indent=2))
+        if not rows:
+            _explain_empty(pool, pool_total, pool_why, sys.stderr)
         sys.exit(0 if rows else 1)
 
     print("🎯 主線：「%s」（來源：%s）" % (ms["title"], src))
     for g, t, its in groups:
-        if g == "主線" or its or show_all:
-            print("   %s「%s」：可抓 %d 張" % (g, t, len(its)))
+        if g in ("主線", "票池", "待分診") or its or show_all:
+            print("   %s「%s」：%s %d 張" % (g, t, "待分診" if g == "待分診" else "可抓", len(its)))
     print()
     if not flat:
-        print("⚪ 沒有可以抓的票——主線與逾期里程碑都抓盡了。")
-        print("   出路：收工回報（這是正常結果，不是故障）。")
-        print("   🔴 不要去抓 backlog／沒里程碑／掛 Human／已有人的票——那些不在規則裡，抓了就是跳線。")
+        _explain_empty(pool, pool_total, pool_why, sys.stdout)
         sys.exit(1)
 
     shown = flat if show_all else flat[:1]
@@ -1554,16 +1718,46 @@ def cmd_pick(argv):
         print("    %s" % (it.get("title") or "")[:80])
         print("    %s「%s」　開票 %s" % (g, t, (it.get("created_at") or "")[:10]))
     print()
+    if flat[0][0] == "待分診":
+        # 分診不是認領：沒有人要「做」這張票，要的是決定它去哪
+        print("📌 可做的票都抓盡了，下一件事是分診（還沒驗傷的票不會自己消失）：")
+        print("   " + _next_cmd("待分診", _ref_of(flat[0][2])))
+        print("   找重複：%s triage --list --all　　組里程碑：%s usage compose" % (self_path(), self_path()))
+        return
     if "--claim" in argv:
         top = flat[0][2]
         cmd_claim([_ref_of(top)] + [a for a in argv if a != "--claim"])
         return
     print("📌 認領（指派＋s/doing＋【身份】留言，一個動作）：")
-    print("   %s claim %s --name <你的名字>" % (self_path(), _ref_of(flat[0][2])))
+    print("   %s claim %s --name <你的名字>%s" % (self_path(), _ref_of(flat[0][2]),
+                                              " --pool" if flat[0][0] == "票池" and "--pool" in argv else ""))
     print("   做完：分支＋證據 → `%s handback %s --to %s --label s/review --next \"…\" --evidence <URL>`"
           % (self_path(), _ref_of(flat[0][2]), HANDBACK_TO))
 
 
+def _next_cmd(group, ref):
+    """這一列的下一步，**貼了就能跑的那一行**（佇列閘照這一格印，不自己猜）。"""
+    if group == "待分診":
+        return ("%s triage %s --to <s/backlog|s/triage|s/pending> --why \"<一句理由>\""
+                "  （重複的：--dup-of <owner/repo#M>）" % (self_path(), ref))
+    return "%s claim %s --name <你的名字>" % (self_path(), ref)
+
+
+def _explain_empty(pool, total, why, out):
+    """可抓 0 張時講清楚池子去哪了。**不准說成「正常、不是故障」**（inkstone/ISEP#130 c7797：
+    09-18 六趟 run 都把「可抓 0 張」寫成正常收工，而池子裡有幾百張 open 票）。"""
+    w = lambda line="": print(line, file=out)
+    if not pool:
+        w("⚪ 主線與逾期里程碑可抓 0 張——**這一趟沒有看票池**，所以這不代表沒事做。")
+        w("   要看整個 open 票池：加 `--pool`（雲端工人的環境設了 ISEP_DRAIN=1 就自動看）。")
+        return
+    w("⚪ 可抓 0 張：主線、逾期里程碑、open 票池（%d 張）都沒有一張符合抓票規則。" % (total or 0))
+    w("   這不是「沒事做」，是池子裡的票全都卡在下面這些格子——把這張表原樣放進收工摘要／載體票，交總管分診：")
+    for k, n in sorted(why.items(), key=lambda kv: (-kv[1], kv[0]))[:12]:
+        w("     %4d 張　%s" % (n, k))
+    w("   🔴 不要自己改欄位去湊一張可抓的票（把 s/triage 改 s/todo、摘 Human、改指派）——那是總管／leo 的判斷。")
+
+
 def cmd_claim(argv):
     """認領＝指派 ＋ s/doing ＋【身份】留言，**一個動作**。抓票規則在這裡再驗一次。"""
     if not argv or argv[0] in ("-h", "--help"):
@@ -1596,21 +1790,31 @@ def cmd_claim(argv):
         if not (due and due < _now()):
             ok, why = False, "里程碑「%s」既不是主線「%s」也還沒逾期（別 repo 的同名里程碑不算主線）" % (
                 ims.get("title"), ms["title"])
+    tier = "（主線）" if on_mainline else "（逾期里程碑，主線已抓盡）"
+    if not ok and pool_mode(argv):
+        # 第三層：open 票池（inkstone/ISEP#130）。規則同 pick 那一層，一格不放寬 Human／指派／hub。
+        pok, pwhy = pickable(issue, None, who, POOL_STATUSES)
+        if pok:
+            ok, tier = True, "（open 票池，主線與逾期里程碑已抓盡）"
+        else:
+            why = pwhy
     if not ok:
         die("""🚫 %s/%s#%d 現在不能抓：%s
 
   抓票規則（inkstone/ISEP#131，全部是 Gitea 欄位）：
     s/* 恰好是 s/todo ＋ 沒有 assignee ＋ 沒有 Human／human/* ＋ 在主線上（hub 里程碑或相依；主線抓盡才抓逾期）
+    帶 --pool（或環境 ISEP_DRAIN=1）時另收 open 票池裡的 s/todo／s/backlog（inkstone/ISEP#130），其他格照舊
   出路：`%s pick` 會回一張符合規則的票；這張如果真的該你做，回票上問總管改欄位，不要硬抓。""" % (
             owner, repo, num, why, self_path()))
 
     api("/repos/%s/%s/issues/%d" % (owner, repo, num), {"assignees": [who]}, method="PATCH")
+    before = sorted(n for n in _label_names(issue) if n.startswith("s/"))
     keep = [n for n in _label_names(issue) if not n.startswith("s/")] + ["s/doing"]
     _set_labels(owner, repo, num, keep)
     lines = [ident, "",
              "🙋 **認領**　→ `%s`" % who, "",
-             "- 里程碑：「%s」%s" % (ims.get("title") or "（無，靠相依在主線上）", "（主線）" if on_mainline else "（逾期里程碑，主線已抓盡）"),
-             "- 狀態：s/todo → s/doing",
+             "- 里程碑：「%s」%s" % (ims.get("title") or ("（無，靠相依在主線上）" if on_mainline else "（無）"), tier),
+             "- 狀態：%s → s/doing" % "、".join(before),
              "- 做完：分支＋證據 → `s/review` ＋ `ticket handback`（不推 main、不出貨、不改里程碑）"]
     api("/repos/%s/%s/issues/%d/comments" % (owner, repo, num), {"body": "\n".join(lines)})
     print("✅ 認領 %s/%s#%d → `%s`" % (owner, repo, num, who))
@@ -1621,10 +1825,372 @@ def cmd_claim(argv):
 
 
 
+# ══════════════════════════════════════════════════════════════════════════
+# inkstone/ISEP#159 — 分診＋組里程碑：雲端工人不只「撿」，還要「組」
+#
+# leo 2026-09-18：「它看到票時要能夠組成 milestone 提出版本，所以不只是看票，還要組票。」
+#                 「我需要幫忙的 AI，而不是我要一直服務它的 AI。」
+# 09-18 實量 inkstone org：open 302 張，沒有 s/* 的 74 張、沒掛里程碑的 257 張。
+#
+# 哪張跟哪張重複、哪幾張該組成一輪——那是**判斷**，留給讀票的人（雲端工人）；
+# 這裡只管判斷寫回 Gitea 的那一步，讓它**一個動作、有說明、碰不到不該碰的**：
+#   · 判準全是欄位與唯一識別碼（s/* 標籤、assignee 登入名、票號、里程碑 id），沒有一格在猜文字
+#   · 不該碰的＝掛 Human／human/*、指派給別人（含 Leo）——讀可以，一個字都不寫
+#   · compose 先全部驗過才寫第一筆；驗不過一次列出全部理由（改一格撞一次＝閘在懲罰人）
+# ══════════════════════════════════════════════════════════════════════════
+
+TRIAGE_TO = ("s/backlog", "s/triage", "s/pending")
+COMPOSE_MEMBER_STATUSES = ("s/backlog", "s/todo", "s/doing", "s/review", "s/stage", "s/pending")
+COMPOSE_MAX_DAYS = 60
+
+
+def hands_off(issue, me):
+    """這張票能不能寫（留言／改標籤／關）。回 None＝可以，否則回理由。**純函式。**"""
+    if not isinstance(issue, dict) or not issue.get("number"):
+        return "讀不到這張票"
+    if issue.get("pull_request"):
+        return "這是 PR，不是票"
+    if (issue.get("state") or "open") != "open":
+        return "已經關了"
+    labels = _label_names(issue)
+    if human_gated(labels):
+        return "掛著 %s——要 leo 親手做的，不碰" % "、".join(
+            n for n in labels if n == "Human" or n.startswith("human/"))
+    who = [a.get("login") for a in (issue.get("assignees") or []) if isinstance(a, dict)]
+    if not who and isinstance(issue.get("assignee"), dict):
+        who = [issue["assignee"].get("login")]
+    others = [w for w in who if w and w != me]
+    if others or (who and not me):
+        return "指派給 %s——棒子在別人手上，不碰" % "、".join(str(w) for w in who if w)
+    return None
+
+
+def _status_of(issue):
+    return sorted(n for n in _label_names(issue) if n.startswith("s/"))
+
+
+def triageable(issue, me):
+    """待分診＝還沒有任何 s/*，而且碰得了。回 (ok, 理由)。**純函式。**"""
+    why = hands_off(issue, me)
+    if why:
+        return False, why
+    st = _status_of(issue)
+    if st:
+        return False, "已經分診過（%s）" % "、".join(st)
+    if _is_carrier(issue):
+        return False, "是里程碑「%s」的載體票（容器，狀態跟著它的前置走）" % issue["milestone"].get("title")
+    return True, "ok"
+
+
+def _is_carrier(issue):
+    """InkStoneCo 裡掛在 open 里程碑上的票＝載體（開工規約第 7 條）。只看欄位：repo 與里程碑狀態。"""
+    full = ((issue.get("repository") or {}).get("full_name")) or ""
+    ims = issue.get("milestone") or {}
+    return full == "%s/%s" % (ORG, CARRIER_REPO) and bool(ims) and (ims.get("state") or "open") == "open"
+
+
+def triage_candidates(issues, me):
+    """票池裡現在待分診的票，舊的先（放最久的最該有人看一眼）。"""
+    found = [it for it in issues if triageable(it, me)[0]]
+    return sorted(found, key=lambda it: (it.get("created_at") or "", _ref_of(it)))
+
+
+def _opt(argv, name, default=None):
+    return argv[argv.index(name) + 1] if name in argv and argv.index(name) + 1 < len(argv) else default
+
+
+def _positional(argv, flags_with_value):
+    out, skip = [], False
+    for a in argv:
+        if skip:
+            skip = False
+            continue
+        if a in flags_with_value:
+            skip = True
+            continue
+        if a.startswith("--"):
+            continue
+        out.append(a)
+    return out
+
+
+def _fetch(owner, repo, num):
+    it = api("/repos/%s/%s/issues/%d" % (owner, repo, num))
+    if isinstance(it, dict):
+        it.setdefault("repository", {"full_name": "%s/%s" % (owner, repo)})
+    return it
+
+
+def _sign(argv):
+    """`--sign cloud-worker` ⇒ 留言內文署名 `[cloud-worker]`。身份欄（--name）只收名單上的名字，
+    雲端工人不在名單上（cloud-worker.md 步驟 1），署名就寫在內文——誰跑的就署誰，不寫死。"""
+    v = (_opt(argv, "--sign") or "").strip()
+    return "[%s]" % v if v else ""
+
+
+def _ident_line(name, owner, repo):
+    return "【身份】%s／%s/%s／-" % (name, owner, repo)
+
+
+# ── triage ───────────────────────────────────────────────────────────────
+def cmd_triage(argv):
+    """分診一張還沒有 s/* 的票：給狀態＋留說明（或當重複關掉並指向留下的那張），一個動作。"""
+    if not argv or argv[0] in ("-h", "--help"):
+        die(usage_text("triage"), 0 if argv else 2)
+    if argv[0] == "--list":
+        return _triage_list(argv[1:])
+
+    ref = argv[0]
+    owner, repo, num = parse_ref(ref)
+    to, dup, why = _opt(argv, "--to"), _opt(argv, "--dup-of"), (_opt(argv, "--why") or "").strip()
+    name = _opt(argv, "--name") or "subagent"
+    # ── 離線就能判的先判，一通 API 都不打 ──
+    problems = []
+    if bool(to) == bool(dup):
+        problems.append("--to 與 --dup-of 恰好給一個（分到哪個狀態，或跟哪張重複）")
+    if to and to not in TRIAGE_TO:
+        extra = ("——s/todo 的意思是「已排進里程碑」，走 `ticket compose` 排進去才給" if to == "s/todo" else "")
+        problems.append("--to 只收 %s，你給的是 %s%s" % ("／".join(TRIAGE_TO), to, extra))
+    if not why:
+        problems.append("--why 要寫一句理由——票上那則說明就是它（驗收：每張被動過的票上都說得出分到哪、為什麼）")
+    dparts = None
+    if dup:
+        dparts = parse_ref(dup)
+        if dparts == (owner, repo, num):
+            problems.append("--dup-of 指到自己")
+    if problems:
+        die("🚫 triage %s 還沒送出，參數要補：\n%s\n\n%s" % (
+            ref, "\n".join("  · " + p for p in problems), usage_text("triage")))
+    ident = _ident_line(name, owner, repo)
+    check_identity(ident, "分診留言")
+
+    me = _me()
+    issue = _fetch(owner, repo, num)
+    ok, reason = triageable(issue, me)
+    if not ok:
+        die("🚫 %s 不分診：%s\n   出路：`%s triage --list` 列得出現在待分診的票；"
+            "已經有 s/* 的票要改狀態，走 `ticket handback`／`ticket decide`。" % (ref, reason, self_path()))
+    before_labels = _label_names(issue)
+    new_status = "close/duplicate" if dup else to
+    ids = _labels_of(owner, repo)
+    if new_status not in ids:
+        die("🚫 %s/%s 沒有標籤 %s（標籤的唯一真相源是 ISEP labels.yaml，改那裡再跑 gitea-labels-sync）"
+            % (owner, repo, new_status))
+
+    target, target_note = None, None
+    if dup:
+        target = _fetch(*dparts)
+        if not isinstance(target, dict) or not target.get("number"):
+            die("🚫 --dup-of %s 讀不到" % dup)
+        if target.get("pull_request"):
+            die("🚫 --dup-of %s 是 PR，不是票" % dup)
+        if (target.get("state") or "open") != "open":
+            die("🚫 --dup-of %s 已經關了——跟一張關掉的票「重複」不代表這件事做完了。\n"
+                "   出路：這張給 --to s/triage 並在 --why 寫「疑似與 %s 重複、那張已關」，交總管看。" % (dup, dup))
+        target_note = hands_off(target, me)
+
+    # ── 寫：說明先落地，再改欄位（改到一半炸掉時，票上至少說得出發生了什麼）──
+    dref = "%s/%s#%d" % dparts if dparts else None
+    lines = [ident, "",
+             "🗂️ **分診**（inkstone/ISEP#159）%s" % _sign(argv), ""]
+    if dup:
+        lines += ["- 與 %s 重複 → 關掉這張，後續在那張" % dref,
+                  "- 為什麼：%s" % why]
+    else:
+        lines += ["- 狀態：（沒有 s/*）→ `%s`" % to,
+                  "- 為什麼：%s" % why]
+    api("/repos/%s/%s/issues/%d/comments" % (owner, repo, num), {"body": "\n".join(lines)})
+    keep = [n for n in before_labels if not n.startswith("s/")] + [new_status]
+    api("/repos/%s/%s/issues/%d/labels" % (owner, repo, num), {"labels": [ids[n] for n in keep]}, method="PUT")
+    if dup:
+        api("/repos/%s/%s/issues/%d" % (owner, repo, num), {"state": "closed"}, method="PATCH")
+        if target_note is None:
+            to_ident = _ident_line(name, dparts[0], dparts[1])
+            api("/repos/%s/%s/issues/%d/comments" % dparts,
+                {"body": "\n".join([to_ident, "", "🗂️ %s 與這張重複，已關掉併到這裡（%s）%s" % (ref, why, _sign(argv))])})
+    print("✅ 分診 %s → %s" % (ref, ("重複，併入 %s（已關）" % dref) if dup else to))
+    print("   票上留了說明：%s" % why)
+    if dup and target_note:
+        print("   ⚪ 沒在 %s 留指回來的留言：%s" % (dref, target_note))
+
+
+def _triage_list(argv):
+    owner = ORG
+    me = _me()
+    issues = pool_issues(owner)
+    pending = triage_candidates(issues, me)
+    show = issues if "--all" in argv else pending
+    if "--json" in argv:
+        rows = [{"ref": _ref_of(it), "title": it.get("title"), "status": _status_of(it),
+                 "milestone": (it.get("milestone") or {}).get("title"),
+                 "triageable": triageable(it, me)[0], "created_at": it.get("created_at")}
+                for it in sorted(show, key=lambda it: _ref_of(it))]
+        print(json.dumps(rows, ensure_ascii=False, indent=2))
+        return
+    untouched = sum(1 for it in issues if not _status_of(it) and not triageable(it, me)[0])
+    print("🗂️ open 票池 %d 張；待分診 %d 張（另有 %d 張沒 s/* 但掛 Human／指派給別人，不碰）"
+          % (len(issues), len(pending), untouched))
+    for it in sorted(show, key=lambda it: _ref_of(it)):
+        st = "、".join(_status_of(it)) or "（沒有 s/*）"
+        print("  %-28s %-12s %s" % (_ref_of(it), st, (it.get("title") or "")[:70]))
+    if pending:
+        print("\n📌 %s" % _next_cmd("待分診", _ref_of(pending[0])))
+
+
+# ── compose ──────────────────────────────────────────────────────────────
+def _version_like(title):
+    """名字就是版本號（`1.4.52 雲端零件包`）——開工規約第 5 條：版本號是 deliverable，不是名字。"""
+    return bool(re.match(r"^\s*[vV]?\d+(\.\d+)+", title or ""))
+
+
+def cmd_compose(argv):
+    """把已分診的票組成一個 InkStoneCo 里程碑（載體票＋前置），先全部驗過才寫。"""
+    if not argv or argv[0] in ("-h", "--help"):
+        die(usage_text("compose"), 0 if argv else 2)
+    from datetime import datetime, timedelta, timezone
+    title = (_opt(argv, "--title") or "").strip()
+    goal = (_opt(argv, "--goal") or "").strip()
+    due_s = (_opt(argv, "--due") or "").strip()
+    carrier_s = _opt(argv, "--carrier")
+    name = _opt(argv, "--name") or "subagent"
+    members_s = _positional(argv, ("--title", "--goal", "--due", "--carrier", "--name", "--sign"))
+
+    problems = []
+    if not title:
+        problems.append("--title 要寫：名字回答「這一輪要讓什麼變成真的」（開工規約第 5 條）")
+    elif _version_like(title):
+        problems.append("--title「%s」以版本號開頭——版本號是 deliverable 不是名字（開工規約第 5 條，leo 2026-08-24）" % title)
+    if not goal:
+        problems.append("--goal 要寫一段話：這一輪做完，用戶那邊什麼會變成真的")
+    due = None
+    now = _now()
+    try:
+        due = datetime.strptime(due_s, "%Y-%m-%d").replace(hour=23, minute=59, second=59, tzinfo=timezone.utc)
+    except ValueError:
+        problems.append("--due 要是 YYYY-MM-DD（開工規約第 6 條：期限一律要填），你給的是「%s」" % due_s)
+    if due and not (now < due <= now + timedelta(days=COMPOSE_MAX_DAYS + 1)):
+        problems.append("--due %s 不在今天之後 %d 天內——過去的期限等於已逾期，太遠的期限是「沒有期限」穿了期限的衣服"
+                        % (due_s, COMPOSE_MAX_DAYS))
+    carrier = None
+    if not carrier_s:
+        problems.append("--carrier 要給一張 inkstone/InkStoneCo 的既有票當載體（開工規約第 7 條；不開新票）")
+    else:
+        carrier = parse_ref(carrier_s)
+        if carrier[:2] != (ORG, CARRIER_REPO):
+            problems.append("--carrier %s 不在 %s/%s——里程碑一律建在 InkStoneCo，載體票也在那裡" % (carrier_s, ORG, CARRIER_REPO))
+    members = []
+    for m in members_s:
+        r = parse_ref(m)
+        if r == carrier:
+            problems.append("%s 是載體票本身，不用再列成前置" % m)
+        elif r not in members:
+            members.append(r)
+    if not members:
+        problems.append("至少列一張前置票（別 repo 的執行票）——沒有前置的里程碑交不出版本")
+    if problems:
+        die("🚫 compose 還沒送出（一筆都沒寫）：\n%s\n\n%s" % (
+            "\n".join("  · " + p for p in problems), usage_text("compose")))
+    ident = _ident_line(name, ORG, CARRIER_REPO)
+    check_identity(ident, "組里程碑留言")
+
+    # ── 線上驗：全部讀過一次，理由收齊才決定寫不寫 ──
+    me = _me()
+    ML = _mainline_lib()
+    cref = "%s/%s#%d" % carrier
+    citem = _fetch(*carrier)
+    why = hands_off(citem, me)
+    if why:
+        problems.append("載體 %s：%s" % (cref, why))
+    elif citem.get("milestone") and (citem["milestone"].get("state") or "open") == "open":
+        problems.append("載體 %s 已經掛在里程碑「%s」——一張載體只載一輪" % (cref, citem["milestone"].get("title")))
+    else:
+        for b in _blocks(*carrier):
+            bm = (b or {}).get("milestone") or {}
+            if (b or {}).get("state", "open") == "open" and bm and (bm.get("state") or "open") == "open":
+                problems.append("載體 %s 已經是 %s（里程碑「%s」）的前置——它那一輪還在跑，不能再載另一輪"
+                                % (cref, ML.issue_ref(b) or "?", bm.get("title")))
+                break
+    existing = api("/repos/%s/%s/milestones?state=open&limit=100" % (ORG, CARRIER_REPO)) or []
+    for m in existing:
+        if isinstance(m, dict) and ML.norm(m.get("title")) == ML.norm(title):
+            problems.append("InkStoneCo 已經有 open 里程碑「%s」（id %s）——同名不再建一個" % (m.get("title"), m.get("id")))
+    rows = []
+    for mo, mr, mn in members:
+        mref = "%s/%s#%d" % (mo, mr, mn)
+        it = _fetch(mo, mr, mn)
+        why = hands_off(it, me)
+        if why:
+            problems.append("前置 %s：%s" % (mref, why))
+            continue
+        st = _status_of(it)
+        if len(st) != 1 or st[0] not in COMPOSE_MEMBER_STATUSES:
+            problems.append("前置 %s 還沒分診（現在 %s）——先 `ticket triage` 決定要不要做" % (mref, st or "沒有 s/*"))
+            continue
+        ims = it.get("milestone") or {}
+        if ims and (ims.get("state") or "open") == "open":
+            problems.append("前置 %s 已經掛在里程碑「%s」" % (mref, ims.get("title")))
+            continue
+        for b in _blocks(mo, mr, mn):
+            bm = (b or {}).get("milestone") or {}
+            if (b or {}).get("state", "open") == "open" and bm and (bm.get("state") or "open") == "open":
+                problems.append("前置 %s 已經是 %s（里程碑「%s」）的前置——一張票同時只排一輪"
+                                % (mref, ML.issue_ref(b) or "?", bm.get("title")))
+                break
+        else:
+            rows.append(((mo, mr, mn), mref, it, st[0]))
+    if problems:
+        die("🚫 compose 驗不過（一筆都沒寫）：\n%s\n\n"
+            "出路：把上面每一格換掉（換一張載體、拿掉那張前置、先 triage），再送一次。"
+            "掛 Human／指派給 Leo 的票不會被組進來——那是 leo 的。" % "\n".join("  · " + p for p in problems))
+
+    # ── 寫 ──
+    member_refs = [r for _, r, _, _ in rows]
+    desc = "\n".join([
+        "這一輪要讓什麼變成真的：%s" % goal,
+        "deliverable＝一個總管在 stage 驗過的新版本（版本號由總管定）；前置全部關閉＝100%＝才出版本。",
+        "載體票：%s；前置：%s" % (cref, "、".join(member_refs)),
+        "組票：%s %s（inkstone/ISEP#159；CLAUDE.md 開工規約 1–7 條）" % (_sign(argv) or name, now.strftime("%Y-%m-%d")),
+    ])
+    ms = api("/repos/%s/%s/milestones" % (ORG, CARRIER_REPO),
+             {"title": title, "description": desc, "due_on": due.strftime("%Y-%m-%dT%H:%M:%SZ")})
+    mid = (ms or {}).get("id")
+    if not mid:
+        die("🔴 建里程碑沒拿到 id（Gitea 回：%s）——後面一筆都沒寫" % str(ms)[:200])
+    url = "%s/%s/%s/milestone/%s" % (HOST, ORG, CARRIER_REPO, mid)
+    print("✅ 里程碑「%s」（%s/%s milestone %s，期限 %s）" % (title, ORG, CARRIER_REPO, mid, due_s))
+    api("/repos/%s/%s/issues/%d" % carrier, {"milestone": mid}, method="PATCH")
+    print("   載體 %s 掛上里程碑" % cref)
+    for (mo, mr, mn), mref, it, st in rows:
+        add_dependency(carrier, (mo, mr, mn))
+        moved = ""
+        if st == "s/backlog":
+            ids = _labels_of(mo, mr)
+            keep = [n for n in _label_names(it) if not n.startswith("s/")] + ["s/todo"]
+            if all(n in ids for n in keep):
+                api("/repos/%s/%s/issues/%d/labels" % (mo, mr, mn), {"labels": [ids[n] for n in keep]}, method="PUT")
+                moved = "；s/backlog → s/todo"
+        api("/repos/%s/%s/issues/%d/comments" % (mo, mr, mn),
+            {"body": "\n".join([_ident_line(name, mo, mr), "",
+                                "🧩 排進里程碑「%s」（載體 %s，期限 %s）%s %s" % (title, cref, due_s, moved, _sign(argv)),
+                                url])})
+        print("   前置 %s%s" % (mref, moved))
+    api("/repos/%s/%s/issues/%d/comments" % carrier,
+        {"body": "\n".join([ident, "", "🧩 **組里程碑**（inkstone/ISEP#159）%s" % _sign(argv), "",
+                            "- 里程碑：「%s」→ %s" % (title, url),
+                            "- 期限：%s" % due_s,
+                            "- 這一輪要讓什麼變成真的：%s" % goal,
+                            "- 前置（全部關閉＝100%%＝才出版本）：%s" % "、".join(member_refs),
+                            "- deliverable：一個總管在 stage 驗過的新版本（版本號由總管定）"])})
+    print("   %s" % url)
+    print("\n📌 接下來照里程碑做：`%s pick --pool` 會先回這個里程碑的前置票（還沒到期的里程碑排在散票之前）" % self_path())
+
+
+
 CMDS = {"where": cmd_where, "say": cmd_say, "new": cmd_new, "close": cmd_close,
         "decide": cmd_decide, "subtask": cmd_subtask, "handoff": cmd_subtask,
         "handback": cmd_handback, "mine": cmd_mine, "loose": cmd_loose,
-        "usage": cmd_usage, "pick": cmd_pick, "claim": cmd_claim}
+        "usage": cmd_usage, "pick": cmd_pick, "claim": cmd_claim,
+        "triage": cmd_triage, "compose": cmd_compose}
 
 if __name__ == "__main__":
     if len(sys.argv) < 2 or sys.argv[1] not in CMDS:

scripts/wiki-panorama.sh

@@ -61,15 +61,21 @@ done
 
 [ -f "$ROSTER" ] || { echo "找不到 roster：$ROSTER" >&2; exit 1; }
 
-# ── Gitea base（含憑證，**絕不可印出來**）────────────────────────────────
-REMOTE=$(git -C "$ROOT" remote get-url gitea 2>/dev/null || true)
-[ -n "$REMOTE" ] || { echo "本 repo 沒有 gitea remote，無法取 repo。" >&2; exit 1; }
+# ── Gitea base（乾淨網址；token 來源＝env／.env，不從 URL 抽——inkstone/ISEP#47）──────────
+_GT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+[ -f "$_GT_DIR/lib/gitea-token.sh" ] && . "$_GT_DIR/lib/gitea-token.sh"
+REMOTE=$(git -C "$ROOT" remote get-url gitea 2>/dev/null || git -C "$ROOT" remote get-url origin 2>/dev/null || true)
+[ -n "$REMOTE" ] || { echo "本 repo 沒有 gitea/origin remote，無法取 repo。" >&2; exit 1; }
+# 去掉網址裡可能還嵌著的舊憑證（遷移期相容）→ 乾淨 base，clone/fetch 靠 credential helper 認證
+REMOTE=$(printf '%s' "$REMOTE" | sed -E 's#//[^/@]*@#//#')
 BASE=${REMOTE%/InkStoneCo.git}
 BASE=${BASE%/InkStoneCo}
 SELF=$(basename "$REMOTE" .git)
-SECRET=$(printf '%s' "$REMOTE" | sed -nE 's|.*//[^:]+:([^@]+)@.*|\1|p')
-# 任何要外流的字串都先過這關（錯誤訊息可能夾帶 clone URL）
+# scrub 用的 SECRET：token 從 env／.env 取（不從 URL 抽），用來遮掉萬一夾帶在錯誤訊息裡的 token
+SECRET=""; command -v gitea_token >/dev/null 2>&1 && SECRET=$(gitea_token || true)
 scrub() { if [ -n "$SECRET" ]; then sed "s|$SECRET|***|g"; else cat; fi; }
+# clone/fetch 的認證：乾淨 URL + credential helper（token 不進 URL、不洩進 log）
+GIT_CRED=""; [ -f "$_GT_DIR/git-credential-gitea.sh" ] && GIT_CRED="-c credential.helper=$_GT_DIR/git-credential-gitea.sh"
 
 mkdir -p "$CACHE"
 # 自己這個 repo 一律讀工作副本 ⇒ 快取裡若留著一份舊的自己，是誤導來源（會被人拿去讀）
@@ -95,7 +101,7 @@ for repo in $REPOS; do
   if [ -d "$dst/.git" ]; then
     if [ "$DO_FETCH" = 1 ]; then
       br=$(git -C "$dst" symbolic-ref --short HEAD 2>/dev/null || echo main)
-      git -C "$dst" fetch --quiet origin "$br" 2>&1 | scrub >&2 || true
+      git $GIT_CRED -C "$dst" fetch --quiet origin "$br" 2>&1 | scrub >&2 || true
       git -C "$dst" reset --quiet --hard FETCH_HEAD 2>/dev/null || true
     fi
   else
@@ -104,7 +110,7 @@ for repo in $REPOS; do
     fi
     # blobless + sparse：只下載 wiki 目錄的內容，但保留完整 commit 歷史
     #（要歷史才算得出「每個檔最後更新是哪天」——淺 clone 會讓所有檔同一天）
-    if ! err=$(git clone --quiet --filter=blob:none --sparse "$BASE/$repo.git" "$dst" 2>&1 | scrub); then
+    if ! err=$(git $GIT_CRED clone --quiet --filter=blob:none --sparse "$BASE/$repo.git" "$dst" 2>&1 | scrub); then
       printf '%s\tclone-failed\t%s\n' "$repo" "$(printf '%s' "$err" | tr '\n' ' ')" >> "$STATUS_TSV"
       rm -rf "$dst"; continue
     fi
@@ -312,7 +318,7 @@ if gap > 0:
       f"Gitea `Leo/*` 在 {ASOF} 實查是 **{TOTAL} 個**，名單 {len(repos)} 個 ⇒ **還有 {gap} 個沒被點名**。")
     w("  補法（人發起，一次呼叫，不排程）——拿到完整清單、把缺的名字加進名單再重跑：")
     w("  ```")
-    w("  TOKEN=$(git remote get-url gitea | sed -E 's|.*//[^:]+:([^@]+)@.*|\\1|')")
+    w("  TOKEN=$GITEA_TOKEN_CLAUDE_CODE   # 來源＝env／.env，不從 remote URL 抽（inkstone/ISEP#47）")
     w("  curl -s -H \"Authorization: token $TOKEN\" \\")
     w("    'https://git.uncle6.me/api/v1/orgs/Leo/repos?limit=100' | python3 -c \\")
     w("    'import sys,json;[print(r[\"name\"]) for r in json.load(sys.stdin)]'")