補上運送鏈缺的兩站：建 release ＋ 回頭覆核（inkstone/ISEP#67）

工單的斷點是「沒有任何東西會建 release」——v0.22.0 tag 早推了，
Gitea Releases 頁卻停在 v0.18.0，對 leo 等於這一版不存在。

新增兩支獨立的站（不改任何既有閘，只補送貨鏈缺的那兩段）：

- scripts/release-ship（＝ arcrun-rag 的 release-record 站）
  把「已推的 tag」變成「leo 看得到的 release」。三個前置條件「必須在場」才放行：
  ①版本一致（重用 check-version-consistency.sh，不另立判準）②tag 真的在 Gitea
  ③release note 有內容（沒給就從 git log 自動生事實清單）。冪等；建完回頭跑
  release-check 拿收貨端覆核——送的人說成功不算。

- scripts/release-check（＝ release-check 站）
  回頭問每一段「到了嗎」，而且**問的是收貨端**（Gitea tags／releases、這個 session
  載到的 plugin.json），不聽送的人說。現行版本缺 tag 或缺 release ⇒ exit 2 並指名
  缺哪一站＋怎麼補（工單驗收 4）。判準是結構（定版 commit / tag / release 在不在），
  不是關鍵字黑名單。

- 兩支離線測試（RELEASE_*_FIXTURE，不打 Gitea）：release-check 9 項、release-ship 7 項全過。

實跑證據：release-ship v0.22.0 已在 Gitea 建起
https://git.uncle6.me/inkstone/ISEP/releases/tag/v0.22.0
release-check 覆核 v0.22.0 tag＋release 都在（收貨端事實）。

版本：新增的是 scripts/（非自動載入），本身不需升版；待總管定版隨下一版一起送出。

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012656SLtw96aCxTgScH5bbK

.claude-plugin/plugin.json

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

README.md

@@ -27,7 +27,7 @@
 | `agents/` | 7 位 | **工人名單**（`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/` | 50 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
+| `scripts/` | 49 支 | `ticket`／`roster`／`isep-nag`／`wiki-compress`／`github-arm.sh` …（頂層檔案，不含 `lib/` 等子目錄） |
 
 > 🔴 這五個數字**每次都要在自己的樹上實數**，不准沿用上一版、也不准用加減推
 > （`system-dev/wiki/mistakes.md`：那是 leo 的驗收介面，多報就是假綠）：

docs/TESTING.md

@@ -419,47 +419,6 @@ bash hooks/tests/gitea-arm-check.test.sh                     .
 - ①③⑤⑥ 任一紅 ⇒ 收手收得太晚，暫存區已經開始長東西（磁碟風險回來了）
 - ② 紅 ⇒ 訊息沒給出走得通的那一行（本票整張票在講的就是這件事）
 - ⑧⑨⑩ 任一紅 ⇒ **誤攔／複製錯**：正常用法被弄壞，或複本裡混進了 `hooks/` 以外的東西
