fix: 前端驗證閘先看這台有沒有瀏覽器能力，再要求用它（inkstone/ISEP#121）

browser-verify-guard.sh 舊版每回合都要求 mcp__Claude_Browser__*，但那套工具在雲端這台叫不出來（ToolSearch：No matching deferred tools），容器內 chromium 也連不出去（ERR_TUNNEL_CONNECTION_FAILED）⇒ 2026-09-01 一整天每回合誤攔一次，在懲罰一個「這台辦不到」的要求。閘現在先判斷「這個 session 有哪種瀏覽器能力」（正向存在性檢查，不是關鍵字）： - CF Browser Rendering：環境變數 CLOUDFLARE_API_TOKEN_YOULIN_CC_USE + CLOUDFLARE_ACCOUNT_ID_YOULIN 都在場（雲端首選） - Browser MCP：這個 session 的 transcript 出現過 Claude_Browser__ - 容器內 chromium：ISEP#121 實測雲端連不出去，不當能力來源判準是「有沒有用某種瀏覽器能力」這個動作：這回合叫過 Claude_Browser__(computer…) 或打過 .../browser-rendering/ 端點 ⇒ 放行。有能力卻沒用它 ⇒ 擋，且教實際可用的那一種（CF 教 browser-rendering 端點的 curl，MCP 教三步）。一種能力都沒有 ⇒ 訊息改成「缺什麼、怎麼補」（找 leo 幫 token 加 Browser Rendering: Edit／明說「本次無前端」），且每個 session 只提醒一次（stamp），不再每回合誤攔。測試 hooks/tests/browser-verify-guard.test.sh（14/14，全離線）： - C 群演練「一種能力都沒有」：第一次提醒一次、同 session 第二次放行（不再誤攔） - B 群：有 CF 能力教 CF 不教 MCP；只有 MCP 能力教 MCP 不教 CF - A 群：用過某種瀏覽器能力／明說本次無前端 ⇒ 放行；fail-open docs/TESTING.md 加 A43；docs/hooks-inventory.md 更新該支說明（＋0 支、＋0 條、腳本不變：62 支、88 條當場數出）。版本待總管定（plugin.json 未動）。 Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TGxitYq49FzYC7EFkbhzF5
2026-09-18 18:00:11 +00:00
49 changed files with 602 additions and 1582 deletions
@@ -1,7 +1,7 @@
 {
  "name": "isep",
-  "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.1",
+  "description": "InkStone Environment Plugin —— leo 的 Claude Code 環境唯一真相源：62 支機械閘（88 條註冊，白話盤點見 docs/hooks-inventory.md）、7 支 slash command、2 支 skill、8 位有名字的工人（agents/，見 docs/governance/worker-roster.md）、65 支腳本，外加治理規範與標籤真相源。本機與雲端裝同一份，沒有子集。",
+  "version": "0.30.10",
  "keywords": [
    "inkstone",
    "guardrails",
@@ -23,11 +23,11 @@

 | | 數量 | 是什麼 |
 |---|---|---|
-| `hooks/` | 65 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 91 條註冊）。**一支一行的白話盤點在 `docs/hooks-inventory.md`，那裡才是這兩個數字的家** |
+| `hooks/` | 62 支 ＋ `hooks.json` | 全部機械閘（PreToolUse／Stop／SubagentStop／SessionStart／PostToolUse／UserPromptSubmit 共 88 條註冊）。**一支一行的白話盤點在 `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/` | 69 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
+| `scripts/` | 65 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |

 > 🔴 這五個數字**每次都要在自己的樹上實數**，不准沿用上一版、也不准用加減推
 > （`system-dev/wiki/mistakes.md`：那是 leo 的驗收介面，多報就是假綠）：
@@ -534,20 +534,14 @@ pick     --pool 時：還沒到期的 InkStoneCo 里程碑的前置 → 排在
 - 真的擋：`compose --carrier InkStoneCo#134 ISEP#47 Arcrun#143` → 離開碼 2、一筆都沒寫，三個理由一次列出
  （#134 已是主線載體 #55 的前置／#47 已排進 milestone 68／#143 還沒分診）

-### A19 — 下游做完時頂層跟著關：54 條
+### A19 — 下游做完時頂層跟著關：49 條
 ```
 bash scripts/test-ticket-handoff-writeback.sh
 ```
-**該看到**：`通過 54 條，失敗 0 條`。**全程離線**——`TICKET_HOST` 指到連不上的位址，
+**該看到**：`通過 49 條，失敗 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 是看頂層的**。」

@@ -832,55 +826,6 @@ 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
@@ -1072,34 +1017,12 @@ 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。

-### 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 條
+### A39 — D20 閘判「push 到哪」看的是指令實際會推的那個 repo：26 條
 ```
 bash scripts/test-github-contact-guard.sh
 ```
-**該看到**：`33/33 通過`。離線；中間 12 條自己開兩顆 git repo（`shell` 的 origin＝github.com、
-`body` 的 origin 是 Gitea 的形狀），payload 帶 `cwd`，跟 hook 真的會收到的一樣；
-最後 7 條（`inkstone/ISEP#119`）把同一條指令帶 `agent_id`（subagent）與不帶（總管）各跑一次，兩者判決必須相同。
+**該看到**：`26/26 通過`。離線；後 12 條自己開兩顆 git repo（`shell` 的 origin＝github.com、
+`body` 的 origin 是 Gitea 的形狀），payload 帶 `cwd`，跟 hook 真的會收到的一樣。

 **它在守什麼**（`inkstone/ISEP#109` → comment 6629，2026-09-07 實撞）：雲端薄殼的 cwd 是 GitHub 那份，
 總管站在那裡 `git -C <InkStoneCo> push origin x`（InkStoneCo 的 origin＝Gitea），舊版拿 **hook 收到的 cwd**
@@ -1113,18 +1036,6 @@ 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 條
 ```
@@ -1266,25 +1177,16 @@ bash hooks/tests/ask-user-question-guard.live.test.sh
 ```
 bash hooks/tests/dispatch-format-guard.test.sh
 ```
-**該看到**：`53/53 通過`（`inkstone/ISEP#88` 之前是 33 條、`#113` 是 52 條；
-本頁一度寫 19，那是更早的數字，**沒有人回頭改** —— 同一個病，只是換一欄）。
-**離線、不打網路、不花錢**——這支閘是純結構判斷，沒有語意判官，
+**該看到**：`52/52 通過`（`inkstone/ISEP#88` 之前是 33 條；本頁一度寫 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 那個病：閘照擋，但它教人怎麼解的那兩行變成空白），
-  **或出路又印回相對路徑的 `scripts/ticket`**（`inkstone/ISEP#113`）：收工方 cwd 常是
-  InkStoneCo，那裡的 `scripts/ticket` 是 2026-08-27 之前的舊複本，相對路徑貼過去會叫到它、
-  什麼都不會發生——同 comment-carries ⑮、`baton-handback-guard`。出路要印**絕對路徑**的 ticket
+- ⑰ 紅 ⇒ 訊息被 shell 展開了（同 A9 ⑩b 那個病：閘照擋，但它教人怎麼解的那兩行變成空白）
 - **D 群⑲⑳㉑㉒ 紅 ⇒ `inkstone/ISEP#88` 的驗收條件沒過**：回覆一個正在跑的 subagent
  時夾帶指令沒被擋（⑲）、或擋了卻沒把那段內容原文印出來（㉑，出路是「貼上票」，
  找不到原文就得回頭自己翻）
@@ -1437,27 +1339,29 @@ bash hooks/tests/gitea-arm-to-github-armed.test.sh .
 - ④ 前兩條紅 ⇒ **沒拿到核准也寫了保險**——這是 D20 等級的洞，最嚴重
 - ④ ★ 紅 ⇒ 擋下之後教的指令又印回相對路徑（站在 InkStoneCo 會叫到舊複本，`inkstone/ISEP#112` 同病）

---
-
-### A27 — 未出貨警察：改了 code 沒出貨要擋，只改 wiki／已出貨／先不出都不擋：13 條
+### A43 — 前端驗證閘先看這台有沒有瀏覽器能力，再要求用它：14 條
 ```
-bash scripts/test-unreleased-police.sh
+bash hooks/tests/browser-verify-guard.test.sh
 ```
-**該看到**：`13/13 通過`。全程在 `mktemp -d` 底下造假 repo 與假 transcript，
-不碰任何真 repo、不打網路、跑完自己清。
+**該看到**：`通過 14 ／ 失敗 0`。**全程離線**：在 `mktemp` 裡造假 transcript，
+瀏覽器能力用環境變數（`CLOUDFLARE_API_TOKEN_YOULIN_CC_USE`／`CLOUDFLARE_ACCOUNT_ID_YOULIN`）
+在場與否來扮演，session 各自帶 id、跑完清掉 `/tmp/.browser-cap-warned-*`。**不打網路、不碰真 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 差幾筆」。
+**它在守什麼**（`inkstone/ISEP#121`，2026-09-01 實撞）：舊版每回合都要求
+`mcp__Claude_Browser__*`，但那套工具在雲端這台**叫不出來**、容器內 chromium 也連不出去
+（`ERR_TUNNEL_CONNECTION_FAILED`）⇒ 它一整天每回合都在懲罰一個「這台辦不到」的要求。
+現在閘先判斷「這個 session 有哪種瀏覽器能力」（CF Browser Rendering 的兩個 env／
+transcript 出現過 `Claude_Browser__`），**有能力才要求用它，且教實際可用的那一種**；
+一種都沒有時訊息改成「缺什麼、怎麼補」，且**每個 session 只提醒一次**。

 **失敗**：
- A 群「該擋」任一放行 ⇒ 假綠：改了 code 卻沒出貨溜過去了
- B 群「不該擋」任一被擋 ⇒ **誤攔**（比漏擋嚴重）——特別看「只改 wiki／docs」「已出貨」
-  「有 exempt marker」「release-holds.md 有它」四條，任何一條紅代表閘在懲罰謹慎
- C 群紅 ⇒ 訊息教的出路（寫 `.claude/release-holds.md` 一行）**跑不動**，
-  被擋的人只會去找繞過去的方法（`mistakes.md` ISEP#112 的課）
- D 群紅 ⇒ 偵測根本不會亮，「全綠」其實是偵測壞了，不是真的乾淨
+- C 群「第二次（同 session）放行」紅 ⇒ 沒能力時仍每回合誤攔，ISEP#121 的主症狀沒解，
+  **這比漏擋嚴重**（一支天天誤擋的閘會被學會忽略）
+- B 群「有 CF 能力沒用它 ⇒ 教 CF 不是 MCP」紅 ⇒ 閘又去教這台叫不出來的那套工具
+- C 群「第一次提醒缺什麼怎麼補」紅 ⇒ 沒能力時的出路（找 leo 加 `Browser Rendering: Edit`／
+  明說「本次無前端」）沒印出來，撞到的人不知道怎麼走
+- A 群「用過某種瀏覽器能力就放行」任一紅 ⇒ 真的看了畫面卻還被擋，誤攔
+- fail-open 任一紅 ⇒ 壞輸入會亂擋

 ---

@@ -120,14 +120,6 @@ 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 -->

 > 🔴 **這一段是「每次都一樣」的唯一真相源。**
@@ -136,54 +128,6 @@ 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. 交件回覆 ＝ 第一行表明身份

 ```
@@ -1,4 +1,4 @@
-# 65 支閘，白話盤點表
+# 62 支閘，白話盤點表

 > 回應 `inkstone/InkStoneCo#40`：「如果加入了，我應該可以白話文看到 hooks 的內容？」
 > 這份表就是那個「白話文」——不用點開任何 `.sh` 檔，一行看懂一支閘在管什麼。
@@ -7,54 +7,10 @@

 ## 一句話結論

-`hooks/` 底下有 **65 個 `.sh` 檔**，`hooks.json` 實際掛上 **91 條註冊**（同一支閘常被多種情境同時掛上）；
+`hooks/` 底下有 **62 個 `.sh` 檔**，`hooks.json` 實際掛上 **88 條註冊**（同一支閘常被多種情境同時掛上）；
 其中 **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`。
@@ -207,13 +163,6 @@
 > 另外描述欄的「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 收工逼它出貨純屬誤攔。
-
 ---

 ## 怎麼讀這張表
@@ -261,7 +210,6 @@
 | `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 不是恰好一份」。
@@ -327,7 +275,6 @@
 | `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）

@@ -339,13 +286,12 @@
 | `mainline-idle-guard.sh` | AI **連續 4 個回合一直在查、一直在讀，卻什麼都沒交出去**（沒派工、沒改檔、沒寫回票）就擋一次。補的是上面兩支中間那一格：「沒動作」空手警察管、「說了下一步卻沒派」稼動率警察管，**而「有動作、但就是不說下一步」以前兩支都放行**。這支**一個字都不讀**，只看有沒有派工／產出／工作區變動。響過一次門檻就加倍（4→8→16），不會變成一直在響的警報。 | 🛑 擋（響過就退讓） |
 | `pr-verdict-guard.sh` | 收工時清點「還有哪些 PR 沒有結論」——open、**沒有人被指派**、也沒有「要求修改」review 的 PR，就擋一次並**點名是哪幾個**（含開了幾天與網址）；已經 merge 但**分支還留著**的也一起點名（票上寫死「併完當場刪掉那條 branch」）。背景：2026-08-27 實查，最久的三個 open PR 躺了兩星期，而當時 46 支閘沒有一支在管 PR——票看起來「已交付」，東西卻沒進 main、沒進版本，**leo 手上永遠不會出現它**。🔴 **擋的是遺忘，不是等待**：指派給誰（或掛 Human）就立刻不再點名它；響過門檻就加倍（1→4→8→16，每個 PR 各自算）。搭配 `scripts/pr-verdict`（merge／reject／changes 各一個動作）。 | 🛑 擋（響過就退讓） |
 | `countdown-guard.sh` | **每一則回覆都自己說出「這件事已經花了多久／距今天收工線還剩多久」**，而且不必有人記得。一支閘掛兩個事件：你送出訊息時它先把算好的那一行放到 AI 眼前（`UserPromptSubmit`），AI 想收工時它再看這一回合的回覆裡到底有沒有那一行，沒有就擋一次要它補（`Stop`）。**只做前半 ＝ 又一個會被忽略的提醒**，所以兩半綁在一起。已過時間從**這段對話的第一則訊息**算起（＝一個 release 的起點）；收工線是台北 16:00，過線後四小時內顯示「已超過」，不會把超時悄悄換算掉。子 session、純工具回合、已經提醒過一次的，全部放行。**同一個注入點還帶第二行 `🎯 現在的主線是哪一個`**（`inkstone/ISEP#82`）——那一行沒有另外立閘，因為主線的名字本來就掛在被查核的 ⏱ 那一行上。 | 🛑 擋（至多攔一次） |
-| `browser-verify-guard.sh` | 這一輪 AI 宣稱「前端驗過了」，卻沒有真的用瀏覽器工具載入過，就擋下——`curl` 抓到 HTML 不算驗過。 | 🛑 擋 |
+| `browser-verify-guard.sh` | 這一輪 AI 宣稱「前端驗過了」，卻沒有真的用瀏覽器載入過，就擋下——`curl` 抓到 HTML 不算驗過。🔴 **先看這個 session 有哪種瀏覽器能力再要求用它**（`inkstone/ISEP#121`）：CF Browser Rendering（兩個 CF env 在場）／Browser MCP（transcript 出現過 `Claude_Browser__`）／容器內 chromium（雲端實測連不出去，不當能力）。有能力沒用它 ⇒ 擋，且教**實際可用的那一種**（雲端＝CF 的 `browser-rendering` 端點，不是叫不出來的 MCP）；**一種能力都沒有** ⇒ 訊息改成「缺什麼、怎麼補」（找 leo 幫 token 加 `Browser Rendering: Edit`／明說「本次無前端」），且**每個 session 只提醒一次**，不再每回合誤攔。 | 🛑 擋（沒能力時每 session 至多攔一次） |
 | `self-drive-police.sh` | AI 想停下來問你「早就決定過的事」（用固定句型判斷，例如「要不要 X」「下一步做什麼」「這交給你」）就擋下，反問它查過 wiki／查過派工表了沒。 | 🛑 擋 |
 | `self-drive-judge.sh` | 跟上面同一件事，但改用小模型（haiku）判斷「換句話說」的請示句——防止 AI 只是把「要不要」改寫成「不確定是否符合期待」就閃過上一支閘。 | 🛑 擋 |
 | `delivery-police.sh` | AI 宣稱「這件事做完了」，卻看不到任何實測證據（畫面截圖、指令輸出、HTTP 狀態碼…）就擋下。 | 🛑 擋 |
 | `wiki-first-police.sh` | AI 做完事卻沒有把結論寫回 wiki 就想收工，就擋下——下次（或別的 AI）查 wiki 會查不到這次做過什麼。 | 🛑 擋 |
 | `unpushed-police.sh` | AI 改好的東西還留在本機、沒有真的推送出去給別人用，卻想收工，就擋下——「改對了但沒送到」跟沒改是一樣的。 | 🛑 擋 |
-| `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 組。 | 🛑 擋（每條線至多一次） |

@@ -149,12 +149,16 @@ check_one(){ # $1 owner $2 repo $3 num
    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
+    # token：掃已知的 checkout 找第一個帶憑證、指向本站的 remote（同 scripts/ticket 的做法）
+    local ROOT="${CLAUDE_PROJECT_DIR:-$(pwd)}" URL="" U dir TOKEN
+    for dir in "$ROOT" "$ROOT/products/$REPO" "$ROOT/matrix/$REPO" "$ROOT/polaris/$REPO"; do
+      [ -e "$dir/.git" ] || continue
+      U=$(git -C "$dir" remote -v 2>/dev/null | grep -m1 'git\.uncle6\.me' | grep '@' | awk '{print $2}') || true
+      [ -n "${U:-}" ] && { URL="$U"; break; }
+    done
+    [ -n "$URL" ] || return 0
+    TOKEN=$(printf '%s' "$URL" | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|')
+    [ "$TOKEN" != "$URL" ] || 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" \
@@ -12,21 +12,42 @@
 #   ⇒ 判準升級：`HTTP 200 不算驗過` → `grep 到字串也不算驗過`
 #              → **只有「瀏覽器載入後看起來能用」才算**。
 #
-# 機制：這回合若出現「前端驗過」類宣稱，就要求同一回合真的用過瀏覽器工具。
-#   有 curl 沒有瀏覽器 ⇒ exit 2。
+# ── inkstone/ISEP#121：閘要先看「這台有沒有瀏覽器能力」，再要求用它 ──────
+# 2026-09-01 實撞：這支閘每回合都要求 `mcp__Claude_Browser__*`，但那套工具
+#   **在雲端這台根本叫不出來**（ToolSearch：No matching deferred tools found），
+#   容器內 chromium 也連不出去（ERR_TUNNEL_CONNECTION_FAILED）。
+#   ⇒ 它一整天每回合都在懲罰一個「這台辦不到」的要求。
+#
+#   正解不是取消驗證，是**先判斷這個 session 有哪種瀏覽器能力，再教對應的那一種**：
+#     · CF Browser Rendering（雲端首選）＝ 環境變數 CLOUDFLARE_API_TOKEN_YOULIN_CC_USE
+#       ＋ CLOUDFLARE_ACCOUNT_ID_YOULIN 都在場（token 需 Browser Rendering: Edit）
+#     · Browser MCP ＝ 這個 session 的 transcript 出現過 Claude_Browser__* 工具
+#     · 容器內 chromium ＝ ISEP#121 實測雲端網路被擋，不可靠 → 不當能力來源
+#
+#   有能力才要求用它（且教實際可用的那一種）；**一種都沒有時**，訊息改成
+#   「缺什麼、怎麼補」，且**每個 session 只提醒一次**（stamp）——不再每回合誤攔。
+#
+# ── 判準是「有沒有用瀏覽器能力」這個動作，不是措辭 ──────────────────────
+#   驗過的證據（正向存在性檢查，任一種即放行）：
+#     · 這回合叫過 Claude_Browser__(preview_start|navigate|computer|…)
+#     · 這回合打過 CF 的 .../browser-rendering/... 端點
 #
 # 逃生口：這次真的沒有前端可驗（純後端／純腳本）⇒ 在回覆裡明說「本次無前端」，
 #   本 hook 認得這句話就放行——留痕，不是默默略過。
 set -eu

-TURN="$(cat 2>/dev/null | python3 -c '
+INPUT="$(cat 2>/dev/null || echo "")"
+[ -z "$INPUT" ] && exit 0
+
+# 這回合的文字＋工具名（最後 40 則）
+TURN="$(printf '%s' "$INPUT" | python3 -c '
 import sys, json
 buf = []
 try:
    d = json.load(sys.stdin)
    t = d.get("transcript_path") or ""
    if t:
-        import io, os
+        import os
        if os.path.exists(t):
            for line in open(t, encoding="utf-8", errors="ignore").readlines()[-40:]:
                try:
@@ -51,16 +72,66 @@ print("\n".join(buf))
 ' 2>/dev/null || echo "")"
 [ -z "$TURN" ] && exit 0

-# 有沒有「前端／畫面驗過」的宣稱？
+# 整個 session 的 transcript 路徑與 session_id（能力偵測與 stamp 用）
+TP="$(printf '%s' "$INPUT" | python3 -c 'import sys,json
+try: print(json.load(sys.stdin).get("transcript_path") or "")
+except Exception: print("")' 2>/dev/null || echo "")"
+SID="$(printf '%s' "$INPUT" | python3 -c 'import sys,json,re
+try:
+    s=str(json.load(sys.stdin).get("session_id") or "nosid")
+    print(re.sub(r"[^A-Za-z0-9_.-]","_",s)[:64])
+except Exception: print("nosid")' 2>/dev/null || echo "nosid")"
+
+# ── 這回合有沒有「前端／畫面驗過」的宣稱？沒有就與本閘無關 ──
 printf '%s' "$TURN" | grep -qiE '前端(驗|測|複驗|確認)|畫面(驗|確認|複驗)|用戶.{0,6}看到的|驗前端|抓實際畫面' || exit 0

-# 明說沒有前端 ⇒ 放行（留痕）
+# ── 逃生口：明說沒有前端 ⇒ 放行（留痕） ──
 printf '%s' "$TURN" | grep -qE '本次無前端|沒有前端可驗|純後端|不涉及前端' && exit 0

-# 真的用過瀏覽器嗎？
-printf '%s' "$TURN" | grep -qE 'Claude_Browser__(preview_start|navigate|computer|get_page_text|read_console_messages)' && exit 0
+# ── 驗過的證據：這回合真的用過某種瀏覽器能力（正向存在性檢查）──
+printf '%s' "$TURN" | grep -qE 'Claude_Browser__(preview_start|navigate|computer|get_page_text|read_console_messages|snapshot)' && exit 0
+printf '%s' "$TURN" | grep -qE 'browser-rendering/' && exit 0   # CF Browser Rendering 端點

-cat >&2 <<'EOF'
+# ── 這個 session 有哪種瀏覽器能力？（正向存在性檢查）──
+CF_CAP=0
+[ -n "${CLOUDFLARE_API_TOKEN_YOULIN_CC_USE:-}" ] && [ -n "${CLOUDFLARE_ACCOUNT_ID_YOULIN:-}" ] && CF_CAP=1
+
+MCP_CAP=0
+if [ -n "$TP" ] && [ -f "$TP" ]; then
+  grep -q 'Claude_Browser__' "$TP" 2>/dev/null && MCP_CAP=1
+fi
+
+# ── 一種能力都沒有：不能要求做不到的事 → 每個 session 只提醒一次「缺什麼、怎麼補」──
+if [ "$CF_CAP" -eq 0 ] && [ "$MCP_CAP" -eq 0 ]; then
+  STAMP="/tmp/.browser-cap-warned-$SID"
+  [ -f "$STAMP" ] && exit 0            # 這個 session 已經提醒過 ⇒ 不再誤攔
+  : > "$STAMP" 2>/dev/null || true
+  cat >&2 <<'EOF'
+🖥️ 前端驗證警察：你宣稱驗了畫面，但**這個 session 一種瀏覽器能力都沒有**——
+   沒有能力就無法看畫面，所以問題不是「你沒驗」，是「這台缺瀏覽器能力，去補」。
+
+【inkstone/ISEP#121】閘要先看這台有沒有瀏覽器能力，才不會要求你做一件辦不到的事。
+
+補齊任一種即可看畫面（雲端首選第①種）：
+  ① CF Browser Rendering ── 需要兩個環境變數在場，且 token 要有 Browser Rendering: Edit：
+       CLOUDFLARE_API_TOKEN_YOULIN_CC_USE
+       CLOUDFLARE_ACCOUNT_ID_YOULIN
+     缺權限就通知 leo 幫該 token 加 Browser Rendering: Edit（ISEP#115 就是這樣解開的）。
+  ② Browser MCP ── mcp__Claude_Browser__*（本機通常有；雲端這台叫不出來）。
+  ③ 容器內 chromium ── ISEP#121 實測雲端網路被擋（ERR_TUNNEL_CONNECTION_FAILED），
+     不可靠，別依賴它當唯一驗法。
+
+在補上能力之前：這次若真的沒有前端可驗（純後端／純腳本），
+在回覆裡明說「本次無前端」即放行。
+
+本閘每個 session 只在這裡提醒一次，不會每回合攔你（inkstone/ISEP#121）。
+EOF
+  exit 2
+fi
+
+# ── 有能力卻沒用它 → 擋，並教「這台實際可用的那一種」──
+if [ "$CF_CAP" -eq 1 ]; then
+  cat >&2 <<'EOF'
 🖥️ 前端驗證警察：你宣稱驗了畫面，但**這回合沒有用過瀏覽器**。

 【leo 2026-08-08】「**你的環境有 web，你應該用 web 驗，你已經開啓了卻沒有完成。**」
@@ -70,7 +141,42 @@ cat >&2 <<'EOF'
  08-08 實撞：我 grep 到文案就說「前端驗過」，
  而使用者實際看到的是整條紅色「設定檔沒載入（config.js）」——**那個畫面我一次都沒看到**。

-改用這三步（看畫面，不是看原始碼）：
+這台有 CF Browser Rendering（雲端首選）。用它看畫面，不是看原始碼：
+
+  # 跑完 JS 的 DOM（能看到 config.js 載入後的真實內容）
+  curl -sS -X POST \
+    "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID_YOULIN}/browser-rendering/content" \
+    -H "Authorization: Bearer ${CLOUDFLARE_API_TOKEN_YOULIN_CC_USE}" \
+    -H "Content-Type: application/json" \
+    --data '{"url":"<用戶會走的網址>"}'
+
+  # 截圖（用戶會看到的那個畫面）
+  curl -sS -X POST \
+    "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID_YOULIN}/browser-rendering/screenshot" \
+    -H "Authorization: Bearer ${CLOUDFLARE_API_TOKEN_YOULIN_CC_USE}" \
+    -H "Content-Type: application/json" \
+    --data '{"url":"<用戶會走的網址>"}' --output /tmp/screen.png
+
+要看的是：有沒有錯誤橫幅／資料是不是還卡在「載入中…」／DOM 裡有沒有紅字錯誤。
+
+⚠️ 順帶：用 curl 查線上狀態時，`?cb=$RANDOM` **繞不掉 Cloudflare 邊緣快取**——
+   要加 `-H "Cache-Control: no-cache"`，否則你可能是在驗快取而不是驗線上。
+
+本次真的沒有前端可驗 ⇒ 在回覆裡明說「本次無前端」即放行。
+EOF
+  exit 2
+fi
+
+# MCP_CAP == 1（且沒有 CF）：教 Browser MCP
+cat >&2 <<'EOF'
+🖥️ 前端驗證警察：你宣稱驗了畫面，但**這回合沒有用過瀏覽器**。
+
+【leo 2026-08-08】「**你的環境有 web，你應該用 web 驗，你已經開啓了卻沒有完成。**」
+
+【為什麼 curl | grep 不算】curl 拿到的是 **HTML 原始碼**——
+  它**不執行 JS、不載入 config.js、不發 API 請求**。
+
+這台有 Browser MCP。改用這三步（看畫面，不是看原始碼）：
  mcp__Claude_Browser__preview_start        {url: "<用戶會走的網址>"}
  mcp__Claude_Browser__computer             {action: "screenshot"}
  mcp__Claude_Browser__read_console_messages {onlyErrors: true}
@@ -83,10 +83,6 @@ 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（回到「沒有這支閘」的狀態）
@@ -155,7 +151,7 @@ __CARRY__
             **本閘每次派工都會自動注入給收工方**，你不必寫、也不會漏。

  只有這次 ⇒ **寫進那張票**（main 是哪顆、今天撞過什麼、另一條線在動什麼）
-             `"__TICKET__" say <owner/repo#N> -F <檔>`
+             `scripts/ticket say <owner/repo#N> -F <檔>`
             然後派工單寫 `【工單】<owner/repo#N> → comment <剛拿到的號碼>`

  🔴 **「票上還沒有」不是把它寫進 prompt 的理由——它就是「去把它寫上票」的指令。**
@@ -211,14 +207,13 @@ if t:
  fi

  DFG_MSG="$MSG" DFG_VIOL="$VIOL_TEXT" DFG_SESSION="$SESSION" \
-  DFG_HEAD="$HEADLINE" DFG_CARRY="$CARRY_TEXT" DFG_TICKET="$TICKET" python3 -c '
+  DFG_HEAD="$HEADLINE" DFG_CARRY="$CARRY_TEXT" 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"
 )
@@ -1,68 +0,0 @@
-#!/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
@@ -82,10 +82,6 @@
 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 '{}')

 # ── 主閘：宣告了下一步，有沒有交出派工憑證？────────────────────────
@@ -267,8 +263,8 @@ leo 2026-08-16（本閘的規格）：

 ━━ 現在怎麼過這道閘（四條，程式碼裡都真的有對應的分支）━━━━━━━━━
  ① **現在就按 trigger**：這個回合直接呼叫 Agent／Task 派出去。
-     沒有票 → 先 \`"$TICKET" where <關鍵字>\` 搜該掛哪張，
-     再 \`"$TICKET" say <owner/repo#N> -F <檔>\`，然後帶【工單】派工。
+     沒有票 → 先 \`scripts/ticket where <關鍵字>\` 搜該掛哪張，
+     再 \`ticket say <owner/repo#N> -F <檔>\`，然後帶【工單】派工。
  ② **它已經在別人手上**：把票號寫進這段收尾文字（例：「已派給 inkstone/ISEP#30」）。
     有 \`#數字\` 就放行——那不是「我等下做」，是「已經有人在做」。
  ③ **它其實不該現在做**：寫一行說明它在等什麼，格式就是這一個標記——
@@ -298,10 +294,7 @@ for d in /private/tmp/claude-501/*/*/tasks; do
 done
 [ "$RUNNING" -gt 0 ] && exit 0

-# 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=""
+TOKEN=$(git -C "$PROJ" remote get-url gitea 2>/dev/null | sed -E 's|.*//[^:]+:([^@]+)@.*|\1|') || TOKEN=""
 [ -z "$TOKEN" ] && exit 0

 # 🔴 org 是 inkstone，不是 Leo（2026-08-13 搬遷；舊值讓本閘靜默失效到 08-16）
@@ -325,7 +318,7 @@ leo 2026-08-10：「你的任務是**維護 loop**，你要去拿任務派任務
  **全工廠停工你要發現，這是警訊**。」

 【現在該做的，不是回報，是派工】
-  1. 撈池子當場撈：\`"$TICKET" where <關鍵字>\`（或 labels=s/todo）
+  1. 撈池子當場撈：\`scripts/ticket where <關鍵字>\`（或 labels=s/todo）
  2. 照 CP 排序：\`system-dev/docs/3-specs/critical-paths/ship.md\` 是有序的六步
  3. 一次派 2–4 件平行跑；同一個 repo 不要塞兩條（會搶工作區）
  4. agent 死於環境錯誤（SSL／API）⇒ **那是要重派的訊號，不是完工**
@@ -126,10 +126,6 @@
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/wiki-size-guard.sh"
-          },
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/kv-write-guard.sh"
          }
        ]
      },
@@ -296,10 +292,6 @@
          {
            "type": "command",
            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/wiki-size-guard.sh"
-          },
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/duplicate-hook-registration-guard.sh"
          }
        ]
      }
@@ -377,14 +369,6 @@
          }
        ]
      },
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/unreleased-police.sh"
-          }
-        ]
-      },
      {
        "hooks": [
          {
@@ -43,12 +43,17 @@ for line in p.splitlines():
 set -- $SPEC
 OWNER="$1"; REPO="$2"; NUM="$3"

-# 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"
+# 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

 curl -s -o /dev/null --max-time 8 \
  -X POST -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
@@ -1,115 +0,0 @@
-#!/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
@@ -1,67 +0,0 @@
-#!/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
@@ -25,16 +25,9 @@ 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"
@@ -65,16 +58,23 @@ def tagname(v):


 def token_from_env_or_remote(host, root=None):
-    """建 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 的洩漏源）
+    """建 release 才用得到。環境變數優先；沒有就從 remote URL 裡撈（bootstrap 會帶）。"""
    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 ""


@@ -79,12 +79,10 @@ set -- $REF
 OWNER="$1"; REPO="$2"; NUM="$3"

 # 拿 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) || exit 0
-[ -n "$TOKEN" ] || exit 0
-HOST="git.uncle6.me"
+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|')

 RESP=$(curl -s --max-time 15 -H "Authorization: token $TOKEN" \
  "https://$HOST/api/v1/repos/$OWNER/$REPO/issues/$NUM" 2>/dev/null || true)
@@ -62,12 +62,17 @@ set -u
 PROJ="${CLAUDE_PROJECT_DIR:-$(pwd)}"
 PAYLOAD=$(cat 2>/dev/null || echo '{}')

-# ── token：來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽 ──
-# （舊法掃各 repo 的 remote 找帶憑證的網址，代表 token 得明文嵌在 URL 裡 → 會洩進 log）
+# ── token：同 scripts/ticket 的做法（掃 remote 找帶憑證的，再退到環境變數）──
 TOKEN=""
 if [ -z "${PR_VERDICT_FIXTURE:-}" ]; then
-  _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=""
+  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
  [ -n "$TOKEN" ] || TOKEN="${GITEA_TOKEN_CLAUDE_CODE:-${GITEA_TOKEN:-}}"
 fi

@@ -0,0 +1,197 @@
+#!/usr/bin/env bash
+# browser-verify-guard.sh 的迴歸測試（inkstone/ISEP#121）。
+#
+# 來由：2026-09-01 雲端這台「一種瀏覽器能力都沒有」，這支閘卻每回合都要求
+#   mcp__Claude_Browser__*（那套工具在這台叫不出來），於是一整天每回合誤攔一次。
+#   正解：閘先判斷「這個 session 有哪種瀏覽器能力」，有能力才要求用它，且教實際
+#   可用的那一種（雲端＝CF Browser Rendering）；一種都沒有時訊息改成「缺什麼、
+#   怎麼補」，且每個 session 只提醒一次。
+#
+# 三個方向都要有證據：
+#   A 群「該放行」——沒宣稱／明說無前端／真的用過某種瀏覽器能力／壞輸入 fail-open
+#   B 群「該擋」  ——有能力卻沒用它（且教對的那一種）
+#   C 群「沒能力時不誤攔」——第一次提醒一次（缺什麼怎麼補），同 session 第二次放行
+#
+# 用法：hooks/tests/browser-verify-guard.test.sh [hooks/browser-verify-guard.sh 的路徑]
+# 🔴 全程在乾淨 TMP 底下造假 transcript，跑完自己清；不碰真 repo、不打網路。
+#    每個案子自帶 session_id，並清掉可能殘留的 /tmp/.browser-cap-warned-* stamp。
+
+set -u
+HOOK="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)/browser-verify-guard.sh}"
+TMP=$(mktemp -d)
+trap 'rm -rf "$TMP"; rm -f /tmp/.browser-cap-warned-bvtest_* 2>/dev/null' EXIT
+rm -f /tmp/.browser-cap-warned-bvtest_* 2>/dev/null || true
+
+PASS=0; FAIL=0; N=0
+
+# mk <transcript 路徑> <block spec>...
+#   單一 assistant 訊息的多個 block：`T:<文字>`＝文字段；`U:<工具名>`＝tool_use
+mk() {
+  python3 - "$@" <<'PY'
+import json, sys
+path, specs = sys.argv[1], sys.argv[2:]
+rows = [{"type": "user", "message": {"content": [{"type": "text", "text": "【工單】去辦這件事"}]}}]
+blocks = []
+for s in specs:
+    k, v = s.split(":", 1)
+    blocks.append({"type": "text", "text": v} if k == "T"
+                  else {"type": "tool_use", "name": v, "id": "t1", "input": {"cmd": v}})
+rows.append({"type": "assistant", "message": {"content": blocks}})
+with open(path, "w") as f:
+    for r in rows:
+        f.write(json.dumps(r, ensure_ascii=False) + "\n")
+PY
+}
+
+# mk2 <transcript 路徑> <早期工具名> <本回合文字>
+#   早一則 assistant 用過某工具（進得了 transcript 但不在「這回合的驗證」裡），
+#   本回合只有文字宣稱 → 用來造「有 MCP 能力、但這回合沒用它」。
+mk2() {
+  python3 - "$@" <<'PY'
+import json, sys
+path, tool, text = sys.argv[1], sys.argv[2], sys.argv[3]
+rows = [
+  {"type": "user", "message": {"content": [{"type": "text", "text": "先看一下"}]}},
+  {"type": "assistant", "message": {"content": [{"type": "tool_use", "name": tool, "id": "e1", "input": {}}]}},
+  {"type": "user", "message": {"content": [{"type": "text", "text": "【工單】去辦這件事"}]}},
+  {"type": "assistant", "message": {"content": [{"type": "text", "text": text}]}},
+]
+with open(path, "w") as f:
+    for r in rows:
+        f.write(json.dumps(r, ensure_ascii=False) + "\n")
+PY
+}
+
+# run <session_id> <cf?> <transcript> → 設定/清空 env，回傳 out（含 stderr），rc 存 $RC
+run() {
+  sid="$1"; cf="$2"; tr="$3"
+  if [ "$cf" = "cf" ]; then
+    out=$(printf '{"transcript_path":"%s","session_id":"%s"}' "$tr" "$sid" \
+      | CLAUDE_PROJECT_DIR="$TMP" \
+        CLOUDFLARE_API_TOKEN_YOULIN_CC_USE="fake-token" \
+        CLOUDFLARE_ACCOUNT_ID_YOULIN="fake-acct" \
+        sh "$HOOK" 2>&1); RC=$?
+  else
+    out=$(printf '{"transcript_path":"%s","session_id":"%s"}' "$tr" "$sid" \
+      | CLAUDE_PROJECT_DIR="$TMP" \
+        CLOUDFLARE_API_TOKEN_YOULIN_CC_USE="" \
+        CLOUDFLARE_ACCOUNT_ID_YOULIN="" \
+        sh "$HOOK" 2>&1); RC=$?
+  fi
+}
+
+# t <期望exit> <cf|nocf> <說明> <block spec>...
+t() {
+  want="$1"; cf="$2"; desc="$3"; shift 3
+  N=$((N+1)); tr="$TMP/tr-$N.jsonl"; mk "$tr" "$@"
+  run "bvtest_$N" "$cf" "$tr"
+  if [ "$RC" -eq "$want" ]; then printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else printf '  ❌ %s —— 期望 exit=%s，實得 exit=%s\n' "$desc" "$want" "$RC"
+       printf '%s\n' "$out" | sed -n '1,6p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+}
+
+echo "── A 群：該放行 ──────────────────────────────────────────────"
+
+t 0 nocf "沒有前端驗過的宣稱 ⇒ 與本閘無關" \
+  'T:我把後端 API 跑了一遍，回 200。'
+
+t 0 nocf "宣稱驗前端 ＋ 明說「本次無前端」⇒ 逃生口放行" \
+  'T:這條線是純腳本，本次無前端可驗。'
+
+t 0 cf "宣稱驗前端 ＋ 這回合用過 Claude_Browser__computer ⇒ 已驗放行" \
+  'T:前端我複驗過了。' 'U:mcp__Claude_Browser__computer'
+
+t 0 cf "宣稱驗前端 ＋ 這回合打過 CF browser-rendering 端點 ⇒ 已驗放行" \
+  'T:畫面確認過了。' 'U:curl -X POST https://api.cloudflare.com/client/v4/accounts/x/browser-rendering/screenshot'
+
+echo
+echo "── B 群：有能力卻沒用它 → 該擋，且教對的那一種 ─────────────────"
+
+# CF 能力在場、這回合只有 curl|grep 宣稱 ⇒ 擋，且教 CF 而不是 MCP
+N=$((N+1)); tr="$TMP/tr-cf.jsonl"
+mk "$tr" 'T:我 curl 抓了頁面，grep 到文案，前端驗過了。'
+run "bvtest_cf" "cf" "$tr"
+if [ "$RC" -eq 2 ] \
+   && printf '%s' "$out" | grep -q 'browser-rendering/screenshot' \
+   && ! printf '%s' "$out" | grep -q 'preview_start'; then
+  printf '  ✅ 有 CF 能力沒用它 ⇒ 擋，且教 CF（browser-rendering），不是 MCP 三步\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ CF 能力在場時，擋法或教學不對（exit=%s）\n' "$RC"
+  printf '%s\n' "$out" | sed -n '1,8p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+
+# 只有 MCP 能力（transcript 早一則用過 Claude_Browser__，但非驗證類、且這回合沒用）⇒ 擋，且教 MCP
+N=$((N+1)); tr="$TMP/tr-mcp.jsonl"
+mk2 "$tr" "mcp__Claude_Browser__close" "我 curl 抓了頁面，前端驗過了。"
+out=$(printf '{"transcript_path":"%s","session_id":"%s"}' "$tr" "bvtest_mcp" \
+  | CLAUDE_PROJECT_DIR="$TMP" CLOUDFLARE_API_TOKEN_YOULIN_CC_USE="" CLOUDFLARE_ACCOUNT_ID_YOULIN="" \
+    sh "$HOOK" 2>&1); RC=$?
+if [ "$RC" -eq 2 ] \
+   && printf '%s' "$out" | grep -q 'preview_start' \
+   && ! printf '%s' "$out" | grep -q 'browser-rendering'; then
+  printf '  ✅ 只有 MCP 能力沒用它 ⇒ 擋，且教 MCP 三步，不是 CF\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ MCP 能力在場時，擋法或教學不對（exit=%s）\n' "$RC"
+  printf '%s\n' "$out" | sed -n '1,8p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+
+echo
+echo "── C 群：一種能力都沒有 → 不誤攔（ISEP#121 的正題）─────────────"
+echo "   演練：這台沒有 CF env、transcript 也沒 Claude_Browser__，卻宣稱驗了前端"
+
+# 第一次：提醒一次（缺什麼、怎麼補），exit 2
+N=$((N+1)); tr="$TMP/tr-nocap.jsonl"
+mk "$tr" 'T:我 curl 抓了 stage 頁面，grep 到標題，前端驗過了。'
+run "bvtest_nocap1" "nocf" "$tr"
+first_rc="$RC"; first_out="$out"
+if [ "$first_rc" -eq 2 ] \
+   && printf '%s' "$first_out" | grep -q '一種瀏覽器能力都沒有' \
+   && printf '%s' "$first_out" | grep -q 'CLOUDFLARE_API_TOKEN_YOULIN_CC_USE' \
+   && printf '%s' "$first_out" | grep -q 'Browser Rendering: Edit' \
+   && printf '%s' "$first_out" | grep -q '只在這裡提醒一次'; then
+  printf '  ✅ 第一次：提醒「缺什麼、怎麼補」（要哪個 env、找 leo 加什麼權限）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ 第一次的提醒內容不對（exit=%s）\n' "$first_rc"
+  printf '%s\n' "$first_out" | sed -n '1,12p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+
+# 第二次：同一個 session、同樣沒能力、同樣宣稱 ⇒ 放行（不再每回合誤攔）
+N=$((N+1)); tr2="$TMP/tr-nocap2.jsonl"
+mk "$tr2" 'T:我又 curl 抓了一次，前端驗過了。'
+run "bvtest_nocap1" "nocf" "$tr2"   # ← 故意沿用同一個 session_id
+if [ "$RC" -eq 0 ]; then
+  printf '  ✅ 第二次（同 session）：放行 ⇒ 不再每回合誤攔（ISEP#121 主症狀已解）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ 第二次還在攔（exit=%s）⇒ 仍會每回合誤攔\n' "$RC"
+  printf '%s\n' "$out" | sed -n '1,8p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+
+echo
+echo "── C 群：沒能力時，逃生口仍走得通 ───────────────────────────"
+
+t 0 nocf "沒能力 ＋ 明說「本次無前端」⇒ 照樣放行（逃生口不受能力影響）" \
+  'T:宣稱一下前端驗過的字樣，但其實本次無前端可驗。'
+
+echo
+echo "── 訊息裡用引號 heredoc，反引號不被當命令執行（mistakes.md）─────"
+N=$((N+1)); tr="$TMP/tr-heredoc.jsonl"
+mk "$tr" 'T:我 curl 抓了頁面，前端驗過了。'
+run "bvtest_heredoc" "cf" "$tr"
+if printf '%s' "$out" | grep -q 'Cache-Control: no-cache' \
+   && ! printf '%s' "$out" | grep -qi 'command not found\|line [0-9].*: '; then
+  printf '  ✅ 訊息原樣印出（反引號沒被展開執行）\n'; PASS=$((PASS+1))
+else
+  printf '  ❌ 訊息疑似被 shell 展開（反引號被當命令）\n'
+  printf '%s\n' "$out" | sed -n '1,4p' | sed 's/^/     /'; FAIL=$((FAIL+1)); fi
+
+echo
+echo "── 壞輸入不准亂擋（fail-open）────────────────────────────────"
+for payload in '{}' '{"transcript_path":"/nonexistent/xx.jsonl"}' 'not-json' ''; do
+  N=$((N+1))
+  printf '%s' "$payload" | CLAUDE_PROJECT_DIR="$TMP" \
+    CLOUDFLARE_API_TOKEN_YOULIN_CC_USE="" CLOUDFLARE_ACCOUNT_ID_YOULIN="" \
+    sh "$HOOK" >/dev/null 2>&1; rc=$?
+  label="${payload:-（空輸入）}"
+  if [ "$rc" -eq 0 ]; then printf '  ✅ 壞輸入 %-34s ⇒ exit=0\n' "$label"; PASS=$((PASS+1))
+  else printf '  ❌ 壞輸入 %-34s ⇒ exit=%s（期望 0）\n' "$label" "$rc"; FAIL=$((FAIL+1)); fi
+done
+
+echo
+echo "────── 通過 $PASS ／ 失敗 $FAIL （共 $N 向）"
+[ "$FAIL" -eq 0 ]
@@ -35,10 +35,7 @@ PY
 # reply_payload <tool_name> <裝話的欄位名> <內容> [額外欄位 JSON]
 #   ISEP#88：通往 subagent 的路不只 Task／Agent 一條，每一條裝話的欄位還不一樣。
 reply_payload() {
-  # 第 4 個參數沒給時要傳合法的 JSON「{}」。原本寫成 "${4:-{\}}"，bash 把它展開成字面上的 {\}
-  # （反斜線留著）⇒ json.loads 當場炸、payload 變空字串 ⇒ E 群 ㉔–㉘ 五條其實從沒送出 payload（09-19 查到）
-  local extra="${4:-}"; [ -n "$extra" ] || extra='{}'
-  python3 - "$1" "$2" "$3" "$extra" <<'RP'
+  python3 - "$1" "$2" "$3" "${4:-{\}}" <<'RP'
 import json, sys
 tool, key, text, extra = sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4]
 ti = {key: text}
@@ -130,21 +127,6 @@ 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 "⑧ 明示豁免戳記在 → 放行一次" \
@@ -234,19 +216,13 @@ 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 -qE '/scripts/ticket" say' \
-   && ! printf '%s' "$msg" | grep -qE '`scripts/ticket' \
+if printf '%s' "$msg" | grep -q 'scripts/ticket say' \
   && printf '%s' "$msg" | grep -q 'touch /tmp/.dispatch-ok-S-TEST' \
   && ! printf '%s' "$msg" | grep -qi 'is a directory\|command not found'; then
-  printf '  ✅ ⑰ 訊息原文照印（反引號沒被執行）＋出路的 ticket 是絕對路徑，沒有相對的 scripts/ticket（ISEP#113）\n'; PASS=$((PASS+1))
+  printf '  ✅ ⑰ 訊息原文照印：反引號沒被當命令執行，出路那兩行沒有變空白\n'; PASS=$((PASS+1))
 else
-  printf '  ❌ ⑰ 訊息被 shell 展開，或出路又印回相對路徑的 scripts/ticket（InkStoneCo 那份是舊複本）\n'
+  printf '  ❌ ⑰ 訊息被 shell 展開了（指令消失，或冒出 shell 錯誤）\n'
  printf '%s\n' "$msg" | sed -n '1,20p' | sed 's/^/     /'
  FAIL=$((FAIL+1))
 fi
@@ -1,111 +0,0 @@
-#!/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 ]
@@ -181,35 +181,6 @@ 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）────────────────────────────────"

@@ -180,30 +180,6 @@ 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
@@ -25,8 +25,6 @@ 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"
@@ -1,62 +0,0 @@
-#!/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 ]
@@ -345,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" "$ROOT/lib/gitea_token.py" "$CACHE/hooks/lib/"
+cp "$ACCOUNT" "$CACHE/scripts/"; cp "$ROOT/lib/mainline.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
@@ -62,16 +62,10 @@ 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=$("${OFF_ENV[@]}" python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/body.md" 2>&1 >/dev/null); rc=$?
+  err=$(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
 }
@@ -93,7 +87,7 @@ g 2 "⑩ 身份欄不在第一行 → 擋（要一眼看得到，不是藏在中
 printf '%s' '【身份】subagent／inkstone/ISEP／feat/x

 做完了' > "$TMP/ok.md"
-err=$("${OFF_ENV[@]}" python3 "$TICKET" say inkstone/ISEP#30 -F "$TMP/ok.md" 2>&1 >/dev/null || true)
+err=$(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
@@ -132,51 +132,38 @@ 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 "$(json_edit "$W/mistakes.md" "$BIG" "$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))")")")
 case "$R" in 2\|*) ok "⑯ 砍掉一大段 wiki ⇒ 擋一次" ;; *) no "⑯ 該擋" "實得 $R" ;; esac
 has "$R" "只搬不改" && ok "⑰ 擋的訊息說得出出路（三步指令）" || no "⑰ 出路" "$R"

-R=$(run "$(mk 2 Edit "$(json_edit "$W/mistakes.md" "這是一句舊的話，長度普通。" "這是一句新的話，長度也普通，改了幾個字。")")")
+R=$(run "$(mk 2 Edit "$(python3 -c "
+import json
+print(json.dumps({'file_path':'$W/mistakes.md','old_string':'這是一句舊的話，長度普通。','new_string':'這是一句新的話，長度也普通，改了幾個字。'}, ensure_ascii=False))")")")
 case "$R" in 0\|*) ok "⑱ 一般編輯不擋（誤攔比漏擋更該修）" ;; *) no "⑱ 不該擋" "實得 $R" ;; esac

-R=$(run "$(mk 3 Edit "$(json_edit "/somewhere/src/app.ts" "$(python3 -c "print('x' * 3000)")" "y")")")
+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))")")")
 case "$R" in 0\|*) ok "⑲ 不是 wiki 的檔不管（別的檔縮水是它們自己的事）" ;; *) no "⑲ 非 wiki" "實得 $R" ;; esac

-R=$(run "$(mk 4 Edit "$(json_edit "$W/mistakes.md" "$BIG" "剩這一句。 wiki-compress-ok")")")
+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))")")")
 case "$R" in 0\|*) ok "⑳ wiki-compress-ok 留痕式豁免走得通" ;; *) no "⑳ 豁免" "實得 $R" ;; esac

-R=$(run "$(mk 5 Write "$(json_write "$W/從來沒有過的新檔.md" "新檔案的一點內容")")")
+R=$(run "$(mk 5 Write "$(python3 -c "
+import json
+print(json.dumps({'file_path':'$W/從來沒有過的新檔.md','content':'新檔案的一點內容'}, ensure_ascii=False))")")")
 case "$R" in 0\|*) ok "㉑ 新建檔案不算壓縮" ;; *) no "㉑ 新檔" "實得 $R" ;; esac

 # 至多擋一次：同一個 session 連兩次，第二次要放行（不然會卡死）
-PAY=$(mk 6 Edit "$(json_edit "$W/mistakes.md" "$BIG" "剩這一句。")")
+PAY=$(mk 6 Edit "$(python3 -c "
+import json
+print(json.dumps({'file_path':'$W/mistakes.md','old_string':'''$BIG''','new_string':'剩這一句。'}, ensure_ascii=False))")")
 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=$?
@@ -116,10 +116,10 @@ fi
 # 不影響「擋下來」這個判斷本身。
 HITS=""
 if [ "$RESOURCE" = "issues" ]; then
-  # 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
+  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|')
    # 只認雙引號的 "title": "..."（curl -d／json.dumps 輸出的實際格式，也是
    # 2026-08-27 那 13 張票真實用的寫法，見 scripts/test-ticket-api-bypass-guard.sh
    # 既有的模擬指令）。刻意不支援單引號版本——這段 python 要塞進 bash 單引號
@@ -1,241 +0,0 @@
-#!/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
@@ -51,7 +51,6 @@ 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 ＝ 要他親手批示或動手
@@ -68,17 +67,28 @@ def die(msg, code=2):
    sys.exit(code)


-# ── 連線（跟 scripts/ticket 同一套 token 來源：env／.env，不碰 remote URL；ISEP#47）────────
+# ── 連線（跟 scripts/ticket 同一套：先找帶憑證的 remote，再退環境變數）────────
 def token():
-    tok = _gitea_token()
-    if tok:
-        return tok
+    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)
+    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
+        if os.environ.get(env):
+            return os.environ[env]
    die(f"""🔴 拿不到 {host} 的 token

 擇一：
-  • 設環境變數 GITEA_TOKEN_CLAUDE_CODE
-  • 或在 $CLAUDE_PROJECT_DIR/.env（或 git 根的 .env）放 GITEA_TOKEN_CLAUDE_CODE=""")
+  • 讓某個 remote 帶憑證（多數 repo 的 gitea/origin 本來就有）
+  • 或設環境變數 GITEA_TOKEN_CLAUDE_CODE""")


 def api(path):
@@ -1,26 +0,0 @@
-#!/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"
@@ -46,47 +46,33 @@ 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")

-# ── 留言內文 ───────────────────────────────────────────────────────────
-# 🔴 inkstone/ISEP#123：**第一行就是人閘記號 `👤` ＋「要 leo 做什麼」**——
-#   leo 一天只看兩眼，他要在一長串留言裡一眼認出「這則是在等我動手的」。
-#   舊版第一行是 `🔐 ARM 請求`（機器術語），沒有 `👤` ⇒ 他掃過去認不出來，
-#   而他手寫的交棒都以 `👤 Leo：` 開頭。這正是「規範在人身上、不在機器上」的形狀。
-#   （`👤` 是留言記號，跟「不准用 `👤 裁決題：` 當**票名**前綴」是兩件事，見 scripts/ticket 的標題閘。）
+STATE_DIR=$(gitea_arm_state_dir)
+PENDING_FILE="$STATE_DIR/pending/${NONCE}.json"
+
+# ── 貼留言到呼叫端指定的那張票 ─────────────────────────────────────────
 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"""👤 Leo：回這則、貼下面那組碼，就放行這一次 —— {mission}
+print(f"""🔐 ARM 請求

-🔐 ARM 請求
+任務：{mission}
 有效時限：{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 \
@@ -16,29 +16,14 @@ set -eu
 REPO=""
 [ "${1:-}" = "-r" ] && { REPO="${2:?-r 後面要接 owner/repo}"; }

-# 取當前 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#//[^/@]*@#//#')
+REMOTE=$(git remote get-url gitea 2>/dev/null) || {
+  echo "✗ 當前目錄沒有名為 gitea 的 remote。請 cd 到目標 repo，或先加 remote。" >&2; exit 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|')
+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|')
 [ -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）。順序＝出貨流程：
@@ -30,15 +30,16 @@ if [[ ! -f "$LABELS_YAML" ]]; then
  exit 1
 fi

-# --- token：來源＝env／.env（inkstone/ISEP#47），不再從 remote URL 抽（那會逼 token 明文嵌在 URL 裡） ---
+# --- token：跟 InkStoneCo 頂層 gitea remote 拿同一把（不落地檔案、不印出來） ---
 TOKEN="${GITEA_TOKEN:-}"
 if [[ -z "$TOKEN" ]]; then
-  _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)"
+  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
 fi
 if [[ -z "$TOKEN" ]]; then
-  echo "拿不到 Gitea token——設 GITEA_TOKEN_CLAUDE_CODE 環境變數，或在 .env／頂層 .env 放 GITEA_TOKEN_CLAUDE_CODE=" >&2
+  echo "拿不到 Gitea token——設 GITEA_TOKEN 環境變數，或確認 $INKSTONE_TOP 的 gitea remote 存在" >&2
  exit 1
 fi

@@ -74,8 +74,6 @@ 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"
@@ -85,8 +83,23 @@ BATON_LABELS = {"s/doing", "s/review"}


 def token():
-    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 None（呼叫者自己判空）。
-    return _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 = 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


 def api(path, tok):
@@ -72,9 +72,6 @@ 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 的閘是哪一份、哪一版 ═══════════════════════════════
 #
@@ -305,8 +302,23 @@ def send_bot_api(text):

 # ══ 三、退路：貼回票上 ═══════════════════════════════════════════════════
 def gitea_token():
-    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 None（呼叫者自己判空）。
-    return _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


 def fallback_body(text, gate_fact, why=None):
@@ -1,44 +0,0 @@
-#!/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
-}
@@ -41,8 +41,6 @@ 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:
@@ -114,8 +112,22 @@ def die(msg, code=2):


 def token():
-    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 ""（呼叫者自己判空）。
-    return _gitea_token() or ""
+    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 ""


 _FX = None
@@ -31,9 +31,6 @@ 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)
@@ -41,12 +38,22 @@ def die(msg, code=2):


 def token():
-    # 來源＝env／.env（ISEP#47），不碰 remote URL。解析順序見 hooks/lib/gitea_token.py。
-    tok = _gitea_token()
-    if tok:
-        return tok
+    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
    host = HOST.split("//")[-1].rstrip("/")
-    die(f"🔴 拿不到 {host} 的 token（沒有 GITEA_TOKEN_CLAUDE_CODE，.env 裡也沒有）")
+    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）")


 def api(path, payload=None, method=None, soft=False):
@@ -41,8 +41,6 @@ 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():
    """清單住哪裡。

@@ -76,8 +74,22 @@ def die(msg, code=2):


 def token():
-    # 來源＝env／.env（ISEP#47），不碰 remote URL。拿不到回 ""（呼叫者自己判空）。
-    return _gitea_token() or ""
+    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 ""


 def _fixture():
@@ -1,108 +0,0 @@
-#!/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 ]
@@ -71,34 +71,6 @@ 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 ]
@@ -125,15 +125,10 @@ else
  printf '  ❌ ⑯ REPORT.md 內容不對\n'; FAIL=$((FAIL+1))
 fi
 N=$((N+1))
-# 🔴 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
+if [ "$(wc -l < "$TMP/led/ledger.jsonl")" = "4" ]; then
  printf '  ✅ ⑰ 帳本剛好四筆（沒有被擋下的那幾次也記進去）\n'; PASS=$((PASS+1))
 else
-  printf '  ❌ ⑰ 帳本筆數不對：%s\n' "$LEDGER_LINES"
+  printf '  ❌ ⑰ 帳本筆數不對：%s\n' "$(wc -l < "$TMP/led/ledger.jsonl" 2>/dev/null)"
  FAIL=$((FAIL+1))
 fi

@@ -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" | tr -d " ")" = 0 ] \
-  && ok "A1 --account 給非 stage（uncle6 的 ID）⇒ 拒絕、講出 stage 是誰、出路是交回地端、一個請求都沒發" || bad "A1 rc=$RC hits=$(wc -l < "$LOG" | tr -d " ") $OUT"
+[ "$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"
 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" | tr -d " ")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_TOKEN_VAR' && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_VALUE_VAR' && printf '%s' "$OUT" | grep -q '紅線' && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--value' && no_value && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] \
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'leo21c.workers.dev' && printf '%s' "$OUT" | grep -q 'arcrun-yuga3bse' && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] && ok "D2 09-02 已死的舊子網域 youlin-hsieh-dev 也拒絕（不是 stage 的識別碼）" || bad "D2 rc=$RC $OUT"
+[ "$RC" = 2 ] && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] && ok "D3 --bearer／--header（值在指令列）⇒ 拒收" || bad "D3 rc=$RC $OUT"
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q -- '--bearer' && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] && ok "D4 --bearer-env 指的變數沒值 ⇒ 拒絕、點名" || bad "D4 rc=$RC $OUT"
+[ "$RC" = 2 ] && printf '%s' "$OUT" | grep -q 'NOPE_KBDB' && [ "$(wc -l < "$LOG")" = 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" | tr -d " ")" = 0 ] && ok "D14 --json 與 --data-file 同時給 ⇒ 拒絕" || bad "D14 rc=$RC"
+[ "$RC" = 2 ] && [ "$(wc -l < "$LOG")" = 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
@@ -68,10 +68,7 @@ echo "   裸引號的 python dict 寫法，跟 2026-08-27 那 13 張票實際的
 echo "   curl -d 那種「JSON 被跳脫成字串塞進另一層引號」的寫法，本閘的猜題功能"
 echo "   刻意不支援，見 hook 檔頭「只認雙引號」那段註解，訊息裡不會列候選舊票，"
 echo "   但擋下來這件事不受影響，另有獨立案例覆蓋。）"
-# 能不能打網路：看 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
+if git remote -v 2>/dev/null | grep 'git\.uncle6\.me' | grep -q '@'; 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=$?
@@ -82,7 +79,7 @@ if [ -n "$_GT_TOK" ]; then
    printf '%s\n' "$OUT"
  fi
 else
-  echo "  ⏭️  SKIP（解不出 Gitea token：沒有 \$GITEA_TOKEN_CLAUDE_CODE、\$CLAUDE_PROJECT_DIR/.env 也沒有，連不上就不算數）"
+  echo "  ⏭️  SKIP（這台機器的 git remote 沒帶 git.uncle6.me 的憑證，連不上就不算數）"
 fi

 [ -n "$SAVED" ] && printf '%s' "$SAVED" > /tmp/.ticket-where-ok
@@ -269,21 +269,6 @@ 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
@@ -1,102 +0,0 @@
-#!/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 ]
@@ -66,7 +66,6 @@ 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):
@@ -110,17 +109,36 @@ def die(msg, code=2):


 def token():
-    # 來源＝env／.env（ISEP#47），不再從 remote URL 抽——那會逼 token 明文嵌在 URL 裡，
-    # 任何印出 remote 的訊息（git-lfs locksverify）都會洩一次。解析順序見 hooks/lib/gitea_token.py。
-    tok = _gitea_token()
-    if tok:
-        return tok
+    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
+    # 掃這個 repo 的**所有** remote，找第一個指向本站、且帶憑證的。
+    # 原本寫死只認名叫 "gitea" 的 remote —— 2026-08-20 實撞：
+    # ISEP 這個新 repo 的 remote 叫 origin，於是這支腳本在那裡整個跑不起來，
+    # 「開票前先搜」那道閘在新 repo 等於不存在。閘不該綁在某個 remote 的名字上。
    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）"}
+
 擇一：
-  • 設環境變數 GITEA_TOKEN_CLAUDE_CODE
-  • 或在 $CLAUDE_PROJECT_DIR/.env（或 git 根的 .env）放 GITEA_TOKEN_CLAUDE_CODE=""")
+  • 讓某個 remote 帶憑證（多數 repo 的 gitea/origin 本來就有）
+  • 或設環境變數 GITEA_TOKEN_CLAUDE_CODE""")


 _TOLERATE = ()          # 這一次呼叫可以吞掉的 HTTP 狀態碼（見 add_dependency）
@@ -661,30 +679,6 @@ 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")}

@@ -1129,7 +1123,13 @@ def cmd_handback(argv):
    deps = _deps(owner, repo, num)
    openn = [i for i in deps if i["state"] == "open"]

-    lines = handback_comment_lines(to, nxt, ev, openn)
+    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]
    api(f"/repos/{owner}/{repo}/issues/{num}/comments", {"body": "\n".join(lines)})

    api(f"/repos/{owner}/{repo}/issues/{num}", {"assignees": [to]}, method="PATCH")
@@ -61,21 +61,15 @@ done

 [ -f "$ROSTER" ] || { echo "找不到 roster：$ROSTER" >&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#//[^/@]*@#//#')
+# ── Gitea base（含憑證，**絕不可印出來**）────────────────────────────────
+REMOTE=$(git -C "$ROOT" remote get-url gitea 2>/dev/null || true)
+[ -n "$REMOTE" ] || { echo "本 repo 沒有 gitea remote，無法取 repo。" >&2; exit 1; }
 BASE=${REMOTE%/InkStoneCo.git}
 BASE=${BASE%/InkStoneCo}
 SELF=$(basename "$REMOTE" .git)
-# scrub 用的 SECRET：token 從 env／.env 取（不從 URL 抽），用來遮掉萬一夾帶在錯誤訊息裡的 token
-SECRET=""; command -v gitea_token >/dev/null 2>&1 && SECRET=$(gitea_token || true)
+SECRET=$(printf '%s' "$REMOTE" | sed -nE 's|.*//[^:]+:([^@]+)@.*|\1|p')
+# 任何要外流的字串都先過這關（錯誤訊息可能夾帶 clone URL）
 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 一律讀工作副本 ⇒ 快取裡若留著一份舊的自己，是誤導來源（會被人拿去讀）
@@ -101,7 +95,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 $GIT_CRED -C "$dst" fetch --quiet origin "$br" 2>&1 | scrub >&2 || true
+      git -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
@@ -110,7 +104,7 @@ for repo in $REPOS; do
    fi
    # blobless + sparse：只下載 wiki 目錄的內容，但保留完整 commit 歷史
    #（要歷史才算得出「每個檔最後更新是哪天」——淺 clone 會讓所有檔同一天）
-    if ! err=$(git $GIT_CRED clone --quiet --filter=blob:none --sparse "$BASE/$repo.git" "$dst" 2>&1 | scrub); then
+    if ! err=$(git 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
@@ -318,7 +312,7 @@ if gap > 0:
      f"Gitea `Leo/*` 在 {ASOF} 實查是 **{TOTAL} 個**，名單 {len(repos)} 個 ⇒ **還有 {gap} 個沒被點名**。")
    w("  補法（人發起，一次呼叫，不排程）——拿到完整清單、把缺的名字加進名單再重跑：")
    w("  ```")
-    w("  TOKEN=$GITEA_TOKEN_CLAUDE_CODE   # 來源＝env／.env，不從 remote URL 抽（inkstone/ISEP#47）")
+    w("  TOKEN=$(git remote get-url gitea | sed -E 's|.*//[^:]+:([^@]+)@.*|\\1|')")
    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)]'")