-### A31 — 雲端工人抓票的規則是機械可判的：48 條
-```
-bash scripts/test-ticket-pick.sh
-```
-**該看到**：`通過 48 條，失敗 0 條`。**全程離線**：假池子（3 個 repo、3 個 open milestone、
-11 張票）餵給換掉的 `api()`，時鐘走 `ISEP_COUNTDOWN_NOW`，`TICKET_HOST` 指到連不上的位址
-——任何一條真的走到網路會當場炸，不會靜靜變成假綠。**不開票、不改票、不留任何東西在 Gitea 上。**
-
-**它在守什麼**（`inkstone/ISEP#131`）：Routine 08-06 起讀 `journeys.md` 本 sprint 段，
-08-19 到期沒續，**連續兩週讀到殘骸只能空轉**。09-07 把 `cloud-worker.md` 步驟 1 改成從
-Gitea 主線里程碑抓票（`inkstone/InkStoneCo#118`），但那是一段給人讀的字。
-這一支把規則做成 `scripts/ticket pick`／`claim` 兩個動詞，規則本體在 `pickable()` 一支純函式：
-
-```
-可抓  s/* 恰好是 {s/todo} ＋ 沒有 assignee ＋ 沒有 Human／human/* ＋ 不是 hub ＋ 里程碑＝主線
-      主線抓盡才抓「逾期的 open 里程碑」；backlog／沒里程碑一律不抓
-認領  claim ＝ 指派 ＋ s/doing ＋ 第一行【身份】的留言，一個動作
-完成  handback --label s/review（本來就有的那半，不重做）
-```
-
-**失敗**：
-- ①「★」那四條任一紅 ⇒ 票上驗收第 1 條破了：Human／有 assignee／backlog 有一種會被抓走
-- ①「s/todo＋s/doing 同時掛著」紅 ⇒ 會把別人正在做的票抓走（09-07 實查 `inkstone/mira#6`
-  就是這個形狀——exclusive 只擋 UI 不擋 API）
-- ②「主線抓盡 → 才輪到逾期」那兩條紅 ⇒ 順序壞了：要嘛主線還有票就去抓逾期的，
-  要嘛抓盡了還回 `Arcrun#8`（既不是主線也沒逾期）
-- ②「離開碼 1」紅 ⇒ 「真的沒有票」與「讀不到」被講成同一句——後者要離開碼 2
-- ②「沒有主線 → 離開碼 2 且一通 API 都沒打」紅 ⇒ 沒主線時去抓了別的
-- ③「該擋」六條任一紅 ⇒ 規則只長在 `pick` 這端，手動 `claim` 一張 Human 的票照樣過
-- ③「身份名不在名單上 → 一通都沒打」紅 ⇒ 名單以外的名字碰到了 Gitea
-- ④ 第一條紅 ⇒ 連不上 Gitea 時回了離開碼 1，雲端會把「斷線」當「沒票」收工
-
-📌 **真實 Gitea 唯讀實跑**（2026-09-07，isep-hand，不改任何票）：
-`ticket pick --mainline InkStoneCo/system-dev/mainline.json --all` 在主線
-「AI 問一次就看得到全部」回 `ISEP#130`、`ISEP#131` 兩張（`Arcrun#175/176` 已有 assignee、
-`Arcrun#86` 是 s/doing、`mira#6` s/todo＋s/doing 都沒被抓）；逾期里程碑組把 `ISEP#31–35`
-五張 `hub` 排除後剩 `Arcrun#83`、`mira#5`、`arcrun-rag#14/27/37`。
-**寫入那半**用 `claim inkstone/ISEP#131 --name isep-hand` 真的認領過一次：
-assignee＝`claude-code`、標籤 `s/todo → s/doing`、留言 6325 第一行【身份】——
-之後再 `pick` 就不再回 #131（票上驗收第 2 條的 log 在票的留言裡）。
-
 ### A19 — 下游做完時頂層跟著關：49 條
 ```
 bash scripts/test-ticket-handoff-writeback.sh
@@ -994,7 +953,6 @@ B2（信標那行）／B3（setup 輸出）／B4（閘的訊息）三個畫面
 | **A17 未推警察不誤攔雲端分支** | 總管 | ✅ 10/10（2026-08-28，inkstone/ISEP#90） |
 | **A18 信標會報雲端接線缺陷** | 總管 | ✅ 14/14（2026-08-28，inkstone/ISEP#90） |
 | **A19 下游做完頂層跟著關** | 總管 | ✅ 49/49（2026-08-28，inkstone/ISEP#92） |
-| **A31 雲端工人抓票規則機械可判** | isep-hand | ✅ 48/48（2026-09-07，inkstone/ISEP#131）＋真實 Gitea 唯讀實跑＋一次真認領 |
 | **A20 舊票有固定管道被撈** | 總管 | ✅ 47/47（2026-08-28，inkstone/ISEP#83）＋真實 229 張唯讀實跑 |
 | A7 plugin 裝得起來 | 總管 | ✅ |
 | **A8 新 session 閘會觸發** | 總管 | 見本版 release note |

scripts/release-check

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""release-check — 回頭問「這一版真的送到了嗎」，而且**問的人不是送的人**
+                  （inkstone/ISEP#67）
+
+leo 2026-08-27 的病（票上原文）：
+    「版本只到 ISEP v0.3.9，你有新版為什麼不推？」
+    v0.4.0／v0.5.0 的 tag 早就推了，但 Gitea Releases 頁停在 v0.3.9
+    ⇒ 對 leo 等於這兩版不存在；claude plugin list 也還顯示舊版。
+
+ISEP 的運送鏈有這幾段，**每一段都要有人回頭問「到了嗎」**：
+
+    定版 commit  →  tag（Gitea）  →  release（Gitea）  →  main 的 plugin.json
+                                                       →  這個 session 真的載入到的版本
+
+🔴 這支的全部價值在一句話：**它不聽上一站說「我送了」，它自己去問收貨的那一端。**
+   tag 在不在 → 問 Gitea 的 tags；release 在不在 → 問 Gitea 的 releases（leo 會看的那頁）；
+   載入到了沒 → 看這個 session 真的掛著的那一份 plugin.json。
+   送的人（release-ship）說「成功」不算數——這支拿收貨端的事實覆核。
+
+判準是**結構**，不是關鍵字（leo 2026-08-17 已證偽關鍵字黑名單：8 次誤攔、0 次正確）：
+   · 哪些版本「應該」被送到 ＝ main 上有 `定版 vX.Y.Z` commit 的那些（git 說了算，不是猜）
+   · 那個版本「送到了沒」＝ 去 Gitea 問它的 tag 與 release 在不在（在＝到了）
+
+離開碼：
+    0  現行版本（plugin.json 宣稱的那一版）**tag 與 release 都在** ⇒ 送貨端完成
+    2  現行版本缺 tag 或缺 release ⇒ **送貨端斷了**，stderr 講出缺哪一站＋怎麼補
+       （這正是工單驗收 4：「故意漏一步 → 管線要擋下來並說出缺哪一站」）
+  說明：比現行版本更舊的 `定版` 版本若缺 tag／release，只**黃字提醒**、不改離開碼——
+       它們多半已被新版取代，硬擋等於「懲罰謹慎」（over-block 比 under-block 嚴重）。
+       載入端落後（這個 session 跑的比 main 舊）也只提醒：那要 update＋重啟，
+       是收貨端的動作，不是送貨端能修的，且 SessionStart 信標本來就一直在報。
+
+離線測試：`scripts/test-release-check.sh`（走 `RELEASE_CHECK_FIXTURE`，不打 Gitea）。
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+
+HOST = os.environ.get("RELEASE_CHECK_HOST", "https://git.uncle6.me")
+REPO = os.environ.get("RELEASE_CHECK_REPO", "inkstone/ISEP")
+FIXTURE = os.environ.get("RELEASE_CHECK_FIXTURE", "")
+HERE = os.path.dirname(os.path.abspath(__file__))
+
+
+def die(msg, code=2):
+    print(msg, file=sys.stderr)
+    sys.exit(code)
+
+
+def proj_root():
+    """這支腳本操作的那個 ISEP repo 的根。"""
+    v = os.environ.get("CLAUDE_PROJECT_DIR")
+    if v and os.path.isfile(os.path.join(v, ".claude-plugin", "plugin.json")):
+        return v
+    return os.path.dirname(HERE)
+
+
+def vtuple(v):
+    nums = re.findall(r"\d+", v or "")
+    return tuple(int(x) for x in nums[:3]) if nums else (0,)
+
+
+# ══ 收貨端事實：全部從「別人」那裡拿，不聽送的人說 ═══════════════════════
+def _fixture():
+    try:
+        with open(FIXTURE) as f:
+            return json.load(f)
+    except Exception:
+        die("🔴 讀不到 RELEASE_CHECK_FIXTURE：%s" % FIXTURE)
+
+
+def token():
+    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
+        if os.environ.get(env):
+            return os.environ[env]
+    root = os.environ.get("CLAUDE_PROJECT_DIR") or proj_root()
+    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 ""
+
+
+def _api_names(path, key):
+    """回一個 set：Gitea 上那個 collection 裡所有的名字（tag_name／name）。"""
+    tk = token()
+    if not tk:
+        die("🔴 拿不到 %s 的 token（remote 沒帶憑證，也沒有 GITEA_TOKEN_CLAUDE_CODE）" % HOST)
+    names, page = set(), 1
+    while True:
+        url = "%s/api/v1/repos/%s/%s?limit=50&page=%d" % (HOST, REPO, path, page)
+        req = urllib.request.Request(url, headers={"Authorization": "token " + tk})
+        try:
+            rows = json.load(urllib.request.urlopen(req, timeout=25))
+        except urllib.error.HTTPError as e:
+            die("🔴 Gitea %s：%s" % (e.code, e.read().decode()[:200]))
+        except Exception as e:
+            die("🔴 連不上 %s：%s" % (HOST, e))
+        if not rows:
+            break
+        for r in rows:
+            n = r.get(key)
+            if n:
+                names.add(n)
+        if len(rows) < 50:
+            break
+        page += 1
+    return names
+
+
+def gitea_tags():
+    if FIXTURE:
+        return set(_fixture().get("tags") or [])
+    return _api_names("tags", "name")
+
+
+def gitea_releases():
+    if FIXTURE:
+        return set(_fixture().get("releases") or [])
+    return _api_names("releases", "tag_name")
+
+
+# ══ 送貨端事實：main 上「定版」了哪些、現在宣稱哪一版、這個 session 載到哪一版 ══
+def dingban_versions():
+    """main 上有 `定版 vX.Y.Z` commit 的版本 —— 「應該被送到」的權威清單。"""
+    if FIXTURE:
+        return list(_fixture().get("dingban") or [])
+    root = proj_root()
+    try:
+        out = subprocess.run(
+            ["git", "-C", root, "log", "--format=%s", "--grep", "定版 v"],
+            capture_output=True, text=True, timeout=30).stdout
+    except Exception:
+        out = ""
+    seen, vers = set(), []
+    for line in out.splitlines():
+        m = re.search(r"定版\s+v?(\d+\.\d+\.\d+)", line)
+        if m and m.group(1) not in seen:
+            seen.add(m.group(1))
+            vers.append(m.group(1))
+    return vers
+
+
+def current_version():
+    """plugin.json 現在宣稱的那一版（＝ main 要送出去的那一版）。"""
+    if FIXTURE:
+        return _fixture().get("current") or ""
+    try:
+        with open(os.path.join(proj_root(), ".claude-plugin", "plugin.json")) as f:
+            return json.load(f).get("version") or ""
+    except Exception:
+        return ""
+
+
+def loaded_version():
+    """這個 session 真的掛著的那一份 plugin 是哪一版（收貨端最後一段）。
+
+    拿不到就回 None —— 不猜、不謊稱到了（house style：不知道就說不知道）。
+    """
+    if FIXTURE:
+        return _fixture().get("loaded")
+    root = os.environ.get("CLAUDE_PLUGIN_ROOT")
+    if not root:
+        return None
+    try:
+        with open(os.path.join(root, ".claude-plugin", "plugin.json")) as f:
+            return json.load(f).get("version")
+    except Exception:
+        return None
+
+
+# ══ 覆核：逐版問「到了嗎」 ════════════════════════════════════════════════
+def audit():
+    cur = current_version()
+    if not cur:
+        die("🔴 讀不到 .claude-plugin/plugin.json 的 version —— 這不是 ISEP repo，或檔案壞了。")
+    dingban = dingban_versions()
+    if cur not in dingban:
+        # 現行版本連 `定版` commit 都沒有 ⇒ plugin.json 宣稱了一個沒被定版的號碼。
+        # 這是 check-version-consistency 那條線的病，不是這支的守備範圍——但要講出來。
+        dingban = [cur] + dingban
+    tags = gitea_tags()
+    rels = gitea_releases()
+
+    def tagname(v):
+        return "v" + v
+
+    rows = []
+    for v in sorted(set(dingban), key=vtuple, reverse=True):
+        rows.append({
+            "ver": v,
+            "dingban": True,   # 這份清單本來就是從 定版 commit 來的
+            "tag": tagname(v) in tags,
+            "release": tagname(v) in rels,
+            "current": v == cur,
+        })
+    return cur, rows
+
+
+STATIONS = [
+    ("dingban", "定版 commit", "在 main 上 commit 一顆 `定版 v<版本>`（＝ plugin.json 也改成那一版）"),
+    ("tag", "tag（Gitea）", "打並推 tag：`git tag v<版本> && git push origin v<版本>`"),
+    ("release", "release（Gitea）", "建 release：`scripts/release-ship v<版本>`（這一站就是最常斷的那站）"),
+]
+
+
+def report():
+    cur, rows = audit()
+    loaded = loaded_version()
+    icon = {True: "✅", False: "❌"}
+    lines = ["ISEP 運送鏈覆核（收貨端事實，不聽送的人說）  repo=%s" % REPO, ""]
+    lines.append("  版本        定版  tag   release   （← ＝現行 plugin.json 宣稱的版本）")
+    for r in rows:
+        mark = " ←" if r["current"] else ""
+        lines.append("  %-10s %s    %s     %s%s" % (
+            "v" + r["ver"], icon[r["dingban"]], icon[r["tag"]], icon[r["release"]], mark))
+
+    # ── 載入端（這個 session）──────────────────────────────────────────
+    lines.append("")
+    if loaded is None:
+        lines.append("  載入端：這個 context 讀不到 CLAUDE_PLUGIN_ROOT ⇒ 說不出「這個 session 載到哪一版」"
+                     "（不是 session 裡跑的，或沒裝 plugin）。")
+    elif vtuple(loaded) < vtuple(cur):
+        lines.append("  🟡 載入端落後：這個 session 掛的是 v%s，main 已到 v%s。" % (loaded, cur))
+        lines.append("     修：本機 `claude plugin update isep@inkstone` **並重啟 session**"
+                     "（升版與生效是兩件事）；雲端去動一下 Environment 的 setup script 逼它重拍快照。")
+        lines.append("     這一段 SessionStart 信標本來就一直在報（beacon_report.py ①）。")
+    else:
+        lines.append("  ✅ 載入端：這個 session 掛的是 v%s，跟 main 宣稱的一致。" % loaded)
+
+    # ── 判決 ────────────────────────────────────────────────────────────
+    currow = next((r for r in rows if r["current"]), None)
+    hard = []
+    if currow:
+        for key, label, fix in STATIONS:
+            if not currow[key]:
+                hard.append((label, fix))
+    older_gaps = [r for r in rows if not r["current"] and (not r["tag"] or not r["release"])]
+
+    lines.append("")
+    if hard:
+        lines.append("🔴 **現行版本 v%s 的送貨端斷了** —— 對 leo 等於這一版不存在：" % cur)
+        for label, fix in hard:
+            lines.append("     缺這一站：%s" % label)
+            lines.append("        怎麼補：%s" % fix)
+        if older_gaps:
+            lines.append("   （另外還有更舊的版本也缺，見下方黃字，但那些不擋。）")
+    else:
+        lines.append("✅ 現行版本 v%s：定版、tag、release 都在 —— 送貨端完成，leo 那頁看得到。" % cur)
+
+    if older_gaps:
+        lines.append("")
+        lines.append("🟡 更舊的定版版本也缺件（多半已被新版取代，只提醒、不擋）：")
+        for r in older_gaps:
+            miss = []
+            if not r["tag"]:
+                miss.append("tag")
+            if not r["release"]:
+                miss.append("release")
+            lines.append("     v%s 缺：%s" % (r["ver"], "＋".join(miss)))
+        lines.append("     要補歷史版本 ⇒ 逐版 `scripts/release-ship v<版本>`；"
+                     "確定不補 ⇒ 這是 leo／總管的決定，記一句在 inkstone/ISEP#67。")
+
+    out = "\n".join(lines)
+    if hard:
+        print(out, file=sys.stderr)
+        return 2
+    print(out)
+    return 0
+
+
+def main(argv):
+    if argv and argv[0] in ("-h", "--help"):
+        print(__doc__)
+        return 0
+    return report()
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

scripts/release-ship

@@ -0,0 +1,360 @@
+#!/usr/bin/env python3
+"""release-ship — 把「已經推上去的 tag」變成「leo 那頁看得到的 release」
+                 （inkstone/ISEP#67，對應 arcrun-rag 的 release-record 站）
+
+工單抓到的斷點，一句話：**沒有任何東西會建 release。**
+    ISEP repo 全樹 grep「建 release」的 API 呼叫 → 0 命中。
+    後果：v0.22.0 的 tag 早就推了，Gitea Releases 頁卻停在 v0.18.0
+    ⇒ 對 leo 等於這一版不存在（「ISEP 現在是哪一版」只有 Releases 答得出來）。
+
+這支就是補上那一站。它**只做 tag → release** 這一段，不打 tag、不改 plugin.json、
+不碰 main —— 打 tag 是 `release-tag-guard.sh` 在管的、總管驗過整個 milestone 之後的動作。
+
+🔴 送之前，三件事「必須在場」才放行（require-something-present，不是關鍵字黑名單）：
+   ① 版本一致：`plugin.json` 的 version ＝ 這個 tag 的號碼
+      —— 直接跑既有的 `scripts/check-version-consistency.sh`，**不另寫一套判準**。
+   ② tag 真的在 Gitea 上：去問收貨端，不在就不給建 release（先去推 tag）。
+   ③ release note 有內容：沒給 `--notes-file` 就從 `git log <上一個release>..<tag>`
+      自動生一份**事實**清單（哪幾顆 commit）——leo 可以再改，但不留白。
+
+🔴 送完**自己不算數**：最後回頭跑一次 `release-check`，拿收貨端（Gitea releases 頁）
+   的事實覆核「真的建起來了」。送的人說成功不算，問收貨的那一端才算
+   （工單：「問的人不能是送的人」）。
+
+冪等：release 已經在了 ⇒ 報「已存在」、離開碼 0，不重複建、不報錯。
+
+離開碼：0 ＝ release 在 Gitea 上了（新建的或本來就在）
+        2 ＝ 某個前置條件沒滿足（stderr 講出是哪一個＋怎麼補）
+
+離線測試：`scripts/test-release-ship.sh`（走 `RELEASE_SHIP_FIXTURE`，不打 Gitea、不建真 release）。
+"""
+import json
+import os
+import re
+import subprocess
+import sys
+import urllib.error
+import urllib.request
+
+HOST = os.environ.get("RELEASE_SHIP_HOST", "https://git.uncle6.me")
+REPO = os.environ.get("RELEASE_SHIP_REPO", "inkstone/ISEP")
+FIXTURE = os.environ.get("RELEASE_SHIP_FIXTURE", "")
+HERE = os.path.dirname(os.path.abspath(__file__))
+VER_RE = re.compile(r"^v?(\d+\.\d+\.\d+)$")
+
+
+def die(msg, code=2):
+    print(msg, file=sys.stderr)
+    sys.exit(code)
+
+
+def proj_root():
+    v = os.environ.get("CLAUDE_PROJECT_DIR")
+    if v and os.path.isfile(os.path.join(v, ".claude-plugin", "plugin.json")):
+        return v
+    return os.path.dirname(HERE)
+
+
+def _fixture():
+    try:
+        with open(FIXTURE) as f:
+            return json.load(f)
+    except Exception:
+        die("🔴 讀不到 RELEASE_SHIP_FIXTURE：%s" % FIXTURE)
+
+
+def token():
+    for env in ("GITEA_TOKEN_CLAUDE_CODE", "GITEA_TOKEN"):
+        if os.environ.get(env):
+            return os.environ[env]
+    root = os.environ.get("CLAUDE_PROJECT_DIR") or proj_root()
+    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 ""
+
+
+# ══ 前置條件 ① 版本一致（重用既有腳本，不另寫判準）═══════════════════════
+def check_consistency():
+    if FIXTURE:
+        fx = _fixture()
+        return bool(fx.get("consistency_ok", True)), fx.get("consistency_msg", "")
+    script = os.path.join(proj_root(), "scripts", "check-version-consistency.sh")
+    if not os.path.isfile(script):
+        return False, "找不到 scripts/check-version-consistency.sh —— 這不是 ISEP repo？"
+    p = subprocess.run(["sh", script], capture_output=True, text=True, timeout=30)
+    return p.returncode == 0, (p.stdout + p.stderr).strip()
+
+
+# ══ 前置條件 ② tag 在不在 Gitea（問收貨端）═════════════════════════════════
+def gitea_has_tag(tagname):
+    if FIXTURE:
+        return tagname in set(_fixture().get("tags") or [])
+    tk = token()
+    if not tk:
+        die("🔴 拿不到 %s 的 token（remote 沒帶憑證，也沒有 GITEA_TOKEN_CLAUDE_CODE）" % HOST)
+    url = "%s/api/v1/repos/%s/tags/%s" % (HOST, REPO, tagname)
+    req = urllib.request.Request(url, headers={"Authorization": "token " + tk})
+    try:
+        urllib.request.urlopen(req, timeout=25)
+        return True
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return False
+        die("🔴 Gitea %s：%s" % (e.code, e.read().decode()[:200]))
+    except Exception as e:
+        die("🔴 連不上 %s：%s" % (HOST, e))
+
+
+def gitea_release(tagname):
+    """回這個 tag 的 release dict，沒有回 None。"""
+    if FIXTURE:
+        rels = _fixture().get("releases") or []
+        if tagname in rels:
+            return {"tag_name": tagname, "html_url": "(fixture)"}
+        return None
+    tk = token()
+    url = "%s/api/v1/repos/%s/releases/tags/%s" % (HOST, REPO, tagname)
+    req = urllib.request.Request(url, headers={"Authorization": "token " + tk})
+    try:
+        return json.load(urllib.request.urlopen(req, timeout=25))
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            return None
+        die("🔴 Gitea %s：%s" % (e.code, e.read().decode()[:200]))
+    except Exception as e:
+        die("🔴 連不上 %s：%s" % (HOST, e))
+
+
+# ══ 前置條件 ③ release note ════════════════════════════════════════════════
+def latest_release_before(ver):
+    """比 ver 舊、且在 Gitea 上有 release 的最新那一版 tag（拿來當 git log 起點）。"""
+    if FIXTURE:
+        rels = _fixture().get("releases") or []
+    else:
+        tk = token()
+        url = "%s/api/v1/repos/%s/releases?limit=50" % (HOST, REPO)
+        req = urllib.request.Request(url, headers={"Authorization": "token " + tk})
+        try:
+            rels = [r.get("tag_name") for r in
+                    json.load(urllib.request.urlopen(req, timeout=25))]
+        except Exception:
+            rels = []
+
+    def vt(v):
+        n = re.findall(r"\d+", v or "")
+        return tuple(int(x) for x in n[:3]) if n else (0,)
+    older = [t for t in rels if t and vt(t) < vt(ver)]
+    return max(older, key=vt) if older else None
+
+
+def dingban_title(ver):
+    """這個版本的 `定版 vX.Y.Z（…）` commit 裡括號那句話 —— 拿來當 release 名，
+    對齊 leo 既有 release 的命名慣例（`vX.Y.Z — 一句人話`）。找不到就回純 tag 名。"""
+    if FIXTURE:
+        return None
+    root = proj_root()
+    try:
+        out = subprocess.run(
+            ["git", "-C", root, "log", "--format=%s", "--grep", "定版 v%s" % ver],
+            capture_output=True, text=True, timeout=30).stdout
+    except Exception:
+        out = ""
+    for line in out.splitlines():
+        m = re.search(r"定版\s+v%s[（(]([^）)]+)[）)]" % re.escape(ver), line)
+        if m:
+            return m.group(1).strip()
+    return None
+
+
+def auto_notes(tagname):
+    """從 git log 生一份事實 note：上一個 release 之後到這個 tag 之間的 commit。"""
+    root = proj_root()
+    since = latest_release_before(tagname)
+    rng = ("%s..%s" % (since, tagname)) if since else tagname
+    try:
+        out = subprocess.run(
+            ["git", "-C", root, "log", "--no-merges", "--format=- %s", rng],
+            capture_output=True, text=True, timeout=30)
+        body = out.stdout.strip()
+    except Exception:
+        body = ""
+    head = ("這一版收了以下改動（%s 之後）：" % since) if since \
+        else "這一版收了以下改動："
+    if not body:
+        body = "-（git log 取不到 commit 清單，請手動補；release 已建起來，leo 可直接編輯。）"
+    return ("%s\n\n%s\n\n---\n（本 note 由 scripts/release-ship 從 git log 自動生成，"
+            "leo／總管可直接在 Gitea 上編輯。inkstone/ISEP#67）" % (head, body))
+
+
+# ══ 真的建 release（POST 收貨端）═══════════════════════════════════════════
+def create_release(tagname, notes, dry, name=None):
+    name = name or tagname
+    payload = {"tag_name": tagname, "name": name, "body": notes,
+               "draft": False, "prerelease": False}
+    if dry:
+        return None, "🧪 --dry-run：不 POST。要建的 release payload：\n%s" % \
+            json.dumps({"tag_name": tagname, "name": name,
+                        "body_lines": notes.count("\n") + 1}, ensure_ascii=False)
+    if FIXTURE:
+        sink = os.environ.get("RELEASE_SHIP_SINK")
+        if sink:
+            try:
+                cur = json.load(open(sink)) if os.path.exists(sink) else []
+            except Exception:
+                cur = []
+            cur.append(tagname)
+            json.dump(cur, open(sink, "w"))
+        return {"tag_name": tagname, "html_url": "(fixture-created)"}, "（fixture 模式，未打網路）"
+    tk = token()
+    if not tk:
+        die("🔴 拿不到 %s 的 token —— 建 release 是寫入，一定要憑證。" % HOST)
+    url = "%s/api/v1/repos/%s/releases" % (HOST, REPO)
+    req = urllib.request.Request(
+        url, data=json.dumps(payload).encode(), method="POST",
+        headers={"Authorization": "token " + tk, "Content-Type": "application/json"})
+    try:
+        r = json.load(urllib.request.urlopen(req, timeout=40))
+        return r, "已建立"
+    except urllib.error.HTTPError as e:
+        die("🔴 Gitea 建 release 失敗 %s：%s" % (e.code, e.read().decode()[:300]))
+    except Exception as e:
+        die("🔴 連不上 %s：%s" % (HOST, e))
+
+
+# ══ 送完覆核：回頭問收貨端（不是問自己）══════════════════════════════════
+def verify_via_check():
+    """跑 release-check，拿收貨端事實覆核。回 (ok, 輸出)。"""
+    check = os.path.join(HERE, "release-check")
+    env = dict(os.environ)
+    if FIXTURE:
+        # fixture 模式下，把剛「建」進 sink 的 release 併進 release-check 的 fixture 視圖
+        fx = _fixture()
+        sink = os.environ.get("RELEASE_SHIP_SINK")
+        extra = []
+        if sink and os.path.exists(sink):
+            try:
+                extra = json.load(open(sink))
+            except Exception:
+                extra = []
+        merged = dict(fx)
+        merged["releases"] = sorted(set((fx.get("releases") or []) + extra))
+        cf = (os.environ.get("RELEASE_SHIP_SINK") or "/tmp/rs") + ".checkfx.json"
+        json.dump(merged, open(cf, "w"))
+        env["RELEASE_CHECK_FIXTURE"] = cf
+    try:
+        p = subprocess.run(["python3", check], capture_output=True, text=True,
+                           timeout=60, env=env)
+        return p.returncode == 0, (p.stdout + p.stderr).strip()
+    except Exception as e:
+        return False, "跑不動 release-check：%s" % e
+
+
+# ══ 主流程 ════════════════════════════════════════════════════════════════
+def ship(arg, notes_file=None, dry=False, do_verify=True):
+    m = VER_RE.match(arg.strip())
+    if not m:
+        die("🔴 版本寫法是 vX.Y.Z 或 X.Y.Z，你給的是：%s" % arg)
+    ver = m.group(1)
+    tagname = "v" + ver
+    out = ["📦 release-ship %s（把 tag 變成 leo 看得到的 release）" % tagname, ""]
+
+    # 前置 ①
+    ok, msg = check_consistency()
+    if not ok:
+        die("🚫 前置①版本一致性沒過 —— 不給建 release。\n%s\n"
+            "   （plugin.json 的 version 要等於 %s。這一步重用 "
+            "scripts/check-version-consistency.sh 的判準，不另立一套。）" % (msg, tagname))
+    out.append("✅ 前置① 版本一致（plugin.json ＝ %s）" % tagname)
+
+    # 前置 ②
+    if not gitea_has_tag(tagname):
+        die("🚫 前置② Gitea 上沒有 tag %s —— 不給建 release。\n"
+            "   release 是「把已存在的 tag 公開成一頁」，tag 都還沒推，先推：\n"
+            "        git tag %s   &&   git push origin %s\n"
+            "   （推 tag 那一刻 release-tag-guard.sh 會擋下版本對不上的 tag。）"
+            % (tagname, tagname, tagname))
+    out.append("✅ 前置② Gitea 上有 tag %s（問過收貨端）" % tagname)
+
+    # 冪等
+    existing = gitea_release(tagname)
+    if existing:
+        out.append("ℹ️ release %s 本來就在了（%s）—— 不重複建。"
+                   % (tagname, existing.get("html_url") or ""))
+        code = 0
+        if do_verify:
+            vok, vout = verify_via_check()
+            out.append("")
+            out.append("── 覆核（release-check，問收貨端）──")
+            out.append(vout)
+            code = 0 if vok else 2
+        return code, "\n".join(out)
+
+    # 前置 ③
+    if notes_file:
+        with open(notes_file) as f:
+            notes = f.read()
+        out.append("✅ 前置③ release note 來自 %s" % notes_file)
+    else:
+        notes = auto_notes(tagname)
+        out.append("✅ 前置③ release note 由 git log 自動生成（leo 可再改）")
+
+    # 建（release 名對齊 leo 慣例：vX.Y.Z — 定版 commit 那句人話）
+    title = dingban_title(ver)
+    relname = ("%s — %s" % (tagname, title)) if title else tagname
+    rel, how = create_release(tagname, notes, dry, name=relname)
+    if dry:
+        out.append("   release 名：%s" % relname)
+        out.append("")
+        out.append(how)
+        return 0, "\n".join(out)
+    out.append("✅ 已建立 release「%s」（%s）" % (relname, (rel or {}).get("html_url") or how))
+
+    # 覆核（送完問收貨端）
+    code = 0
+    if do_verify:
+        vok, vout = verify_via_check()
+        out.append("")
+        out.append("── 覆核（release-check，問收貨端，不是問自己）──")
+        out.append(vout)
+        code = 0 if vok else 2
+    return code, "\n".join(out)
+
+
+def main(argv):
+    arg, notes_file, dry, do_verify = None, None, False, True
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a in ("-h", "--help"):
+            print(__doc__)
+            return 0
+        elif a == "--notes-file":
+            i += 1
+            notes_file = argv[i]
+        elif a == "--dry-run":
+            dry = True
+        elif a == "--no-verify":
+            do_verify = False
+        elif a.startswith("-"):
+            die("不認得的參數：%s（--help 看用法）" % a)
+        else:
+            arg = a
+        i += 1
+    if not arg:
+        die("用法：release-ship <版本 vX.Y.Z> [--notes-file <檔>] [--dry-run] [--no-verify]")
+    code, report = ship(arg, notes_file, dry, do_verify)
+    print(report, file=(sys.stdout if code == 0 else sys.stderr))
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

scripts/test-release-check.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+# scripts/release-check 的迴歸測試（inkstone/ISEP#67）
+#
+# 兩個方向都要有證據：
+#   A 群「該擋」（exit 2）——現行版本缺 tag 或缺 release，且**說得出缺哪一站**
+#     （這就是工單驗收 4：「故意漏一步 → 管線要擋下來並說出缺哪一站」）
+#   B 群「該過」（exit 0）——現行版本 tag＋release 都在；更舊版本缺件只黃字提醒不擋
+#
+# 🔴 全程離線（RELEASE_CHECK_FIXTURE），不打 Gitea。fixture 直接給收貨端與送貨端的事實。
+set -u
+TOOL="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/release-check}"
+TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
+PASS=0; FAIL=0; N=0
+
+mkfx() { # $1=檔名 之後 heredoc
+  cat > "$TMP/$1"
+}
+
+run() { RELEASE_CHECK_FIXTURE="$TMP/$1" python3 "$TOOL" 2>&1; }
+
+# t <期望exit> <說明> <必須出現的字串> <fixture檔>
+t() {
+  want="$1"; desc="$2"; must="$3"; fx="$4"
+  N=$((N+1))
+  out=$(RELEASE_CHECK_FIXTURE="$TMP/$fx" python3 "$TOOL" 2>&1); rc=$?
+  ok=1
+  [ "$rc" -eq "$want" ] || ok=0
+  if [ -n "$must" ] && ! printf '%s' "$out" | grep -qF "$must"; then ok=0; fi
+  if [ "$ok" -eq 1 ]; then printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 期望 exit=%s%s，實得 exit=%s\n' "$desc" "$want" \
+      "${must:+ 且輸出含「$must」}" "$rc"
+    printf '%s\n' "$out" | sed -n '1,14p' | sed 's/^/     /'; FAIL=$((FAIL+1))
+  fi
+}
+
+echo "── A 群：該擋（現行版本送貨端斷了，要說出缺哪一站）──"
+
+# A1：這就是 2026-09-05 的真實狀態——v0.22.0 有 tag、沒 release
+mkfx a1.json <<'JSON'
+{"current":"0.22.0",
+ "dingban":["0.22.0","0.21.0","0.20.0","0.19.0","0.18.0"],
+ "tags":["v0.22.0","v0.18.0"],
+ "releases":["v0.18.0"],
+ "loaded":"0.22.0"}
+JSON
+t 2 "現行 v0.22.0 有 tag 沒 release → 擋，且指名缺 release 站" "release（Gitea）" a1.json
+t 2 "缺 release 時給得出補法（release-ship）" "release-ship" a1.json
+
+# A2：連 tag 都沒有（v0.19-0.21 的真實狀態搬成現行來測）
+mkfx a2.json <<'JSON'
+{"current":"0.20.0",
+ "dingban":["0.20.0","0.18.0"],
+ "tags":["v0.18.0"],
+ "releases":["v0.18.0"],
+ "loaded":"0.20.0"}
+JSON
+t 2 "現行版本連 tag 都沒有 → 擋，且指名缺 tag 站" "tag（Gitea）" a2.json
+t 2 "缺 tag 時給得出補法（push tag）" "git push origin" a2.json
+
+echo "── B 群：該過（現行版本 tag＋release 都在）──"
+
+# B1：全部送到
+mkfx b1.json <<'JSON'
+{"current":"0.18.0",
+ "dingban":["0.18.0","0.9.0"],
+ "tags":["v0.18.0","v0.9.0"],
+ "releases":["v0.18.0","v0.9.0"],
+ "loaded":"0.18.0"}
+JSON
+t 0 "現行版本 tag＋release 都在 → 放行" "送貨端完成" b1.json
+
+# B2：現行版本送到了，但更舊的 定版 版本缺件 → 仍放行，只黃字
+mkfx b2.json <<'JSON'
+{"current":"0.22.0",
+ "dingban":["0.22.0","0.21.0","0.20.0","0.19.0","0.18.0"],
+ "tags":["v0.22.0","v0.18.0"],
+ "releases":["v0.22.0","v0.18.0"],
+ "loaded":"0.22.0"}
+JSON
+t 0 "現行送到、舊版缺件 → 放行（不 over-block）" "送貨端完成" b2.json
+t 0 "舊版缺件會被黃字提醒出來" "更舊的定版版本也缺件" b2.json
+
+# B3：載入端落後（送貨端完成，但這個 session 掛的是舊版）→ 仍 exit 0，但要報出來
+mkfx b3.json <<'JSON'
+{"current":"0.22.0",
+ "dingban":["0.22.0","0.18.0"],
+ "tags":["v0.22.0","v0.18.0"],
+ "releases":["v0.22.0","v0.18.0"],
+ "loaded":"0.21.0"}
+JSON
+t 0 "載入端落後 → 送貨端仍算完成（exit 0）" "送貨端完成" b3.json
+t 0 "載入端落後會被明確報出＋給 update／重啟的修法" "載入端落後" b3.json
+
+echo ""
+echo "──────────────────────────────"
+printf '共 %d 項：✅ %d ／ ❌ %d\n' "$N" "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]

scripts/test-release-ship.sh

@@ -0,0 +1,82 @@
+#!/usr/bin/env bash
+# scripts/release-ship 的迴歸測試（inkstone/ISEP#67）
+#
+# 兩個方向都要有證據：
+#   A 群「該擋」（exit 2）——前置條件沒滿足就不給建 release，且說得出是哪一個前置
+#     ① 版本不一致 ② Gitea 上沒那個 tag ③ 版本寫法不對
+#   B 群「該放行」（exit 0）——前置都在就建；release 已存在則冪等不重複建；--dry-run 不 POST
+#
+# 🔴 全程離線（RELEASE_SHIP_FIXTURE ＋ RELEASE_SHIP_SINK），不打 Gitea、不建任何真 release。
+set -u
+TOOL="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)/release-ship}"
+TMP=$(mktemp -d); trap 'rm -rf "$TMP"' EXIT
+PASS=0; FAIL=0; N=0
+
+# t <期望exit> <說明> <必須出現的字串> <fixture檔> [額外參數…]
+t() {
+  want="$1"; desc="$2"; must="$3"; fx="$4"; shift 4
+  N=$((N+1))
+  rm -f "$TMP/sink.json" "$TMP/sink.json.checkfx.json"
+  out=$(RELEASE_SHIP_FIXTURE="$TMP/$fx" RELEASE_SHIP_SINK="$TMP/sink.json" \
+        python3 "$TOOL" "$@" 2>&1); rc=$?
+  ok=1
+  [ "$rc" -eq "$want" ] || ok=0
+  if [ -n "$must" ] && ! printf '%s' "$out" | grep -qF "$must"; then ok=0; fi
+  if [ "$ok" -eq 1 ]; then printf '  ✅ %s\n' "$desc"; PASS=$((PASS+1))
+  else
+    printf '  ❌ %s —— 期望 exit=%s%s，實得 exit=%s\n' "$desc" "$want" \
+      "${must:+ 且輸出含「$must」}" "$rc"
+    printf '%s\n' "$out" | sed -n '1,14p' | sed 's/^/     /'; FAIL=$((FAIL+1))
+  fi
+}
+
+echo "── A 群：該擋（前置條件沒滿足）──"
+
+# A1：版本一致性沒過
+cat > "$TMP/a1.json" <<'JSON'
+{"consistency_ok":false,"consistency_msg":"❌ plugin.json=0.21.0 但 tag=v0.22.0",
+ "tags":["v0.22.0"],"releases":[]}
+JSON
+t 2 "版本不一致 → 擋，指名前置①" "前置①" a1.json v0.22.0
+
+# A2：Gitea 上沒有這個 tag
+cat > "$TMP/a2.json" <<'JSON'
+{"consistency_ok":true,"tags":["v0.18.0"],"releases":["v0.18.0"]}
+JSON
+t 2 "Gitea 沒有該 tag → 擋，指名前置②＋叫人先推 tag" "git push origin v0.22.0" a2.json v0.22.0
+
+# A3：版本寫法不對
+cat > "$TMP/a3.json" <<'JSON'
+{"consistency_ok":true,"tags":[],"releases":[]}
+JSON
+t 2 "版本寫法不對 → 擋" "版本寫法" a3.json "0.22"
+
+echo "── B 群：該放行 ──"
+
+# B1：前置都在、release 還沒建 → 建（fixture sink），然後覆核通過
+cat > "$TMP/b1.json" <<'JSON'
+{"consistency_ok":true,
+ "current":"0.22.0","dingban":["0.22.0","0.18.0"],"loaded":"0.22.0",
+ "tags":["v0.22.0","v0.18.0"],"releases":["v0.18.0"]}
+JSON
+t 0 "前置齊全、release 缺 → 建起來" "已建立 release「v0.22.0」" b1.json v0.22.0 --notes-file "$TMP/b1.json"
+t 0 "建完回頭跑 release-check 覆核（問收貨端）" "覆核" b1.json v0.22.0 --notes-file "$TMP/b1.json"
+
+# B2：release 已存在 → 冪等，不重複建
+cat > "$TMP/b2.json" <<'JSON'
+{"consistency_ok":true,
+ "current":"0.18.0","dingban":["0.18.0"],"loaded":"0.18.0",
+ "tags":["v0.18.0"],"releases":["v0.18.0"]}
+JSON
+t 0 "release 已存在 → 冪等放行、不重複建" "本來就在了" b2.json v0.18.0 --notes-file "$TMP/b2.json"
+
+# B3：--dry-run 不 POST
+cat > "$TMP/b3.json" <<'JSON'
+{"consistency_ok":true,"tags":["v0.22.0"],"releases":[]}
+JSON
+t 0 "--dry-run 全走一遍但不 POST" "不 POST" b3.json v0.22.0 --dry-run
+
+echo ""
+echo "──────────────────────────────"
+printf '共 %d 項：✅ %d ／ ❌ %d\n' "$N" "$PASS" "$FAIL"
+[ "$FAIL" -eq 0 ]

scripts/test-ticket-pick.sh

@@ -1,224 +0,0 @@
-#!/bin/bash
-# 雲端工人抓票規則的測試（inkstone/ISEP#131）
-#
-# 票上的驗收第 1 條：「`scripts/ticket pick` 給定主線檔，回一張符合規則的票；
-# 池子裡塞一張 `Human`、一張有 assignee、一張 backlog，三張都不會被挑到（測試綠）。」
-#
-# 這支測四件事：
-#   ① `pickable()` 純函式——規則本體，一格一條，不打網路
-#   ② `pick` 走整條路（把 api() 換成錄音機餵一個假池子）：挑到誰、順序、主線抓盡才抓逾期、
-#      沒有可抓的票時離開碼 1、沒有主線時離開碼 2 且訊息講得出出路
-#   ③ `claim` 一個動作三件事（指派／s/doing／【身份】留言），以及該擋的擋在**打 API 之前**
-#   ④ 不該擋的（誤攔比漏擋更該修）
-#
-# 全程離線：假池子在下面的 POOL；TICKET_HOST 指到連不上的位址，任何一條真的走到網路會當場炸，
-# 不會靜靜變成假綠。不開票、不改票、不留任何東西在 Gitea 上。
-cd "$(dirname "$0")/.." || exit 1
-T=scripts/ticket
-TMP=$(mktemp -d)
-trap 'rm -rf "$TMP"' EXIT
-PASS=0; FAIL=0
-export TICKET_HOST=http://127.0.0.1:9 GITEA_TOKEN=x
-export ISEP_COUNTDOWN_STATE_DIR="$TMP/state"; mkdir -p "$ISEP_COUNTDOWN_STATE_DIR"
-export ISEP_COUNTDOWN_NOW=$(python3 -c 'import datetime as d;print(int(d.datetime(2026,9,7,0,0,tzinfo=d.timezone.utc).timestamp()))')
-unset ISEP_MAINLINE_FILE ISEP_IDENTITY CLAUDE_PROJECT_DIR
-
-MAIN="$TMP/mainline.json"
-cat > "$MAIN" <<'JSON'
-{"ref":"inkstone/Arcrun#48","owner":"inkstone","repo":"Arcrun","id":48,
- "title":"主線 M","description":"測試用主線","due_on":"2026-09-12T23:59:59Z",
- "open_issues":3,"closed_issues":0,"members":[],"set_at":"2026-09-07 07:30"}
-JSON
-
-# ── 假池子：三個 repo、三個 open milestone、十一張票 ─────────────────────
-#   主線 M（未逾期，主線）／逾期 M（2026-08-19 到期）／未來 M（2026-10-01 到期，不是主線）
-cat > "$TMP/pool.py" <<'PY'
-import json, os
-MS = {"main": {"id": 48, "title": "主線 M", "due_on": "2026-09-12T23:59:59Z"},
-      "late": {"id": 49, "title": "逾期 M", "due_on": "2026-08-19T23:59:59Z"},
-      "future": {"id": 50, "title": "未來 M", "due_on": "2026-10-01T23:59:59Z"}}
-def I(repo, n, labels, ms=None, assignees=(), created="2026-09-01T00:00:00Z", pr=False, title=None):
-    d = {"number": n, "title": title or f"票 {repo}#{n}", "state": "open",
-         "labels": [{"name": l} for l in labels],
-         "assignees": [{"login": a} for a in assignees],
-         "milestone": MS[ms] if ms else None, "created_at": created,
-         "repository": {"full_name": f"inkstone/{repo}"}}
-    if pr: d["pull_request"] = {"merged": False}
-    return d
-POOL = {
-  "ISEP": [I("ISEP", 1, ["s/todo"], "main"),                                   # ★ 可抓
-           I("ISEP", 2, ["s/todo", "Human"], "main"),                          # 票上第 1 條：Human
-           I("ISEP", 3, ["s/todo"], "main", assignees=("someone",)),           # 票上第 1 條：有 assignee
-           I("ISEP", 4, ["s/backlog"], None),                                  # 票上第 1 條：backlog
-           I("ISEP", 5, ["s/todo"], None),                                     # 沒里程碑
-           I("ISEP", 10, ["s/todo"], "main", pr=True),                         # PR 不是票
-           I("ISEP", 11, ["s/todo", "human/exec"], "main")],                   # 執行者是人
-  "Arcrun": [I("Arcrun", 6, ["s/todo", "p/high"], "main", created="2026-08-27T00:00:00Z"),  # ★ 主線裡最優先
-             I("Arcrun", 7, ["s/todo"], "late"),                               # 逾期里程碑：主線抓盡才輪到
-             I("Arcrun", 8, ["s/todo"], "future")],                            # 不是主線也沒逾期：永遠不抓
-  "mira": [I("mira", 9, ["s/todo", "s/doing"], "main")],                       # 09-07 實查 mira#6 的形狀：有人在做
-}
-MSN = {"ISEP": ["main", "late", "future"], "Arcrun": ["main", "late", "future"], "mira": ["main"]}
-DROP = set(json.loads(os.environ.get("DROP", "[]")))     # 測「主線抓盡」用：把某幾張從池子拿掉
-def fake_api(path, payload=None, method=None):
-    rec.append((method or ("POST" if payload is not None else "GET"), path, payload))
-    if path.startswith("/orgs/inkstone/repos"):
-        return [{"name": r} for r in POOL]
-    if path == "/user":
-        return {"login": "claude-code"}
-    if "/milestones?" in path:
-        repo = path.split("/")[3]
-        return [MS[k] for k in MSN.get(repo, [])]
-    if "/issues?" in path:
-        repo = path.split("/")[3]
-        import urllib.parse
-        q = urllib.parse.parse_qs(path.split("?", 1)[1])
-        want = q.get("milestones", [""])[0]
-        return [i for i in POOL[repo] if (i["milestone"] or {}).get("title") == want
-                and f"{repo}#{i['number']}" not in DROP]
-    if path.endswith("/labels?limit=100"):
-        return [{"name": n, "id": k} for k, n in
-                enumerate(["s/todo", "s/doing", "s/review", "p/high", "Human"], 1)]
-    import re
-    m = re.match(r"/repos/inkstone/(\w+)/issues/(\d+)$", path)
-    if m and (method or "GET") == "GET":
-        return next(i for i in POOL[m.group(1)] if i["number"] == int(m.group(2)))
-    return {}
-rec = []
-PY
-
-# probe <python 片段> —— 把 scripts/ticket 當模組載進來、api() 換成假池子，印出片段的值
-probe() {
-  python3 - "$1" "$2" <<'PY'
-import sys, os, json, io, contextlib, importlib.util as u
-from importlib.machinery import SourceFileLoader as L
-spec = u.spec_from_loader("t", L("t", "scripts/ticket"))
-m = u.module_from_spec(spec); spec.loader.exec_module(m)
-ns = {}
-exec(open(os.environ["POOL_PY"]).read(), ns)
-m.api = ns["fake_api"]; rec = ns["rec"]
-argv = json.loads(sys.argv[2]) if sys.argv[2] else None
-buf = io.StringIO(); rc = None
-if argv is not None:
-    with contextlib.redirect_stdout(buf), contextlib.redirect_stderr(buf):
-        try:
-            getattr(m, argv[0])(argv[1:])
-        except SystemExit as e:
-            rc = e.code
-print(eval(sys.argv[1], {"m": m, "rec": rec, "rc": rc, "out": buf.getvalue(), "I": ns["I"], "json": json}))
-PY
-}
-export POOL_PY="$TMP/pool.py"
-
-p() { # p <說明> <want> <python 片段> [argv json]
-  got=$(probe "$3" "${4:-}" 2>&1)
-  if [ "$got" = "$2" ]; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-  printf 'want=%s got=%s  %s\n' "$2" "$got" "$1"
-}
-
-echo "── ① pickable()：規則本體，一格一條（純函式，不打網路）──"
-p "★ s/todo＋沒人＋沒 Human＋主線 → 可抓" "True" "m.pickable(I('ISEP',1,['s/todo'],'main'),'主線 M')[0]"
-p "★ 掛 Human → 不可抓（票上第 1 條）" "False" "m.pickable(I('ISEP',2,['s/todo','Human'],'main'),'主線 M')[0]"
-p "★ 有 assignee → 不可抓（票上第 1 條）" "False" "m.pickable(I('ISEP',3,['s/todo'],'main',assignees=('x',)),'主線 M')[0]"
-p "★ s/backlog、沒里程碑 → 不可抓（票上第 1 條）" "False" "m.pickable(I('ISEP',4,['s/backlog'],None),'主線 M')[0]"
-p "s/todo 但沒里程碑 → 不可抓（不抓沒里程碑的）" "False" "m.pickable(I('ISEP',5,['s/todo'],None),'主線 M')[0]"
-p "human/exec（執行者是人）→ 不可抓" "False" "m.pickable(I('ISEP',11,['s/todo','human/exec'],'main'),'主線 M')[0]"
-p "s/todo＋s/doing 同時掛著（mira#6 的形狀）→ 不可抓，有人在做" "False" "m.pickable(I('mira',9,['s/todo','s/doing'],'main'),'主線 M')[0]"
-p "hub（scope 容器，09-07 實查 ISEP#31–35 的形狀）→ 不可抓" "False" "m.pickable(I('ISEP',12,['s/todo','hub'],'main'),'主線 M')[0]"
-p "PR 不是票 → 不可抓" "False" "m.pickable(I('ISEP',10,['s/todo'],'main',pr=True),'主線 M')[0]"
-p "里程碑不是要求的那個 → 不可抓" "False" "m.pickable(I('Arcrun',8,['s/todo'],'future'),'主線 M')[0]"
-p "里程碑標題只差空白／大小寫 → 仍算同一個（norm 只有 mainline.py 那一份）" "True" "m.pickable(I('ISEP',1,['s/todo'],'main'),' 主線  m ')[0]"
-p "理由講得出「為什麼不能抓」（不是只回 False）" "True" "'Human' in m.pickable(I('ISEP',2,['s/todo','Human'],'main'),'主線 M')[1]"
-p "順序：p/high 先於沒標，沒標先於 p/low" "True" \
-  "m.pick_order(I('a',1,['s/todo','p/high'],'main')) < m.pick_order(I('a',2,['s/todo'],'main')) < m.pick_order(I('a',3,['s/todo','p/low'],'main'))"
-p "順序：同優先序看開票時間，舊的先" "True" \
-  "m.pick_order(I('a',9,['s/todo'],'main',created='2026-08-01T00:00:00Z')) < m.pick_order(I('a',1,['s/todo'],'main',created='2026-09-01T00:00:00Z'))"
-
-echo
-echo "── ② pick 走整條路（假池子 11 張，三個 repo）──"
-ARGS="[\"cmd_pick\",\"--mainline\",\"$MAIN\"]"
-ALL="[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--all\",\"--json\"]"
-p "★ 給定主線檔 → 回一張，而且是主線裡最優先的 Arcrun#6（p/high）" "True" "'inkstone/Arcrun#6' in out and rc is None" "$ARGS"
-p "只回一張（不是整份清單）" "1" "out.count('  ● ')" "$ARGS"
-p "★ --all：主線裡可抓的恰好是 Arcrun#6、ISEP#1 兩張——Human／assignee／backlog 三張都不在" \
-  "['inkstone/Arcrun#6', 'inkstone/ISEP#1']" "[r['ref'] for r in json.loads(out) if r['group']=='主線']" "$ALL"
-p "★ --all：逾期里程碑那張 Arcrun#7 排在主線之後（主線抓盡才輪到）" \
-  "['inkstone/Arcrun#7']" "[r['ref'] for r in json.loads(out) if r['group']!='主線']" "$ALL"
-p "沒逾期也不是主線的 Arcrun#8 不在清單裡" "False" "'inkstone/Arcrun#8' in out" "$ALL"
-p "backlog（ISEP#4）／沒里程碑（ISEP#5）不在清單裡" "False" "'ISEP#4' in out or 'ISEP#5' in out" "$ALL"
-p "沒有任何一條真的走到網路（api 全被錄音機接住）" "True" "all(p.startswith('/') for _,p,_ in rec)" "$ALL"
-p "pick 只讀不寫（沒有 POST／PATCH／PUT）" "True" "all(mm=='GET' for mm,_,_ in rec)" "$ALL"
-p "訊息印出下一步（認領那一行用絕對路徑，貼到別的 cwd 也叫得到正本）" "True" "'claim inkstone/Arcrun#6' in out and m.self_path() in out" "$ARGS"
-
-echo
-echo "   （主線抓盡 → 才輪到逾期里程碑）"
-export DROP='["Arcrun#6","ISEP#1"]'
-p "★ 主線兩張都被拿走後 → 回逾期里程碑的 Arcrun#7" "True" "'inkstone/Arcrun#7' in out and rc is None" "$ARGS"
-export DROP='["Arcrun#6","ISEP#1","Arcrun#7"]'
-p "★ 主線與逾期都抓盡 → 離開碼 1（真的沒有，不是故障）" "1" "rc" "$ARGS"
-p "訊息明講「不要去抓 backlog」（出路是收工回報，不是換規則）" "True" "'backlog' in out and '收工' in out" "$ARGS"
-p "抓盡時**沒有**回 Arcrun#8（未來里程碑）" "False" "'Arcrun#8' in out" "$ARGS"
-unset DROP
-
-echo
-echo "   （沒有主線 ≠ 去抓別的）"
-NOML="[\"cmd_pick\",\"--mainline\",\"$TMP/none.json\"]"
-p "主線檔讀不到 → 離開碼 2（讀不到 ≠ 沒有）" "2" "rc" "$NOML"
-p "…而且一通 API 都沒打" "0" "len(rec)" "$NOML"
-p "沒給 --mainline、狀態檔也沒有、cwd 也沒有 → 離開碼 2，訊息給出兩條出路" "True" \
-  "rc==2 and 'mainline set' in out and 'system-dev/mainline.json' in out" "[\"cmd_pick\"]"
-
-echo
-echo "── ③ claim：一個動作三件事 ──"
-CL="[\"cmd_claim\",\"inkstone/Arcrun#6\",\"--mainline\",\"$MAIN\",\"--name\",\"isep-hand\"]"
-p "★ 指派給本 token 的使用者（欄位，不是一句話）" "[['claude-code']]" \
-  "[pl['assignees'] for mm,p,pl in rec if mm=='PATCH' and p=='/repos/inkstone/Arcrun/issues/6']" "$CL"
-p "★ s/todo 換成 s/doing，p/high 留著（不是整組蓋掉）" "True" \
-  "[sorted(pl['labels'])==[2,4] for mm,p,pl in rec if mm=='PUT' and p.endswith('/issues/6/labels')]==[True]" "$CL"
-p "★ 留言第一行是【身份】isep-hand／inkstone/Arcrun／-" "True" \
-  "[pl['body'].split(chr(10))[0] for mm,p,pl in rec if mm=='POST' and p.endswith('/issues/6/comments')]==['【身份】isep-hand／inkstone/Arcrun／-']" "$CL"
-p "留言講了做完要走 handback（不推 main、不出貨）" "True" \
-  "any('handback' in pl['body'] and '不推 main' in pl['body'] for mm,p,pl in rec if mm=='POST' and p.endswith('/comments'))" "$CL"
-p "三件事都做了，離開碼 0" "None" "rc" "$CL"
-p "--as 指定登入名時用它" "[['cloud-bot']]" \
-  "[pl['assignees'] for mm,p,pl in rec if mm=='PATCH']" "[\"cmd_claim\",\"inkstone/Arcrun#6\",\"--mainline\",\"$MAIN\",\"--as\",\"cloud-bot\"]"
-p "逾期里程碑的票（Arcrun#7）也認領得了——主線抓盡時輪到它" "None" "rc" \
-  "[\"cmd_claim\",\"inkstone/Arcrun#7\",\"--mainline\",\"$MAIN\"]"
-p "pick --claim：挑到誰就認領誰（Arcrun#6）" "True" \
-  "any(mm=='PATCH' and p.endswith('/issues/6') for mm,p,pl in rec)" "[\"cmd_pick\",\"--mainline\",\"$MAIN\",\"--claim\",\"--name\",\"isep-hand\"]"
-
-echo
-echo "   （該擋的：規則在 claim 這一端再驗一次，擋在**寫入之前**）"
-blocked() { # blocked <說明> <ref> [extra argv...]
-  what=$1; ref=$2; shift 2
-  extra=$(printf '%s\n' "$@" | python3 -c "import sys,json;print(','.join(json.dumps(l.rstrip()) for l in sys.stdin if l.strip()))")
-  argv="[\"cmd_claim\",\"$ref\",\"--mainline\",\"$MAIN\"${extra:+,$extra}]"
-  p "$what → 離開碼 2，且沒有任何寫入" "True" \
-    "rc==2 and not any(mm in ('PATCH','PUT','POST') for mm,_,_ in rec)" "$argv"
-}
-blocked "掛 Human 的 ISEP#2" inkstone/ISEP#2
-blocked "已指派的 ISEP#3" inkstone/ISEP#3
-blocked "backlog 的 ISEP#4" inkstone/ISEP#4
-blocked "沒逾期也不是主線的 Arcrun#8" inkstone/Arcrun#8
-blocked "有人在做的 mira#9（s/doing 也掛著）" inkstone/mira#9
-p "擋下時訊息講得出理由與出路（pick）" "True" "'Human' in out and 'pick' in out" \
-  "[\"cmd_claim\",\"inkstone/ISEP#2\",\"--mainline\",\"$MAIN\"]"
-p "身份名不在名單上 → 在打任何 API 之前就擋（一通都沒打）" "True" "rc==2 and len(rec)==0" \
-  "[\"cmd_claim\",\"inkstone/Arcrun#6\",\"--mainline\",\"$MAIN\",\"--name\",\"路人\"]"
-
-echo
-echo "── ④ 動詞接得上（不帶假池子，走到網路才炸）──"
-out=$(python3 "$T" pick --mainline "$MAIN" 2>&1); got=$?
-if [ "$got" = 2 ] && printf '%s' "$out" | grep -q '拿不到 Gitea'; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-printf 'want=2 got=%s  pick 連不上 Gitea → 離開碼 2 並說「讀不到 ≠ 沒有」（不是離開碼 1 的假「沒票」）\n' "$got"
-out=$(python3 "$T" 2>&1)
-if printf '%s' "$out" | grep -q "ticket pick" && printf '%s' "$out" | grep -q "ticket claim"; then PASS=$((PASS+1)); printf '  ✅ '
-else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-printf '不帶參數的說明裡列得出 pick／claim（撈不到的東西等於不存在）\n'
-out=$(python3 "$T" usage pick 2>&1); got=$?
-if [ "$got" = 0 ] && printf '%s' "$out" | grep -q -- '--mainline'; then PASS=$((PASS+1)); printf '  ✅ '; else FAIL=$((FAIL+1)); printf '  ❌ '; fi
-printf 'ticket usage pick 印得出用法\n'
-
-echo
-echo "通過 $PASS 條，失敗 $FAIL 條"
-[ "$FAIL" = 0 ] || exit 1

scripts/ticket

@@ -28,12 +28,6 @@ leo 2026-08-16 三句話，本工具就是它們的機械化：
 
     ticket usage <動詞> [--example]               用法的唯一真相源——**閘印的那一行從這裡來**
 
-雲端工人抓票（inkstone/ISEP#131，規則機械可判，不靠 prompt 叮嚀）：
-
-    ticket pick [--mainline <主線檔>] [--all] [--json]   回一張現在可以抓的票（主線抓盡才抓逾期）
-    ticket claim <票> [--as <登入名>] [--name <身份>]    認領＝指派＋s/doing＋【身份】留言，一個動作
-    ticket pick --claim …                                 上面兩件連著做
-
 票的寫法：`owner/repo#N`，例：`inkstone/InkStoneCo#44`
 """
 import json
@@ -820,17 +814,6 @@ def subtask_example(parent=None, draft=None):
 # 🔴 `{bin}` 一定要留成佔位符、由 usage_text() 現填 self_path()：
 #    用法裡寫死 `ticket` 或 `scripts/ticket`，讀的人照著貼就又踩回這張票的坑。
 USAGE = {
-    "pick":
-        "用法：{bin} pick [--mainline <主線 json 檔>] [--all] [--json] [--claim [--as <登入名>] [--name <身份>]]\n"
-        "      回**一張**現在可以抓的票（主線里程碑抓盡才輪到逾期里程碑；不抓 backlog、不抓沒里程碑的）\n"
-        "      --mainline 不給時依序找：$ISEP_MAINLINE_FILE → ~/.claude/isep-countdown/mainline.json"
-        " → $CLAUDE_PROJECT_DIR/system-dev/mainline.json\n"
-        "      離開碼：0 ＝ 有票（印在 stdout）；1 ＝ 真的沒有可抓的票；2 ＝ 讀不到（讀不到 ≠ 沒有）",
-    "claim":
-        "用法：{bin} claim <owner/repo#N> [--as <登入名，預設本 token 的使用者>] [--name <身份名，預設 subagent>]"
-        " [--mainline <主線 json 檔>]\n"
-        "      認領＝指派給自己 ＋ 換成 s/doing ＋ 第一行【身份】的留言，**一個動作**。\n"
-        "      抓票規則在這裡再驗一次：不是 s/todo、已有人、掛 Human、不在主線也不逾期 ⇒ 擋下（離開碼 2）",
     "subtask":
         "用法：{bin} subtask <母票 owner/repo#N> --title \"<User Story>\" -F <內文檔>\n"
         "      [--repo <收件 repo，預設跟母票同一個>] [--label <s/xxx，預設 s/todo>]\n"
@@ -1187,327 +1170,10 @@ def cmd_loose(argv):
     return loose
 
 
-# ══════════════════════════════════════════════════════════════════════════
-# inkstone/ISEP#131 — 雲端工人抓票：規則是機械可判的，不靠 prompt 叮嚀
-#
-# 票上的原話：Routine 08-06 起讀 `journeys.md` 本 sprint 段，08-19 到期沒續，
-# **連續兩週讀到殘骸只能空轉**。09-07 把 `cloud-worker.md` 步驟 1 改成從 Gitea 主線
-# 里程碑抓票（inkstone/InkStoneCo#118）——但那是一段給人讀的字，讀漏一句就抓錯。
-# 這一段把它做成一個指令，規則寫在 `pickable()` 一支純函式裡，離線測得動。
-#
-# 規則（全部是 Gitea 欄位，沒有一格在猜文字）：
-#   可抓  s/* 狀態恰好是 {s/todo} ＋ 沒有 assignee ＋ 沒有 Human／human/* ＋ 不是 hub ＋ 有里程碑
-#         且里程碑 ＝ 主線；主線抓盡才抓「逾期的 open 里程碑」；backlog／沒里程碑一律不抓
-#   認領  指派 ＋ s/doing ＋【身份】留言，一個動作（`claim`）
-#   完成  分支 ＋ 證據 ＋ s/review ＋ `handback`——那半本來就有，不重做
-#
-# 🔴 為什麼是「s/* 恰好等於 {s/todo}」而不是「有 s/todo」：2026-09-07 實查
-#    `inkstone/mira#6` 同時掛著 s/doing 與 s/todo（exclusive 只擋 UI，不擋 API）。
-#    只看「有 s/todo」會把一張別人正在做的票抓走。要求的是**狀態在場且唯一**，
-#    仍然是「要求某個東西在場」那個形狀，不是黑名單。
-#
-# 🔴 Human 那一格用的是**標籤**（唯一識別碼），不是票上有沒有 👤 這個字——
-#    cloud-worker.md 寫過「票上沒有 👤」，那是文字判準，leo 2026-08-17 已證偽那條路。
-#    `human/exec`（執行者是人）與 `Human` 同組（labels.yaml「人的介入」），一起算。
-# ══════════════════════════════════════════════════════════════════════════
-
-_ML = None
-
-
-def _mainline_lib():
-    """`hooks/lib/mainline.py`——「主線」這件事的唯一存放處。norm() 也只有那一份。"""
-    global _ML
-    if _ML is None:
-        import importlib.machinery
-        import importlib.util
-        path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "hooks", "lib", "mainline.py")
-        loader = importlib.machinery.SourceFileLoader("isep_mainline_lib", path)
-        spec = importlib.util.spec_from_file_location("isep_mainline_lib", path, loader=loader)
-        mod = importlib.util.module_from_spec(spec)
-        loader.exec_module(mod)
-        _ML = mod
-    return _ML
-
-
-def _now():
-    """現在。測試用 ISEP_COUNTDOWN_NOW（epoch 秒）把時鐘定住——跟 countdown 同一個開關。"""
-    from datetime import datetime, timezone
-    override = os.environ.get("ISEP_COUNTDOWN_NOW", "").strip()
-    if override:
-        try:
-            return datetime.fromtimestamp(float(override), tz=timezone.utc)
-        except Exception:
-            pass
-    return datetime.now(timezone.utc)
-
-
-def _label_names(issue):
-    out = []
-    for l in issue.get("labels") or []:
-        out.append(l["name"] if isinstance(l, dict) else str(l))
-    return out
-
-
-def human_gated(labels):
-    """掛著「人的介入」那一組標籤（labels.yaml：`Human`／`human/*`）。"""
-    return any(n == "Human" or n.startswith("human/") for n in labels)
-
-
-def pickable(issue, milestone_title):
-    """這張票現在能不能被雲端工人抓走。回 (ok, 理由)。**純函式，不打網路。**
-
-    `milestone_title`＝要求它掛在哪個里程碑底下（主線，或輪到的那個逾期里程碑）。
-    理由是給人看的：`pick --all` 與 `claim` 擋下時都印它，一張票為什麼不能抓要說得出來。
-    """
-    if issue.get("pull_request"):
-        return False, "這是 PR，不是票"
-    labels = _label_names(issue)
-    st = sorted(n for n in labels if n.startswith("s/"))
-    if st != ["s/todo"]:
-        return False, "狀態不是單一的 s/todo（現在是 %s）" % (st or "沒有 s/*")
-    if issue.get("assignees") or issue.get("assignee"):
-        who = [a.get("login") for a in (issue.get("assignees") or []) if isinstance(a, dict)] \
-            or [(issue.get("assignee") or {}).get("login")]
-        return False, "已經指派給 %s" % "、".join(str(w) for w in who if w)
-    if human_gated(labels):
-        return False, "掛著 %s——要 leo 親手做的" % "、".join(n for n in labels if n == "Human" or n.startswith("human/"))
-    if "hub" in labels:
-        # labels.yaml：hub ＝「聚合一批 leaf 的 scope 容器，本身不掛 milestone、不對應 PR」
-        # 2026-09-07 實查：ISEP#31–35 五張 hub 掛在逾期里程碑上、s/todo、沒人——
-        # 照欄位規則會被抓走，但它們不是一件可以做完的事。容器不是任務。
-        return False, "是 hub（scope 容器，不是一件可以做完的事）"
-    ms = (issue.get("milestone") or {}).get("title")
-    if not ms:
-        return False, "沒有里程碑（backlog／沒排進 sprint 的不抓）"
-    norm = _mainline_lib().norm
-    if norm(ms) != norm(milestone_title):
-        return False, "里程碑是「%s」，不是「%s」" % (ms, milestone_title)
-    return True, "ok"
-
-
-def pick_order(issue):
-    """同一個里程碑裡先抓誰：p/high → 沒標 → p/low；再看開票時間（舊的先）；最後票號。
-    結果要**可重現**——同一個池子問兩次要拿到同一張。"""
-    labels = _label_names(issue)
-    prio = 0 if "p/high" in labels else (2 if "p/low" in labels else 1)
-    return (prio, issue.get("created_at") or "", issue.get("number") or 0)
-
-
-def _ref_of(issue, owner=None, repo=None):
-    full = ((issue.get("repository") or {}).get("full_name")) or ("%s/%s" % (owner, repo))
-    return "%s#%s" % (full, issue.get("number"))
-
-
-def load_mainline(argv):
-    """主線從哪來（依序）：--mainline <檔> → $ISEP_MAINLINE_FILE → 本機狀態檔
-    （`scripts/mainline set` 寫的那個）→ $CLAUDE_PROJECT_DIR/system-dev/mainline.json（進 repo 的那份，
-    雲端 clone 就讀得到，inkstone/InkStoneCo#118）。回 (dict, 來源說明)。"""
-    def opt(name):
-        return argv[argv.index(name) + 1] if name in argv and argv.index(name) + 1 < len(argv) else None
-    ML = _mainline_lib()
-    tried = []
-    explicit = opt("--mainline") or os.environ.get("ISEP_MAINLINE_FILE", "").strip()
-    if explicit:
-        try:
-            with open(explicit) as f:
-                d = json.load(f)
-        except Exception as e:
-            die("🔴 讀不到主線檔 %s：%s\n   讀不到 ≠ 沒有主線——先把檔案路徑修對，不要因此去抓別的票。" % (explicit, e))
-        if not isinstance(d, dict) or not d.get("title"):
-            die("🔴 主線檔 %s 裡沒有 title 欄——那不是 `scripts/mainline set` 寫出來的檔。" % explicit)
-        return d, explicit
-    tried.append(ML.path())
-    d = ML.load()
-    if d:
-        return d, ML.path()
-    root = os.environ.get("CLAUDE_PROJECT_DIR") or os.getcwd()
-    cand = os.path.join(root, "system-dev", "mainline.json")
-    tried.append(cand)
-    try:
-        with open(cand) as f:
-            d = json.load(f)
-        if isinstance(d, dict) and d.get("title"):
-            return d, cand
-    except Exception:
-        pass
-    die("""🔴 現在沒有主線 ⇒ 沒有「可以抓的票」這回事。
-
-  找過：
-%s
-
-  這不是叫你去抓 backlog 或沒里程碑的票——那是總管排 sprint 的事，不是工人的。
-  出路（擇一）：
-    • 雲端：clone inkstone/InkStoneCo，用它 repo 裡那份 → `%s pick --mainline <clone>/system-dev/mainline.json`
-    • 本機：`scripts/mainline list` 看有哪些 → `scripts/mainline set <owner/repo#id>`""" % (
-        "\n".join("    · " + t for t in tried), self_path()))
-
-
-def _repos(owner):
-    return [r["name"] for r in (api("/orgs/%s/repos?limit=100" % owner) or [])
-            if isinstance(r, dict) and r.get("name")]
-
-
-def _open_milestones(owner, repos):
-    """每個 repo 的 open milestone。回 [(repo, milestone dict)]。"""
-    out = []
-    for r in repos:
-        for m in (api("/repos/%s/%s/milestones?state=open&limit=100" % (owner, r)) or []):
-            if isinstance(m, dict) and m.get("title"):
-                out.append((r, m))
-    return out
-
-
-def _issues_in(owner, repo, title):
-    q = urllib.parse.urlencode({"state": "open", "type": "issues", "milestones": title, "limit": 100})
-    rows = api("/repos/%s/%s/issues?%s" % (owner, repo, q)) or []
-    for it in rows:
-        if isinstance(it, dict):
-            it.setdefault("repository", {"full_name": "%s/%s" % (owner, repo)})
-    return [it for it in rows if isinstance(it, dict)]
-
-
-def pick_candidates(ms, now=None):
-    """依序回 [(組名, 里程碑標題, [可抓的票…])]：第一組是主線，之後是逾期的 open 里程碑
-    （最逾期的先）。**每一組裡都已經照 pick_order 排好。**"""
-    ML = _mainline_lib()
-    now = now or _now()
-    owner = ms.get("owner") or ORG
-    repos = _repos(owner)
-    opened = _open_milestones(owner, repos)
-    groups = []
-
-    def collect(title):
-        found = []
-        for r, m in opened:
-            if ML.norm(m.get("title")) != ML.norm(title):
-                continue
-            for it in _issues_in(owner, r, m.get("title")):
-                ok, _ = pickable(it, title)
-                if ok:
-                    found.append(it)
-        return sorted(found, key=pick_order)
-
-    groups.append(("主線", ms["title"], collect(ms["title"])))
-
-    overdue = {}
-    for r, m in opened:
-        if ML.norm(m.get("title")) == ML.norm(ms["title"]):
-            continue
-        due = ML.due_of(m)
-        if due and due < now:
-            key = ML.norm(m.get("title"))
-            if key not in overdue or due < overdue[key][0]:
-                overdue[key] = (due, m.get("title"))
-    for due, title in sorted(overdue.values()):
-        groups.append(("逾期里程碑", title, collect(title)))
-    return groups
-
-
-def cmd_pick(argv):
-    """回一張現在可以抓的票。離開碼：0 有、1 真的沒有、2 讀不到／沒主線。"""
-    if argv and argv[0] in ("-h", "--help"):
-        die(usage_text("pick"), 0)
-    ms, src = load_mainline(argv)
-    as_json = "--json" in argv
-    show_all = "--all" in argv
-    try:
-        groups = pick_candidates(ms)
-    except (urllib.error.URLError, OSError) as e:
-        die("🔴 拿不到 Gitea（%s）。讀不到 ≠ 沒有可抓的票——先修連線，不要空轉也不要抓別的。" % e)
-
-    flat = [(g, t, it) for g, t, its in groups for it in its]
-    if as_json:
-        rows = [{"ref": _ref_of(it), "title": it.get("title"), "group": g, "milestone": t,
-                 "labels": _label_names(it), "created_at": it.get("created_at")}
-                for g, t, it in flat]
-        print(json.dumps(rows if show_all else (rows[0] if rows else None), ensure_ascii=False, indent=2))
-        sys.exit(0 if rows else 1)
-
-    print("🎯 主線：「%s」（來源：%s）" % (ms["title"], src))
-    for g, t, its in groups:
-        if g == "主線" or its or show_all:
-            print("   %s「%s」：可抓 %d 張" % (g, t, len(its)))
-    print()
-    if not flat:
-        print("⚪ 沒有可以抓的票——主線與逾期里程碑都抓盡了。")
-        print("   出路：收工回報（這是正常結果，不是故障）。")
-        print("   🔴 不要去抓 backlog／沒里程碑／掛 Human／已有人的票——那些不在規則裡，抓了就是跳線。")
-        sys.exit(1)
-
-    shown = flat if show_all else flat[:1]
-    for g, t, it in shown:
-        print("  ● %s　%s" % (_ref_of(it), _label_names(it)))
-        print("    %s" % (it.get("title") or "")[:80])
-        print("    %s「%s」　開票 %s" % (g, t, (it.get("created_at") or "")[:10]))
-    print()
-    if "--claim" in argv:
-        top = flat[0][2]
-        cmd_claim([_ref_of(top)] + [a for a in argv if a != "--claim"])
-        return
-    print("📌 認領（指派＋s/doing＋【身份】留言，一個動作）：")
-    print("   %s claim %s --name <你的名字>" % (self_path(), _ref_of(flat[0][2])))
-    print("   做完：分支＋證據 → `%s handback %s --to %s --label s/review --next \"…\" --evidence <URL>`"
-          % (self_path(), _ref_of(flat[0][2]), HANDBACK_TO))
-
-
-def cmd_claim(argv):
-    """認領＝指派 ＋ s/doing ＋【身份】留言，**一個動作**。抓票規則在這裡再驗一次。"""
-    if not argv or argv[0] in ("-h", "--help"):
-        die(usage_text("claim"), 0 if argv else 2)
-    owner, repo, num = parse_ref(argv[0])
-
-    def opt(name, default=None):
-        return argv[argv.index(name) + 1] if name in argv and argv.index(name) + 1 < len(argv) else default
-
-    name = opt("--name") or "subagent"
-    ident = "【身份】%s／%s/%s／%s" % (name, owner, repo, opt("--branch") or "-")
-    # 身份先驗，**在打任何 API 之前**——名單以外的名字連 Gitea 都不會碰到
-    check_identity(ident, "認領留言")
-
-    ms, _ = load_mainline(argv)
-    ML = _mainline_lib()
-    who = opt("--as") or (api("/user") or {}).get("login")
-    if not who:
-        die("🔴 拿不到本 token 的使用者名稱，也沒給 --as。")
-
-    issue = api("/repos/%s/%s/issues/%d" % (owner, repo, num))
-    issue.setdefault("repository", {"full_name": "%s/%s" % (owner, repo)})
-    ims = issue.get("milestone") or {}
-    ok, why = pickable(issue, ims.get("title") or "")
-    if ok:
-        on_mainline = ML.norm(ims.get("title")) == ML.norm(ms["title"])
-        due = ML.due_of(ims)
-        if not on_mainline and not (due and due < _now()):
-            ok, why = False, "里程碑「%s」既不是主線「%s」也還沒逾期" % (ims.get("title"), ms["title"])
-    if not ok:
-        die("""🚫 %s/%s#%d 現在不能抓：%s
-
-  抓票規則（inkstone/ISEP#131，全部是 Gitea 欄位）：
-    s/* 恰好是 s/todo ＋ 沒有 assignee ＋ 沒有 Human／human/* ＋ 里程碑是主線（主線抓盡才抓逾期）
-  出路：`%s pick` 會回一張符合規則的票；這張如果真的該你做，回票上問總管改欄位，不要硬抓。""" % (
-            owner, repo, num, why, self_path()))
-
-    api("/repos/%s/%s/issues/%d" % (owner, repo, num), {"assignees": [who]}, method="PATCH")
-    keep = [n for n in _label_names(issue) if not n.startswith("s/")] + ["s/doing"]
-    _set_labels(owner, repo, num, keep)
-    lines = [ident, "",
-             "🙋 **認領**　→ `%s`" % who, "",
-             "- 里程碑：「%s」%s" % (ims.get("title"), "（主線）" if ML.norm(ims.get("title")) == ML.norm(ms["title"]) else "（逾期里程碑，主線已抓盡）"),
-             "- 狀態：s/todo → s/doing",
-             "- 做完：分支＋證據 → `s/review` ＋ `ticket handback`（不推 main、不出貨、不改里程碑）"]
-    api("/repos/%s/%s/issues/%d/comments" % (owner, repo, num), {"body": "\n".join(lines)})
-    print("✅ 認領 %s/%s#%d → `%s`" % (owner, repo, num, who))
-    print("   指派：%s　　tag：%s" % (who, [n for n in keep if n.startswith("s/")]))
-    print("   留言第一行：%s" % ident)
-    print("\n📌 做完：%s handback %s/%s#%d --to %s --label s/review --next \"…\" --evidence <URL>"
-          % (self_path(), owner, repo, num, HANDBACK_TO))
-
-
-
 CMDS = {"where": cmd_where, "say": cmd_say, "new": cmd_new, "close": cmd_close,
         "decide": cmd_decide, "subtask": cmd_subtask, "handoff": cmd_subtask,
         "handback": cmd_handback, "mine": cmd_mine, "loose": cmd_loose,
-        "usage": cmd_usage, "pick": cmd_pick, "claim": cmd_claim}
+        "usage": cmd_usage}
 
 if __name__ == "__main__":
     if len(sys.argv) < 2 or sys.argv[1] not in CMDS: