feat: teai role

considerIssue 原先僅在 anyOpen(children) 時標 parent-tracking，子項全關閉時
退回通用原因（如 assignee-idle），與 gitea.py（agents#44 修正）不一致，
導致巡邏「父項收尾」規則永不觸發。改為 children 非空一律 parent-tracking，
並移除已無引用的 anyOpen。

回歸測試 TestScanStalledParentWrapup 補子項全關閉 fixture；
fakeSource.OpenIssues 過濾 closed 以對齊真實 API 語義。

.gitignore

@@ -19,3 +19,4 @@ coverage.*
 # 作業系統
 .DS_Store
 Thumbs.db
+teai-bin

README.md

@@ -6,17 +6,69 @@ teai 是 Gitea 的命令列（CLI）工具，以更完整、更可靠的方式
 
 - **語言：** Go（與 Gitea 本體一致），僅用標準庫，離線可建置
 - **目標站點：** `https://gitea.alterminal.com`
-- **狀態：** 基礎建設（#5：internal/gitea）、工作流命令（#6：whoami/orgs/members/mine/pulls/next）與日常操作命令（#8：issues/pulls/labels/milestones/releases/repos/api）已實作；stalled/xrefs（#7）進行中
+- **狀態：** 基礎建設（#5：internal/gitea）、工作流命令（#6：whoami/role/orgs/members/mine/pulls/next）、日常操作命令（#8：issues/pulls/labels/milestones/releases/repos/api）與管理者巡邏命令（#7：stalled/xrefs）已實作
 - **範圍（#3）：** 不避開 tea 已有的功能；單一工具涵蓋完整操作
 
 ## 安裝與建置
 
-需要 Go 1.26 以上。
+### 需求
+
+- **Go 1.26 以上**（`go version` 確認；本倉庫僅用標準庫，離線可建置）
+- **git**
+- Gitea 帳號的 **API token**（設定階段使用；在 Gitea「設定 → 應用程式」產生）
+
+### 以 go install 安裝（建議）
+
+自 v0.1.0 起 module 已發佈 tag，可直接以版本安裝（二元檔裝進 `GOBIN`，預設 `~/go/bin`）：
 
 ```sh
-go build -o teai ./cmd/teai
+go install gitea.alterminal.com/alterminal/teai/cmd/teai@latest    # 最新 tag（亦可 @v<版本> 指定）
+teai version                                                       # 驗證：顯示安裝的 tag 版本（見下方說明）
 ```
 
+本 module 為公開倉庫，預設 `GOPROXY`／`GOSUMDB` 即可解析（已於乾淨環境驗證）。
+若所在網路環境無法經公用 proxy 抓取，可改設 `GOPRIVATE=gitea.alterminal.com`
+（略過 proxy 與 checksum database，直接從 Gitea 抓取）。
+
+`teai version` 顯示建入的 module 版本，即安裝指定的 tag（如 `v0.1.1`）。
+注意：讀 build info 顯示安裝版本的支援，自包含該變更的 tag 起（v0.1.1）才生效——
+v0.1.0 早於此變更，以 `@v0.1.0` 安裝（或此變更前的 `@latest`）仍顯示舊行為 `0.1.0-dev`。
+
+### 從原始碼建置（開發用）
+
+開發、離線或想鎖定特定 commit 時，clone 後自行建置：
+
+```sh
+git clone https://gitea.alterminal.com/alterminal/teai.git
+cd teai
+go build -o teai ./cmd/teai
+install -Dm755 teai ~/.local/bin/teai   # 或複製到任何 PATH 內目錄
+teai version                             # 驗證：teai version v0.1.1-0.<時間戳>-<commit>（見下方說明）
+```
+
+也可以在 clone 目錄內直接裝進 `GOBIN`：
+
+```sh
+go install ./cmd/teai
+```
+
+clone 建置時 Go 會把 VCS 狀態寫進 build info：位於 tag 上顯示該 tag、
+其後的 commit 顯示 pseudo-version（如 `v0.1.1-0.20260912160956-5a48fdd590b2`）、
+工作樹有修改再附加 `+dirty`；無 VCS 資訊（如從 tarball 解壓建置）時
+`Main.Version` 為 `(devel)`，此時退回開發版本號 `0.1.0-dev`。
+
+### 登入設定（首次使用）
+
+```sh
+teai login add --url https://gitea.alterminal.com
+# 未給 --token 時自 stdin 讀一行：貼上 token 後按 Enter（不會進 shell 歷史）
+teai whoami    # 驗證：應輸出 {"username":"<你的帳號>"}
+```
+
+- token 驗證失敗（HTTP 401）不會寫入組態，結束碼 3。
+- 組態檔：`--config`／`TEAI_CONFIG` 指定，預設 `~/.config/teai/config.yml`；檔案權限 `0600`。
+- 多站台以 `--name` 區分、`teai login default <名稱>` 切換預設；詳見下方 [`teai login`](#teai-login--管理登入) 一節。
+
 ## 指令設計
 
 > 工作流規則的唯一來源是 [`alterminal/agents`](https://gitea.alterminal.com/alterminal/agents) 的 `AGENTS.md`；
@@ -28,39 +80,51 @@ go build -o teai ./cmd/teai
 2. **規則單一來源**：「最後一則留言不是自己」等工作流判定規則以 `AGENTS.md` 為準，teai 只實作、不改義。規則要變更，先改 AGENTS.md，teai 跟著改。
 3. **機器可讀優先**：預設輸出 JSON；`--output table` 僅供人工抽查。
 4. **可直接替換原型**：`gitea.py` 的每個子命令在 teai 都有語義相同的對應命令，可交叉驗證、平滑遷移。
-5. **認證沿用 tea**：讀 `tea` 的登入組態（`TEA_CONFIG` 或 `~/.config/tea/config.yml`），不另建認證體系。
+5. **自主認證組態**：登入資料寫在 teai 自己的組態（`TEAI_CONFIG` 或 `~/.config/teai/config.yml`），不依賴 tea。
 6. **安全預設**：查詢類唯讀；寫入類命令（#8 起）一律要求明確 `--yes`，未確認時不發出任何請求、不產生任何遠端變更。
 
 ### 日常操作（tea 對等指令；#3 不避開 tea 已有功能；#8 已實作）
 
-issues／pulls／labels／milestones／releases／repos／api 的日常操作，自行實作、輸出一致 JSON、共用同一套認證與全域選項。介面語義以 `tea`／Gitea API 為相容參考。已實作：
+issues／pulls／labels／milestones／releases／repos／organizations／api 的日常操作，自行實作、輸出一致 JSON、共用同一套認證與全域選項。介面語義以 `tea`／Gitea API 為相容參考。已實作：
 
 ```sh
 # issues
-teai issues list --repo <owner>/<repo> [--state open|closed|all]
+teai issues list --repo <owner>/<repo> [--state open|closed|all] [--labels a,b]   # 多標籤 AND
 teai issues view --repo <owner>/<repo> <number> [--comments]
 teai issues create --repo <owner>/<repo> --title … [--body …] [--assignees a,b] --yes
 teai issues close --repo <owner>/<repo> --yes <number>
-teai issues comment --repo <owner>/<repo> --body … --yes <number>
+teai issues comment --repo <owner>/<repo> [--body …] --yes <number> [留言…]       # 位置參數優先（#40）
 # pulls（無子命令仍是工作流清單：--mine／--reviewer／--repo）
 teai pulls list --repo <owner>/<repo> [--state open|closed|all]
 teai pulls view --repo <owner>/<repo> <number> [--comments]
 teai pulls create --repo <owner>/<repo> --head <branch> [--base main] --title … [--body …] --yes
 teai pulls merge --repo <owner>/<repo> [--style merge|rebase|rebase-merge|squash] --yes <number>
-teai pulls comment --repo <owner>/<repo> --body … --yes <number>
+teai pulls approve --repo <owner>/<repo> [--body …] --yes <number> [意見…]        # POST reviews，event=APPROVED（#40）
+teai pulls close --repo <owner>/<repo> --yes <number>                              # 關閉不合併（PATCH state=closed；#40）
+teai pulls checkout --repo <owner>/<repo> [--dir <path>] <number>                   # 本機 git 取得 head（#40）
+teai pulls comment --repo <owner>/<repo> [--body …] --yes <number> [留言…]
+# 通用留言（tea comment 對等；issue 與 PR 共用端點，#40）
+teai comment --repo <owner>/<repo> [--body …] --yes <number> [留言…]
 # labels／milestones／releases／repos
 teai labels list --repo <owner>/<repo>
 teai labels create --repo <owner>/<repo> --name … [--color #RRGGBB] [--description …] --yes
+teai milestones                          # 跨倉庫 open 里程碑總覽（gitea.py milestones 對應；期限近者在前）
+teai milestones --repo <owner>/<repo>    # 同 milestones list（單倉庫，維持既有語義）
 teai milestones list --repo <owner>/<repo> [--state open|closed|all]
 teai milestones create --repo <owner>/<repo> --title … [--description …] [--due RFC3339] --yes
 teai releases list --repo <owner>/<repo>
 teai repos list [--org <org>]
+# 組織管理（tea organizations 對等；#45）
+teai organizations list                                            # 列出自己可存取的組織（GET /user/orgs）
+teai organizations create --name <org> [--full-name …] [--description …] [--website …] [--location …] [--visibility public|limited|private] --yes
+teai organizations delete <org> --yes                              # 刪除組織（不可逆；DELETE /orgs/{org}）
 # 任意 API 呼叫（逃生口）
 teai api <path> [--method GET|POST|PATCH|DELETE] [--data '<json>'] [--yes]
 ```
 
-> `--yes` 閘門：所有寫入類命令（create／close／comment／merge／labels create／milestones create／api 非 GET 動詞）未帶 `--yes` 時回 exit 2（用法錯誤），且不發出任何 HTTP 請求。
+> `--yes` 閘門：所有寫入類命令（create／close／comment／merge／approve／labels create／milestones create／organizations create／delete／api 非 GET 動詞）未帶 `--yes` 時回 exit 2（用法錯誤），且不發出任何 HTTP 請求。
 > `teai api` 的 path 內含查詢字串（如 `/repos/a/b/issues?state=closed`）時會正確傳遞。
+> `teai pulls checkout` 是本機唯讀輔助：同倉庫 head 在 `--dir`（預設當前目錄）的既有工作樹 `git fetch origin <ref> && git checkout -B <ref> FETCH_HEAD`；跨倉庫 head 需 `--dir`（新目錄）執行 `git clone --branch <ref> <clone_url>`。teai 不代管 git 認證，私有倉庫請自備 credential helper。
 
 ### 全域介面
 
@@ -71,8 +135,8 @@ teai [全域選項] <命令> [參數]
 | 選項 | 說明 |
 | --- | --- |
 | `--url <URL>` | Gitea 站點，預設 `https://gitea.alterminal.com` |
-| `--token <TOKEN>` | API token；未給則依序嘗試 `TEAI_TOKEN` 環境變數、tea 登入組態 |
-| `--config <path>` | tea 組態檔路徑，等同 `TEA_CONFIG` |
+| `--token <TOKEN>` | API token；未給則依序嘗試 `TEAI_TOKEN` 環境變數、teai 登入組態 |
+| `--config <path>` | teai 組態檔路徑，等同 `TEAI_CONFIG` |
 | `--output json\|table` | 輸出格式，預設 `json` |
 | `--timeout <dur>` | HTTP 請求逾時，預設 `30s` |
 
@@ -80,8 +144,11 @@ teai [全域選項] <命令> [參數]
 
 | 命令 | 對應 gitea.py | 說明 |
 | --- | --- | --- |
+| `teai login list\|add\|default\|remove` | — | 管理登入組態（見下） |
 | `teai whoami` | `get_current_username` | 目前帳號 |
+| `teai role` | — | 目前角色（Supervisor 團隊→supervisor，Agents 團隊→worker） |
 | `teai orgs` | `for_all_organizations` | 我所屬的組織 |
+| `teai organizations list\|create\|delete` | — | 組織管理（tea 對等日常操作；`orgs` 是工作流精簡版） |
 | `teai members [--has-work]` | `members [--has-work]` | Agents 團隊成員；`--has-work` 只列有未完成工作者 |
 | `teai mine` | `mine` | 分派給我、待跟進的 issues |
 | `teai pulls [--mine\|--reviewer] [--repo <owner>/<repo>]` | `pulls` 系列 | 跨倉庫 PR 跟進清單 |
@@ -118,6 +185,24 @@ teai next --output table  # 人類可讀
 }
 ```
 
+### `teai login` — 管理登入
+
+登入組態由 teai 自行管理（`--config`／`TEAI_CONFIG`，預設 `~/.config/teai/config.yml`）。
+寫入採行級編輯：只動目標項目的行，未知欄位與註解逐字保留；檔案權限 `0600`、暫存檔原子替換。
+
+```sh
+teai login list                      # 列出登入（一律不含 token）
+teai login add [--url <URL>] [--name <名稱>] [--default=false] [--token <TOKEN>]
+                                     # 先以 token 呼叫 GET /user 驗證，成功才寫入（並記下帳號）
+teai login default <名稱>            # 設定預設登入
+teai login remove <名稱> [--yes]     # 移除登入；移除預設者時其餘第一筆自動遞補
+```
+
+- `login add` 未給 `--token` 時自 stdin 讀一行，避免 token 進 shell 歷史；token 驗證失敗（401）
+  不寫入，結束碼 3。
+- 未給 `--name` 時：同站（URL 主機相同）已有登入 → 就地更新該項目；否則以 URL 主機為名稱。
+- 輸出 JSON（`--output table` 供人工查看），欄位 `name`／`url`／`user`／`default`，**永不輸出 token**。
+
 ### `teai stalled [--hours N]` — 管理者巡邏
 
 ```sh
@@ -152,6 +237,47 @@ PR 改帶 `author` 與 `reviewers` 欄位。`reason` 取值：
 - issue：`no-assignee`、`assignee-idle`、`no-commenter`、`waiting-outside`、`parent-tracking`
 - PR：`no-reviewer`、`author-idle`、`reviewer-idle`、`no-commenter`
 
+### `teai milestones` — 跨倉庫里程碑總覽
+
+```sh
+teai milestones              # 各倉庫 open 里程碑概況（跨所屬組織；期限近者在前）
+teai milestones --output table
+```
+
+管理者巡邏用（`gitea.py milestones` 對應，agents AGENTS.md 10.1）。帶 `--repo` 時
+維持現行單倉庫 `list` 語義（`teai milestones --repo a/b` ＝ `teai milestones list --repo a/b`）。
+
+每筆欄位（鍵集鍵序與 `gitea.py` 全等，實測位元組一致）：
+
+```json
+{
+  "repo": "alterminal/test",
+  "id": 6,
+  "title": "xcheck31-ms-overdue",
+  "url": "https://gitea.alterminal.com/alterminal/test/milestone/6",
+  "open_issues": 2,
+  "closed_issues": 0,
+  "due_on": "2026-09-08T08:00:00+08:00",
+  "due_hours": 61.3,
+  "overdue": true,
+  "unassigned": [
+    {
+      "type": "issue",
+      "number": 14,
+      "title": "…",
+      "url": "https://gitea.alterminal.com/alterminal/test/issues/14"
+    }
+  ],
+  "updated_at": "2026-09-10T21:17:37+08:00"
+}
+```
+
+- **排序**：`due_on` 近者在前；無期限者最後（`gitea.py` 的 `(due_on is None, due_on)` 鍵）。
+- **`overdue`／`due_hours`**：期限已過為 `true`（`due_hours` 正數）；無期限 → `null`。
+- **`unassigned`**：該里程碑 open 條目（issue 與 PR）中無 assignee 者的摘要；PR 條目另帶 `author`。
+- **`updated_at`**：里程碑本身與其 open 條目 `updated_at` 的最大值（判斷活躍度用）。
+- 空輸出 → `[]`（`gitea.py` 無輸出；依 #26 慣例差異）。
+
 ### `teai members [--has-work]`
 
 ```sh
@@ -176,13 +302,21 @@ teai pulls --repo alterminal/teai # 限定單一倉庫
 teai mine                 # 分派給我、最後一則留言不是自己的 open issues（跨所屬組織）
 ```
 
-### `teai orgs` / `teai whoami`
+### `teai orgs` / `teai whoami` / `teai role`
 
 ```sh
 teai orgs                 # 我所屬的組織
-teai whoami               # 目前帳號（讀 tea 組態）
+teai whoami               # 目前帳號
+teai role                 # 目前角色
 ```
 
+角色由所屬組織的團隊決定：
+
+- 在 **Supervisor** 團隊 → `{"role":"supervisor"}`
+- 在 **Agents** 團隊 → `{"role":"worker"}`
+- 同時屬於兩者時以 supervisor 為準
+- 兩者都不屬於 → 輸出 `null`，exit 0
+
 ### `teai xrefs <owner>/<repo> <number>` — 引用解析
 
 解析該 issue／PR 內文與全部留言中的 `#N`、`repo#N`、`owner/repo#N` 引用，輸出解析後的目標清單（去重）：
@@ -201,7 +335,7 @@ teai whoami               # 目前帳號（讀 tea 組態）
 
 | 碼 | 意義 |
 | --- | --- |
-| 0 | 成功（含「沒有工作」→ 輸出 `null`／`[]`） |
+| 0 | 成功（含「沒有結果」→ 清單類命令輸出 `[]`、`next`／`role` 輸出 `null`；#37 判決） |
 | 2 | 用法錯誤（未知命令／參數） |
 | 3 | API 錯誤（連線失敗、401、403、5xx） |
 
@@ -211,11 +345,32 @@ teai whoami               # 目前帳號（讀 tea 組態）
 | --- | --- | --- |
 | `next` | `teai next` | 相同：author-PR → reviewer-PR → issue，最久未更新優先 |
 | `stalled [--hours N]` | `teai stalled [--hours N]` | 相同，含 xref 父子追蹤與冷卻 |
+| `milestones` | `teai milestones` | 相同：跨倉庫 open 里程碑總覽，期限近者在前（#31） |
 | `members [--has-work]` | `teai members [--has-work]` | 相同 |
 | `pulls`／`pulls --mine`／`pulls --reviewer` | `teai pulls [--mine\|--reviewer]` | 相同 |
 | `mine` | `teai mine` | 相同 |
 | （底線函式） | `internal/` 套件 | 不設 CLI 命令；`xrefs` 為其邏輯的公開化 |
 
+已知輸出差異（刻意保留，機器可讀優先）：
+
+- **空清單**：`gitea.py` 的 `_dump` 對空清單**不輸出任何內容**；teai 的清單類命令
+  （`mine`／`pulls`／`stalled`／`milestones` 總覽）空清單一律輸出 `[]`（exit 0）。對 JSON
+  消費者來說 `[]` 比「無輸出」更明確（可區分「沒有結果」與「查詢失敗無輸出」），交叉驗證時
+  以此差異為準。`next` 兩者語義相同：無工作時 teai 輸出 `null`（exit 0）、`gitea.py` 印
+  「沒有未完成的工作」。**判決 #37：維持 teai 現行 JSON 一致性（方向 2）**——消費端
+  （agents 倉庫巡邏提示與觸發腳本）應以「輸出 `[]`／`null` 且 exit 0」為「沒有」判據，
+  不得以「無輸出」判斷；`members [--has-work]` 維持逐行帳號、空時無輸出（兩者一致，不受影響）。
+  `teai role` 不在 Supervisor／Agents 時同樣輸出 `null`（exit 0）。
+- **清單欄位集（`mine`／`pulls`）**：`gitea.py` 直接傾倒完整 Gitea API 物件
+  （`_dump` 的副作用，欄位集隨 Gitea 版本浮動）；teai 輸出策展摘要欄位
+  （`mine`：repo／number／title／url；`pulls`：number／title／state／author／
+  head／base／updated_at…依命令定義）。交叉驗證比對**項目集合**（列出哪些
+  issue／PR）與判定語義，不逐欄位比對；`next`／`stalled`／`milestones` 總覽
+  兩者為策展欄位且鍵集鍵序全等，可逐欄位比對（#31 實測位元組一致）。判定 #26（維持摘要、文件化差異）。
+- **全域選項位置**：teai 的全域選項（`--output` 等）可出現在命令之前或之後，
+  且可與命令旗標交錯（`teai members --has-work --output table`）；
+  gitea.py 的旗標剖析較寬鬆，兩者命令列介面以此行為對齊。
+
 遷移策略：
 
 1. 以 gitea.py 為行為基準：同帳號同時跑兩者，輸出應一致（交叉驗證）。
@@ -225,7 +380,7 @@ teai whoami               # 目前帳號（讀 tea 組態）
 ### 安全設計
 
 - 本期命令全部唯讀；寫入類命令未來加入時須 `--yes` 明確確認。
-- token 不入輸出、不入日誌；建議用 `TEAI_TOKEN` 或 tea 組態，避免出現在命令列。
+- token 不入輸出、不入日誌；建議用 `TEAI_TOKEN` 或 teai 組態，避免出現在命令列。
 - 清單類 API 一律帶 `limit`（Gitea 預設上限 50），避免漏抓。
 - 「有無實際產出」的判斷一律對照遠端實況（API 回傳），不信任回報文字。
 

cmd/xcheck/main.go

@@ -0,0 +1,302 @@
+// cmd/xcheck 是 #7 的交叉驗證工具（不屬於 teai 本體，PR 內附驗證說明）。
+//
+// 以真實 Gitea API 資料源實作 workflow.Source，跑 Go 版 ScanStalled，
+// 再與 gitea.py stalled（行為基準）的 JSON 輸出逐欄位比對。
+// 建立限制：與 teai 本體一致，僅標準庫。
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+	"time"
+
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+// apiSource 以 Gitea API 實作 workflow.Source。
+type apiSource struct {
+	base  string
+	token string
+	hc    *http.Client
+}
+
+func (s *apiSource) get(path string, params map[string]string) ([]byte, int, error) {
+	u := s.base + path
+	if len(params) > 0 {
+		q := url.Values{}
+		for k, v := range params {
+			q.Set(k, v)
+		}
+		u += "?" + q.Encode()
+	}
+	req, err := http.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, 0, err
+	}
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Authorization", "token "+s.token)
+	resp, err := s.hc.Do(req)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+	body, err := io.ReadAll(resp.Body)
+	return body, resp.StatusCode, err
+}
+
+func (s *apiSource) getJSON(path string, params map[string]string, out any) error {
+	body, code, err := s.get(path, params)
+	if err != nil {
+		return err
+	}
+	if code != 200 {
+		return fmt.Errorf("GET %s: HTTP %d", path, code)
+	}
+	return json.Unmarshal(body, out)
+}
+
+// listAll 分頁拉取清單類 API（Gitea 上限 50/頁）。
+func (s *apiSource) listAll(path string, params map[string]string, out any) error {
+	var items []json.RawMessage
+	page := 1
+	for {
+		q := map[string]string{"page": fmt.Sprint(page), "limit": "50"}
+		for k, v := range params {
+			q[k] = v
+		}
+		var chunk json.RawMessage
+		if err := s.getJSON(path, q, &chunk); err != nil {
+			return err
+		}
+		var arr []json.RawMessage
+		if err := json.Unmarshal(chunk, &arr); err != nil {
+			return fmt.Errorf("GET %s: 回傳非陣列", path)
+		}
+		items = append(items, arr...)
+		if len(arr) < 50 {
+			break
+		}
+		page++
+	}
+	var b strings.Builder
+	b.WriteByte('[')
+	for i, item := range items {
+		if i > 0 {
+			b.WriteByte(',')
+		}
+		b.Write(item)
+	}
+	b.WriteByte(']')
+	return json.Unmarshal([]byte(b.String()), out)
+}
+
+// CurrentUser 以 token 呼叫 /user 取實際帳號，與 gitea.py 的
+// get_current_username() 同源（token 決定帳號，不接受環境變數覆寫，
+// 失敗即報錯退出，不靜默退回預設值）。
+func (s *apiSource) CurrentUser() (string, error) {
+	var user struct {
+		Username string `json:"username"`
+		Login    string `json:"login"`
+	}
+	if err := s.getJSON("user", nil, &user); err != nil {
+		return "", err
+	}
+	if user.Username != "" {
+		return user.Username, nil
+	}
+	if user.Login != "" {
+		return user.Login, nil
+	}
+	return "", fmt.Errorf("無法從 Gitea API /user 取得目前帳號")
+}
+
+func (s *apiSource) MyOrganizations() ([]string, error) {
+	var orgs []struct {
+		Username string `json:"username"`
+	}
+	if err := s.listAll("user/orgs", nil, &orgs); err != nil {
+		return nil, err
+	}
+	names := make([]string, 0, len(orgs))
+	for _, o := range orgs {
+		if o.Username != "" {
+			names = append(names, o.Username)
+		}
+	}
+	return names, nil
+}
+
+func (s *apiSource) OrganizationRepositories(org string) ([]workflow.Repo, error) {
+	var repos []workflow.Repo
+	if err := s.listAll("orgs/"+org+"/repos", nil, &repos); err != nil {
+		return nil, err
+	}
+	return repos, nil
+}
+
+func (s *apiSource) OpenIssues(owner, repo string) ([]workflow.Issue, error) {
+	var issues []workflow.Issue
+	// 與 gitea.py 一致：type=issues 排除 PR；state=open。
+	if err := s.listAll(fmt.Sprintf("repos/%s/%s/issues", owner, repo), map[string]string{"type": "issues", "state": "open"}, &issues); err != nil {
+		return nil, err
+	}
+	return issues, nil
+}
+
+func (s *apiSource) OpenPulls(owner, repo string) ([]workflow.PullRequest, error) {
+	var pulls []workflow.PullRequest
+	if err := s.listAll(fmt.Sprintf("repos/%s/%s/pulls", owner, repo), map[string]string{"state": "open"}, &pulls); err != nil {
+		return nil, err
+	}
+	return pulls, nil
+}
+
+func (s *apiSource) IssueComments(owner, repo string, number int64) ([]workflow.Comment, error) {
+	var comments []workflow.Comment
+	if err := s.listAll(fmt.Sprintf("repos/%s/%s/issues/%d/comments", owner, repo, number), nil, &comments); err != nil {
+		return nil, err
+	}
+	return comments, nil
+}
+
+func (s *apiSource) IssueTimeline(owner, repo string, number int64) ([]workflow.TimelineEvent, error) {
+	var events []workflow.TimelineEvent
+	if err := s.listAll(fmt.Sprintf("repos/%s/%s/issues/%d/timeline", owner, repo, number), nil, &events); err != nil {
+		return nil, err
+	}
+	return events, nil
+}
+
+func (s *apiSource) TryGetIssue(owner, repo string, number int64) (workflow.Issue, bool, error) {
+	var issue workflow.Issue
+	body, code, err := s.get(fmt.Sprintf("repos/%s/%s/issues/%d", owner, repo, number), nil)
+	if err != nil {
+		return workflow.Issue{}, false, nil
+	}
+	if code != 200 {
+		return workflow.Issue{}, false, nil
+	}
+	if err := json.Unmarshal(body, &issue); err != nil {
+		return workflow.Issue{}, false, nil
+	}
+	return issue, true, nil
+}
+
+// loadEnv 讀 agents 倉庫的 .env（ACCESS_TOKEN、GITEA_API_DOMAIN）。
+func loadEnv(path string) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return
+	}
+	for _, line := range strings.Split(string(data), "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		k, v, ok := strings.Cut(line, "=")
+		if !ok {
+			continue
+		}
+		k = strings.TrimSpace(k)
+		v = strings.Trim(strings.TrimSpace(v), "'\"")
+		if os.Getenv(k) == "" {
+			os.Setenv(k, v)
+		}
+	}
+}
+
+func main() {
+	// --xrefs 模式：從 stdin 讀文字，輸出解析後的引用目標（與 gitea.py
+	// _resolve_xref_targets 對照用）。組織與倉庫清單來自真實 API。
+	if len(os.Args) > 1 && os.Args[1] == "--xrefs" {
+		xrefsMain()
+		return
+	}
+	loadEnv(os.Getenv("HOME") + "/agents/.env")
+	domain := os.Getenv("GITEA_API_DOMAIN")
+	token := os.Getenv("ACCESS_TOKEN")
+	if domain == "" || token == "" {
+		fmt.Fprintln(os.Stderr, "缺少 GITEA_API_DOMAIN／ACCESS_TOKEN")
+		os.Exit(1)
+	}
+	src := &apiSource{
+		base:  "https://" + domain + "/api/v1/",
+		token: token,
+		hc:    &http.Client{Timeout: 30 * time.Second},
+	}
+	username, err := src.CurrentUser()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "CurrentUser:", err)
+		os.Exit(1)
+	}
+	hours := 4.0
+	items, scanErr := workflow.ScanStalled(src, username, hours, time.Now())
+	if scanErr != nil {
+		fmt.Fprintln(os.Stderr, "ScanStalled:", scanErr)
+		os.Exit(1)
+	}
+	// json.Marshal* 會把 <、>、& 轉義成 \u003c 等（含自訂 MarshalJSON 的輸出），
+	// 與 gitea.py（ensure_ascii=False）位元組不相容；必須停用 HTML 轉義。
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(items); err != nil {
+		fmt.Fprintln(os.Stderr, "Encode:", err)
+		os.Exit(1)
+	}
+	fmt.Print(buf.String())
+}
+
+// xrefsMain 對 stdin 的每行文字解析引用目標並輸出 JSON。
+func xrefsMain() {
+	loadEnv(os.Getenv("HOME") + "/agents/.env")
+	domain := os.Getenv("GITEA_API_DOMAIN")
+	token := os.Getenv("ACCESS_TOKEN")
+	if domain == "" || token == "" {
+		fmt.Fprintln(os.Stderr, "缺少 GITEA_API_DOMAIN／ACCESS_TOKEN")
+		os.Exit(1)
+	}
+	src := &apiSource{
+		base:  "https://" + domain + "/api/v1/",
+		token: token,
+		hc:    &http.Client{Timeout: 30 * time.Second},
+	}
+	orgs, err := src.MyOrganizations()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "MyOrganizations:", err)
+		os.Exit(1)
+	}
+	myOrgs := map[string]bool{}
+	for _, o := range orgs {
+		myOrgs[o] = true
+	}
+	data, _ := io.ReadAll(os.Stdin)
+	repos, _ := src.OrganizationRepositories("alterminal")
+	names := make([]string, 0, len(repos))
+	for _, r := range repos {
+		names = append(names, r.Name)
+	}
+	targets, err := workflow.ResolveXrefTargets("alterminal", "agents", []string{string(data)}, myOrgs, func(string) ([]string, error) {
+		return names, nil
+	})
+	if err != nil {
+		fmt.Fprintln(os.Stderr, "ResolveXrefTargets:", err)
+		os.Exit(1)
+	}
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(targets); err != nil {
+		fmt.Fprintln(os.Stderr, "Encode:", err)
+		os.Exit(1)
+	}
+	fmt.Print(buf.String())
+}

internal/cli/cli.go

@@ -15,6 +15,7 @@ import (
 	"flag"
 	"fmt"
 	"io"
+	"runtime/debug"
 	"sort"
 	"strings"
 	"time"
@@ -23,8 +24,24 @@ import (
 )
 
 // Version 是目前開發中的版本號。採用語意化版本；正式發佈前以 0 開頭。
+// 僅作為 fallback：以 `go install module@version` 或納入其他 module 建置時，
+// buildVersion 會改用 build info 內的 module 版本（見 runVersion）。
 var Version = "0.1.0-dev"
 
+// buildVersion 回傳應顯示的版本字串。go install pkg@tag 建置的二元檔
+// 會在 Main.Version 帶入 tag（如 v0.1.0）；clone 目錄內本機建置則帶
+// pseudo-version（如 v0.1.1-0.<時間戳>-<commit>，工作樹有修改時再附加
+// "+dirty"），同樣直接顯示。Main.Version 為 "(devel)" 或空（go test 環境、
+// 無 VCS 資訊的 tarball 建置）時，才退回開發版本號 Version。
+func buildVersion() string {
+	if info, ok := debug.ReadBuildInfo(); ok {
+		if v := info.Main.Version; v != "" && v != "(devel)" {
+			return v
+		}
+	}
+	return Version
+}
+
 // ExitCode 是 Run 回傳的行程結束碼。
 type ExitCode int
 
@@ -58,9 +75,9 @@ type command struct {
 type Globals struct {
 	// URL 是 Gitea 站點網址。
 	URL string
-	// Token 來自 --token 旗標；空字串表示未提供（依序退回環境變數與 tea 組態）。
+	// Token 來自 --token 旗標；空字串表示未提供（依序退回環境變數與 teai 組態）。
 	Token string
-	// ConfigPath 是 tea 組態路徑（--config，等同 TEA_CONFIG）。
+	// ConfigPath 是 teai 組態路徑（--config，等同 TEAI_CONFIG）。
 	ConfigPath string
 	// Output 是輸出格式。
 	Output gitea.Format
@@ -89,6 +106,11 @@ type Env struct {
 
 // commands 是已註冊的子命令表。新增功能時在這裡註冊即可。
 var commands = map[string]*command{
+	"login": {
+		name:  "login",
+		usage: "管理登入（list/add/default/remove）",
+		run:   runLogin,
+	},
 	"version": {
 		name:  "version",
 		usage: "顯示版本資訊",
@@ -145,10 +167,31 @@ var globalFlags = map[string]bool{
 	"--timeout": true,
 }
 
+// reservedFlags 回傳 dispatch 不得搶走的旗標名稱（含 -- 前綴）：這些
+// 旗標屬於目前命令（或其子命令），即使與全域選項同名也必須原樣留給
+// 命令剖析。目前唯一與全域同名的是 login add 的 --url／--token
+// （README「teai login add --url … --token …」）。其餘命令的旗標
+// （--repo、--has-work、--mine……）本來就不在 globalFlags 內，不受影響。
+func reservedFlags(name string) map[string]bool {
+	reserved := make(map[string]bool)
+	for _, f := range commandReservedFlags[name] {
+		reserved[f] = true
+	}
+	return reserved
+}
+
+// commandReservedFlags 登記每個命令「與全域選項同名」的自有旗標。
+// 命令旗標優先留給命令；新命令有同姓旗標時在這裡登記（#18）。
+var commandReservedFlags = map[string][]string{
+	"login": {"--url", "--token"},
+}
+
 // extractGlobals 從 args 中「抽取」全域選項（可出現在命令之後、與命令
 // 旗標交錯），其餘引數依原順序保留給子命令剖析。未知的選項一律留給
 // 子命令處理（可能是命令旗標，如 --has-work），不在這裡報錯。
-func extractGlobals(g *Globals, args []string) ([]string, error) {
+// reserved 是目前命令保留的旗標名稱（含 -- 前綴，見 reservedFlags）：
+// 列於其中的選項即使與全域同名也原樣留給命令，命令旗標優先（#18）。
+func extractGlobals(g *Globals, args []string, reserved map[string]bool) ([]string, error) {
 	rest := make([]string, 0, len(args))
 	applyGlobal := func(name, value string) error {
 		switch name {
@@ -192,6 +235,17 @@ func extractGlobals(g *Globals, args []string) ([]string, error) {
 			continue
 		}
 		name, inline, hasInline := strings.Cut(arg, "=")
+		if reserved[name] {
+			// 命令保留旗標：即使與全域選項同名也留給命令剖析（#18）。
+			rest = append(rest, arg)
+			if !hasInline && i+1 < len(args) {
+				// 旗標值跟在下一個引數；一併保留，不當成全域值。
+				rest = append(rest, args[i+1])
+				i++
+			}
+			i++
+			continue
+		}
 		_, ok := globalFlags[name]
 		if !ok {
 			// 不是全域選項：留給子命令（可能是 --has-work 這類命令旗標）。
@@ -288,11 +342,12 @@ func parseGlobals(g *Globals, args []string) ([]string, error) {
 // 旗標剖析交由各命令自行處理（不同命令有不同旗標，如 pulls --mine）；
 // 全域選項允許出現在命令之後（README 範例：teai next --output table），
 // dispatch 先從 args 剝離全域選項併入 Globals，其餘（含命令自己的旗標，
-// 如 --has-work）原樣交給命令，不會誤判為未知全域選項。
+// 如 --has-work）原樣交給命令，不會誤判為未知全域選項。與全域選項
+// 同名的命令旗標（登記於 commandReservedFlags）優先留給命令（#18）。
 func dispatch(env *Env, name string, args []string) int {
 	cmd := commands[name]
 	g := env.Globals
-	rest, err := extractGlobals(&g, args)
+	rest, err := extractGlobals(&g, args, reservedFlags(name))
 	if err != nil {
 		fmt.Fprintf(env.Err, "teai: %v\n\n", err)
 		printUsage(env.Err)
@@ -310,24 +365,79 @@ func dispatch(env *Env, name string, args []string) int {
 // 用法，靜默成功結束即可。
 var errHelp = errors.New("help requested")
 
-// parseFlags 剖析命令旗標：-h/--help 回 errHelp（由 exitCodeFor 視為成功），
-// 其他剖析錯誤回 ErrUsage。
+// parseFlags 剖析命令旗標，允許旗標與位置參數交錯（#25）：Go 標準
+// flag 在遇到第一個非旗標參數後即停止剖析，其後的旗標會被當成位置
+// 參數。做法：先掃描 args 把「旗標（含其值）」與「位置參數」分離成
+// 兩串，再以旗標串呼叫 fs.Parse，最後以第二次 Parse 把位置參數設回
+// fs.Args（Parse 遇到 "--" 即停止並收下其餘引數，第一次剖析已設好
+// 的旗標值不受影響）。
+// -h/--help 回 errHelp（由 exitCodeFor 視為成功），其他剖析錯誤回 ErrUsage。
 func parseFlags(fs *flag.FlagSet, args []string) error {
-	if err := fs.Parse(args); err != nil {
+	var flags, positional []string
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		if arg == "--" {
+			// "--" 之後全部是位置參數（不再剖析旗標；同標準 flag）。
+			positional = append(positional, args[i+1:]...)
+			break
+		}
+		if len(arg) < 2 || arg[0] != '-' {
+			positional = append(positional, arg)
+			continue
+		}
+		flags = append(flags, arg)
+		// 判斷旗標是否需要「下一個引數」當值（布林旗標與 inline
+		// 形式 --name=value 不需要）。未知或格式錯誤的旗標不消費
+		// 下一個引數，交給 fs.Parse 產生標準錯誤訊息。
+		numMinuses := 1
+		if arg[1] == '-' {
+			numMinuses = 2
+		}
+		name := arg[numMinuses:]
+		if name == "" || name[0] == '-' || name[0] == '=' {
+			continue // ---x／--=…：bad flag syntax，由 fs.Parse 報錯
+		}
+		flagName, _, hasInline := strings.Cut(name, "=")
+		if !hasInline {
+			if fl := fs.Lookup(flagName); fl != nil && !isBoolFlag(fl) && i+1 < len(args) {
+				i++
+				flags = append(flags, args[i])
+			}
+		}
+	}
+	if err := fs.Parse(flags); err != nil {
 		if errors.Is(err, flag.ErrHelp) {
 			return errHelp
 		}
 		return &ErrUsage{Msg: err.Error()}
 	}
+	if len(positional) > 0 {
+		if err := fs.Parse(append([]string{"--"}, positional...)); err != nil {
+			if errors.Is(err, flag.ErrHelp) {
+				return errHelp
+			}
+			return &ErrUsage{Msg: err.Error()}
+		}
+	}
 	return nil
 }
 
+// isBoolFlag 回傳旗標是否為布林型（不需要值；同 flag 包內部判斷）。
+func isBoolFlag(fl *flag.Flag) bool {
+	bf, ok := fl.Value.(interface{ IsBoolFlag() bool })
+	return ok && bf.IsBoolFlag()
+}
+
 // exitCodeFor 把命令錯誤映射到結束碼：用法錯誤 → 2，API 錯誤 → 3，
-// 其他（內部）→ 1。
+// 其他（內部）→ 1。errHelp（命令的 -h/--help）視為成功（#25：
+// 與 parseFlags 註解宣稱一致，FlagSet 已印出用法說明）。
 func exitCodeFor(err error) ExitCode {
 	if err == nil {
 		return ExitOK
 	}
+	if err == errHelp {
+		return ExitOK
+	}
 	var usage *ErrUsage
 	if errors.As(err, &usage) {
 		return ExitUsage
@@ -339,9 +449,12 @@ func exitCodeFor(err error) ExitCode {
 	return ExitInternal
 }
 
-// runVersion 輸出版本資訊。
+// runVersion 輸出版本資訊；不接受任何參數。
 func runVersion(env *Env, args []string) error {
-	fmt.Fprintf(env.Out, "teai version %s\n", Version)
+	if len(args) > 0 {
+		return &ErrUsage{Msg: "version 不接受參數"}
+	}
+	fmt.Fprintf(env.Out, "teai version %s\n", buildVersion())
 	return nil
 }
 
@@ -351,8 +464,8 @@ func printUsage(w io.Writer) {
 	fmt.Fprintf(w, "用法：\n  teai [全域選項] <命令> [參數]\n\n")
 	fmt.Fprintf(w, "全域選項：\n")
 	fmt.Fprintf(w, "  --url <URL>        Gitea 站點（預設 https://gitea.alterminal.com）\n")
-	fmt.Fprintf(w, "  --token <TOKEN>    API token；未給則依序嘗試 TEAI_TOKEN、tea 登入組態\n")
-	fmt.Fprintf(w, "  --config <path>    tea 組態檔路徑，等同 TEA_CONFIG\n")
+	fmt.Fprintf(w, "  --token <TOKEN>    API token；未給則依序嘗試 TEAI_TOKEN、teai 登入組態\n")
+	fmt.Fprintf(w, "  --config <path>    teai 組態檔路徑，等同 TEAI_CONFIG\n")
 	fmt.Fprintf(w, "  --output <format>  輸出格式 json|table（預設 json）\n")
 	fmt.Fprintf(w, "  --timeout <dur>    HTTP 逾時（預設 30s）\n\n")
 	fmt.Fprintf(w, "命令：\n")

internal/cli/cli_test.go

@@ -51,8 +51,10 @@ func TestRunVersion(t *testing.T) {
 
 func TestRunUnknownCommand(t *testing.T) {
 	_, stderr, code := run("no-such-command")
-	if code != int(ExitUsage) {
-		t.Errorf("未知命令應回 ExitUsage(%d)，得到 %d", int(ExitUsage), code)
+	// 直接對照 README「輸出與結束碼」的數值（用法錯誤＝2），
+	// 不以常數互比，避免常數與規格再次脫鉤（#10）。
+	if code != 2 {
+		t.Errorf("未知命令應回 2（README 用法錯誤），得到 %d", code)
 	}
 	if !strings.Contains(stderr, "unknown command") {
 		t.Errorf("未知命令應在 stderr 說明，得到：%q", stderr)

internal/cli/dailyops_commands.go

@@ -1,5 +1,5 @@
 // dailyops_commands.go — 日常操作命令的 CLI 接線（#8）：issues、pulls、
-// labels、milestones、releases、repos、api（tea 對等指令）。
+// labels、milestones、releases、repos、organizations、api（tea 對等指令）。
 //
 // 規則：
 //   - 寫入類命令（create／close／comment／merge…）一律要求 --yes，
@@ -14,6 +14,9 @@ import (
 	"encoding/json"
 	"flag"
 	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
 	"strconv"
 	"strings"
 
@@ -23,12 +26,14 @@ import (
 
 func init() {
 	register := func(c *command) { commands[c.name] = c }
-	register(&command{name: "issues", usage: "issues 管理（list/view/create/close/comment）", run: runIssues})
-	register(&command{name: "pulls", usage: "PR 管理（list/view/create/merge/comment；無子命令＝工作流清單）", run: runPullsDaily})
+	register(&command{name: "issues", usage: "issues 管理（list/view/create/close/comment；list 支援 --labels 過濾）", run: runIssues})
+	register(&command{name: "pulls", usage: "PR 管理（list/view/create/merge/approve/close/checkout/comment；無子命令＝工作流清單）", run: runPullsDaily})
+	register(&command{name: "comment", usage: "對 issue 或 PR 留言（--repo owner/repo <number> --body …）", run: runCommentDirect})
 	register(&command{name: "labels", usage: "標籤管理（list/create）", run: runLabels})
-	register(&command{name: "milestones", usage: "里程碑管理（list/create）", run: runMilestones})
+	register(&command{name: "milestones", usage: "里程碑（跨倉庫總覽；list/create 管理單倉庫）", run: runMilestones})
 	register(&command{name: "releases", usage: "發佈清單（list）", run: runReleases})
 	register(&command{name: "repos", usage: "倉庫查詢（list）", run: runRepos})
+	register(&command{name: "organizations", usage: "組織管理（list/create/delete；tea organizations 對等）", run: runOrganizations})
 	register(&command{name: "api", usage: "任意 API 呼叫（--method/--data；寫入動詞需 --yes）", run: runAPIDirect})
 }
 
@@ -122,12 +127,13 @@ func runIssues(env *Env, args []string) error {
 	}
 }
 
-// runIssuesList：teai issues list --repo owner/repo [--state open|closed|all]
+// runIssuesList：teai issues list --repo owner/repo [--state open|closed|all] [--labels a,b]
 func runIssuesList(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai issues list", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	repo := fs.String("repo", "", "倉庫（owner/repo，必填）")
 	state := fs.String("state", "open", "狀態：open|closed|all")
+	labels := fs.String("labels", "", "標籤過濾（逗號分隔，可選；多標籤為 AND）")
 	if err := parseFlags(fs, args); err != nil {
 		return err
 	}
@@ -141,11 +147,19 @@ func runIssuesList(env *Env, args []string) error {
 	if owner == "" {
 		return &ErrUsage{Msg: "issues list 需要 --repo owner/repo"}
 	}
+	var labelList []string
+	if strings.TrimSpace(*labels) != "" {
+		for _, l := range strings.Split(*labels, ",") {
+			if l = strings.TrimSpace(l); l != "" {
+				labelList = append(labelList, l)
+			}
+		}
+	}
 	ops, err := newOpsClient(env)
 	if err != nil {
 		return err
 	}
-	issues, err := ops.ListIssues(context.Background(), owner, name, *state)
+	issues, err := ops.ListIssues(context.Background(), owner, name, *state, labelList)
 	if err != nil {
 		return err
 	}
@@ -316,6 +330,8 @@ func runIssuesClose(env *Env, args []string) error {
 }
 
 // runComment：teai issues comment / teai pulls comment 共用。
+// 相容 tea 用法：留言可作為位置參數（tea comment --repo a/b <index> "內容"），
+// 亦可 teai 慣用的 --body；兩者同時給時位置參數優先（與 tea 行為一致）。
 func runComment(env *Env, args []string, isPR bool) error {
 	name := "issues comment"
 	if isPR {
@@ -324,7 +340,7 @@ func runComment(env *Env, args []string, isPR bool) error {
 	fs := flag.NewFlagSet("teai "+name, flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	repo := fs.String("repo", "", "倉庫（owner/repo，必填）")
-	body := fs.String("body", "", "留言內容（必填）")
+	body := fs.String("body", "", "留言內容（可改用位置參數）")
 	yes := fs.Bool("yes", false, "確認寫入")
 	if err := parseFlags(fs, args); err != nil {
 		return err
@@ -336,16 +352,21 @@ func runComment(env *Env, args []string, isPR bool) error {
 	if owner == "" {
 		return &ErrUsage{Msg: name + " 需要 --repo owner/repo"}
 	}
-	if strings.TrimSpace(*body) == "" {
-		return &ErrUsage{Msg: name + " 需要 --body"}
-	}
-	if fs.NArg() != 1 {
-		return &ErrUsage{Msg: name + " 需要恰好一個編號"}
+	// 位置參數：<number> [body…]；尾端多餘引數以空格接成一則留言（tea 相容）。
+	if fs.NArg() < 1 {
+		return &ErrUsage{Msg: name + " 需要恰好一個編號（可選加留言位置參數）"}
 	}
 	num, err := parseNumber(fs.Arg(0))
 	if err != nil {
 		return err
 	}
+	text := strings.TrimSpace(*body)
+	if fs.NArg() > 1 {
+		text = strings.TrimSpace(strings.Join(fs.Args()[1:], " "))
+	}
+	if text == "" {
+		return &ErrUsage{Msg: name + " 需要留言內容（--body 或位置參數）"}
+	}
 	if err := requireYes(*yes, name); err != nil {
 		return err
 	}
@@ -353,7 +374,7 @@ func runComment(env *Env, args []string, isPR bool) error {
 	if err != nil {
 		return err
 	}
-	comment, err := ops.AddComment(context.Background(), owner, rname, num, *body)
+	comment, err := ops.AddComment(context.Background(), owner, rname, num, text)
 	if err != nil {
 		return err
 	}
@@ -381,13 +402,26 @@ func runPullsDaily(env *Env, args []string) error {
 		return runPullsCreate(env, rest)
 	case "merge":
 		return runPullsMerge(env, rest)
+	case "approve":
+		return runPullsApprove(env, rest)
+	case "close":
+		return runPullsClose(env, rest)
+	case "checkout":
+		return runPullsCheckout(env, rest)
 	case "comment":
 		return runComment(env, rest, true)
 	default:
-		return &ErrUsage{Msg: fmt.Sprintf("pulls 未知子命令 %q（可用：list | view | create | merge | comment；或無子命令＝工作流清單）", sub)}
+		return &ErrUsage{Msg: fmt.Sprintf("pulls 未知子命令 %q（可用：list | view | create | merge | approve | close | checkout | comment；或無子命令＝工作流清單）", sub)}
 	}
 }
 
+// runCommentDirect：teai comment --repo owner/repo <number> <body> [--yes]。
+// tea 的通用留言指令：issue 與 PR 共用同一端點（Gitea 以 number 定位，
+// issues/<n>/comments 對兩者皆有效），故不需 --type 旗標。
+func runCommentDirect(env *Env, args []string) error {
+	return runComment(env, args, false)
+}
+
 // runPullsList：teai pulls list --repo owner/repo [--state open|closed|all]
 func runPullsList(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai pulls list", flag.ContinueOnError)
@@ -560,6 +594,179 @@ func runPullsMerge(env *Env, args []string) error {
 	}, gitea.Values{num, "merged"})
 }
 
+// runPullsApprove：teai pulls approve --repo owner/repo [--body …] --yes <number>。
+// tea 相容：意見也可作為位置參數（teai pulls approve --repo a/b <n> "驗證通過。"）。
+func runPullsApprove(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai pulls approve", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	repo := fs.String("repo", "", "倉庫（owner/repo，必填）")
+	body := fs.String("body", "", "審核意見（可改用位置參數）")
+	yes := fs.Bool("yes", false, "確認寫入")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	owner, name, err := splitRepoFlag(*repo)
+	if err != nil {
+		return err
+	}
+	if owner == "" {
+		return &ErrUsage{Msg: "pulls approve 需要 --repo owner/repo"}
+	}
+	if fs.NArg() < 1 {
+		return &ErrUsage{Msg: "pulls approve 需要恰好一個編號（可選加意見位置參數）"}
+	}
+	num, err := parseNumber(fs.Arg(0))
+	if err != nil {
+		return err
+	}
+	text := strings.TrimSpace(*body)
+	if fs.NArg() > 1 {
+		text = strings.TrimSpace(strings.Join(fs.Args()[1:], " "))
+	}
+	if err := requireYes(*yes, "pulls approve"); err != nil {
+		return err
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	review, err := ops.ApprovePull(context.Background(), owner, name, num, text)
+	if err != nil {
+		return err
+	}
+	return printer(env).PrintOne([]gitea.Field{
+		{Name: "number"}, {Name: "state"}, {Name: "author"}, {Name: "body"},
+	}, gitea.Values{review.Number, review.State, review.Author(), review.Body})
+}
+
+// runPullsClose：teai pulls close --repo owner/repo --yes <number>。
+// 關閉不合併；工作流約定 merge 才是正途（AGENTS.md 6.2），本指令提供語義對等。
+func runPullsClose(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai pulls close", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	repo := fs.String("repo", "", "倉庫（owner/repo，必填）")
+	yes := fs.Bool("yes", false, "確認寫入")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	owner, name, err := splitRepoFlag(*repo)
+	if err != nil {
+		return err
+	}
+	if owner == "" {
+		return &ErrUsage{Msg: "pulls close 需要 --repo owner/repo"}
+	}
+	if fs.NArg() != 1 {
+		return &ErrUsage{Msg: "pulls close 需要恰好一個編號"}
+	}
+	num, err := parseNumber(fs.Arg(0))
+	if err != nil {
+		return err
+	}
+	if err := requireYes(*yes, "pulls close"); err != nil {
+		return err
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	pr, err := ops.ClosePull(context.Background(), owner, name, num)
+	if err != nil {
+		return err
+	}
+	return printer(env).PrintOne([]gitea.Field{
+		{Name: "number"}, {Name: "title"}, {Name: "state"}, {Name: "url"},
+	}, gitea.Values{pr.Number, pr.Title, pr.State, pr.HTMLURL})
+}
+
+// runPullsCheckout：teai pulls checkout --repo owner/repo <number> [--dir <path>]。
+// 唯讀輔助指令：取得 PR head 資訊，在本機以 git 取得工作副本——
+// 同倉庫分支 → git fetch --quiet origin <ref> && git checkout -B <ref> FETCH_HEAD
+// （在 --dir 指定的既有 git 工作樹內執行；預設當前目錄）；
+// 跨倉庫 head → git clone --branch <ref> <clone_url> <dir>（--dir 必填，目錄不得已存在）。
+// teai 不碰認證：clone 走 https 公開網址，私有倉庫時請自備 git 認證（credential helper）。
+func runPullsCheckout(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai pulls checkout", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	repo := fs.String("repo", "", "倉庫（owner/repo，必填）")
+	dir := fs.String("dir", "", "工作樹目錄（預設當前目錄；跨倉庫 head 時必填且不得已存在）")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	owner, name, err := splitRepoFlag(*repo)
+	if err != nil {
+		return err
+	}
+	if owner == "" {
+		return &ErrUsage{Msg: "pulls checkout 需要 --repo owner/repo"}
+	}
+	if fs.NArg() != 1 {
+		return &ErrUsage{Msg: "pulls checkout 需要恰好一個編號"}
+	}
+	num, err := parseNumber(fs.Arg(0))
+	if err != nil {
+		return err
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	info, err := ops.PullHeadInfo(context.Background(), owner, name, num)
+	if err != nil {
+		return err
+	}
+	if info.Ref == "" {
+		return fmt.Errorf("PR #%d 缺少 head 分支資訊", num)
+	}
+	workDir := *dir
+	if workDir == "" {
+		workDir = "."
+	}
+	// git 指令一律固定參數（不經 shell、不插入使用者字串），分支名僅作為
+	// git 自身剖析的引數傳入；錯誤訊息往 env.Err，成功輸出到 env.Out。
+	// 注意：git clone 的目標目錄是位置參數，cmd.Dir 不可指向不存在目錄，
+	// 故 clone 一律在當前目錄執行（--dir 以絕對路徑傳入）。
+	runGit := func(dir string, args ...string) error {
+		cmd := exec.Command("git", args...)
+		cmd.Dir = dir
+		cmd.Stdout = env.Out
+		cmd.Stderr = env.Err
+		return cmd.Run()
+	}
+	if info.Repo == "" {
+		// 同倉庫：fetch 指定分支並建立／更新本地分支。
+		if err := runGit(workDir, "fetch", "--quiet", "origin", "--", info.Ref); err != nil {
+			return fmt.Errorf("git fetch origin %s 失敗（在 %s）：%w", info.Ref, workDir, err)
+		}
+		if err := runGit(workDir, "checkout", "-q", "-B", info.Ref, "FETCH_HEAD"); err != nil {
+			return fmt.Errorf("git checkout -B %s 失敗：%w", info.Ref, err)
+		}
+		return printer(env).PrintOne([]gitea.Field{
+			{Name: "number"}, {Name: "branch"}, {Name: "workdir"},
+		}, gitea.Values{num, info.Ref, workDir})
+	}
+	// 跨倉庫 head：clone 到 --dir（不得已存在）。
+	if *dir == "" {
+		return &ErrUsage{Msg: "pulls checkout：跨倉庫 head（" + info.Repo + "）需要 --dir <目錄>"}
+	}
+	if st, err := os.Stat(*dir); err == nil && st.IsDir() {
+		return &ErrUsage{Msg: "pulls checkout：--dir 已存在（跨倉庫 head 需要新目錄）：" + *dir}
+	}
+	if info.CloneURL == "" {
+		return fmt.Errorf("PR #%d 的 head 倉庫 %s 未提供 clone 網址", num, info.Repo)
+	}
+	abs, err := filepath.Abs(*dir)
+	if err != nil {
+		return &ErrUsage{Msg: "pulls checkout：無效的 --dir：" + err.Error()}
+	}
+	if err := runGit(".", "clone", "--quiet", "--branch", info.Ref, "--", info.CloneURL, abs); err != nil {
+		return fmt.Errorf("git clone %s 失敗：%w", info.CloneURL, err)
+	}
+	return printer(env).PrintOne([]gitea.Field{
+		{Name: "number"}, {Name: "branch"}, {Name: "repo"}, {Name: "workdir"},
+	}, gitea.Values{num, info.Ref, info.Repo, *dir})
+}
+
 // ---- labels ----
 
 // runLabels：teai labels list --repo owner/repo｜teai labels create … --yes
@@ -650,10 +857,12 @@ func runLabelsCreate(env *Env, args []string) error {
 
 // ---- milestones ----
 
-// runMilestones：teai milestones list｜create …
+// runMilestones：teai milestones [list|create] …；不帶子命令時輸出
+// 跨倉庫里程碑總覽（#31，對應 gitea.py milestones）。帶 --repo 直接
+// 跟在 milestones 之後時維持現行單倉庫 list 語義。
 func runMilestones(env *Env, args []string) error {
 	if len(args) == 0 {
-		return &ErrUsage{Msg: "milestones 需要子命令：list | create"}
+		return runMilestonesOverview(env)
 	}
 	sub, rest := args[0], args[1:]
 	switch sub {
@@ -662,7 +871,32 @@ func runMilestones(env *Env, args []string) error {
 	case "create":
 		return runMilestonesCreate(env, rest)
 	default:
-		return &ErrUsage{Msg: fmt.Sprintf("milestones 未知子命令 %q（可用：list | create）", sub)}
+		if !strings.HasPrefix(sub, "-") {
+			return &ErrUsage{Msg: fmt.Sprintf("milestones 未知子命令 %q（可用：list | create；或不帶參數輸出跨倉庫總覽）", sub)}
+		}
+		// milestones 之後直接跟旗標（非子命令）：帶 --repo → 整串轉發，
+		// 維持現行單倉庫 list 語義（--state 等旗標一併生效）；否則為
+		// 跨倉庫總覽（總覽不接受任何命令旗標，空 FlagSet 讓未知旗標
+		// 報用法錯誤）。
+		hasRepo := false
+		for _, a := range args {
+			if a == "--repo" || strings.HasPrefix(a, "--repo=") {
+				hasRepo = true
+				break
+			}
+		}
+		if hasRepo {
+			return runMilestonesList(env, args)
+		}
+		fs := flag.NewFlagSet("teai milestones", flag.ContinueOnError)
+		fs.SetOutput(env.Err)
+		if err := parseFlags(fs, args); err != nil {
+			return err
+		}
+		if fs.NArg() != 0 {
+			return &ErrUsage{Msg: "milestones 不接受位置參數（子命令：list | create）"}
+		}
+		return runMilestonesOverview(env)
 	}
 }
 
@@ -864,3 +1098,134 @@ func runAPIDirect(env *Env, args []string) error {
 	}
 	return err
 }
+
+// ---- organizations（#45，tea organizations 對等）----
+
+// orgListFields 是 organizations 清單的欄位定義。
+func orgListFields() []gitea.Field {
+	return []gitea.Field{
+		{Name: "name"}, {Name: "full_name"}, {Name: "website"},
+		{Name: "location"}, {Name: "description"}, {Name: "visibility"},
+	}
+}
+
+// runOrganizations：teai organizations [list|create|delete] …。
+// tea 對等：organizations list 列出自己可存取的組織；create／delete 是
+// 寫入操作，比照慣例要求 --yes。
+func runOrganizations(env *Env, args []string) error {
+	if len(args) == 0 {
+		return &ErrUsage{Msg: "organizations 需要子命令：list | create | delete"}
+	}
+	sub, rest := args[0], args[1:]
+	switch sub {
+	case "list":
+		return runOrganizationsList(env, rest)
+	case "create":
+		return runOrganizationsCreate(env, rest)
+	case "delete":
+		return runOrganizationsDelete(env, rest)
+	default:
+		return &ErrUsage{Msg: fmt.Sprintf("organizations 未知子命令 %q（可用：list | create | delete）", sub)}
+	}
+}
+
+// runOrganizationsList：teai organizations list。
+// GET /user/orgs（與 teai orgs 工作流命令同一端點，但輸出完整欄位）。
+func runOrganizationsList(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai organizations list", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 0 {
+		return &ErrUsage{Msg: "organizations list 不接受位置參數"}
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	orgs, err := ops.ListMyOrganizations(context.Background())
+	if err != nil {
+		return err
+	}
+	p := printer(env)
+	rows := make([]gitea.Values, 0, len(orgs))
+	for i := range orgs {
+		org := &orgs[i]
+		rows = append(rows, gitea.Values{
+			org.Account(), org.FullName, org.Website,
+			org.Location, org.Description, org.Visibility,
+		})
+	}
+	return p.PrintList(orgListFields(), rows)
+}
+
+// runOrganizationsCreate：teai organizations create --name … [--full-name …]
+// [--description …] [--website …] [--location …] [--visibility public|limited|private] --yes。
+// tea 以位置參數給組織名；teai 慣例用 --name（語義等價，命名與其他 create 一致）。
+func runOrganizationsCreate(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai organizations create", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	name := fs.String("name", "", "組織帳號名（必填，同 tea 的位置參數）")
+	fullName := fs.String("full-name", "", "顯示名稱")
+	desc := fs.String("description", "", "說明")
+	website := fs.String("website", "", "網站")
+	location := fs.String("location", "", "所在地")
+	visibility := fs.String("visibility", "", "可見度：public|limited|private（預設服務端決定）")
+	yes := fs.Bool("yes", false, "確認寫入")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if strings.TrimSpace(*name) == "" {
+		return &ErrUsage{Msg: "organizations create 需要 --name"}
+	}
+	switch *visibility {
+	case "", "public", "limited", "private":
+	default:
+		return &ErrUsage{Msg: "organizations create 的 --visibility 需為 public|limited|private"}
+	}
+	if err := requireYes(*yes, "organizations create"); err != nil {
+		return err
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	org, err := ops.CreateOrganization(context.Background(), *name, *fullName, *desc, *website, *location, *visibility)
+	if err != nil {
+		return err
+	}
+	return printer(env).PrintOne(orgListFields(), gitea.Values{
+		org.Account(), org.FullName, org.Website,
+		org.Location, org.Description, org.Visibility,
+	})
+}
+
+// runOrganizationsDelete：teai organizations delete <name> --yes。
+// tea 相容：組織名作為位置參數。
+func runOrganizationsDelete(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai organizations delete", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	yes := fs.Bool("yes", false, "確認寫入")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 1 {
+		return &ErrUsage{Msg: "organizations delete 需要恰好一個組織名"}
+	}
+	orgName := strings.TrimSpace(fs.Arg(0))
+	if orgName == "" {
+		return &ErrUsage{Msg: "organizations delete 需要組織名"}
+	}
+	if err := requireYes(*yes, "organizations delete"); err != nil {
+		return err
+	}
+	ops, err := newOpsClient(env)
+	if err != nil {
+		return err
+	}
+	if err := ops.DeleteOrganization(context.Background(), orgName); err != nil {
+		return err
+	}
+	return printer(env).PrintOne([]gitea.Field{{Name: "name"}, {Name: "state"}}, gitea.Values{orgName, "deleted"})
+}

internal/cli/dailyops_commands_test.go

@@ -53,8 +53,9 @@ func TestIssuesListRequiresRepo(t *testing.T) {
 		t.Errorf("不應發出任何請求")
 	})
 	_, stderr, code := run("issues", "list")
-	if code != int(ExitUsage) {
-		t.Errorf("缺 --repo 應回 ExitUsage，得到 %d", code)
+	// 對照 README「輸出與結束碼」：用法錯誤＝2（#10）。
+	if code != 2 {
+		t.Errorf("缺 --repo 應回 2（README 用法錯誤），得到 %d", code)
 	}
 	if !strings.Contains(stderr, "--repo") {
 		t.Errorf("錯誤訊息應提及 --repo，得到：%s", stderr)
@@ -110,8 +111,9 @@ func TestWriteCommandsRequireYes(t *testing.T) {
 				t.Errorf("%s：未帶 --yes 不得發出請求（%s %s）", tc.name, r.Method, r.URL.Path)
 			})
 			_, stderr, code := run(tc.args...)
-			if code != int(ExitUsage) {
-				t.Errorf("%s 未帶 --yes 應回 ExitUsage(2)，得到 %d", tc.name, code)
+			// 對照 README「輸出與結束碼」：用法錯誤＝2（#10）。
+			if code != 2 {
+				t.Errorf("%s 未帶 --yes 應回 2（README 用法錯誤），得到 %d", tc.name, code)
 			}
 			if !strings.Contains(stderr, "--yes") {
 				t.Errorf("%s 錯誤訊息應提及 --yes，得到：%s", tc.name, stderr)
@@ -218,6 +220,52 @@ func TestLabelsMilestonesReleasesList(t *testing.T) {
 	}
 }
 
+// TestStateAllSendsExplicitParam 是 #33 的回歸測試：issues／milestones
+// 端點省略 state 時 API 預設 open，closed 項目會漏列，因此 --state all
+// 必須明確帶 state=all；pulls 端點雖省略時也回全部，同樣明確帶上。
+func TestStateAllSendsExplicitParam(t *testing.T) {
+	cases := []struct {
+		args    []string
+		resp    string
+		wantOut string
+	}{
+		{
+			args:    []string{"issues", "list", "--repo", "a/b", "--state", "all"},
+			resp:    `[{"number":30,"title":"open","state":"open","user":{"login":"ceo"},"updated_at":"t"},{"number":12,"title":"closed","state":"closed","user":{"login":"ceo"},"updated_at":"t"}]`,
+			wantOut: `"title":"closed"`,
+		},
+		{
+			args:    []string{"pulls", "list", "--repo", "a/b", "--state", "all"},
+			resp:    `[{"number":5,"title":"open PR","state":"open","user":{"login":"ceo"},"head":{"ref":"f"},"base":{"ref":"main"},"updated_at":"t"},{"number":2,"title":"closed PR","state":"closed","user":{"login":"ceo"},"head":{"ref":"f2"},"base":{"ref":"main"},"updated_at":"t"}]`,
+			wantOut: `"title":"closed PR"`,
+		},
+		{
+			args:    []string{"milestones", "list", "--repo", "a/b", "--state", "all"},
+			resp:    `[{"title":"v2","state":"open","description":"","due_on":""},{"title":"v1","state":"closed","description":"","due_on":""}]`,
+			wantOut: `"title":"v1"`,
+		},
+	}
+	for _, tc := range cases {
+		t.Run(strings.Join(tc.args, " "), func(t *testing.T) {
+			var gotQuery string
+			run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+				gotQuery = r.URL.RawQuery
+				fmt.Fprint(w, tc.resp)
+			})
+			stdout, _, code := run(tc.args...)
+			if code != 0 {
+				t.Fatalf("%v 應回 0，得到 %d", tc.args, code)
+			}
+			if !strings.Contains(gotQuery, "state=all") {
+				t.Errorf("%v 應明確帶 state=all（省略時 issues／milestones 端點預設 open），得到查詢 %q", tc.args, gotQuery)
+			}
+			if !strings.Contains(stdout, tc.wantOut) {
+				t.Errorf("%v 輸出應含 closed 項目 %s，得到：%s", tc.args, tc.wantOut, stdout)
+			}
+		})
+	}
+}
+
 // TestAPIDirectPassthrough 驗證 teai api 原樣輸出、GET 免 --yes、
 // POST 未帶 --yes 被擋。
 func TestAPIDirectPassthrough(t *testing.T) {
@@ -235,7 +283,8 @@ func TestAPIDirectPassthrough(t *testing.T) {
 	}
 
 	_, stderr, code := run("api", "--method", "POST", "/version")
-	if code != int(ExitUsage) || !strings.Contains(stderr, "--yes") {
+	// 對照 README「輸出與結束碼」：用法錯誤＝2（#10）。
+	if code != 2 || !strings.Contains(stderr, "--yes") {
 		t.Errorf("POST 未帶 --yes 應回 2 並提及 --yes，得到 %d：%s", code, stderr)
 	}
 }

internal/cli/dailyops_parity_commands_test.go

@@ -0,0 +1,289 @@
+// dailyops_parity_commands_test.go — #40 的驗收測試：補齊 tea 對等指令
+// pulls approve／close／checkout、通用 comment、issues list --labels 過濾。
+// 寫入命令未帶 --yes 不得發出任何請求；帶 --yes 時打對端點與 payload。
+package cli
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestParityWriteCommandsRequireYes 驗證新增寫入命令未帶 --yes：
+// 回 2 且不發請求（#40 驗收：寫入閘門慣例）。
+func TestParityWriteCommandsRequireYes(t *testing.T) {
+	cases := []struct {
+		name string
+		args []string
+	}{
+		{"pulls approve", []string{"pulls", "approve", "--repo", "a/b", "1"}},
+		{"pulls close", []string{"pulls", "close", "--repo", "a/b", "1"}},
+		{"comment direct", []string{"comment", "--repo", "a/b", "1", "內容"}},
+		{"comment direct body flag", []string{"comment", "--repo", "a/b", "--body", "內容", "1"}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+				t.Errorf("%s：未帶 --yes 不得發出請求（%s %s）", tc.name, r.Method, r.URL.Path)
+			})
+			_, stderr, code := run(tc.args...)
+			if code != 2 {
+				t.Errorf("%s 未帶 --yes 應回 2，得到 %d", tc.name, code)
+			}
+			if !strings.Contains(stderr, "--yes") {
+				t.Errorf("%s 錯誤訊息應提及 --yes，得到：%s", tc.name, stderr)
+			}
+		})
+	}
+}
+
+// TestPullsApprovePostsReview 驗證 pulls approve --yes：
+// POST /repos/{owner}/{repo}/pulls/{n}/reviews，payload 帶 event=APPROVED 與意見；
+// 意見可用位置參數（tea 相容：teai pulls approve --repo a/b <n> "驗證通過。"）。
+func TestPullsApprovePostsReview(t *testing.T) {
+	var gotMethod, gotPath, gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		buf := make([]byte, 512)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"ID":42,"number":13,"state":"APPROVED","body":"驗證通過。","submitted_at":"t","user":{"login":"max"}}`)
+	})
+	stdout, _, code := run("pulls", "approve", "--repo", "alterminal/teai", "--yes", "13", "驗證通過。")
+	if code != 0 {
+		t.Fatalf("approve --yes 應回 0，得到 %d", code)
+	}
+	if gotMethod != "POST" || !strings.HasSuffix(gotPath, "/repos/alterminal/teai/pulls/13/reviews") {
+		t.Errorf("應 POST /repos/alterminal/teai/pulls/13/reviews，得到 %s %s", gotMethod, gotPath)
+	}
+	if !strings.Contains(gotBody, `"event":"APPROVED"`) || !strings.Contains(gotBody, "驗證通過。") {
+		t.Errorf("body 應含 event=APPROVED 與意見，得到：%s", gotBody)
+	}
+	if !strings.Contains(stdout, `"state":"APPROVED"`) {
+		t.Errorf("輸出應含 APPROVED，得到：%s", stdout)
+	}
+}
+
+// TestPullsClosePatchesState 驗證 pulls close --yes：
+// PATCH /repos/{owner}/{repo}/pulls/{n}，payload 帶 state=closed。
+func TestPullsClosePatchesState(t *testing.T) {
+	var gotMethod, gotPath, gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		buf := make([]byte, 512)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"number":13,"title":"PR","state":"closed","html_url":"https://x/13"}`)
+	})
+	_, _, code := run("pulls", "close", "--repo", "alterminal/teai", "--yes", "13")
+	if code != 0 {
+		t.Fatalf("close --yes 應回 0，得到 %d", code)
+	}
+	if gotMethod != "PATCH" || !strings.HasSuffix(gotPath, "/repos/alterminal/teai/pulls/13") {
+		t.Errorf("應 PATCH /repos/alterminal/teai/pulls/13，得到 %s %s", gotMethod, gotPath)
+	}
+	if !strings.Contains(gotBody, `"state":"closed"`) {
+		t.Errorf("body 應含 state=closed，得到：%s", gotBody)
+	}
+}
+
+// TestCommentDirectPostsComment 驗證通用 comment（tea 相容形式）：
+// --repo a/b <number> <body> --yes → POST issues/<n>/comments，
+// issue 與 PR 共用（不需要 type 旗標）。
+func TestCommentDirectPostsComment(t *testing.T) {
+	var gotMethod, gotPath, gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		buf := make([]byte, 512)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"body":"已依評論更新：commit abc1234。","created_at":"t","user":{"login":"max"}}`)
+	})
+	stdout, _, code := run("comment", "--repo", "alterminal/teai", "--yes", "13", "已依評論更新：commit abc1234。")
+	if code != 0 {
+		t.Fatalf("comment --yes 應回 0，得到 %d", code)
+	}
+	if gotMethod != "POST" || !strings.HasSuffix(gotPath, "/repos/alterminal/teai/issues/13/comments") {
+		t.Errorf("應 POST /repos/alterminal/teai/issues/13/comments，得到 %s %s", gotMethod, gotPath)
+	}
+	if !strings.Contains(gotBody, "已依評論更新：commit abc1234。") {
+		t.Errorf("body 應含留言內容，得到：%s", gotBody)
+	}
+	if !strings.Contains(stdout, "已依評論更新") {
+		t.Errorf("輽出應含留言，得到：%s", stdout)
+	}
+}
+
+// TestCommentDirectBodyFlag 驗證 comment 也接受 --body（teai 慣用），
+// 且位置參數與 --body 同時存在時位置參數優先。
+func TestCommentDirectBodyFlag(t *testing.T) {
+	var gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 512)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"body":"x","created_at":"t","user":{"login":"max"}}`)
+	})
+	if _, _, code := run("comment", "--repo", "a/b", "--body", "旗標版", "--yes", "5"); code != 0 {
+		t.Fatalf("--body 版應回 0，得到 %d", code)
+	}
+	if !strings.Contains(gotBody, "旗標版") {
+		t.Errorf("body 應為 --body 值，得到：%s", gotBody)
+	}
+	if _, _, code := run("comment", "--repo", "a/b", "--body", "旗標版", "--yes", "5", "位置版"); code != 0 {
+		t.Fatalf("位置參數版應回 0，得到 %d", code)
+	}
+	if !strings.Contains(gotBody, "位置版") || strings.Contains(gotBody, "旗標版") {
+		t.Errorf("位置參數應優先於 --body，得到：%s", gotBody)
+	}
+}
+
+// TestIssuesListLabelsFilter 驗證 issues list --labels：
+// 查詢參數帶 labels=a,b（多標籤 AND 語義），輸出仍為 JSON 陣列。
+func TestIssuesListLabelsFilter(t *testing.T) {
+	var gotQuery string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotQuery = r.URL.RawQuery
+		fmt.Fprint(w, `[{"number":9,"title":"标签過濾","state":"open","user":{"login":"ceo"},"updated_at":"t"}]`)
+	})
+	stdout, _, code := run("issues", "list", "--repo", "alterminal/teai", "--labels", "bug, help wanted")
+	if code != 0 {
+		t.Fatalf("--labels 應回 0，得到 %d", code)
+	}
+	if !strings.Contains(gotQuery, "labels=bug%2Chelp+wanted") && !strings.Contains(gotQuery, "labels=bug%2C+help+wanted") {
+		t.Errorf("查詢應帶 labels=bug,help+wanted（URL 編碼後），得到 %q", gotQuery)
+	}
+	if !strings.Contains(stdout, `"number":9`) {
+		t.Errorf("輽出應含過濾後的 issue，得到：%s", stdout)
+	}
+}
+
+// TestPullsCheckoutSameRepo 驗證 checkout 同倉庫分支：
+// 在 --dir 的 git 工作樹 fetch origin <ref> 並 checkout -B <ref>。
+func TestPullsCheckoutSameRepo(t *testing.T) {
+	// 建立裸「origin」倉庫與分支 feat/x。
+	origin := t.TempDir()
+	gitRun := func(args ...string) {
+		t.Helper()
+		cmd := exec.Command("git", args...)
+		cmd.Dir = origin
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v 失敗：%v\n%s", args, err, out)
+		}
+	}
+	gitRun("init", "-q", "-b", "main", ".")
+	gitRun("config", "user.email", "t@t")
+	gitRun("config", "user.name", "t")
+	gitRun("commit", "--allow-empty", "-m", "init")
+	gitRun("checkout", "-q", "-b", "feat/x")
+	gitRun("commit", "--allow-empty", "-m", "x1")
+	gitRun("checkout", "-q", "main")
+	// 工作樹 clone 自 origin（file:// 協定讓 fetch 生效）。
+	work := t.TempDir()
+	if out, err := exec.Command("git", "clone", "-q", "file://"+origin, work).CombinedOutput(); err != nil {
+		t.Fatalf("clone 失敗：%v\n%s", err, out)
+	}
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"number":7,"title":"PR","state":"open","head":{"ref":"feat/x","repo":{"full_name":"alterminal/teai","clone_url":"https://gitea.alterminal.com/alterminal/teai.git"}},"base":{"ref":"main"}}`)
+	})
+	stdout, _, code := run("pulls", "checkout", "--repo", "alterminal/teai", "--dir", work, "7")
+	if code != 0 {
+		t.Fatalf("checkout 應回 0，得到 %d", code)
+	}
+	brOut, err := exec.Command("git", "-C", work, "branch", "--show-current").Output()
+	if err != nil || strings.TrimSpace(string(brOut)) != "feat/x" {
+		t.Errorf("工作樹應在 feat/x，得到 %q（err=%v）", string(brOut), err)
+	}
+	if !strings.Contains(stdout, `"branch":"feat/x"`) {
+		t.Errorf("輽出應含 branch 欄位，得到：%s", stdout)
+	}
+}
+
+// TestPullsCheckoutCrossRepo 驗證 checkout 跨倉庫 head：
+// 需 --dir（新目錄），git clone --branch <ref> <clone_url> <dir>。
+func TestPullsCheckoutCrossRepo(t *testing.T) {
+	// 假伺服器同時當 git remote：把 PR head 指向本地裸倉庫。
+	origin := t.TempDir()
+	gitRun := func(args ...string) {
+		t.Helper()
+		cmd := exec.Command("git", args...)
+		cmd.Dir = origin
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("git %v 失敗：%v\n%s", args, err, out)
+		}
+	}
+	gitRun("init", "-q", "-b", "main", "--bare", ".")
+	seed := t.TempDir()
+	cmd := exec.Command("git", "clone", "-q", "file://"+origin, seed)
+	if out, err := cmd.CombinedOutput(); err != nil {
+		t.Fatalf("clone seed 失敗：%v\n%s", err, out)
+	}
+	for _, args := range [][]string{
+		{"config", "user.email", "t@t"},
+		{"config", "user.name", "t"},
+		{"commit", "--allow-empty", "-m", "init"},
+		{"checkout", "-q", "-b", "feat/y"},
+		{"commit", "--allow-empty", "-m", "y1"},
+		{"push", "-q", "origin", "feat/y"},
+	} {
+		c := exec.Command("git", args...)
+		c.Dir = seed
+		if out, err := c.CombinedOutput(); err != nil {
+			t.Fatalf("git %v 失敗：%v\n%s", args, err, out)
+		}
+	}
+	target := filepath.Join(t.TempDir(), "wk")
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, `{"number":8,"title":"PR","state":"open","head":{"ref":"feat/y","repo":{"full_name":"other/fork","clone_url":"file://%s"}},"base":{"ref":"main"}}`, origin)
+	})
+	stdout, _, code := run("pulls", "checkout", "--repo", "alterminal/teai", "--dir", target, "8")
+	if code != 0 {
+		t.Fatalf("checkout 跨倉庫應回 0，得到 %d", code)
+	}
+	brOut, err := exec.Command("git", "-C", target, "branch", "--show-current").Output()
+	if err != nil || strings.TrimSpace(string(brOut)) != "feat/y" {
+		t.Errorf("工作樹應在 feat/y，得到 %q（err=%v）", string(brOut), err)
+	}
+	if !strings.Contains(stdout, `"repo":"other/fork"`) {
+		t.Errorf("輽出應含 head 倉庫，得到：%s", stdout)
+	}
+}
+
+// TestPullsCheckoutCrossRepoRequiresDir 驗證跨倉庫 head 未帶 --dir：
+// 用法錯誤（exit 2）。
+func TestPullsCheckoutCrossRepoRequiresDir(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `{"number":8,"title":"PR","state":"open","head":{"ref":"feat/y","repo":{"full_name":"other/fork","clone_url":"https://x/y.git"}},"base":{"ref":"main"}}`)
+	})
+	_, stderr, code := run("pulls", "checkout", "--repo", "alterminal/teai", "8")
+	if code != 2 {
+		t.Errorf("跨倉庫 head 未帶 --dir 應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "--dir") {
+		t.Errorf("錯誤訊息應提及 --dir，得到：%s", stderr)
+	}
+}
+
+// TestIssuesCommentPositionalBody 驗證 issues comment 也吃位置參數留言
+// （tea comment 相容语法在子命令下的行為）。
+func TestIssuesCommentPositionalBody(t *testing.T) {
+	var gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		buf := make([]byte, 512)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"body":"x","created_at":"t","user":{"login":"max"}}`)
+	})
+	if _, _, code := run("issues", "comment", "--repo", "a/b", "--yes", "3", "多餘", "引數", "串留言"); code != 0 {
+		t.Fatalf("issues comment 位置參數應回 0，得到 %d", code)
+	}
+	if !strings.Contains(gotBody, "多餘 引數 串留言") {
+		t.Errorf("尾端引數應串成留言，得到：%s", gotBody)
+	}
+}
+
+var _ = os.Getenv // 保持 import 一致（checkout 測試用 exec，此檔亦引用 os 於需要時）

internal/cli/exitcode_test.go

@@ -10,20 +10,22 @@ import (
 )
 
 func TestExitCodeMapping(t *testing.T) {
+	// want 直接寫 README「輸出與結束碼」的數值（0／2／3；內部錯誤 1），
+	// 不以常數互比，避免常數與規格再次脫鉤（#10）。
 	cases := []struct {
 		name string
 		err  error
-		want ExitCode
+		want int
 	}{
-		{"usage error", &ErrUsage{Msg: "bad flag"}, ExitUsage},
-		{"api error 401", &gitea.ErrAPI{StatusCode: 401, Op: "GET /api/v1/user"}, ExitAPI},
-		{"api error transport", &gitea.ErrAPI{Op: "GET /api/v1/user", Err: errString("dial tcp")}, ExitAPI},
-		{"wrapped api error", wrapped(&gitea.ErrAPI{StatusCode: 500}), ExitAPI},
-		{"other error", errString("boom"), ExitInternal},
-		{"nil maps to OK", nil, ExitOK},
+		{"usage error", &ErrUsage{Msg: "bad flag"}, 2},
+		{"api error 401", &gitea.ErrAPI{StatusCode: 401, Op: "GET /api/v1/user"}, 3},
+		{"api error transport", &gitea.ErrAPI{Op: "GET /api/v1/user", Err: errString("dial tcp")}, 3},
+		{"wrapped api error", wrapped(&gitea.ErrAPI{StatusCode: 500}), 3},
+		{"other error", errString("boom"), 1},
+		{"nil maps to OK", nil, 0},
 	}
 	for _, tc := range cases {
-		if got := exitCodeFor(tc.err); got != tc.want {
+		if got := int(exitCodeFor(tc.err)); got != tc.want {
 			t.Errorf("%s: exitCodeFor = %d, want %d", tc.name, got, tc.want)
 		}
 	}
@@ -68,16 +70,16 @@ func TestRunExitCodes(t *testing.T) {
 	})
 }
 
-func TestParseGlobals(t *testing.T) {
+func TestExtractGlobals(t *testing.T) {
 	g := defaultGlobals()
-	rest, err := parseGlobals(&g, []string{
+	rest, err := extractGlobals(&g, []string{
 		"--url", "https://example.com",
 		"--token=tok",
 		"--config", "/tmp/c.yml",
 		"--output", "table",
 		"--timeout", "45s",
 		"next",
-	})
+	}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -95,16 +97,115 @@ func TestParseGlobals(t *testing.T) {
 	}
 }
 
-func TestParseGlobalsStopsAtCommand(t *testing.T) {
+func TestExtractGlobalsAfterCommand(t *testing.T) {
+	// 全域選項出現在命令之後也應抽出（README：teai next --output table）。
 	g := defaultGlobals()
-	rest, err := parseGlobals(&g, []string{"version", "--output", "table"})
+	rest, err := extractGlobals(&g, []string{"version", "--output", "table"}, nil)
 	if err != nil {
 		t.Fatal(err)
 	}
-	// 命令之後的選項屬於命令，不屬於全域。
-	if len(rest) != 3 || rest[0] != "version" {
+	if len(rest) != 1 || rest[0] != "version" {
+		t.Fatalf("rest = %v, want [version]", rest)
+	}
+	if g.Output != gitea.FormatTable {
+		t.Fatalf("output = %v, want table", g.Output)
+	}
+}
+
+func TestExtractGlobalsKeepsCommandFlags(t *testing.T) {
+	// 非全域選項屬於子命令：原樣依序交回，不能攔成 ErrUsage。
+	cases := [][]string{
+		{"members", "--has-work"},
+		{"pulls", "--mine"},
+		{"pulls", "--reviewer"},
+		{"pulls", "--repo", "alterminal/teai"},
+		{"members", "--has-work", "--output", "table"},
+		{"pulls", "--mine", "--repo", "alterminal/teai", "--output", "table"},
+	}
+	for _, args := range cases {
+		g := defaultGlobals()
+		rest, err := extractGlobals(&g, args, nil)
+		if err != nil {
+			t.Fatalf("extractGlobals(%v) 不應報錯：%v", args, err)
+		}
+		want := args
+		if strings.HasSuffix(strings.Join(args, " "), "--output table") {
+			want = args[:len(args)-2]
+		}
+		if len(rest) != len(want) {
+			t.Fatalf("extractGlobals(%v) rest = %v, want %v", args, rest, want)
+		}
+		for i := range want {
+			if rest[i] != want[i] {
+				t.Fatalf("extractGlobals(%v) rest = %v, want %v", args, rest, want)
+			}
+		}
+	}
+}
+
+func TestExtractGlobalsDoubleDashStops(t *testing.T) {
+	g := defaultGlobals()
+	rest, err := extractGlobals(&g, []string{"--output", "table", "--", "--url", "x"}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// -- 之後全部交回，--url 不再視為全域選項。
+	if len(rest) != 2 || rest[0] != "--url" || rest[1] != "x" {
 		t.Fatalf("rest = %v", rest)
 	}
+	if g.Output != gitea.FormatTable {
+		t.Fatalf("output = %v, want table", g.Output)
+	}
+}
+
+// TestExtractGlobalsReservedFlags 驗證 #18：與全域同名的命令旗標
+// （登記於 commandReservedFlags）必須留給命令，其餘全域選項照常抽取。
+func TestExtractGlobalsReservedFlags(t *testing.T) {
+	g := defaultGlobals()
+	rest, err := extractGlobals(&g, []string{
+		"add",
+		"--url", "https://srv.example.com", // login add 自有旗標：保留
+		"--token=tok", // 同上（inline 形式）：保留
+		"--name", "test-site",
+		"--output", "table", // 非保留：仍是全域
+	}, reservedFlags("login"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	want := []string{"add", "--url", "https://srv.example.com", "--token=tok", "--name", "test-site"}
+	if len(rest) != len(want) {
+		t.Fatalf("rest = %v, want %v", rest, want)
+	}
+	for i := range want {
+		if rest[i] != want[i] {
+			t.Fatalf("rest = %v, want %v", rest, want)
+		}
+	}
+	if g.Output != gitea.FormatTable {
+		t.Fatalf("output = %v, want table", g.Output)
+	}
+	if g.URL != defaultGlobals().URL || g.Token != "" {
+		t.Fatalf("reserved flags must not leak into globals: %+v", g)
+	}
+}
+
+// TestExtractGlobalsNonReservedCommand 驗證 #13 行為不回歸：未登記保留
+// 旗標的命令（如 next/members/pulls），命令後的全域選項照常抽取、
+// 命令自己的旗標（--has-work 等）原樣保留。
+func TestExtractGlobalsNonReservedCommand(t *testing.T) {
+	g := defaultGlobals()
+	rest, err := extractGlobals(&g, []string{
+		"members", "--has-work", "--output", "table",
+	}, reservedFlags("members"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rest) != 2 || rest[0] != "members" || rest[1] != "--has-work" {
+		t.Fatalf("rest = %v, want [members --has-work]", rest)
+	}
+	if g.Output != gitea.FormatTable {
+		t.Fatalf("output = %v, want table", g.Output)
+	}
 }
 
 // errString 把字串轉成 error（測試輔助）。

internal/cli/interleaved_flags_test.go

@@ -0,0 +1,160 @@
+// interleaved_flags_test.go — #25 的回歸測試：命令旗標放在位置參數
+// （path／編號／名稱）之後也必須被剖析，不得被當成位置參數。
+// 涵蓋 parseFlags 走的命令（issues/pulls view、api、stalled）與
+// 原本直接 fs.Parse 的命令（login default/remove、members）。
+package cli
+
+import (
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"testing"
+)
+
+// TestAPIFlagsAfterPath 驗證 #25 重現步驟一：teai api <path> --method POST
+// --data '{}' --yes 的旗標在 path 之後仍被剖析（POST 送達伺服器而非 exit 2）。
+func TestAPIFlagsAfterPath(t *testing.T) {
+	var gotMethod string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod = r.Method
+		fmt.Fprint(w, `{}`)
+	})
+	_, _, code := run("api", "/version", "--method", "POST", "--data", `{}`, "--yes")
+	if code != 0 {
+		t.Fatalf("api 旗標在 path 之後應回 0（#25），得到 %d", code)
+	}
+	if gotMethod != "POST" {
+		t.Fatalf("應送出 POST，得到 %s", gotMethod)
+	}
+}
+
+// TestIssuesViewCommentsFlagAfterNumber 驗證 #25 重現步驟二：
+// teai issues view --repo owner/repo <編號> --comments 的 --comments
+// 在編號之後仍生效（有打 /comments 端點）。
+func TestIssuesViewCommentsFlagAfterNumber(t *testing.T) {
+	var commentsHit bool
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/comments"):
+			commentsHit = true
+			fmt.Fprint(w, `[]`)
+		case strings.HasSuffix(r.URL.Path, "/issues/8"):
+			fmt.Fprint(w, `{"number":8,"title":"t","state":"open","user":{"login":"ceo"},"body":"","html_url":"u","labels":[],"updated_at":"t"}`)
+		default:
+			fmt.Fprint(w, `[]`)
+		}
+	})
+	stdout, _, code := run("issues", "view", "--repo", "alterminal/teai", "8", "--comments")
+	if code != 0 {
+		t.Fatalf("issues view 編號在前旗標在後應回 0（#25），得到 %d", code)
+	}
+	if !commentsHit {
+		t.Fatalf("--comments 在編號之後應觸發 /comments 請求；輸出：%s", stdout)
+	}
+}
+
+// TestPullsViewCommentsFlagAfterNumber 同上，驗證 pulls view。
+func TestPullsViewCommentsFlagAfterNumber(t *testing.T) {
+	var commentsHit bool
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case strings.HasSuffix(r.URL.Path, "/comments"):
+			commentsHit = true
+			fmt.Fprint(w, `[]`)
+		case strings.HasSuffix(r.URL.Path, "/pulls/13"):
+			fmt.Fprint(w, `{"number":13,"title":"t","state":"open","user":{"login":"ceo"},"body":"","html_url":"u","labels":[],"updated_at":"t"}`)
+		default:
+			fmt.Fprint(w, `[]`)
+		}
+	})
+	_, _, code := run("pulls", "view", "--repo", "alterminal/teai", "13", "--comments")
+	if code != 0 {
+		t.Fatalf("pulls view 編號在前旗標在後應回 0（#25），得到 %d", code)
+	}
+	if !commentsHit {
+		t.Fatal("--comments 在編號之後應觸發 /comments 請求")
+	}
+}
+
+// TestStalledHoursFlagAfterPositional 驗證 stalled 即使混入位置參數
+// 也不誤剖析：--hours 在位置參數後仍被剖析，而 stalled 本身不接受
+// 位置參數 → 應回 2（用法錯誤）而非誤把 --hours 當位置參數。
+func TestStalledHoursFlagAfterPositional(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprint(w, `[]`)
+	})
+	_, stderr, code := run("stalled", "9", "--hours", "3")
+	if code != 2 {
+		t.Fatalf("stalled 帶位置參數應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "位置參數") {
+		t.Fatalf("錯誤訊息應提及位置參數，得到：%s", stderr)
+	}
+	// 對照組：--hours 值非法（剖析層錯誤）應回 2，而非把旗標當位置參數。
+	_, stderr, code = run("stalled", "--hours", "abc")
+	if code != 2 || !strings.Contains(stderr, "invalid value") {
+		t.Fatalf("stalled --hours abc 應回 2 且提及 invalid value，得到 %d：%s", code, stderr)
+	}
+	// 交錯但無多餘位置參數：--hours 值不會被誤收。
+	_, stderr, code = run("stalled", "--hours")
+	if code != 2 || !strings.Contains(stderr, "flag needs an argument") {
+		t.Fatalf("stalled --hours 缺值應回 2 且提及 flag needs an argument，得到 %d：%s", code, stderr)
+	}
+}
+
+// TestLoginDefaultNameOnly 驗證 login default <名稱>：位置參數在旗標
+// 之後（--config 在前）仍正確收取一個名稱。
+func TestLoginDefaultNameOnly(t *testing.T) {
+	cfg := `logins:
+    - name: a
+      url: https://a.example.com
+      token: ta
+      default: true
+    - name: b
+      url: https://b.example.com
+      token: tb
+      default: false
+`
+	prefix, _ := loginTestEnv(t, cfg)
+	stdout, _, code := run(append(prefix, "login", "default", "b")...)
+	if code != 0 || !strings.Contains(stdout, `"name":"b"`) {
+		t.Fatalf("login default b 應回 0 並輸出 b：code=%d out=%s", code, stdout)
+	}
+	// 多給一個位置參數仍應報用法錯誤（不受交錯支援影響）。
+	_, stderr, code := run(append(prefix, "login", "default", "b", "c")...)
+	if code != 2 || !strings.Contains(stderr, "exactly one") {
+		t.Fatalf("兩個名稱應回 2，得到 %d：%s", code, stderr)
+	}
+}
+
+// TestMemberHelpExitZero 驗證命令的 -h 結束碼為 0（#25 順帶修正：
+// errHelp 視為成功）。
+func TestMemberHelpExitZero(t *testing.T) {
+	_, _, code := run("members", "-h")
+	if code != 0 {
+		t.Fatalf("members -h 應回 0，得到 %d", code)
+	}
+}
+
+// TestLoginRemoveFlagInterleaved 驗證 login remove <名稱> --yes：
+// --yes 在名稱之後仍視為旗標（未帶時走確認流程會讀 stdin）。
+func TestLoginRemoveFlagInterleaved(t *testing.T) {
+	prefix, configPath := loginTestEnv(t, `logins:
+    - name: a
+      url: https://a.example.com
+      token: ta
+      default: true
+`)
+	old := loginStdin
+	loginStdin = strings.NewReader("y\n") // 若 --yes 失效會讀到這行
+	defer func() { loginStdin = old }()
+	_, _, code := run(append(prefix, "login", "remove", "a", "--yes")...)
+	if code != 0 {
+		t.Fatalf("login remove a --yes 應回 0，得到 %d", code)
+	}
+	data, _ := os.ReadFile(configPath)
+	if strings.Contains(string(data), "token: ta") {
+		t.Fatalf("--yes 在名稱之後應生效（直接刪除）：\n%s", data)
+	}
+}

internal/cli/login.go

@@ -0,0 +1,365 @@
+// login.go — teai login 指令：管理 teai 自己的登入組態。
+//
+// 組態由 teai 自行讀寫（README 設計原則 5），不依賴 tea。login 的職責是：
+// 以 token 向站點驗證（GET /user），成功後才寫入組態並記下帳號。
+// token 只走記憶體與組態檔，不進輸出、日誌或錯誤訊息。
+//
+// 子命令：list／add／default／remove。
+package cli
+
+import (
+	"bufio"
+	"context"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"gitea.alterminal.com/alterminal/teai/internal/gitea"
+)
+
+// loginStdin 是讀 token 與確認的輸入（測試可替換）。
+var loginStdin io.Reader = os.Stdin
+
+// loginConfigPath 回傳組態檔路徑：--config／TEAI_CONFIG 優先，其次
+// ~/.config/teai/config.yml。找不到可用路徑回空字串。
+func loginConfigPath(g Globals) string {
+	if p := strings.TrimSpace(g.ConfigPath); p != "" {
+		return expandHome(p)
+	}
+	if p := os.Getenv("TEAI_CONFIG"); strings.TrimSpace(p) != "" {
+		return expandHome(strings.TrimSpace(p))
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return ""
+	}
+	return filepath.Join(home, ".config", "teai", "config.yml")
+}
+
+// expandHome 展開路徑開頭的 ~。
+func expandHome(p string) string {
+	if p == "~" || strings.HasPrefix(p, "~/") {
+		if home, err := os.UserHomeDir(); err == nil {
+			return filepath.Join(home, strings.TrimPrefix(p, "~"))
+		}
+	}
+	return p
+}
+
+// runLogin 是 teai login 的進入點：分派子命令。
+func runLogin(env *Env, args []string) error {
+	if len(args) == 0 {
+		return &ErrUsage{Msg: "login requires a subcommand: list, add, default, remove"}
+	}
+	sub, rest := args[0], args[1:]
+	switch sub {
+	case "list":
+		return runLoginList(env, rest)
+	case "add":
+		return runLoginAdd(env, rest)
+	case "default":
+		return runLoginDefault(env, rest)
+	case "remove":
+		return runLoginRemove(env, rest)
+	default:
+		return &ErrUsage{Msg: fmt.Sprintf("unknown login subcommand %q (want list, add, default, remove)", sub)}
+	}
+}
+
+// loginFields 是輸出欄位（不含 token）。
+var loginFields = []gitea.Field{
+	{Name: "name"},
+	{Name: "url"},
+	{Name: "user"},
+	{Name: "default"},
+}
+
+// printLoginList 依格式輸出登入清單。
+func printLoginList(env *Env, logins []gitea.LoginEntry) error {
+	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
+	rows := make([]gitea.Values, 0, len(logins))
+	for _, l := range logins {
+		rows = append(rows, gitea.Values{l.Name, l.URL, l.User, l.Default})
+	}
+	return p.PrintList(loginFields, rows)
+}
+
+// runLoginList 列出組態中的登入（一律不含 token）。
+func runLoginList(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai login list", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() > 0 {
+		return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))}
+	}
+	path := loginConfigPath(env.Globals)
+	if path == "" {
+		return fmt.Errorf("cannot determine config path")
+	}
+	logins, err := gitea.ListLoginsFile(path)
+	if err != nil {
+		return fmt.Errorf("read config %s: %w", path, err)
+	}
+	return printLoginList(env, logins)
+}
+
+// runLoginAdd 新增或更新登入：先驗證 token（GET /user），成功才寫入。
+//
+// token 來源：--token 旗標，或 stdin（預設未給旗標時讀一行，
+// 避免 token 進 shell 歷史）。
+func runLoginAdd(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai login add", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	urlFlag := fs.String("url", env.Globals.URL, "Gitea 站點網址")
+	nameFlag := fs.String("name", "", "登入名稱（省略時取 URL 主機）")
+	tokenFlag := fs.String("token", "", "API token（省略時自 stdin 讀一行）")
+	defaultFlag := fs.Bool("default", true, "設為預設登入")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() > 0 {
+		return &ErrUsage{Msg: fmt.Sprintf("unexpected argument %q", fs.Arg(0))}
+	}
+	siteURL := strings.TrimSuffix(strings.TrimSpace(*urlFlag), "/")
+	if siteURL == "" {
+		return &ErrUsage{Msg: "--url must not be empty"}
+	}
+
+	token := strings.TrimSpace(*tokenFlag)
+	if token == "" {
+		t, err := readLineFrom(loginStdin)
+		if err != nil {
+			return fmt.Errorf("read token from stdin: %w", err)
+		}
+		token = t
+	}
+	if token == "" {
+		return &ErrUsage{Msg: "token must not be empty"}
+	}
+
+	path := loginConfigPath(env.Globals)
+	if path == "" {
+		return fmt.Errorf("cannot determine config path")
+	}
+	data, err := os.ReadFile(path)
+	if err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("read config %s: %w", path, err)
+	}
+
+	name := strings.TrimSpace(*nameFlag)
+	if name == "" {
+		// 未指定名稱：同站（主機相同）已有登入就就地更新，避免重複項目。
+		if existing, ok := findLoginByHost(data, siteURL); ok {
+			name = existing.Name
+		} else {
+			name = defaultLoginName(siteURL)
+		}
+	}
+
+	// 先驗證再寫入：token 無效時不動組態檔。
+	user, err := verifyToken(env, siteURL, token)
+	if err != nil {
+		return err
+	}
+	out, final, err := gitea.UpsertLogin(data, gitea.LoginEntry{
+		Name:    name,
+		URL:     siteURL,
+		Token:   token,
+		Default: *defaultFlag,
+		User:    user,
+	}, *defaultFlag)
+	if err != nil {
+		return err
+	}
+	if err := gitea.SaveConfigFile(path, out); err != nil {
+		return err
+	}
+	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
+	return p.PrintOne(loginFields, gitea.Values{final.Name, final.URL, final.User, final.Default})
+}
+
+// readLineFrom 讀一行並去除頭尾空白；EOF 且無內容回空字串。
+func readLineFrom(r io.Reader) (string, error) {
+	line, err := bufio.NewReader(r).ReadString('\n')
+	if err != nil && err != io.EOF {
+		return "", err
+	}
+	return strings.TrimSpace(line), nil
+}
+
+// verifyToken 以 token 呼叫 GET /user，回傳帳號名稱。
+// 401 特別標明是 token 遭拒，其餘依 *gitea.ErrAPI 對應結束碼 3。
+func verifyToken(env *Env, siteURL, token string) (string, error) {
+	c, err := gitea.New(siteURL, token, env.Globals.Timeout)
+	if err != nil {
+		return "", &ErrUsage{Msg: err.Error()}
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), env.Globals.Timeout)
+	defer cancel()
+	var out struct {
+		Login string `json:"login"`
+	}
+	if err := c.GetJSON(ctx, "/user", &out); err != nil {
+		var api *gitea.ErrAPI
+		if errors.As(err, &api) && api.StatusCode == 401 {
+			// 包 %w 保留 *ErrAPI：結束碼對應 3（API 錯誤）。
+			return "", fmt.Errorf("token rejected by %s: %w", siteURL, api)
+		}
+		return "", err
+	}
+	if out.Login == "" {
+		return "", fmt.Errorf("empty account name returned by %s", siteURL)
+	}
+	return out.Login, nil
+}
+
+// runLoginDefault 設定預設登入。
+func runLoginDefault(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai login default", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 1 {
+		return &ErrUsage{Msg: "login default requires exactly one login name"}
+	}
+	name := fs.Arg(0)
+	data, err := readLoginConfig(env, "login default")
+	if err != nil {
+		return err
+	}
+	entry, found := findLogin(data, name)
+	if !found {
+		return fmt.Errorf("gitea: login %q not found", name)
+	}
+	out, err := gitea.SetDefaultLogin(data, name)
+	if err != nil {
+		return err
+	}
+	if err := saveLoginConfig(env, out); err != nil {
+		return err
+	}
+	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
+	return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, true})
+}
+
+// runLoginRemove 移除登入；未加 --yes 時先確認。
+func runLoginRemove(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai login remove", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	yesFlag := fs.Bool("yes", false, "跳過確認")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 1 {
+		return &ErrUsage{Msg: "login remove requires exactly one login name"}
+	}
+	name := fs.Arg(0)
+	data, err := readLoginConfig(env, "login remove")
+	if err != nil {
+		return err
+	}
+	entry, found := findLogin(data, name)
+	if !found {
+		return fmt.Errorf("gitea: login %q not found", name)
+	}
+	if !*yesFlag {
+		confirmed, err := confirmRemove(env, entry)
+		if err != nil {
+			return err
+		}
+		if !confirmed {
+			fmt.Fprintln(env.Out, "cancelled")
+			return nil
+		}
+	}
+	out, promoted, err := gitea.RemoveLogin(data, name)
+	if err != nil {
+		return err
+	}
+	if err := saveLoginConfig(env, out); err != nil {
+		return err
+	}
+	if promoted != "" {
+		fmt.Fprintf(env.Err, "default login is now %q\n", promoted)
+	}
+	p := gitea.Printer{Format: env.Globals.Output, Out: env.Out}
+	return p.PrintOne(loginFields, gitea.Values{entry.Name, entry.URL, entry.User, false})
+}
+
+// confirmRemove 印出待移除項目（不含 token）並讀 y/yes 確認；
+// 其他輸入（含 EOF）一律視為取消。
+func confirmRemove(env *Env, entry gitea.LoginEntry) (bool, error) {
+	fmt.Fprintf(env.Err, "remove login %q (url %s, user %s)? [y/N] ", entry.Name, entry.URL, entry.User)
+	line, err := readLineFrom(loginStdin)
+	if err != nil {
+		return false, fmt.Errorf("read confirmation: %w", err)
+	}
+	switch strings.ToLower(line) {
+	case "y", "yes":
+		return true, nil
+	default:
+		return false, nil
+	}
+}
+
+// readLoginConfig 讀組態檔內容；路徑無法判定或讀取失敗時回錯。
+func readLoginConfig(env *Env, op string) ([]byte, error) {
+	path := loginConfigPath(env.Globals)
+	if path == "" {
+		return nil, fmt.Errorf("cannot determine config path")
+	}
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("%s: read config %s: %w", op, path, err)
+	}
+	return data, nil
+}
+
+// saveLoginConfig 原子寫回組態檔。
+func saveLoginConfig(env *Env, data []byte) error {
+	path := loginConfigPath(env.Globals)
+	if path == "" {
+		return fmt.Errorf("cannot determine config path")
+	}
+	return gitea.SaveConfigFile(path, data)
+}
+
+// findLoginByHost 在組態內容中找 URL 主機與 siteURL 相同的登入。
+func findLoginByHost(data []byte, siteURL string) (gitea.LoginEntry, bool) {
+	for _, l := range gitea.ListLogins(data) {
+		if gitea.HostOf(l.URL) == gitea.HostOf(siteURL) {
+			return l, true
+		}
+	}
+	return gitea.LoginEntry{}, false
+}
+
+// findLogin 在組態內容中找指定名稱的登入。
+func findLogin(data []byte, name string) (gitea.LoginEntry, bool) {
+	for _, l := range gitea.ListLogins(data) {
+		if l.Name == name {
+			return l, true
+		}
+	}
+	return gitea.LoginEntry{}, false
+}
+
+// defaultLoginName 以 URL 主機作為登入名稱。
+func defaultLoginName(rawURL string) string {
+	s := rawURL
+	if !strings.Contains(s, "://") {
+		s = "https://" + s
+	}
+	if u, err := url.Parse(s); err == nil && u.Host != "" {
+		return u.Host
+	}
+	return rawURL
+}

internal/cli/login_test.go

@@ -0,0 +1,323 @@
+// login_test.go 驗證 login 指令：list/add/default/remove 的輸出、
+// 驗證流程（先 GET /user 再寫入）、401 不寫檔、token 不外洩。
+package cli
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"gitea.alterminal.com/alterminal/teai/internal/gitea"
+)
+
+// loginTestEnv 建立測試環境：臨時組態檔路徑 + 可替換的 stdin。
+func loginTestEnv(t *testing.T, configContent string) (args []string, configPath string) {
+	t.Helper()
+	dir := t.TempDir()
+	configPath = filepath.Join(dir, "config.yml")
+	if configContent != "" {
+		if err := os.WriteFile(configPath, []byte(configContent), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	t.Setenv("TEAI_CONFIG", configPath)
+	return []string{"--config", configPath}, configPath
+}
+
+// newAPIServer 建立假的 Gitea API：/user 檢查 Authorization。
+func newAPIServer(t *testing.T, wantToken string, status int) (*httptest.Server, *atomic.Value) {
+	t.Helper()
+	var gotAuth atomic.Value
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotAuth.Store(r.Header.Get("Authorization"))
+		if r.URL.Path != "/api/v1/user" {
+			w.WriteHeader(http.StatusNotFound)
+			return
+		}
+		if status != 0 {
+			w.WriteHeader(status)
+			return
+		}
+		fmt.Fprint(w, `{"login":"ceo"}`)
+	}))
+	t.Cleanup(srv.Close)
+	return srv, &gotAuth
+}
+
+func TestLoginListJSONNoToken(t *testing.T) {
+	prefix, _ := loginTestEnv(t, `logins:
+    - name: alterminal
+      url: https://gitea.alterminal.com
+      token: super-secret
+      default: true
+      user: ceo
+`)
+	stdout, _, code := run(append(prefix, "login", "list")...)
+	if code != 0 {
+		t.Fatalf("code = %d", code)
+	}
+	if !strings.Contains(stdout, `"name":"alterminal"`) || !strings.Contains(stdout, `"user":"ceo"`) {
+		t.Fatalf("unexpected output: %s", stdout)
+	}
+	if strings.Contains(stdout, "super-secret") || strings.Contains(stdout, "token") {
+		t.Fatalf("token leaked: %s", stdout)
+	}
+}
+
+func TestLoginListEmpty(t *testing.T) {
+	prefix, path := loginTestEnv(t, "")
+	if _, err := os.Stat(path); err == nil {
+		t.Fatal("precondition: config should not exist")
+	}
+	stdout, _, code := run(append(prefix, "login", "list")...)
+	if code != 0 {
+		t.Fatalf("code = %d", code)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("want [], got %q", stdout)
+	}
+}
+
+func TestLoginAddVerifiesThenWrites(t *testing.T) {
+	srv, gotAuth := newAPIServer(t, "tok-xyz", 0)
+	prefix, configPath := loginTestEnv(t, "")
+	stdout, _, code := run(append(prefix,
+		"--url", srv.URL, "login", "add", "--name", "test-site", "--token", "tok-xyz")...)
+	if code != 0 {
+		t.Fatalf("code = %d, stdout = %s", code, stdout)
+	}
+	if got := gotAuth.Load(); got != "token tok-xyz" {
+		t.Fatalf("server saw Authorization %v", got)
+	}
+	if !strings.Contains(stdout, `"name":"test-site"`) || !strings.Contains(stdout, `"user":"ceo"`) {
+		t.Fatalf("unexpected output: %s", stdout)
+	}
+	if strings.Contains(stdout, "tok-xyz") {
+		t.Fatalf("token leaked: %s", stdout)
+	}
+	// 寫入的組態可被解析，且欄位齊全。
+	data, err := os.ReadFile(configPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	logins := gitea.ListLogins(data)
+	if len(logins) != 1 {
+		t.Fatalf("want 1 login, got %d:\n%s", len(logins), data)
+	}
+	l := logins[0]
+	if l.Name != "test-site" || l.URL != srv.URL || l.Token != "tok-xyz" || !l.Default || l.User != "ceo" {
+		t.Fatalf("entry mismatch: %+v", l)
+	}
+	info, _ := os.Stat(configPath)
+	if info.Mode().Perm() != 0o600 {
+		t.Fatalf("perm = %v", info.Mode().Perm())
+	}
+	// 新項目只寫 teai 欄位，不含 tea 的 ssh_*／preferences。
+	s := string(data)
+	for _, ban := range []string{"ssh_", "insecure:", "version_check:", "preferences:"} {
+		if strings.Contains(s, ban) {
+			t.Fatalf("tea field leaked %q:\n%s", ban, s)
+		}
+	}
+}
+
+func TestLoginAddTokenFromStdin(t *testing.T) {
+	srv, _ := newAPIServer(t, "stdin-tok", 0)
+	prefix, configPath := loginTestEnv(t, "")
+	old := loginStdin
+	loginStdin = strings.NewReader("stdin-tok\n")
+	defer func() { loginStdin = old }()
+	stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add")...)
+	if code != 0 {
+		t.Fatalf("code = %d, stdout = %s", code, stdout)
+	}
+	data, _ := os.ReadFile(configPath)
+	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "stdin-tok" {
+		t.Fatalf("stdin token not saved:\n%s", data)
+	}
+}
+
+func TestLoginAddRejected401NoWrite(t *testing.T) {
+	srv, _ := newAPIServer(t, "", http.StatusUnauthorized)
+	prefix, configPath := loginTestEnv(t, `logins:
+    - name: keep
+      url: https://keep.example.com
+      token: keep-tok
+      default: true
+`)
+	_, stderr, code := run(append(prefix,
+		"--url", srv.URL, "login", "add", "--token", "bad-tok")...)
+	// 401 是 API 錯誤；對照 README「輸出與結束碼」＝3（#10）。
+	if code != 3 {
+		t.Fatalf("401 should exit 3 (README api error), got %d (stderr %s)", code, stderr)
+	}
+	if !strings.Contains(stderr, "401") {
+		t.Fatalf("stderr should mention 401: %s", stderr)
+	}
+	// 組態不受影響。
+	data, _ := os.ReadFile(configPath)
+	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Token != "keep-tok" {
+		t.Fatalf("config must be untouched:\n%s", data)
+	}
+}
+
+func TestLoginAddUpdatesExistingInPlace(t *testing.T) {
+	srv, _ := newAPIServer(t, "new-tok", 0)
+	prefix, configPath := loginTestEnv(t, `logins:
+    - name: alterminal
+      url: `+srv.URL+`
+      token: old-tok
+      default: true
+      user: someone-else
+      ssh_key: "keep-me"
+preferences:
+    editor: false
+`)
+	stdout, _, code := run(append(prefix, "--url", srv.URL, "login", "add", "--token", "new-tok")...)
+	if code != 0 {
+		t.Fatalf("code = %d, out = %s", code, stdout)
+	}
+	data, _ := os.ReadFile(configPath)
+	s := string(data)
+	// 未給 --name：同站既有項目（name: alterminal）就地更新，不新增重複項目。
+	if strings.Contains(stdout, `"name":"127.0.0.1:`) {
+		t.Fatalf("should reuse existing entry name, got %s", stdout)
+	}
+	if !strings.Contains(s, "- name: alterminal") {
+		t.Fatalf("existing entry name lost:\n%s", s)
+	}
+	if strings.Contains(s, "old-tok") || !strings.Contains(s, "token: new-tok") {
+		t.Fatalf("token not replaced:\n%s", s)
+	}
+	// 未知欄位與其他區段逐字保留（行級編輯，不整檔覆寫）。
+	if !strings.Contains(s, `ssh_key: "keep-me"`) || !strings.Contains(s, "editor: false") {
+		t.Fatalf("unrelated content lost:\n%s", s)
+	}
+	if !strings.Contains(s, "user: ceo") {
+		t.Fatalf("user not refreshed:\n%s", s)
+	}
+}
+
+func TestLoginDefaultAndRemove(t *testing.T) {
+	cfg := `logins:
+    - name: a
+      url: https://a.example.com
+      token: ta
+      default: true
+    - name: b
+      url: https://b.example.com
+      token: tb
+      default: false
+`
+	prefix, configPath := loginTestEnv(t, cfg)
+	stdout, _, code := run(append(prefix, "login", "default", "b")...)
+	if code != 0 || !strings.Contains(stdout, `"name":"b"`) {
+		t.Fatalf("default failed: code=%d out=%s", code, stdout)
+	}
+	data, _ := os.ReadFile(configPath)
+	if l := gitea.ListLogins(data); !l[1].Default || l[0].Default {
+		t.Fatalf("default not switched:\n%s", data)
+	}
+
+	// remove --yes：移除預設者 b，a 遞補。
+	stdout, _, code = run(append(prefix, "login", "remove", "--yes", "b")...)
+	if code != 0 || !strings.Contains(stdout, `"name":"b"`) {
+		t.Fatalf("remove failed: code=%d out=%s", code, stdout)
+	}
+	data, _ = os.ReadFile(configPath)
+	if l := gitea.ListLogins(data); len(l) != 1 || l[0].Name != "a" || !l[0].Default {
+		t.Fatalf("promote failed:\n%s", data)
+	}
+}
+
+func TestLoginRemoveAsksConfirmation(t *testing.T) {
+	prefix, _ := loginTestEnv(t, `logins:
+    - name: a
+      url: https://a.example.com
+      token: ta
+      default: true
+`)
+	old := loginStdin
+	loginStdin = strings.NewReader("n\n")
+	defer func() { loginStdin = old }()
+	_, _, code := run(append(prefix, "login", "remove", "a")...)
+	if code != 0 {
+		t.Fatalf("cancel should still exit 0, got %d", code)
+	}
+	// 取消：檔案不變（token 仍在）。
+	data, _ := os.ReadFile(filepath.Dir(prefix[1]) + "/config.yml")
+	if !strings.Contains(string(data), "token: ta") {
+		t.Fatalf("cancelled remove must not write:\n%s", data)
+	}
+}
+
+func TestLoginUnknownSubcommandUsage(t *testing.T) {
+	prefix, _ := loginTestEnv(t, "")
+	_, stderr, code := run(append(prefix, "login", "bogus")...)
+	// 對照 README「輸出與結束碼」：用法錯誤＝2（#10）。
+	if code != 2 {
+		t.Fatalf("want exit 2 (README usage), got %d", code)
+	}
+	if !strings.Contains(stderr, "unknown login subcommand") {
+		t.Fatalf("stderr: %s", stderr)
+	}
+}
+
+func TestLoginNoSubcommandUsage(t *testing.T) {
+	prefix, _ := loginTestEnv(t, "")
+	_, stderr, code := run(append(prefix, "login")...)
+	// 對照 README「輸出與結束碼」：用法錯誤＝2（#10）。
+	if code != 2 {
+		t.Fatalf("want exit 2 (README usage), got %d", code)
+	}
+	if !strings.Contains(stderr, "subcommand") {
+		t.Fatalf("stderr: %s", stderr)
+	}
+}
+
+func TestLoginRemoveNotFound(t *testing.T) {
+	prefix, _ := loginTestEnv(t, "logins: []\n")
+	_, stderr, code := run(append(prefix, "login", "remove", "--yes", "ghost")...)
+	// ExitInternal 不在 README 保證範圍；此處固定為 1（內部錯誤，#10）。
+	if code != 1 {
+		t.Fatalf("want exit 1 (internal), got %d", code)
+	}
+	if !strings.Contains(stderr, `login "ghost" not found`) {
+		t.Fatalf("stderr: %s", stderr)
+	}
+}
+
+func TestLoginRegisteredInUsage(t *testing.T) {
+	stdout, _, code := run()
+	if code != 0 || !strings.Contains(stdout, "login") {
+		t.Fatalf("usage should list login: %s", stdout)
+	}
+}
+
+func TestLoginConfigPathIndependentOfTea(t *testing.T) {
+	t.Setenv("TEA_CONFIG", "/from-tea.yml")
+	t.Setenv("TEAI_CONFIG", "")
+	g := defaultGlobals()
+	got := loginConfigPath(g)
+	if got == "/from-tea.yml" {
+		t.Fatal("TEA_CONFIG must not be used")
+	}
+	if !strings.HasSuffix(filepath.ToSlash(got), ".config/teai/config.yml") {
+		t.Fatalf("default path want ~/.config/teai/config.yml, got %q", got)
+	}
+
+	t.Setenv("TEAI_CONFIG", "/from-teai.yml")
+	if got := loginConfigPath(g); got != "/from-teai.yml" {
+		t.Fatalf("TEAI_CONFIG: got %q", got)
+	}
+
+	g.ConfigPath = "/explicit.yml"
+	if got := loginConfigPath(g); got != "/explicit.yml" {
+		t.Fatalf("--config: got %q", got)
+	}
+}

internal/cli/milestones_commands.go

@@ -0,0 +1,97 @@
+// milestones_commands.go — 跨倉庫里程碑總覽命令的 CLI 接線（#31）：
+// teai milestones（不帶 --repo）。
+//
+// 核心邏輯在 internal/workflow（MilestoneOverview），本檔只做旗標
+// 剖析、資料源接線與輸出格式化（與 stalled_commands.go 同模式）。
+// 輸出與 gitea.py milestones 位元組相容（MilestoneEntry 自訂
+// MarshalJSON；縮排 2、停用 HTML 轉義、空清單輸出 []，見 #26 慣例）。
+package cli
+
+import (
+	"fmt"
+	"time"
+
+	"gitea.alterminal.com/alterminal/teai/internal/gitea"
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+// newMilestoneSourceFunc 建立總覽的資料源；宣告為變數讓接線層測試
+// 可注入假資料源（與 newStalledSourceFunc 同模式）。
+var newMilestoneSourceFunc = newMilestoneSource
+
+// newMilestoneSource 依全域選項建立 workflow.MilestoneSource（API 實作）。
+func newMilestoneSource(env *Env) (workflow.MilestoneSource, error) {
+	token, _, err := gitea.ResolveToken(gitea.AuthOptions{
+		FlagToken:  env.Globals.Token,
+		SiteURL:    env.Globals.URL,
+		ConfigPath: env.Globals.ConfigPath,
+	})
+	if err != nil {
+		return nil, err
+	}
+	client, err := gitea.New(env.Globals.URL, token, env.Globals.Timeout)
+	if err != nil {
+		return nil, err
+	}
+	return &workflow.APIClient{Client: client}, nil
+}
+
+// milestonesNowFunc 回傳總覽的基準時刻；宣告為變數讓測試可固定時刻。
+var milestonesNowFunc = time.Now
+
+// milestoneEntryRow 把 MilestoneEntry 轉成 table 列（unassigned 僅 JSON
+// 模式輸出完整摘要；table 給人工抽查用，取計數）。
+func milestoneEntryRow(e workflow.MilestoneEntry) gitea.Values {
+	dueOn := ""
+	if e.DueOn != nil {
+		dueOn = *e.DueOn
+	}
+	dueHours := ""
+	if e.DueHours != nil {
+		dueHours = fmt.Sprintf("%.1f", *e.DueHours)
+	}
+	updatedAt := ""
+	if e.UpdatedAt != nil {
+		updatedAt = *e.UpdatedAt
+	}
+	id := ""
+	if e.ID != nil {
+		id = fmt.Sprintf("%d", *e.ID)
+	}
+	return gitea.Values{
+		e.Repo, id, e.Title, e.URL,
+		e.OpenIssues, e.ClosedIssues, dueOn, dueHours,
+		e.Overdue, len(e.Unassigned), updatedAt,
+	}
+}
+
+// runMilestonesOverview：teai milestones（跨倉庫總覽）。
+// JSON 輸出與 gitea.py milestones 位元組相容；空清單輸出 []（#26 慣例：
+// gitea.py 對空清單不輸出，teai 輸出 [] 供 JSON 消費者明確判斷）。
+func runMilestonesOverview(env *Env) error {
+	src, err := newMilestoneSourceFunc(env)
+	if err != nil {
+		return err
+	}
+	entries, err := workflow.MilestoneOverview(src, env.Globals.URL, milestonesNowFunc())
+	if err != nil {
+		return err
+	}
+	p := printer(env)
+	if p.Format == gitea.FormatTable {
+		rows := make([]gitea.Values, 0, len(entries))
+		for i := range entries {
+			rows = append(rows, milestoneEntryRow(entries[i]))
+		}
+		return p.PrintList([]gitea.Field{
+			{Name: "repo"}, {Name: "id"}, {Name: "title"}, {Name: "url"},
+			{Name: "open_issues"}, {Name: "closed_issues"}, {Name: "due_on"},
+			{Name: "due_hours"}, {Name: "overdue"}, {Name: "unassigned"}, {Name: "updated_at"},
+		}, rows)
+	}
+	if len(entries) == 0 {
+		_, err := fmt.Fprintln(env.Out, "[]")
+		return err
+	}
+	return printJSON(env.Out, entries)
+}

internal/cli/milestones_commands_test.go

@@ -0,0 +1,188 @@
+// milestones_commands_test.go — 跨倉庫里程碑總覽的 CLI 接線層測試（#31）：
+// 注入假 MilestoneSource，驗證 Run→dispatch→輸出完整路徑，不走網路
+// （與 stalled_commands_test.go 同模式）。
+package cli
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+// stubMilestoneSource 以記憶體資料實作 workflow.MilestoneSource。
+type stubMilestoneSource struct {
+	orgs       []string
+	repos      map[string][]workflow.Repo
+	milestones map[string][]workflow.Milestone
+	openIssues map[string][]workflow.Issue // key: owner/repo?milestone=<title>
+}
+
+func (s *stubMilestoneSource) MyOrganizations() ([]string, error) { return s.orgs, nil }
+func (s *stubMilestoneSource) OrganizationRepositories(org string) ([]workflow.Repo, error) {
+	return s.repos[org], nil
+}
+func (s *stubMilestoneSource) OpenMilestones(owner, repo string) ([]workflow.Milestone, error) {
+	return s.milestones[owner+"/"+repo], nil
+}
+func (s *stubMilestoneSource) MilestoneOpenIssues(owner, repo, title string) ([]workflow.Issue, error) {
+	return s.openIssues[owner+"/"+repo+"?milestone="+title], nil
+}
+
+// newStubMilestoneEnv 注入假資料源並固定時刻。
+func newStubMilestoneEnv(t *testing.T, src *stubMilestoneSource, frozen time.Time) {
+	t.Helper()
+	origSrc, origNow := newMilestoneSourceFunc, milestonesNowFunc
+	newMilestoneSourceFunc = func(env *Env) (workflow.MilestoneSource, error) { return src, nil }
+	milestonesNowFunc = func() time.Time { return frozen }
+	t.Cleanup(func() {
+		newMilestoneSourceFunc, milestonesNowFunc = origSrc, origNow
+	})
+}
+
+// stubPullIssue 以 JSON 建構帶 pull_request 標記的條目（pullMarker 未匯出，
+// 測試從套件外以 API 回應的形狀建構，走 Issue.UnmarshalJSON 同一路徑）。
+func stubPullIssue(t *testing.T) workflow.Issue {
+	t.Helper()
+	var issue workflow.Issue
+	err := json.Unmarshal([]byte(`{
+		"number": 32, "title": "文件", "state": "open",
+		"updated_at": "2026-09-08T00:00:00Z",
+		"html_url": "https://gitea.alterminal.com/alterminal/agents/pulls/32",
+		"user": {"username": "alex"},
+		"pull_request": {}
+	}`), &issue)
+	if err != nil {
+		t.Fatalf("建構 stub PR 條目失敗：%v", err)
+	}
+	return issue
+}
+
+// idPtr／msPtr 是測試用指標 helper（workflow 套件內同名函式未匯出）。
+func idPtr(i int64) *int64   { return &i }
+func msPtr(s string) *string { return &s }
+
+// newStubMilestoneData 建構總覽情境：兩倉庫各一里程碑、一個未分派 PR。
+func newStubMilestoneData(t *testing.T) *stubMilestoneSource {
+	due := "2026-09-09T00:00:00Z"
+	return &stubMilestoneSource{
+		orgs: []string{"alterminal"},
+		repos: map[string][]workflow.Repo{"alterminal": {
+			{Name: "agents"}, {Name: "teai"},
+		}},
+		milestones: map[string][]workflow.Milestone{
+			"alterminal/agents": {
+				{ID: idPtr(7), Title: "MVP", State: "open",
+					DueOn: &due, UpdatedAt: "2026-09-01T00:00:00Z",
+					OpenIssues: 1, ClosedIssues: 0},
+			},
+			"alterminal/teai": {
+				{ID: idPtr(3), Title: "CLI", State: "open",
+					DueOn: msPtr("2026-09-12T00:00:00Z"), UpdatedAt: "2026-09-05T00:00:00Z",
+					OpenIssues: 1, ClosedIssues: 2},
+			},
+		},
+		openIssues: map[string][]workflow.Issue{
+			"alterminal/agents?milestone=MVP": {stubPullIssue(t)},
+		},
+	}
+}
+
+// TestWiringMilestonesOverview 驗證 teai milestones 輸出跨倉庫總覽
+// （JSON 縮排 2、鍵序與欄位齊 gitea.py）。
+func TestWiringMilestonesOverview(t *testing.T) {
+	newStubMilestoneEnv(t, newStubMilestoneData(t), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("milestones")
+	if code != 0 {
+		t.Fatalf("milestones 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	for _, want := range []string{
+		`"repo": "alterminal/agents"`,
+		`"title": "MVP"`,
+		`"overdue": true`,
+		`"type": "pull"`,
+		`"author": "alex"`,
+	} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("milestones 輸出應含 %q，得到：\n%s", want, stdout)
+		}
+	}
+	// 排序：agents MVP（09-09）在 teai CLI（09-12）前。
+	if strings.Index(stdout, `"title": "MVP"`) > strings.Index(stdout, `"title": "CLI"`) {
+		t.Fatalf("期限近者應在前：\n%s", stdout)
+	}
+}
+
+// TestWiringMilestonesEmpty 驗證無里程碑 → []（#26 慣例）。
+func TestWiringMilestonesEmpty(t *testing.T) {
+	newStubMilestoneEnv(t, &stubMilestoneSource{
+		orgs:       []string{"alterminal"},
+		repos:      map[string][]workflow.Repo{"alterminal": {{Name: "agents"}}},
+		milestones: map[string][]workflow.Milestone{},
+		openIssues: map[string][]workflow.Issue{},
+	}, time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("milestones")
+	if code != 0 {
+		t.Fatalf("milestones 空清單應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("無里程碑應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringMilestonesTable 驗證 table 輸出（人工抽查用）。
+func TestWiringMilestonesTable(t *testing.T) {
+	newStubMilestoneEnv(t, newStubMilestoneData(t), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("milestones", "--output", "table")
+	if code != 0 {
+		t.Fatalf("milestones --output table 應回 0，得到 %d", code)
+	}
+	for _, want := range []string{"repo", "overdue", "MVP", "alterminal/agents"} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("table 輸出應含 %q，得到：\n%s", want, stdout)
+		}
+	}
+}
+
+// TestWiringMilestonesRepoFlagCompat 驗證 teai milestones --repo a/b
+// 維持現行單倉庫 list 語義（#31：帶 --repo 時不變）。
+func TestWiringMilestonesRepoFlagCompat(t *testing.T) {
+	var gotPath, gotQuery string
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		gotPath, gotQuery = r.URL.Path, r.URL.RawQuery
+		w.Write([]byte(`[{"title":"v1","state":"open","description":"","due_on":""}]`))
+	}))
+	t.Cleanup(srv.Close)
+	stdout, _, code := run("--url", srv.URL, "milestones", "--repo", "a/b")
+	if code != 0 {
+		t.Fatalf("milestones --repo a/b 應回 0，得到 %d", code)
+	}
+	if gotPath != "/api/v1/repos/a/b/milestones" {
+		t.Fatalf("應呼叫 /repos/a/b/milestones，得到 %s", gotPath)
+	}
+	if !strings.Contains(gotQuery, "state=open") {
+		t.Fatalf("查詢應含 state=open，得到 %q", gotQuery)
+	}
+	if !strings.Contains(stdout, `"title":"v1"`) {
+		t.Fatalf("輸出應含 title v1，得到：%s", stdout)
+	}
+}
+
+// TestWiringMilestonesUsage 驗證未知子命令與位置參數 → exit 2。
+func TestWiringMilestonesUsage(t *testing.T) {
+	newStubMilestoneEnv(t, newStubMilestoneData(t), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	if _, _, code := run("milestones", "bogus"); code != int(ExitUsage) {
+		t.Fatalf("milestones bogus 應回 ExitUsage，得到 %d", code)
+	}
+	if _, _, code := run("milestones", "extra", "arg"); code != int(ExitUsage) {
+		t.Fatalf("milestones 位置參數應回 ExitUsage，得到 %d", code)
+	}
+	// milestones list 仍照舊要求 --repo。
+	if _, _, code := run("milestones", "list"); code != int(ExitUsage) {
+		t.Fatalf("milestones list 缺 --repo 應回 ExitUsage，得到 %d", code)
+	}
+}

internal/cli/organizations_commands_test.go

@@ -0,0 +1,169 @@
+// organizations_commands_test.go — #45 的驗收測試：tea organizations 對等指令
+// list／create／delete。讀取 list 打對端點；寫入 create／delete 未帶 --yes
+// 不得發出任何請求，帶 --yes 時打對端點與 payload。
+package cli
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+)
+
+// TestOrganizationsListGetsUserOrgs 驗證 organizations list：
+// GET /user/orgs，輸出 name（username 優先）與 full_name 等欄位。
+func TestOrganizationsListGetsUserOrgs(t *testing.T) {
+	var gotMethod, gotPath string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		fmt.Fprint(w, `[{"username":"alterminal","name":"alterminal","full_name":"Alterminal Co., Ltd.","website":"","location":"","description":"","visibility":"public"},{"username":"","name":"fallback-org","full_name":"Fallback Org","visibility":"public"}]`)
+	})
+	stdout, _, code := run("organizations", "list")
+	if code != 0 {
+		t.Fatalf("organizations list 應回 0，得到 %d", code)
+	}
+	if gotMethod != "GET" || !strings.HasSuffix(gotPath, "/user/orgs") {
+		t.Errorf("應 GET /user/orgs，得到 %s %s", gotMethod, gotPath)
+	}
+	if !strings.Contains(stdout, `"name":"alterminal"`) || !strings.Contains(stdout, `"full_name":"Alterminal Co., Ltd."`) {
+		t.Errorf("輸出應含 name 與 full_name，得到：%s", stdout)
+	}
+	// username 缺漏時回退 name 欄位（同 workflow.Org.Account 取值順序）。
+	if !strings.Contains(stdout, `"name":"fallback-org"`) {
+		t.Errorf("username 缺漏時 name 应回退 name 欄位，得到：%s", stdout)
+	}
+}
+
+// TestOrganizationsListRejectsPositionalArgs 驗證 list 不接受位置參數（回 2）。
+func TestOrganizationsListRejectsPositionalArgs(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("不應發出任何請求")
+	})
+	_, stderr, code := run("organizations", "list", "alterminal")
+	if code != 2 {
+		t.Errorf("list 帶位置參數應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "位置參數") {
+		t.Errorf("錯誤訊息應提及位置參數，得到：%s", stderr)
+	}
+}
+
+// TestOrganizationsCreateRequiresYes 驗證 create 未帶 --yes：回 2 且不發請求。
+func TestOrganizationsCreateRequiresYes(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("未帶 --yes 不得發出請求（%s %s）", r.Method, r.URL.Path)
+	})
+	_, stderr, code := run("organizations", "create", "--name", "neworg")
+	if code != 2 {
+		t.Errorf("create 未帶 --yes 應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "--yes") {
+		t.Errorf("錯誤訊息應提及 --yes，得到：%s", stderr)
+	}
+}
+
+// TestOrganizationsCreateRequiresName 驗證 create 缺 --name：回 2（且在 --yes 閘門之前檢查）。
+func TestOrganizationsCreateRequiresName(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("缺 --name 不應發出請求")
+	})
+	_, stderr, code := run("organizations", "create", "--yes")
+	if code != 2 {
+		t.Errorf("create 缺 --name 應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "--name") {
+		t.Errorf("錯誤訊息應提及 --name，得到：%s", stderr)
+	}
+}
+
+// TestOrganizationsCreatePostsOrg 驗證 create --yes：
+// POST /orgs，payload 帶 username 與 full_name；visibility 空時不傳。
+func TestOrganizationsCreatePostsOrg(t *testing.T) {
+	var gotMethod, gotPath, gotBody string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		buf := make([]byte, 1024)
+		n, _ := r.Body.Read(buf)
+		gotBody = string(buf[:n])
+		fmt.Fprint(w, `{"username":"neworg","name":"neworg","full_name":"New Org","website":"https://x","location":"TW","description":"d","visibility":"public"}`)
+	})
+	stdout, _, code := run("organizations", "create", "--yes", "--name", "neworg", "--full-name", "New Org", "--website", "https://x", "--location", "TW", "--description", "d")
+	if code != 0 {
+		t.Fatalf("create --yes 應回 0，得到 %d", code)
+	}
+	if gotMethod != "POST" || !strings.HasSuffix(gotPath, "/orgs") {
+		t.Errorf("應 POST /orgs，得到 %s %s", gotMethod, gotPath)
+	}
+	for _, want := range []string{`"username":"neworg"`, `"full_name":"New Org"`, `"website":"https://x"`, `"location":"TW"`, `"description":"d"`} {
+		if !strings.Contains(gotBody, want) {
+			t.Errorf("body 應含 %s，得到：%s", want, gotBody)
+		}
+	}
+	if strings.Contains(gotBody, "visibility") {
+		t.Errorf("未指定 --visibility 時 body 不應含 visibility，得到：%s", gotBody)
+	}
+	if !strings.Contains(stdout, `"name":"neworg"`) || !strings.Contains(stdout, `"full_name":"New Org"`) {
+		t.Errorf("輸出應含 name 與 full_name，得到：%s", stdout)
+	}
+}
+
+// TestOrganizationsCreateRejectsBadVisibility 驗證 --visibility 值域檢查（回 2，不發請求）。
+func TestOrganizationsCreateRejectsBadVisibility(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("值域檢查失敗不應發出請求")
+	})
+	_, stderr, code := run("organizations", "create", "--yes", "--name", "neworg", "--visibility", "secret")
+	if code != 2 {
+		t.Errorf("--visibility secret 應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "visibility") {
+		t.Errorf("錯誤訊息應提及 visibility，得到：%s", stderr)
+	}
+}
+
+// TestOrganizationsDeleteRequiresYes 驗證 delete 未帶 --yes：回 2 且不發請求。
+func TestOrganizationsDeleteRequiresYes(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("未帶 --yes 不得發出請求（%s %s）", r.Method, r.URL.Path)
+	})
+	_, stderr, code := run("organizations", "delete", "oldorg")
+	if code != 2 {
+		t.Errorf("delete 未帶 --yes 應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "--yes") {
+		t.Errorf("錯誤訊息應提及 --yes，得到：%s", stderr)
+	}
+}
+
+// TestOrganizationsDeleteOrg 驗證 delete --yes：DELETE /orgs/{org}。
+func TestOrganizationsDeleteOrg(t *testing.T) {
+	var gotMethod, gotPath string
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		gotMethod, gotPath = r.Method, r.URL.Path
+		w.WriteHeader(http.StatusNoContent)
+	})
+	stdout, _, code := run("organizations", "delete", "--yes", "oldorg")
+	if code != 0 {
+		t.Fatalf("delete --yes 應回 0，得到 %d", code)
+	}
+	if gotMethod != "DELETE" || !strings.HasSuffix(gotPath, "/orgs/oldorg") {
+		t.Errorf("應 DELETE /orgs/oldorg，得到 %s %s", gotMethod, gotPath)
+	}
+	if !strings.Contains(stdout, `"state":"deleted"`) {
+		t.Errorf("輸出應含 state=deleted，得到：%s", stdout)
+	}
+}
+
+// TestOrganizationsUnknownSubcommand 驗證未知子命令回 2。
+func TestOrganizationsUnknownSubcommand(t *testing.T) {
+	run := opsTestServer(t, func(w http.ResponseWriter, r *http.Request) {
+		t.Errorf("未知子命令不應發出請求")
+	})
+	_, stderr, code := run("organizations", "rename")
+	if code != 2 {
+		t.Errorf("未知子命令應回 2，得到 %d", code)
+	}
+	if !strings.Contains(stderr, "organizations") {
+		t.Errorf("錯誤訊息應提及 organizations，得到：%s", stderr)
+	}
+}

internal/cli/stalled_commands.go

@@ -0,0 +1,170 @@
+// stalled_commands.go — 管理者巡邏命令的 CLI 接線（#7）：
+// stalled [--hours N] 與 xrefs <owner>/<repo> <number>。
+//
+// 核心邏輯在 internal/workflow（ScanStalled／ResolveIssueXrefs），
+// 本檔只做旗標剖析、資料源接線與輸出格式化。輸出走得體架構的
+// Printer（--output json|table）；錯誤經 cli.exitCodeFor 映射結束碼
+// （用法 2／API 3）。token 解析選序見 internal/gitea/auth.go。
+package cli
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"io"
+	"strconv"
+	"time"
+
+	"gitea.alterminal.com/alterminal/teai/internal/gitea"
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+func init() {
+	commands["stalled"] = &command{
+		name:  "stalled",
+		usage: "停滯的 open issues／PR（管理者巡邏；--hours N 門檻，預設 4）",
+		run:   runStalled,
+	}
+	commands["xrefs"] = &command{
+		name:  "xrefs",
+		usage: "解析 issue／PR 內文與留言中的 #N／repo#N／owner/repo#N 引用",
+		run:   runXrefs,
+	}
+}
+
+// newStalledSourceFunc 建立 stalled／xrefs 的資料源；宣告為變數讓
+// 接線層測試可注入假資料源（不走網路），與 newScannerFunc 同模式。
+var newStalledSourceFunc = newStalledSource
+
+// newStalledSource 依全域選項建立 workflow.StalledSource（API 實作）。
+func newStalledSource(env *Env) (workflow.StalledSource, error) {
+	token, _, err := gitea.ResolveToken(gitea.AuthOptions{
+		FlagToken:  env.Globals.Token,
+		SiteURL:    env.Globals.URL,
+		ConfigPath: env.Globals.ConfigPath,
+	})
+	if err != nil {
+		return nil, err
+	}
+	client, err := gitea.New(env.Globals.URL, token, env.Globals.Timeout)
+	if err != nil {
+		return nil, err
+	}
+	return &workflow.APIClient{Client: client}, nil
+}
+
+// stalledFields 是 stalled 的 table 欄位（JSON 模式輸出完整 Item，
+// 欄位序與 gitea.py 一致，見 workflow.Item.MarshalJSON）。
+func stalledFields() []gitea.Field {
+	return []gitea.Field{
+		{Name: "type"}, {Name: "repo"}, {Name: "number"}, {Name: "title"},
+		{Name: "last_comment_by"}, {Name: "last_activity_at"},
+		{Name: "stalled_hours"}, {Name: "reason"},
+	}
+}
+
+// stalledRow 把 Item 轉成 table 列（assignees／reviewers／child_activity
+// 僅 JSON 模式輸出；table 給人工抽查用，取共同欄位）。
+// stalled_hours 定點一位小數（fmt.Sprint(9.0) 會印 "9"，與 JSON 的 9.0 不一致）。
+func stalledRow(item workflow.Item) gitea.Values {
+	return gitea.Values{
+		item.Type, item.Repo, item.Number, item.Title,
+		item.LastCommentBy, workflow.FormatMoment(item.LastActivityAt),
+		strconv.FormatFloat(item.StalledHours, 'f', 1, 64), item.Reason,
+	}
+}
+
+// runStalled：teai stalled [--hours N]。
+// 預設門檻 4 小時；--hours 需為正數（同 gitea.py _parse_hours）。
+// JSON 輸出與 gitea.py stalled 位元組相容（workflow.Item 自訂 MarshalJSON；
+// 這裡輸出前停用 HTML 轉義並縮排 2，對應 Python json.dumps(indent=2)）。
+func runStalled(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai stalled", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	hours := fs.Float64("hours", workflow.StalledDefaultHours, "停滯門檻（小時，正數）")
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 0 {
+		return &ErrUsage{Msg: "stalled 不接受位置參數"}
+	}
+	if *hours <= 0 {
+		return &ErrUsage{Msg: "--hours 需為正數（小時），例如 --hours 4"}
+	}
+	src, err := newStalledSourceFunc(env)
+	if err != nil {
+		return err
+	}
+	items, err := workflow.RunStalled(src, *hours, nowFunc())
+	if err != nil {
+		return err
+	}
+	p := printer(env)
+	if p.Format == gitea.FormatTable {
+		rows := make([]gitea.Values, 0, len(items))
+		for _, item := range items {
+			rows = append(rows, stalledRow(item))
+		}
+		return p.PrintList(stalledFields(), rows)
+	}
+	// JSON：空清單輸出 []（README：無停滯項目 → 空陣列）；有項目時
+	// 縮排 2 且停用 HTML 轉義，與 gitea.py 的 _dump 位元組相容。
+	if len(items) == 0 {
+		_, err := fmt.Fprintln(env.Out, "[]")
+		return err
+	}
+	return printJSON(env.Out, items)
+}
+
+// runXrefs：teai xrefs <owner>/<repo> <number>。
+// 編號不存在 → API 錯誤（結束碼 3）；無引用 → []。
+func runXrefs(env *Env, args []string) error {
+	fs := flag.NewFlagSet("teai xrefs", flag.ContinueOnError)
+	fs.SetOutput(env.Err)
+	if err := parseFlags(fs, args); err != nil {
+		return err
+	}
+	if fs.NArg() != 2 {
+		return &ErrUsage{Msg: "xrefs 需要 <owner>/<repo> <number> 兩個參數"}
+	}
+	owner, name, err := splitRepoFlag(args[0])
+	if err != nil {
+		return err
+	}
+	number, err := strconv.ParseInt(args[1], 10, 64)
+	if err != nil || number <= 0 {
+		return &ErrUsage{Msg: fmt.Sprintf("編號需為正整數，得到 %q", args[1])}
+	}
+	src, err := newStalledSourceFunc(env)
+	if err != nil {
+		return err
+	}
+	hits, err := workflow.ResolveIssueXrefs(src, owner, name, number)
+	if err != nil {
+		return err
+	}
+	p := printer(env)
+	rows := make([]gitea.Values, 0, len(hits))
+	for _, h := range hits {
+		rows = append(rows, gitea.Values{h.Owner, h.Repo, h.Number, h.Source})
+	}
+	return p.PrintList(
+		[]gitea.Field{
+			{Name: "owner"}, {Name: "repo"}, {Name: "number"}, {Name: "source"},
+		},
+		rows,
+	)
+}
+
+// nowFunc 回傳目前時刻；宣告為變數讓測試可固定時刻（stalled 判定用）。
+var nowFunc = time.Now
+
+// printJSON 以縮排 2、停用 HTML 轉義輸出 JSON（與 gitea.py 的
+// json.dumps(ensure_ascii=False, indent=2) 位元組相容；HTML 轉義會把
+// <、>、& 變 \u003c 等，破壞相容性）。
+func printJSON(w io.Writer, v any) error {
+	enc := json.NewEncoder(w)
+	enc.SetEscapeHTML(false)
+	enc.SetIndent("", "  ")
+	return enc.Encode(v)
+}

internal/cli/stalled_commands_test.go

@@ -0,0 +1,248 @@
+// stalled_commands_test.go — stalled／xrefs CLI 接線層測試（#7）：
+// 注入假 StalledSource，驗證 Run→dispatch→flagset 完整路徑，
+// 不走網路（與 workflow_commands_test.go 同模式）。
+package cli
+
+import (
+	"strings"
+	"testing"
+	"time"
+
+	"gitea.alterminal.com/alterminal/teai/internal/gitea"
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+// stubStalledSource 以記憶體資料實作 workflow.StalledSource。
+type stubStalledSource struct {
+	username string
+	orgs     []string
+	repos    map[string][]workflow.Repo
+	issues   map[string]map[int64]workflow.Issue
+	comments map[string][]workflow.Comment
+	getErr   error
+}
+
+func (s *stubStalledSource) CurrentUser() (string, error) { return s.username, nil }
+func (s *stubStalledSource) MyOrganizations() ([]string, error) {
+	return s.orgs, nil
+}
+func (s *stubStalledSource) OrganizationRepositories(org string) ([]workflow.Repo, error) {
+	return s.repos[org], nil
+}
+func (s *stubStalledSource) OpenIssues(owner, repo string) ([]workflow.Issue, error) {
+	var out []workflow.Issue
+	for _, i := range s.issues[owner+"/"+repo] {
+		out = append(out, i)
+	}
+	return out, nil
+}
+func (s *stubStalledSource) OpenPulls(owner, repo string) ([]workflow.PullRequest, error) {
+	return nil, nil
+}
+func (s *stubStalledSource) IssueComments(owner, repo string, number int64) ([]workflow.Comment, error) {
+	return s.comments[owner+"/"+repo+"/"+itoa(number)], nil
+}
+func (s *stubStalledSource) TryGetIssue(owner, repo string, number int64) (workflow.Issue, bool, error) {
+	i, ok := s.issues[owner+"/"+repo][number]
+	return i, ok, nil
+}
+func (s *stubStalledSource) IssueTimeline(owner, repo string, number int64) ([]workflow.TimelineEvent, error) {
+	return nil, nil
+}
+func (s *stubStalledSource) GetIssue(owner, repo string, number int64) (workflow.Issue, error) {
+	if s.getErr != nil {
+		return workflow.Issue{}, s.getErr
+	}
+	i, ok := s.issues[owner+"/"+repo][number]
+	if !ok {
+		return workflow.Issue{}, &gitea.ErrAPI{Op: "GET /repos/" + owner + "/" + repo + "/issues/" + itoa(number), StatusCode: 404}
+	}
+	return i, nil
+}
+
+func itoa(n int64) string {
+	if n == 0 {
+		return "0"
+	}
+	var b []byte
+	for n > 0 {
+		b = append([]byte{byte('0' + n%10)}, b...)
+		n /= 10
+	}
+	return string(b)
+}
+
+// newStubStalledEnv 注入假資料源並固定時刻。
+func newStubStalledEnv(t *testing.T, src *stubStalledSource, frozen time.Time) {
+	t.Helper()
+	origSrc, origNow := newStalledSourceFunc, nowFunc
+	newStalledSourceFunc = func(env *Env) (workflow.StalledSource, error) { return src, nil }
+	nowFunc = func() time.Time { return frozen }
+	t.Cleanup(func() { newStalledSourceFunc, nowFunc = origSrc, origNow })
+}
+
+// isoAt 把相對分鐘轉成 ISO8601 字串（假資料用；錨點同 workflow 測試）。
+func isoAt(minutes int) string {
+	return workflow.FormatMoment(time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC).Add(time.Duration(minutes) * time.Minute))
+}
+
+// newStubStalledData 建構 stalled 情境：agents#1 停滯 10 小時（no-assignee）。
+func newStubStalledData() *stubStalledSource {
+	return &stubStalledSource{
+		username: "ceo",
+		orgs:     []string{"alterminal"},
+		repos:    map[string][]workflow.Repo{"alterminal": {{Name: "agents"}}},
+		issues: map[string]map[int64]workflow.Issue{
+			"alterminal/agents": {
+				1: {Number: 1, Title: "停滯項", State: "open",
+					CreatedAt: isoAt(-600), UpdatedAt: isoAt(-600),
+					Repository: &workflow.Repository{FullName: "alterminal/agents"}},
+			},
+		},
+		comments: map[string][]workflow.Comment{},
+	}
+}
+
+// TestWiringStalled 驗證 stalled 基本路徑：JSON 輸出含停滯欄位。
+func TestWiringStalled(t *testing.T) {
+	newStubStalledEnv(t, newStubStalledData(), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("stalled")
+	if code != 0 {
+		t.Fatalf("stalled 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	for _, want := range []string{`"type": "issue"`, `"reason": "no-assignee"`, `"stalled_hours": 10.0`} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("stalled 輸出應含 %q，得到：\n%s", want, stdout)
+		}
+	}
+}
+
+// TestWiringStalledEmpty 驗證 stalled 無任何條目時輸出 []、exit 0（#37）。
+func TestWiringStalledEmpty(t *testing.T) {
+	newStubStalledEnv(t, &stubStalledSource{
+		username: "ceo",
+		orgs:     []string{"alterminal"},
+		repos:    map[string][]workflow.Repo{"alterminal": {}},
+		issues:   map[string]map[int64]workflow.Issue{},
+		comments: map[string][]workflow.Comment{},
+	}, time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("stalled")
+	if code != 0 {
+		t.Fatalf("stalled 空情境應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("stalled 無條目應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringStalledHoursFlag 驗證 --hours 覆寫門檻與非正數被攔。
+func TestWiringStalledHoursFlag(t *testing.T) {
+	freeze := time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC)
+	newStubStalledEnv(t, newStubStalledData(), freeze)
+	// 門檻 20h → 10h 停滯未過門檻 → 空陣列。
+	stdout, _, code := run("stalled", "--hours", "20")
+	if code != 0 {
+		t.Fatalf("stalled --hours 20 應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("無停滯項應輸出 []，得到 %q", stdout)
+	}
+	// 非正數 → exit 2。
+	_, stderr, code := run("stalled", "--hours", "-1")
+	if code != int(ExitUsage) {
+		t.Fatalf("stalled --hours -1 應回 ExitUsage(%d)，得到 %d（stderr=%q）", int(ExitUsage), code, stderr)
+	}
+	// 位置參數 → exit 2。
+	_, _, code = run("stalled", "extra")
+	if code != int(ExitUsage) {
+		t.Fatalf("stalled extra 應回 ExitUsage(%d)，得到 %d", int(ExitUsage), code)
+	}
+}
+
+// TestWiringStalledTable 驗證 table 輸出（README 範例）。
+func TestWiringStalledTable(t *testing.T) {
+	newStubStalledEnv(t, newStubStalledData(), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("stalled", "--output", "table")
+	if code != 0 {
+		t.Fatalf("stalled --output table 應回 0，得到 %d", code)
+	}
+	for _, want := range []string{"reason", "no-assignee", "停滯項"} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("table 輸出應含 %q，得到：\n%s", want, stdout)
+		}
+	}
+}
+
+// TestWiringXrefs 驗證 xrefs 解析輸出（含 body／comment 出處）。
+func TestWiringXrefs(t *testing.T) {
+	src := newStubStalledData()
+	src.issues["alterminal/agents"][1] = workflow.Issue{
+		Number: 1, Title: "父項", State: "open",
+		Body:       "子項：agents#2",
+		Repository: &workflow.Repository{FullName: "alterminal/agents"},
+	}
+	src.issues["alterminal/agents"][2] = workflow.Issue{
+		Number: 2, Title: "子項", State: "open",
+		Repository: &workflow.Repository{FullName: "alterminal/agents"},
+	}
+	src.comments["alterminal/agents/1"] = []workflow.Comment{
+		{Body: "看 agents#2", User: &workflow.User{UserName: "alex"}},
+	}
+	newStubStalledEnv(t, src, time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("xrefs", "alterminal/agents", "1")
+	if code != 0 {
+		t.Fatalf("xrefs 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	// Printer JSON 為單行緊湊格式（無縮排）；命令清單類輸出一律如此。
+	for _, want := range []string{`"repo":"agents"`, `"number":2`, `"source":"body"`} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("xrefs 輸出應含 %q，得到：\n%s", want, stdout)
+		}
+	}
+}
+
+// TestWiringXrefsEmpty 驗證無引用 → []。
+func TestWiringXrefsEmpty(t *testing.T) {
+	src := newStubStalledData()
+	src.issues["alterminal/agents"][1] = workflow.Issue{
+		Number: 1, Title: "無引用", State: "open",
+		Body:       "沒有任何引用",
+		Repository: &workflow.Repository{FullName: "alterminal/agents"},
+	}
+	newStubStalledEnv(t, src, time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	stdout, _, code := run("xrefs", "alterminal/agents", "1")
+	if code != 0 {
+		t.Fatalf("xrefs 應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("無引用應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringXrefsUsage 驗證參數不足／格式錯誤 → exit 2。
+func TestWiringXrefsUsage(t *testing.T) {
+	newStubStalledEnv(t, newStubStalledData(), time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	if _, _, code := run("xrefs"); code != int(ExitUsage) {
+		t.Fatalf("xrefs 無參數應回 ExitUsage，得到 %d", code)
+	}
+	if _, _, code := run("xrefs", "alterminal/agents"); code != int(ExitUsage) {
+		t.Fatalf("xrefs 缺編號應回 ExitUsage，得到 %d", code)
+	}
+	if _, _, code := run("xrefs", "not-a-repo", "1"); code != int(ExitUsage) {
+		t.Fatalf("xrefs repo 格式錯誤應回 ExitUsage，得到 %d", code)
+	}
+	if _, _, code := run("xrefs", "alterminal/agents", "abc"); code != int(ExitUsage) {
+		t.Fatalf("xrefs 編號非數字應回 ExitUsage，得到 %d", code)
+	}
+}
+
+// TestWiringXrefsNotFound 驗證 404 → exit 3（API 錯誤）。
+func TestWiringXrefsNotFound(t *testing.T) {
+	src := newStubStalledData()
+	src.getErr = &gitea.ErrAPI{Op: "GET /repos/alterminal/agents/issues/99", StatusCode: 404}
+	newStubStalledEnv(t, src, time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC))
+	_, stderr, code := run("xrefs", "alterminal/agents", "99")
+	if code != int(ExitAPI) {
+		t.Fatalf("xrefs 404 應回 ExitAPI(%d)，得到 %d（stderr=%q）", int(ExitAPI), code, stderr)
+	}
+}

internal/cli/version_test.go

@@ -0,0 +1,33 @@
+// version_test.go 驗證版本字串解析：go test 環境 Main.Version 為 "(devel)"
+// 時應退回開發版本號；tag 與 pseudo-version 行為由建置驗證涵蓋
+// （go install pkg@tag 顯示 tag；clone 建置顯示 pseudo-version）。
+package cli
+
+import (
+	"strings"
+	"testing"
+)
+
+// TestBuildVersionFallsBackToDev 確認本地測試環境（Main.Version == "(devel)"）
+// 退回 Version；同時確保輸出是可讀版本字串（非空、無括號）。
+func TestBuildVersionFallsBackToDev(t *testing.T) {
+	v := buildVersion()
+	if v == "" {
+		t.Fatalf("buildVersion 不應為空")
+	}
+	if strings.ContainsAny(v, "()") {
+		t.Errorf("buildVersion 不應含內部佔位（括號），得到：%q", v)
+	}
+}
+
+// TestRunVersionUsesBuildVersion 確認 version 命令輸出 buildVersion 的結果。
+func TestRunVersionUsesBuildVersion(t *testing.T) {
+	stdout, _, code := run("version")
+	if code != 0 {
+		t.Fatalf("version 應回 0，得到 %d", code)
+	}
+	want := "teai version " + buildVersion()
+	if !strings.Contains(stdout, want) {
+		t.Errorf("version 輸出應含 %q，得到：%q", want, stdout)
+	}
+}

internal/cli/workflow_commands.go

@@ -1,5 +1,5 @@
 // workflow_commands.go — gitea.py 工作流命令的 CLI 接線（#6）：
-// whoami、orgs、members [--has-work]、mine、pulls [--mine|--reviewer] [--repo]、next。
+// whoami、role、orgs、members [--has-work]、mine、pulls [--mine|--reviewer] [--repo]、next。
 //
 // 輸出走 internal/gitea 的 Printer（--output json|table）；錯誤經 cli.exitCodeFor
 // 映射結束碼（用法 2／API 3）。token 解析選序見 internal/gitea/auth.go。
@@ -20,6 +20,7 @@ func init() {
 		commands[c.name] = c
 	}
 	register(&command{name: "whoami", usage: "目前帳號", run: runWhoami})
+	register(&command{name: "role", usage: "目前角色（Supervisor→supervisor，Agents→worker）", run: runRole})
 	register(&command{name: "orgs", usage: "我所屬的組織", run: runOrgs})
 	register(&command{name: "members", usage: "Agents 團隊成員；--has-work 只列有未完成工作者", run: runMembers})
 	register(&command{name: "mine", usage: "分派給我、待跟進的 issues", run: runMine})
@@ -31,6 +32,11 @@ func init() {
 // errNoRepoFlag 是 --repo 值格式錯誤。
 var errNoRepoFlag = errors.New("--repo 需為 owner/repo 形式")
 
+// newScannerFunc 建立工作流 Scanner；正式環境用 API client。
+// 宣告為變數讓接線層測試可注入假 client（不走網路），
+// 彌補 workflow 套件單元測試覆蓋不到 CLI 分派路徑的缺口。
+var newScannerFunc = newWorkflowClient
+
 // newWorkflowClient 依全域選項建立 workflow 所需的 API client。
 func newWorkflowClient(env *Env) (*workflow.Scanner, error) {
 	token, _, err := gitea.ResolveToken(gitea.AuthOptions{
@@ -58,7 +64,7 @@ func runWhoami(env *Env, args []string) error {
 	if len(args) != 0 {
 		return &ErrUsage{Msg: "whoami 不接受參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -72,12 +78,35 @@ func runWhoami(env *Env, args []string) error {
 	)
 }
 
+// runRole：teai role。不在 Supervisor／Agents 團隊時輸出 null（exit 0）。
+func runRole(env *Env, args []string) error {
+	if len(args) != 0 {
+		return &ErrUsage{Msg: "role 不接受參數"}
+	}
+	s, err := newScannerFunc(env)
+	if err != nil {
+		return err
+	}
+	role, err := s.Role()
+	if err != nil {
+		return err
+	}
+	p := printer(env)
+	if role == "" {
+		return p.PrintNull()
+	}
+	return p.PrintOne(
+		[]gitea.Field{{Name: "role"}},
+		gitea.Values{role},
+	)
+}
+
 // runOrgs：teai orgs。
 func runOrgs(env *Env, args []string) error {
 	if len(args) != 0 {
 		return &ErrUsage{Msg: "orgs 不接受參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -100,13 +129,13 @@ func runMembers(env *Env, args []string) error {
 	fs := flag.NewFlagSet("teai members", flag.ContinueOnError)
 	fs.SetOutput(env.Err)
 	hasWork := fs.Bool("has-work", false, "只列出有未完成工作的成員")
-	if err := fs.Parse(args); err != nil {
-		return &ErrUsage{Msg: err.Error()}
+	if err := parseFlags(fs, args); err != nil {
+		return err
 	}
 	if fs.NArg() != 0 {
 		return &ErrUsage{Msg: "members 不接受位置參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -126,7 +155,7 @@ func runMine(env *Env, args []string) error {
 	if len(args) != 0 {
 		return &ErrUsage{Msg: "mine 不接受參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -149,8 +178,8 @@ func runPulls(env *Env, args []string) error {
 	mine := fs.Bool("mine", false, "限定作者是目前帳號")
 	reviewer := fs.Bool("reviewer", false, "限定自己是 requested reviewer")
 	repo := fs.String("repo", "", "限定單一倉庫（owner/repo）")
-	if err := fs.Parse(args); err != nil {
-		return &ErrUsage{Msg: err.Error()}
+	if err := parseFlags(fs, args); err != nil {
+		return err
 	}
 	if fs.NArg() != 0 {
 		return &ErrUsage{Msg: "pulls 不接受位置參數"}
@@ -166,7 +195,7 @@ func runPulls(env *Env, args []string) error {
 		}
 		owner, name = parts[0], parts[1]
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -199,7 +228,7 @@ func runNext(env *Env, args []string) error {
 	if len(args) != 0 {
 		return &ErrUsage{Msg: "next 不接受參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}

internal/cli/workflow_commands_test.go

@@ -0,0 +1,298 @@
+// workflow_commands_test.go — CLI 接線層測試：驗證 Run→dispatch→命令 flagset
+// 的完整路徑。ceo 於 PR #13 審核指出帶旗標命令（members --has-work、
+// pulls --mine/--reviewer）在 CLI 層全部 exit 2，workflow 單元測試覆蓋不到
+// 這條路徑——本檔以注入假 client 的方式補上，不走網路。
+package cli
+
+import (
+	"strings"
+	"testing"
+
+	"gitea.alterminal.com/alterminal/teai/internal/workflow"
+)
+
+// stubClient 以記憶體資料實作 workflow.Client（最小集，僅供接線測試）。
+type stubClient struct {
+	currentUser string
+	orgs        []workflow.Org
+	teams       map[string][]workflow.Team
+	members     map[int64][]string
+	repos       map[string][]workflow.Repo
+	issues      map[string][]workflow.Issue
+	pulls       map[string][]workflow.PullRequest
+	comments    map[string][]workflow.Comment
+}
+
+func (c *stubClient) CurrentUser() (string, error) { return c.currentUser, nil }
+func (c *stubClient) ListOrgs() ([]string, error) {
+	out := make([]string, 0, len(c.orgs))
+	for _, o := range c.orgs {
+		out = append(out, o.Account())
+	}
+	return out, nil
+}
+func (c *stubClient) ListTeams(org string) ([]workflow.Team, error) {
+	return c.teams[org], nil
+}
+func (c *stubClient) ListTeamMembers(teamID int64) ([]string, error) {
+	return c.members[teamID], nil
+}
+func (c *stubClient) ListOrgRepos(org string) ([]workflow.Repo, error) {
+	return c.repos[org], nil
+}
+func (c *stubClient) ListIssues(owner, repo string) ([]workflow.Issue, error) {
+	return c.issues[owner+"/"+repo], nil
+}
+func (c *stubClient) ListPulls(owner, repo string) ([]workflow.PullRequest, error) {
+	return c.pulls[owner+"/"+repo], nil
+}
+func (c *stubClient) ListComments(owner, repo string, number int64) ([]workflow.Comment, error) {
+	return c.comments[owner+"/"+repo], nil
+}
+
+// newStubEnv 注入假 client，回傳還原函式（測試結束時呼叫）。
+func newStubEnv(t *testing.T, c *stubClient) {
+	t.Helper()
+	orig := newScannerFunc
+	newScannerFunc = func(env *Env) (*workflow.Scanner, error) {
+		return &workflow.Scanner{Client: c}, nil
+	}
+	t.Cleanup(func() { newScannerFunc = orig })
+}
+
+// newStubData 建構標準情境：alterminal 組織、Agents 團隊、teai 倉庫。
+func newStubData() *stubClient {
+	return &stubClient{
+		currentUser: "alex",
+		orgs:        []workflow.Org{{UserName: "alterminal"}},
+		teams:       map[string][]workflow.Team{"alterminal": {{ID: 1, Name: "Agents"}}},
+		members:     map[int64][]string{1: {"alex", "max", "queena"}},
+		repos:       map[string][]workflow.Repo{"alterminal": {{Name: "teai"}}},
+		issues:      map[string][]workflow.Issue{},
+		pulls:       map[string][]workflow.PullRequest{},
+		comments:    map[string][]workflow.Comment{},
+	}
+}
+
+// TestWiringMembersHasWork 驗證 members --has-work 不再被攔成 exit 2。
+func TestWiringMembersHasWork(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("members", "--has-work")
+	if code != 0 {
+		t.Fatalf("members --has-work 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	// 無未完成工作 → 空輸出（每行一個帳號，無帳號即無輸出）。
+	if strings.TrimSpace(stdout) != "" {
+		t.Fatalf("無工作時 members --has-work 應無輸出，得到 %q", stdout)
+	}
+}
+
+// TestWiringPullsMine 驗證 pulls --mine 不再被攔成 exit 2。
+func TestWiringPullsMine(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("pulls", "--mine")
+	if code != 0 {
+		t.Fatalf("pulls --mine 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("pulls --mine 空清單應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringPullsReviewer 驗證 pulls --reviewer 不再被攔成 exit 2。
+func TestWiringPullsReviewer(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("pulls", "--reviewer")
+	if code != 0 {
+		t.Fatalf("pulls --reviewer 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("pulls --reviewer 空清單應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringPullsRepoFilter 驗證 --repo 旗標可解析且值可帶斜線。
+func TestWiringPullsRepoFilter(t *testing.T) {
+	newStubEnv(t, newStubData())
+	_, _, code := run("pulls", "--repo", "alterminal/teai")
+	if code != 0 {
+		t.Fatalf("pulls --repo alterminal/teai 應回 0，得到 %d", code)
+	}
+	// --repo 值格式錯誤 → exit 2。
+	_, _, code = run("pulls", "--repo", "not-a-repo")
+	if code != int(ExitUsage) {
+		t.Fatalf("pulls --repo not-a-repo 應回 ExitUsage(%d)，得到 %d", int(ExitUsage), code)
+	}
+}
+
+// TestWiringGlobalAfterCommandFlag 驗證命令旗標與全域選項交錯出現。
+func TestWiringGlobalAfterCommandFlag(t *testing.T) {
+	newStubEnv(t, newStubData())
+	// members --has-work --output table：命令旗標在前、全域選項在後。
+	stdout, _, code := run("members", "--has-work", "--output", "table")
+	if code != 0 {
+		t.Fatalf("members --has-work --output table 應回 0，得到 %d", code)
+	}
+	if strings.Contains(stdout, "--has-work") {
+		t.Fatalf("全域剖析不應把 --has-work 當成全域選項處理：%q", stdout)
+	}
+}
+
+// TestWiringMembersAll 驗證 members 不帶旗標仍正常（回歸保護）。
+func TestWiringMembersAll(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("members")
+	if code != 0 {
+		t.Fatalf("members 應回 0，得到 %d", code)
+	}
+	for _, want := range []string{"alex", "max", "queena"} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("members 輸出應含 %q，得到 %q", want, stdout)
+		}
+	}
+}
+
+// TestWiringMine 驗證 mine 空清單輸出 []（與 gitea.py 空輸出的差異見 README）。
+func TestWiringMine(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("mine")
+	if code != 0 {
+		t.Fatalf("mine 應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "[]" {
+		t.Fatalf("mine 空清單應輸出 []，得到 %q", stdout)
+	}
+}
+
+// TestWiringNextNull 驗證 next 無工作輸出 null、exit 0。
+func TestWiringNextNull(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("next")
+	if code != 0 {
+		t.Fatalf("next 應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "null" {
+		t.Fatalf("next 無工作應輸出 null，得到 %q", stdout)
+	}
+}
+
+// TestWiringNextTable 驗證 teai next --output table（README 範例）。
+func TestWiringNextTable(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("next", "--output", "table")
+	if code != 0 {
+		t.Fatalf("next --output table 應回 0，得到 %d", code)
+	}
+	if !strings.Contains(stdout, "(none)") {
+		t.Fatalf("next --output table 無工作應輸出 (none)，得到 %q", stdout)
+	}
+}
+
+// TestWiringNextWithPull 驗證有工作時 next 輸出 JSON 物件（role=author）。
+func TestWiringNextWithPull(t *testing.T) {
+	c := newStubData()
+	c.pulls["alterminal/teai"] = []workflow.PullRequest{{
+		Number: 13,
+		Title:  "gitea.py 工作流命令 Go 化",
+		User:   &workflow.User{UserName: "alex"},
+	}}
+	c.comments["alterminal/teai"] = []workflow.Comment{
+		{CreatedAt: "2026-09-10T00:44:00Z", User: &workflow.User{UserName: "ceo"}},
+	}
+	newStubEnv(t, c)
+	stdout, _, code := run("next")
+	if code != 0 {
+		t.Fatalf("next 應回 0，得到 %d", code)
+	}
+	for _, want := range []string{`"type":"pull"`, `"role":"author"`, `"number":13`} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("next 輸出應含 %q，得到 %q", want, stdout)
+		}
+	}
+}
+
+// TestWiringWhoamiOrgs 驗證 whoami／orgs 的接線輸出。
+func TestWiringWhoamiOrgs(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("whoami")
+	if code != 0 || !strings.Contains(stdout, "alex") {
+		t.Fatalf("whoami code=%d stdout=%q", code, stdout)
+	}
+	stdout, _, code = run("orgs")
+	if code != 0 || !strings.Contains(stdout, "alterminal") {
+		t.Fatalf("orgs code=%d stdout=%q", code, stdout)
+	}
+}
+
+// TestWiringRoleWorker 驗證 Agents 成員的 role 輸出 worker。
+func TestWiringRoleWorker(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("role")
+	if code != 0 {
+		t.Fatalf("role 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	if strings.TrimSpace(stdout) != `{"role":"worker"}` {
+		t.Fatalf("Agents 成員 role 應輸出 worker，得到 %q", stdout)
+	}
+}
+
+// TestWiringRoleSupervisor 驗證 Supervisor 成員的 role 輸出 supervisor。
+func TestWiringRoleSupervisor(t *testing.T) {
+	c := newStubData()
+	c.teams["alterminal"] = []workflow.Team{
+		{ID: 1, Name: "Agents"},
+		{ID: 2, Name: "Supervisor"},
+	}
+	c.members[2] = []string{"alex"}
+	newStubEnv(t, c)
+	stdout, _, code := run("role")
+	if code != 0 {
+		t.Fatalf("role 應回 0，得到 %d（stdout=%q）", code, stdout)
+	}
+	if strings.TrimSpace(stdout) != `{"role":"supervisor"}` {
+		t.Fatalf("Supervisor 成員 role 應輸出 supervisor，得到 %q", stdout)
+	}
+}
+
+// TestWiringRoleNone 驗證不在任一角色團隊時輸出 null、exit 0。
+func TestWiringRoleNone(t *testing.T) {
+	c := newStubData()
+	c.currentUser = "outsider"
+	newStubEnv(t, c)
+	stdout, _, code := run("role")
+	if code != 0 {
+		t.Fatalf("role 無角色應回 0，得到 %d", code)
+	}
+	if strings.TrimSpace(stdout) != "null" {
+		t.Fatalf("role 無角色應輸出 null，得到 %q", stdout)
+	}
+}
+
+// TestWiringRoleRejectsArgs 驗證 role 不接受參數。
+func TestWiringRoleRejectsArgs(t *testing.T) {
+	newStubEnv(t, newStubData())
+	_, _, code := run("role", "extra")
+	if code != int(ExitUsage) {
+		t.Fatalf("role extra 應回 ExitUsage(%d)，得到 %d", int(ExitUsage), code)
+	}
+}
+
+// TestWiringRoleTable 驗證 teai role --output table。
+func TestWiringRoleTable(t *testing.T) {
+	newStubEnv(t, newStubData())
+	stdout, _, code := run("role", "--output", "table")
+	if code != 0 {
+		t.Fatalf("role --output table 應回 0，得到 %d", code)
+	}
+	if !strings.Contains(stdout, "worker") {
+		t.Fatalf("role --output table 應含 worker，得到 %q", stdout)
+	}
+}
+
+// TestWiringVersionRejectsArgs 驗證 version 不接受參數（新剖析語義下仍 exit 2）。
+func TestWiringVersionRejectsArgs(t *testing.T) {
+	_, _, code := run("version", "--wat")
+	if code != int(ExitUsage) {
+		t.Fatalf("version --wat 應回 ExitUsage(%d)，得到 %d", int(ExitUsage), code)
+	}
+}

internal/dailyops/dailyops.go

@@ -11,6 +11,7 @@ import (
 	"fmt"
 	"net/url"
 	"strconv"
+	"strings"
 
 	"gitea.alterminal.com/alterminal/teai/internal/gitea"
 )
@@ -119,8 +120,10 @@ type Pull struct {
 // pullRef 是 PR 的 head／base 參照。
 type pullRef struct {
 	Ref  string `json:"ref"`
+	SHA  string `json:"sha"`
 	Repo *struct {
 		FullName string `json:"full_name"`
+		CloneURL string `json:"clone_url"`
 	} `json:"repo"`
 }
 
@@ -165,14 +168,18 @@ func repoPath(owner, repo string) string {
 }
 
 // ListIssues 列出倉庫 issues。state：open｜closed｜all（預設 open）；
-// type=issues 排除 PR（Gitea 的 issues 端點會連 PR 一起回）。
-func (o *Ops) ListIssues(ctx context.Context, owner, repo, state string) ([]Issue, error) {
+// labels 非空時以逗號連接傳給 API 的 labels 參數（Gitea labels 過濾，
+// 多標籤為 AND 語義）；type=issues 排除 PR（Gitea 的 issues 端點會連 PR 一起回）。
+func (o *Ops) ListIssues(ctx context.Context, owner, repo, state string, labels []string) ([]Issue, error) {
 	if state == "" {
 		state = "open"
 	}
+	// state 一律明確傳給 API：issues／milestones 端點省略 state 時預設
+	// open（#33），closed 項目會漏列；all 也不能省略。
 	extra := url.Values{}
-	if state != "all" {
 	extra.Set("state", state)
+	if len(labels) > 0 {
+		extra.Set("labels", strings.Join(labels, ","))
 	}
 	// type=issues：排除 PR（PR 在此端點帶 pull_request 欄位）。
 	extra.Set("type", "issues")
@@ -246,10 +253,10 @@ func (o *Ops) ListPulls(ctx context.Context, owner, repo, state string) ([]Pull,
 	if state == "" {
 		state = "open"
 	}
+	// state 一律明確傳給 API：pulls 端點省略 state 時雖回全部，仍明確
+	// 帶上，避免依賴端點預設值（#33）。
 	extra := url.Values{}
-	if state != "all" {
 	extra.Set("state", state)
-	}
 	var pulls []Pull
 	if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/pulls", gitea.ListOptions{Extra: extra}, &pulls); err != nil {
 		return nil, err
@@ -259,12 +266,93 @@ func (o *Ops) ListPulls(ctx context.Context, owner, repo, state string) ([]Pull,
 
 // GetPull 取得單一 PR。
 func (o *Ops) GetPull(ctx context.Context, owner, repo string, number int64) (*Pull, error) {
-	var pull Pull
+	var pr Pull
 	path := repoPath(owner, repo) + "/pulls/" + strconv.FormatInt(number, 10)
-	if err := o.Client.GetJSON(ctx, path, &pull); err != nil {
+	if err := o.Client.GetJSON(ctx, path, &pr); err != nil {
 		return nil, err
 	}
-	return &pull, nil
+	return &pr, nil
+}
+
+// Review 是 pull request 審核的精簡欄位。
+type Review struct {
+	ID        int64  `json:"ID"`
+	Number    int64  `json:"number"`
+	State     string `json:"state"`
+	Body      string `json:"body"`
+	Submitted string `json:"submitted_at"`
+	User      *User  `json:"user"`
+}
+
+// Author 回傳審核者帳號。
+func (r *Review) Author() string { return r.User.Name() }
+
+// ApprovePull 核准 PR（POST /repos/{owner}/{repo}/pulls/{n}/reviews，event=APPROVED）。
+// body 是審核意見，可為空。
+func (o *Ops) ApprovePull(ctx context.Context, owner, repo string, number int64, body string) (*Review, error) {
+	payload := map[string]any{
+		"event": "APPROVED",
+		"body":  body,
+	}
+	var review Review
+	path := repoPath(owner, repo) + "/pulls/" + strconv.FormatInt(number, 10) + "/reviews"
+	if err := o.Client.DoJSON(ctx, "POST", path, "", payload, &review); err != nil {
+		return nil, err
+	}
+	return &review, nil
+}
+
+// ClosePull 關閉 PR 不合併（PATCH /repos/{owner}/{repo}/pulls/{n}，state=closed）。
+func (o *Ops) ClosePull(ctx context.Context, owner, repo string, number int64) (*Pull, error) {
+	payload := map[string]any{"state": "closed"}
+	var pr Pull
+	path := repoPath(owner, repo) + "/pulls/" + strconv.FormatInt(number, 10)
+	if err := o.Client.DoJSON(ctx, "PATCH", path, "", payload, &pr); err != nil {
+		return nil, err
+	}
+	return &pr, nil
+}
+
+// HeadInfo 是 PR head 參照的完整資訊（checkout 用：同倉庫分支 or 跨倉庫 clone 網址）。
+type HeadInfo struct {
+	// Ref 是 head 分支名。
+	Ref string
+	// Repo 是 head 所屬倉庫（owner/name）；與目標倉庫相同時為空。
+	Repo string
+	// CloneURL 是 head 倉庫的 https clone 網址；同倉庫時為空。
+	CloneURL string
+	// SHA 是 head commit（暫不使用，保留給未來 reset/rebase 用）。
+	SHA string
+}
+
+// PullHeadInfo 取得 PR 的 head 資訊。同倉庫分支 → Repo/CloneURL 為空、只剩 Ref；
+// 跨倉庫 fork → Ref+Repo+CloneURL 齊備，checkout 改以 clone --branch Ref CloneURL。
+func (o *Ops) PullHeadInfo(ctx context.Context, owner, repo string, number int64) (*HeadInfo, error) {
+	pr, err := o.GetPull(ctx, owner, repo, number)
+	if err != nil {
+		return nil, err
+	}
+	info := &HeadInfo{Ref: pr.HeadRef()}
+	if pr.Head != nil {
+		info.SHA = pr.Head.SHA
+		if pr.Head.Repo != nil {
+			full := pr.Head.Repo.FullName
+			same := full != "" && full == owner+"/"+repo
+			if !same {
+				info.Repo = full
+				info.CloneURL = pr.Head.Repo.CloneURL
+			}
+		}
+	}
+	return info, nil
+}
+
+// String 依 head 來源輸出人類可讀描述（輸出用）。
+func (h *HeadInfo) String() string {
+	if h.Repo != "" {
+		return h.Repo + "#" + h.Ref
+	}
+	return h.Ref
 }
 
 // CreatePull 建立 PR。
@@ -320,10 +408,10 @@ func (o *Ops) ListMilestones(ctx context.Context, owner, repo, state string) ([]
 	if state == "" {
 		state = "open"
 	}
+	// state 一律明確傳給 API：milestones 端點省略 state 時預設 open
+	// （#33），closed 項目會漏列。
 	extra := url.Values{}
-	if state != "all" {
 	extra.Set("state", state)
-	}
 	var ms []Milestone
 	if err := o.Client.ListAll(ctx, repoPath(owner, repo)+"/milestones", gitea.ListOptions{Extra: extra}, &ms); err != nil {
 		return nil, err
@@ -382,3 +470,64 @@ func (o *Ops) CallAPIDirect(ctx context.Context, method, path, rawQuery string,
 	}
 	return o.Client.DoRaw(ctx, method, path, rawQuery, data)
 }
+
+// ---- organizations（#45，tea organizations 對等）----
+
+// Organization 是帳號所屬／可存取組織的精簡欄位
+// （GET /user/orgs、POST /orgs 回應共用）。name 是帳號名、
+// full_name 是顯示名稱（如 "Alterminal Co., Ltd."），兩者不同。
+type Organization struct {
+	UserName    string `json:"username"`
+	Name        string `json:"name"`
+	FullName    string `json:"full_name"`
+	Website     string `json:"website"`
+	Location    string `json:"location"`
+	Description string `json:"description"`
+	Visibility  string `json:"visibility"`
+}
+
+// Account 回傳組織帳號名：先 username，缺漏時回退 name
+// （同 workflow.Org.Account 的取值順序）。
+func (o *Organization) Account() string {
+	if o.UserName != "" {
+		return o.UserName
+	}
+	return o.Name
+}
+
+// ListMyOrganizations 列出自己可存取的組織（GET /user/orgs，分頁）。
+// tea organizations list 的對等端點；teai orgs（工作流）輸出帳號清單，
+// 本指令輸出完整欄位供日常操作使用。
+func (o *Ops) ListMyOrganizations(ctx context.Context) ([]Organization, error) {
+	var orgs []Organization
+	if err := o.Client.ListAll(ctx, "/user/orgs", gitea.ListOptions{}, &orgs); err != nil {
+		return nil, err
+	}
+	return orgs, nil
+}
+
+// CreateOrganization 建立組織（POST /orgs）。name 必填；其餘欄位可空。
+// visibility：public|limited|private（空值交由服務端預設）。
+func (o *Ops) CreateOrganization(ctx context.Context, name, fullName, description, website, location, visibility string) (*Organization, error) {
+	payload := map[string]any{
+		"username":    name,
+		"full_name":   fullName,
+		"description": description,
+		"website":     website,
+		"location":    location,
+	}
+	if visibility != "" {
+		payload["visibility"] = visibility
+	}
+	var org Organization
+	if err := o.Client.DoJSON(ctx, "POST", "/orgs", "", payload, &org); err != nil {
+		return nil, err
+	}
+	return &org, nil
+}
+
+// DeleteOrganization 刪除組織（DELETE /orgs/{org}）。
+func (o *Ops) DeleteOrganization(ctx context.Context, org string) error {
+	path := "/orgs/" + url.PathEscape(org)
+	return o.Client.DoJSON(ctx, "DELETE", path, "", nil, nil)
+}

internal/gitea/auth.go

@@ -1,7 +1,7 @@
 // auth.go — 認證來源的解析與選序。
 //
 // 選序（README「全域介面」）：--token 旗標 → TEAI_TOKEN 環境變數 →
-// tea 登入組態（TEA_CONFIG 指定的路徑，或 ~/.config/tea/config.yml）。
+// teai 登入組態（TEAI_CONFIG 指定的路徑，或 ~/.config/teai/config.yml）。
 // token 一律只在記憶體傳遞，不寫入輸出、日誌或錯誤訊息。
 package gitea
 
@@ -23,8 +23,8 @@ const (
 	SourceFlag
 	// SourceEnv 是 TEAI_TOKEN 環境變數。
 	SourceEnv
-	// SourceTeaConfig 是 tea 登入組態。
-	SourceTeaConfig
+	// SourceConfig 是 teai 登入組態。
+	SourceConfig
 )
 
 // String 回傳來源名稱（診斷用）。
@@ -34,8 +34,8 @@ func (s TokenSource) String() string {
 		return "flag"
 	case SourceEnv:
 		return "env"
-	case SourceTeaConfig:
-		return "tea-config"
+	case SourceConfig:
+		return "config"
 	default:
 		return "none"
 	}
@@ -62,12 +62,12 @@ func osReadFile(path string) ([]byte, error) {
 type AuthOptions struct {
 	// FlagToken 是 --token 旗標值；空字串表示未提供。
 	FlagToken string
-	// SiteURL 是目標站點（用來比對 tea 組態中的 login url）。
+	// SiteURL 是目標站點（用來比對組態中的 login url）。
 	SiteURL string
 	// Env 是環境變數查詢；nil 時用 os.LookupEnv。
 	Env EnvLookup
-	// ConfigPath 是 tea 組態的明確路徑（TEA_CONFIG 或 --config）。
-	// 空字串表示用預設 ~/.config/tea/config.yml。
+	// ConfigPath 是 teai 組態的明確路徑（TEAI_CONFIG 或 --config）。
+	// 空字串表示用預設 ~/.config/teai/config.yml。
 	ConfigPath string
 	// Home 是使用者家目錄（展開 ~ 用）；空字串表示不展開。
 	Home string
@@ -75,7 +75,7 @@ type AuthOptions struct {
 	ReadFile ReadFileFunc
 }
 
-// ResolveToken 依選序解析 token：flag → env(TEAI_TOKEN) → tea 組態。
+// ResolveToken 依選序解析 token：flag → env(TEAI_TOKEN) → teai 組態。
 //
 // 找不到任何 token 時回傳 ("", SourceNone, nil)——查詢公開端點不需要
 // token，是否為錯由呼叫端依情境決定。組態檔存在但解析失敗（格式錯誤）
@@ -93,8 +93,8 @@ func ResolveToken(opts AuthOptions) (string, TokenSource, error) {
 	}
 	path := opts.ConfigPath
 	if path == "" {
-		// --config 未給時，先看 TEA_CONFIG 環境變數。
-		if p, ok := env("TEA_CONFIG"); ok && strings.TrimSpace(p) != "" {
+		// --config 未給時，先看 TEAI_CONFIG 環境變數。
+		if p, ok := env("TEAI_CONFIG"); ok && strings.TrimSpace(p) != "" {
 			path = strings.TrimSpace(p)
 		}
 	}
@@ -110,7 +110,7 @@ func ResolveToken(opts AuthOptions) (string, TokenSource, error) {
 		if home == "" {
 			return "", SourceNone, nil
 		}
-		path = filepath.Join(home, ".config", "tea", "config.yml")
+		path = filepath.Join(home, ".config", "teai", "config.yml")
 	}
 	if path == "" {
 		return "", SourceNone, nil
@@ -124,33 +124,32 @@ func ResolveToken(opts AuthOptions) (string, TokenSource, error) {
 		// 組態不存在或讀不到：視為沒有這個來源，不是錯誤。
 		return "", SourceNone, nil
 	}
-	login, err := parseTeaConfig(data, opts.SiteURL)
+	login, err := parseConfig(data, opts.SiteURL)
 	if err != nil {
-		return "", SourceNone, fmt.Errorf("gitea: parse tea config %s: %w", path, err)
+		return "", SourceNone, fmt.Errorf("gitea: parse config %s: %w", path, err)
 	}
 	if login.Token == "" {
 		return "", SourceNone, nil
 	}
-	return login.Token, SourceTeaConfig, nil
+	return login.Token, SourceConfig, nil
 }
 
-// teaLogin 是 tea 組態中一筆登入資料（只取 teai 需要的欄位）。
-type teaLogin struct {
+// configLogin 是組態中一筆登入資料（只取解析 token 需要的欄位）。
+type configLogin struct {
 	Name    string
 	URL     string
 	Token   string
 	Default bool
 }
 
-// parseTeaConfig 從 tea 的 config.yml 內容挑出最匹配 siteURL 的登入：
+// parseConfig 從 teai 的 config.yml 內容挑出最匹配 siteURL 的登入：
 // url 主機相同者優先，其中 default: true 最優，否則取第一筆；
 // 都不相同時退而取 default: true，再退第一筆。
 //
-// 僅解析 tea 實際寫出的 YAML 子集：頂層 `logins:` 清單，項目為
-// `key: value` 的平面映射。不處理錨點、多文件、巢狀清單——tea 不會寫出
-// 這些，遇到也不該默默誤讀。
-func parseTeaConfig(data []byte, siteURL string) (teaLogin, error) {
-	var logins []teaLogin
+// 僅解析 teai 寫出的 YAML 子集：頂層 `logins:` 清單，項目為
+// `key: value` 的平面映射。不處理錨點、多文件、巢狀清單。
+func parseConfig(data []byte, siteURL string) (configLogin, error) {
+	var logins []configLogin
 	inLogins := false
 	cur := -1 // 目前項目在 logins 的索引；-1 表示尚未開始任何項目
 	for lineNo, raw := range strings.Split(string(data), "\n") {
@@ -171,26 +170,26 @@ func parseTeaConfig(data []byte, siteURL string) (teaLogin, error) {
 		}
 		if strings.HasPrefix(trimmed, "- ") || trimmed == "-" {
 			// 新的清單項目；`- name: x` 形式同行帶鍵值。
-			logins = append(logins, teaLogin{})
+			logins = append(logins, configLogin{})
 			cur = len(logins) - 1
 			rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-"))
 			if rest != "" {
 				if err := applyLoginField(&logins[cur], rest, lineNo+1); err != nil {
-					return teaLogin{}, err
+					return configLogin{}, err
 				}
 			}
 			continue
 		}
 		if cur < 0 {
 			// logins: 底下卻不是清單項目——不是預期的結構。
-			return teaLogin{}, fmt.Errorf("line %d: expected list item under logins:", lineNo+1)
+			return configLogin{}, fmt.Errorf("line %d: expected list item under logins:", lineNo+1)
 		}
 		if err := applyLoginField(&logins[cur], trimmed, lineNo+1); err != nil {
-			return teaLogin{}, err
+			return configLogin{}, err
 		}
 	}
 	if len(logins) == 0 {
-		return teaLogin{}, nil
+		return configLogin{}, nil
 	}
 	wantHost := hostOf(siteURL)
 	// 第一輪：主機相符者，default 優先，否則第一筆。
@@ -219,7 +218,7 @@ func parseTeaConfig(data []byte, siteURL string) (teaLogin, error) {
 }
 
 // applyLoginField 把 `key: value` 套用到 login；value 的引號會剝除。
-func applyLoginField(l *teaLogin, kv string, lineNo int) error {
+func applyLoginField(l *configLogin, kv string, lineNo int) error {
 	key, value, ok := strings.Cut(kv, ":")
 	if !ok {
 		return fmt.Errorf("line %d: expected key: value, got %q", lineNo, kv)

internal/gitea/auth_test.go

@@ -1,5 +1,5 @@
-// auth_test.go 驗證認證來源選序（--token → TEAI_TOKEN → tea 組態）
-// 與 tea 組態解析。
+// auth_test.go 驗證認證來源選序（--token → TEAI_TOKEN → teai 組態）
+// 與組態解析。
 package gitea
 
 import (
@@ -25,7 +25,7 @@ func fakeReadFile(m map[string]string) ReadFileFunc {
 	}
 }
 
-const sampleTeaConfig = `logins:
+const sampleConfig = `logins:
     - name: other.example.com
       url: https://other.example.com
       token: other-token
@@ -43,7 +43,7 @@ func TestResolveTokenOrdering(t *testing.T) {
 		SiteURL: "https://gitea.alterminal.com",
 		Env:     fakeEnv(nil),
 		ReadFile: fakeReadFile(map[string]string{
-			"/cfg/config.yml": sampleTeaConfig,
+			"/cfg/config.yml": sampleConfig,
 		}),
 		ConfigPath: "/cfg/config.yml",
 	}
@@ -67,11 +67,11 @@ func TestResolveTokenOrdering(t *testing.T) {
 		}
 	})
 
-	t.Run("tea config used when flag and env absent", func(t *testing.T) {
+	t.Run("config used when flag and env absent", func(t *testing.T) {
 		opts := base
 		tok, src, err := ResolveToken(opts)
-		if err != nil || tok != "site-token" || src != SourceTeaConfig {
-			t.Fatalf("want site-token/tea-config, got %q/%v (err %v)", tok, src, err)
+		if err != nil || tok != "site-token" || src != SourceConfig {
+			t.Fatalf("want site-token/config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 
@@ -88,8 +88,8 @@ func TestResolveTokenOrdering(t *testing.T) {
 		opts := base
 		opts.Env = fakeEnv(map[string]string{"TEAI_TOKEN": "   "})
 		tok, src, err := ResolveToken(opts)
-		if err != nil || tok != "site-token" || src != SourceTeaConfig {
-			t.Fatalf("want site-token/tea-config, got %q/%v (err %v)", tok, src, err)
+		if err != nil || tok != "site-token" || src != SourceConfig {
+			t.Fatalf("want site-token/config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 
@@ -103,36 +103,54 @@ func TestResolveTokenOrdering(t *testing.T) {
 		}
 	})
 
-	t.Run("TEA_CONFIG points config path", func(t *testing.T) {
+	t.Run("TEAI_CONFIG points config path", func(t *testing.T) {
 		opts := base
-		opts.ConfigPath = "" // 不用 --config，改用 TEA_CONFIG
+		opts.ConfigPath = "" // 不用 --config，改用 TEAI_CONFIG
 		opts.Env = fakeEnv(map[string]string{
-			"TEA_CONFIG": "/cfg/config.yml",
+			"TEAI_CONFIG": "/cfg/config.yml",
 		})
 		tok, src, err := ResolveToken(opts)
-		if err != nil || tok != "site-token" || src != SourceTeaConfig {
-			t.Fatalf("want site-token/tea-config via TEA_CONFIG, got %q/%v (err %v)", tok, src, err)
+		if err != nil || tok != "site-token" || src != SourceConfig {
+			t.Fatalf("want site-token/config via TEAI_CONFIG, got %q/%v (err %v)", tok, src, err)
 		}
 	})
 
-	t.Run("explicit --config beats TEA_CONFIG", func(t *testing.T) {
+	t.Run("explicit --config beats TEAI_CONFIG", func(t *testing.T) {
 		opts := base // ConfigPath = /cfg/config.yml（有 site-token）
 		opts.Env = fakeEnv(map[string]string{
-			"TEA_CONFIG": "/cfg/other.yml",
+			"TEAI_CONFIG": "/cfg/other.yml",
 		})
 		read := fakeReadFile(map[string]string{
-			"/cfg/config.yml": sampleTeaConfig,
+			"/cfg/config.yml": sampleConfig,
 			"/cfg/other.yml":  "logins:\n    - name: x\n      url: https://gitea.alterminal.com\n      token: other\n      default: true\n",
 		})
 		opts.ReadFile = read
 		tok, src, err := ResolveToken(opts)
-		if err != nil || tok != "site-token" || src != SourceTeaConfig {
+		if err != nil || tok != "site-token" || src != SourceConfig {
 			t.Fatalf("want site-token from explicit config, got %q/%v (err %v)", tok, src, err)
 		}
 	})
+
+	t.Run("TEA_CONFIG is ignored", func(t *testing.T) {
+		opts := AuthOptions{
+			SiteURL: "https://gitea.alterminal.com",
+			Env: fakeEnv(map[string]string{
+				"TEA_CONFIG": "/cfg/config.yml",
+			}),
+			ReadFile: fakeReadFile(map[string]string{
+				"/cfg/config.yml":               sampleConfig,
+				"/home/.config/teai/config.yml": "logins:\n    - name: x\n      url: https://gitea.alterminal.com\n      token: teai-token\n      default: true\n",
+			}),
+			Home: "/home",
+		}
+		tok, src, err := ResolveToken(opts)
+		if err != nil || tok != "teai-token" || src != SourceConfig {
+			t.Fatalf("want teai-token from teai config, got %q/%v (err %v)", tok, src, err)
+		}
+	})
 }
 
-func TestParseTeaConfigPicksMatchingLogin(t *testing.T) {
+func TestParseConfigPicksMatchingLogin(t *testing.T) {
 	t.Run("host match preferred over default", func(t *testing.T) {
 		cfg := `logins:
     - name: other
@@ -144,7 +162,7 @@ func TestParseTeaConfigPicksMatchingLogin(t *testing.T) {
       token: right-token
       default: false
 `
-		login, err := parseTeaConfig([]byte(cfg), "https://gitea.alterminal.com")
+		login, err := parseConfig([]byte(cfg), "https://gitea.alterminal.com")
 		if err != nil {
 			t.Fatalf("parse error: %v", err)
 		}
@@ -155,7 +173,7 @@ func TestParseTeaConfigPicksMatchingLogin(t *testing.T) {
 
 	t.Run("quoted token unquoted", func(t *testing.T) {
 		cfg := "logins:\n    - name: t\n      url: https://gitea.alterminal.com\n      token: \"quoted-token\"\n      default: true\n"
-		login, err := parseTeaConfig([]byte(cfg), "https://gitea.alterminal.com")
+		login, err := parseConfig([]byte(cfg), "https://gitea.alterminal.com")
 		if err != nil {
 			t.Fatalf("parse error: %v", err)
 		}
@@ -166,14 +184,14 @@ func TestParseTeaConfigPicksMatchingLogin(t *testing.T) {
 
 	t.Run("malformed login entry errors", func(t *testing.T) {
 		cfg := "logins:\n    - name: t\n      url: https://gitea.alterminal.com\n      oops\n"
-		if _, err := parseTeaConfig([]byte(cfg), ""); err == nil {
+		if _, err := parseConfig([]byte(cfg), ""); err == nil {
 			t.Fatal("malformed line should error")
 		}
 	})
 
 	t.Run("no logins yields empty", func(t *testing.T) {
 		cfg := "preferences:\n    editor: false\n"
-		login, err := parseTeaConfig([]byte(cfg), "")
+		login, err := parseConfig([]byte(cfg), "")
 		if err != nil || login.Token != "" {
 			t.Fatalf("want empty login, got %+v (err %v)", login, err)
 		}

internal/gitea/config.go

@@ -0,0 +1,412 @@
+// config.go — teai 登入組態的讀取與行級編輯。
+//
+// 組態由 teai 自行管理（README 設計原則 5），不依賴 tea。寫入採「行級編輯」：
+// 只修改目標登入項目的所屬行，其餘內容（未知欄位、註解、空行與縮排）逐字
+// 保留。新增項目只寫 teai 使用的欄位：name／url／token／default／user。
+//
+// token 值只會進出這個套件的資料結構與組態檔本身，永遠不出現在錯誤訊息。
+package gitea
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+// LoginEntry 是組態檔中的一筆登入資料（編輯用，含 user 欄位）。
+type LoginEntry struct {
+	Name    string
+	URL     string
+	Token   string
+	Default bool
+	User    string
+}
+
+// loginItemSpan 標記 logins 清單中一個項目在檔案中的行範圍 [start, end)。
+type loginItemSpan struct {
+	name  string
+	start int
+	end   int
+}
+
+// configDoc 是解析後的組態檔：原始行與 logins 項目的位置資訊。
+type configDoc struct {
+	lines        []string
+	items        []loginItemSpan
+	loginsHeader int    // 「logins:」所在行；-1 表示沒有
+	itemIndent   string // 項目行的縮排（取第一個項目）；預設四格空白
+}
+
+// parseConfigDoc 掃描組態內容，定位 logins 清單與各項目的行範圍。
+// 只認識 teai 寫出的格式：頂層 `logins:` 加縮排的 `- key: value` 項目；
+// 其餘行原樣保留在 lines 中。
+func parseConfigDoc(data []byte) configDoc {
+	doc := configDoc{lines: splitLines(data), loginsHeader: -1, itemIndent: "    "}
+	inLogins := false
+	cur := -1
+	for i, raw := range doc.lines {
+		line := raw
+		trimmed := strings.TrimSpace(line)
+		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
+			continue
+		}
+		indent := line[:len(line)-len(strings.TrimLeft(line, " "))]
+		if indent == "" {
+			if inLogins && doc.loginsHeader >= 0 {
+				// 離開 logins 區段；listEnd 由最後一個項目的 end 決定，這裡不用記。
+			}
+			inLogins = strings.HasPrefix(trimmed, "logins:")
+			if inLogins && doc.loginsHeader < 0 {
+				doc.loginsHeader = i
+			}
+			cur = -1
+			continue
+		}
+		if !inLogins {
+			continue
+		}
+		if strings.HasPrefix(trimmed, "- ") || trimmed == "-" {
+			if cur >= 0 {
+				doc.items[cur].end = i
+			}
+			doc.items = append(doc.items, loginItemSpan{start: i, end: i + 1})
+			cur = len(doc.items) - 1
+			if len(doc.items) == 1 {
+				doc.itemIndent = indent
+			}
+			if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" {
+				if key, value, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(key) == "name" {
+					doc.items[cur].name = unquoteYAML(strings.TrimSpace(value))
+				}
+			}
+			continue
+		}
+		if cur >= 0 {
+			doc.items[cur].end = i + 1
+		}
+	}
+	return doc
+}
+
+// findItem 依名稱找項目；找不到回 -1。
+func (d configDoc) findItem(name string) int {
+	for i, it := range d.items {
+		if it.name == name {
+			return i
+		}
+	}
+	return -1
+}
+
+// fieldIndent 回傳項目內屬性行的縮排（項目縮排 + 兩格）。
+func (d configDoc) fieldIndent() string {
+	return d.itemIndent + "  "
+}
+
+// entryAt 取某個項目的完整欄位值。
+func (d configDoc) entryAt(it loginItemSpan) LoginEntry {
+	var e LoginEntry
+	apply := func(kv string) {
+		key, value, ok := strings.Cut(kv, ":")
+		if !ok {
+			return
+		}
+		key = strings.TrimSpace(key)
+		value = unquoteYAML(strings.TrimSpace(value))
+		switch key {
+		case "name":
+			e.Name = value
+		case "url":
+			e.URL = value
+		case "token":
+			e.Token = value
+		case "default":
+			e.Default = value == "true"
+		case "user":
+			e.User = value
+		}
+	}
+	first := strings.TrimSpace(d.lines[it.start])
+	if rest := strings.TrimSpace(strings.TrimPrefix(first, "-")); rest != "" {
+		apply(rest)
+	}
+	for i := it.start + 1; i < it.end; i++ {
+		if kv := strings.TrimSpace(d.lines[i]); kv != "" && !strings.HasPrefix(kv, "#") {
+			apply(kv)
+		}
+	}
+	return e
+}
+
+// ListLogins 回傳組態內容中的所有登入（依檔案順序）。
+func ListLogins(data []byte) []LoginEntry {
+	doc := parseConfigDoc(data)
+	out := make([]LoginEntry, 0, len(doc.items))
+	for _, it := range doc.items {
+		out = append(out, doc.entryAt(it))
+	}
+	return out
+}
+
+// ListLoginsFile 讀取組態檔並列出登入；檔案不存在視為空清單（非錯誤）。
+func ListLoginsFile(path string) ([]LoginEntry, error) {
+	data, err := os.ReadFile(path)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil, nil
+		}
+		return nil, err
+	}
+	return ListLogins(data), nil
+}
+
+// UpsertLogin 新增或更新名為 e.Name 的登入。
+//
+// 已存在則就地更新 url/token/user/default（保留其他欄位與行）；不存在則
+// 依 teai 的欄位順序插入新項目。makeDefault 為 true 時將其設為預設並取消
+// 其他登入的預設旗標；新增後若成為唯一登入也自動成為預設。
+// 回傳新內容與最終生效的項目值。
+func UpsertLogin(data []byte, e LoginEntry, makeDefault bool) ([]byte, LoginEntry, error) {
+	if strings.TrimSpace(e.Name) == "" {
+		return nil, LoginEntry{}, fmt.Errorf("gitea: login name must not be empty")
+	}
+	if strings.TrimSpace(e.URL) == "" {
+		return nil, LoginEntry{}, fmt.Errorf("gitea: login url must not be empty")
+	}
+	if e.Token == "" {
+		return nil, LoginEntry{}, fmt.Errorf("gitea: login token must not be empty")
+	}
+	doc := parseConfigDoc(data)
+	idx := doc.findItem(e.Name)
+	if idx >= 0 {
+		existing := doc.entryAt(doc.items[idx])
+		wantDefault := existing.Default || makeDefault
+		it := doc.items[idx]
+		lines := doc.lines
+		// 就地替換各欄位；缺少的欄位補在項目結尾。
+		for _, kv := range []struct{ key, value string }{
+			{"name", yamlScalar(e.Name)},
+			{"url", yamlScalar(e.URL)},
+			{"token", yamlScalar(e.Token)},
+			{"user", yamlScalar(e.User)},
+			{"default", strconv.FormatBool(wantDefault)},
+		} {
+			lines = setFieldInItem(lines, it, kv.key, kv.value, doc.fieldIndent())
+		}
+		out := joinLines(lines)
+		if wantDefault {
+			var err error
+			out, err = SetDefaultLogin(out, e.Name)
+			if err != nil {
+				return nil, LoginEntry{}, err
+			}
+		}
+		final := existing
+		final.URL, final.Token, final.User = e.URL, e.Token, e.User
+		final.Default = wantDefault
+		return out, final, nil
+	}
+
+	// 新增項目。
+	wantDefault := makeDefault || len(doc.items) == 0
+	block := newLoginBlock(doc.itemIndent, e.Name, e.URL, e.Token, wantDefault, e.User)
+	var lines []string
+	var insertAt int
+	if doc.loginsHeader < 0 {
+		if len(doc.lines) == 0 {
+			lines = []string{"logins:"}
+		} else {
+			lines = append(slices.Clone(doc.lines), "", "logins:")
+		}
+		insertAt = len(lines)
+	} else {
+		lines = slices.Clone(doc.lines)
+		// 「logins: []」是空清單的串流寫法，直接接項目會變無效 YAML；改回區段寫法。
+		if len(doc.items) == 0 && strings.TrimSpace(lines[doc.loginsHeader]) == "logins: []" {
+			lines[doc.loginsHeader] = "logins:"
+		}
+		if len(doc.items) > 0 {
+			insertAt = doc.items[len(doc.items)-1].end
+		} else {
+			insertAt = doc.loginsHeader + 1
+		}
+	}
+	out := append(slices.Clone(lines[:insertAt]), block...)
+	out = append(out, lines[insertAt:]...)
+	data2 := joinLines(out)
+	if wantDefault {
+		var err error
+		data2, err = SetDefaultLogin(data2, e.Name)
+		if err != nil {
+			return nil, LoginEntry{}, err
+		}
+	}
+	return data2, LoginEntry{
+		Name:    e.Name,
+		URL:     e.URL,
+		Token:   e.Token,
+		Default: wantDefault,
+		User:    e.User,
+	}, nil
+}
+
+// SetDefaultLogin 把名為 name 的登入設為預設，其餘一律取消預設。
+func SetDefaultLogin(data []byte, name string) ([]byte, error) {
+	doc := parseConfigDoc(data)
+	idx := doc.findItem(name)
+	if idx < 0 {
+		return nil, fmt.Errorf("gitea: login %q not found", name)
+	}
+	lines := doc.lines
+	// 反序處理：前面的插入不影響後面已算好的行範圍，這裡的反序則保證
+	// 後方項目的插入/修改不會推移前方項目的範圍。
+	for i := len(doc.items) - 1; i >= 0; i-- {
+		want := "false"
+		if i == idx {
+			want = "true"
+		}
+		lines = setFieldInItem(lines, doc.items[i], "default", want, doc.fieldIndent())
+	}
+	return joinLines(lines), nil
+}
+
+// RemoveLogin 移除名為 name 的登入。若被移除者是預設且還有其他登入，
+// 剩下的第一筆自動遞補為預設。回傳新內容與遞補後的預設名稱（無則空字串）。
+func RemoveLogin(data []byte, name string) ([]byte, string, error) {
+	doc := parseConfigDoc(data)
+	idx := doc.findItem(name)
+	if idx < 0 {
+		return nil, "", fmt.Errorf("gitea: login %q not found", name)
+	}
+	removed := doc.entryAt(doc.items[idx])
+	it := doc.items[idx]
+	lines := slices.Delete(slices.Clone(doc.lines), it.start, it.end)
+	out := joinLines(lines)
+	promoted := ""
+	if removed.Default {
+		rest := ListLogins(out)
+		if len(rest) > 0 {
+			promoted = rest[0].Name
+			var err error
+			out, err = SetDefaultLogin(out, promoted)
+			if err != nil {
+				return nil, "", err
+			}
+		}
+	}
+	return out, promoted, nil
+}
+
+// setFieldInItem 把項目內 key 的值換成 value，保留該行的原始縮排；
+// key 不存在時以 fieldIndent 插在項目結尾。回傳新的行切片。
+func setFieldInItem(lines []string, it loginItemSpan, key, value, fieldIndent string) []string {
+	first := lines[it.start]
+	trimmed := strings.TrimSpace(first)
+	if rest := strings.TrimSpace(strings.TrimPrefix(trimmed, "-")); rest != "" {
+		if k, _, ok := strings.Cut(rest, ":"); ok && strings.TrimSpace(k) == key {
+			prefix := first[:strings.Index(first, "-")] + "- "
+			lines[it.start] = prefix + key + ": " + value
+			return lines
+		}
+	}
+	for i := it.start + 1; i < it.end; i++ {
+		t := strings.TrimSpace(lines[i])
+		if k, _, ok := strings.Cut(t, ":"); ok && strings.TrimSpace(k) == key {
+			indent := lines[i][:len(lines[i])-len(strings.TrimLeft(lines[i], " "))]
+			lines[i] = indent + key + ": " + value
+			return lines
+		}
+	}
+	out := append(slices.Clone(lines[:it.end]), fieldIndent+key+": "+value)
+	return append(out, lines[it.end:]...)
+}
+
+// newLoginBlock 產生 teai 格式的新登入項目（name／url／token／default／user）。
+func newLoginBlock(itemIndent, name, url, token string, isDefault bool, user string) []string {
+	f := itemIndent + "  "
+	return []string{
+		itemIndent + "- name: " + yamlScalar(name),
+		f + "url: " + yamlScalar(url),
+		f + "token: " + yamlScalar(token),
+		f + "default: " + strconv.FormatBool(isDefault),
+		f + "user: " + yamlScalar(user),
+	}
+}
+
+// plainScalar 是可以不加引號直接寫出的 YAML 純量。
+var plainScalar = regexp.MustCompile(`^[A-Za-z0-9][A-Za-z0-9._:/~+=@-]*$`)
+
+// yamlScalar 把值寫成 YAML 純量：安全字元集直接輸出，其餘加雙引號。
+func yamlScalar(s string) string {
+	if plainScalar.MatchString(s) {
+		return s
+	}
+	return strconv.Quote(s)
+}
+
+// HostOf 取 URL 的主機部分（連埠，小寫）；解析失敗回空字串。
+// 供比對「同一站點」的登入時使用。
+func HostOf(rawURL string) string { return hostOf(rawURL) }
+
+// splitLines 把內容拆成行（去掉行尾換行與 CR）。
+func splitLines(data []byte) []string {
+	if len(data) == 0 {
+		return nil
+	}
+	s := strings.TrimSuffix(string(data), "\n")
+	if s == "" {
+		return []string{""}
+	}
+	return strings.Split(s, "\n")
+}
+
+// joinLines 把行組回內容，保證以單一換行結尾。
+func joinLines(lines []string) []byte {
+	if len(lines) == 0 {
+		return nil
+	}
+	s := strings.Join(lines, "\n")
+	if !strings.HasSuffix(s, "\n") {
+		s += "\n"
+	}
+	return []byte(s)
+}
+
+// SaveConfigFile 把組態內容原子寫入 path：先寫同目錄暫存檔（0600），
+// 再 rename 取代，避免半寫入狀態。必要時建立上層目錄（0700）。
+func SaveConfigFile(path string, data []byte) error {
+	dir := filepath.Dir(path)
+	if err := os.MkdirAll(dir, 0o700); err != nil {
+		return fmt.Errorf("gitea: create config dir: %w", err)
+	}
+	tmp, err := os.CreateTemp(dir, ".config-*.yml")
+	if err != nil {
+		return fmt.Errorf("gitea: create temp file: %w", err)
+	}
+	tmpName := tmp.Name()
+	defer func() {
+		if tmpName != "" {
+			_ = os.Remove(tmpName)
+		}
+	}()
+	if _, err := tmp.Write(data); err != nil {
+		tmp.Close()
+		return fmt.Errorf("gitea: write temp file: %w", err)
+	}
+	if err := tmp.Chmod(0o600); err != nil {
+		tmp.Close()
+		return fmt.Errorf("gitea: chmod temp file: %w", err)
+	}
+	if err := tmp.Close(); err != nil {
+		return fmt.Errorf("gitea: close temp file: %w", err)
+	}
+	if err := os.Rename(tmpName, path); err != nil {
+		return fmt.Errorf("gitea: rename config: %w", err)
+	}
+	tmpName = "" // 已改名成功，不必清理。
+	return nil
+}

internal/gitea/config_test.go

@@ -0,0 +1,274 @@
+// config_test.go 驗證登入組態的行級編輯：新增、更新、設預設、
+// 移除，以及「未知欄位與其他區段逐字保留」的關鍵性質。
+package gitea
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// extraFieldsConfig 含未知欄位與額外區段，用來驗證行級編輯不會改壞不相干內容。
+const extraFieldsConfig = `logins:
+    - name: alterminal
+      url: https://gitea.alterminal.com
+      token: tok-1
+      default: true
+      ssh_host: ""
+      ssh_key: ""
+      insecure: false
+      ssh_certificate_principal: ""
+      ssh_agent: false
+      ssh_key_agent_pub: ""
+      version_check: false
+      user: ceo
+      created: 0
+preferences:
+    editor: false
+    flag_defaults:
+        remote: ""
+`
+
+func TestListLoginsParsesAllEntries(t *testing.T) {
+	logins := ListLogins([]byte(extraFieldsConfig))
+	if len(logins) != 1 {
+		t.Fatalf("want 1 login, got %d", len(logins))
+	}
+	l := logins[0]
+	if l.Name != "alterminal" || l.URL != "https://gitea.alterminal.com" || l.Token != "tok-1" || !l.Default || l.User != "ceo" {
+		t.Fatalf("unexpected entry: %+v", l)
+	}
+}
+
+func TestUpsertLoginUpdatesExistingPreservesRest(t *testing.T) {
+	out, final, err := UpsertLogin([]byte(extraFieldsConfig), LoginEntry{
+		Name: "alterminal", URL: "https://gitea.alterminal.com", Token: "tok-2", User: "ceo",
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(out)
+	// 更新 token、保留其他欄位。
+	if !strings.Contains(s, "token: tok-2") || strings.Contains(s, "tok-1") {
+		t.Fatalf("token not updated:\n%s", s)
+	}
+	for _, want := range []string{
+		"ssh_host: \"\"", "insecure: false", "ssh_key_agent_pub: \"\"",
+		"user: ceo", "created: 0", "default: true",
+		"preferences:", "editor: false", "flag_defaults:", `remote: ""`,
+	} {
+		if !strings.Contains(s, want) {
+			t.Fatalf("missing %q after edit:\n%s", want, s)
+		}
+	}
+	if final.Default != true {
+		t.Fatalf("existing default should stay default, got %+v", final)
+	}
+	// 編輯後仍可解析出正確值。
+	logins := ListLogins(out)
+	if len(logins) != 1 || logins[0].Token != "tok-2" || !logins[0].Default {
+		t.Fatalf("reparse mismatch: %+v", logins)
+	}
+}
+
+func TestUpsertLoginAppendsNewAndMakesDefault(t *testing.T) {
+	out, final, err := UpsertLogin([]byte(extraFieldsConfig), LoginEntry{
+		Name: "second", URL: "https://git.example.com", Token: "tok-b", User: "bob",
+	}, true)
+	if err != nil {
+		t.Fatal(err)
+	}
+	logins := ListLogins(out)
+	if len(logins) != 2 {
+		t.Fatalf("want 2 logins, got %d:\n%s", len(logins), out)
+	}
+	if logins[0].Default || !logins[1].Default {
+		t.Fatalf("only the new login should be default: %+v", logins)
+	}
+	if logins[1].Name != "second" || logins[1].Token != "tok-b" || logins[1].User != "bob" {
+		t.Fatalf("new entry mismatch: %+v", logins[1])
+	}
+	if !final.Default {
+		t.Fatalf("final should be default: %+v", final)
+	}
+	// 新項目依 teai 欄位順序附加。
+	s := string(out)
+	if !strings.Contains(s, "    - name: second\n") {
+		t.Fatalf("new item not appended:\n%s", s)
+	}
+	for _, ban := range []string{"ssh_", "insecure:", "version_check:", "created:"} {
+		if strings.Contains(s[strings.Index(s, "- name: second"):], ban) {
+			t.Fatalf("new item leaked tea field %q:\n%s", ban, s)
+		}
+	}
+}
+
+func TestUpsertLoginFirstEverLoginCreatesSection(t *testing.T) {
+	out, final, err := UpsertLogin(nil, LoginEntry{
+		Name: "only", URL: "https://gitea.alterminal.com", Token: "tok", User: "ceo",
+	}, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	logins := ListLogins(out)
+	if len(logins) != 1 || !logins[0].Default || logins[0].Token != "tok" {
+		t.Fatalf("first login should auto-default: %s", out)
+	}
+	if !final.Default {
+		t.Fatalf("final should be default: %+v", final)
+	}
+	if !strings.HasPrefix(string(out), "logins:\n") {
+		t.Fatalf("section not created:\n%s", out)
+	}
+	s := string(out)
+	for _, ban := range []string{"ssh_", "insecure:", "version_check:", "created:", "preferences:"} {
+		if strings.Contains(s, ban) {
+			t.Fatalf("new config leaked tea field %q:\n%s", ban, s)
+		}
+	}
+}
+
+func TestUpsertLoginRejectsBadInput(t *testing.T) {
+	cases := []LoginEntry{
+		{Name: "", URL: "https://x", Token: "t"},
+		{Name: "n", URL: "  ", Token: "t"},
+		{Name: "n", URL: "https://x", Token: ""},
+	}
+	for _, e := range cases {
+		if _, _, err := UpsertLogin(nil, e, true); err == nil {
+			t.Errorf("UpsertLogin(%+v) should fail", e)
+		}
+	}
+}
+
+func TestSetDefaultLoginSwitchesFlag(t *testing.T) {
+	cfg := `logins:
+    - name: a
+      url: https://a.example.com
+      token: ta
+      default: true
+    - name: b
+      url: https://b.example.com
+      token: tb
+      default: false
+`
+	out, err := SetDefaultLogin([]byte(cfg), "b")
+	if err != nil {
+		t.Fatal(err)
+	}
+	logins := ListLogins(out)
+	if logins[0].Default || !logins[1].Default {
+		t.Fatalf("default flag not switched:\n%s", out)
+	}
+	// b 之後的內容（如有）不受影響。
+	if !strings.Contains(string(out), "token: ta") || !strings.Contains(string(out), "token: tb") {
+		t.Fatalf("tokens lost:\n%s", out)
+	}
+}
+
+func TestSetDefaultLoginUnknownNameErrors(t *testing.T) {
+	if _, err := SetDefaultLogin([]byte(extraFieldsConfig), "nope"); err == nil {
+		t.Fatal("unknown name should error")
+	}
+}
+
+func TestRemoveLoginPromotesNextDefault(t *testing.T) {
+	// 第二個登入放在 logins 區段內（preferences 之前）。
+	cfg := `logins:
+    - name: alterminal
+      url: https://gitea.alterminal.com
+      token: tok-1
+      default: true
+      user: ceo
+    - name: backup
+      url: https://backup.example.com
+      token: tb
+      default: false
+preferences:
+    editor: false
+`
+	out, promoted, err := RemoveLogin([]byte(cfg), "alterminal")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if promoted != "backup" {
+		t.Fatalf("promoted = %q, want backup:\n%s", promoted, out)
+	}
+	logins := ListLogins(out)
+	if len(logins) != 1 || logins[0].Name != "backup" || !logins[0].Default {
+		t.Fatalf("remaining login mismatch: %+v", logins)
+	}
+	if strings.Contains(string(out), "tok-1") || strings.Contains(string(out), "name: alterminal") {
+		t.Fatalf("login not fully removed:\n%s", out)
+	}
+}
+
+func TestRemoveLoginLastOne(t *testing.T) {
+	out, promoted, err := RemoveLogin([]byte(extraFieldsConfig), "alterminal")
+	if err != nil || promoted != "" {
+		t.Fatalf("want clean removal, promoted=%q err=%v", promoted, err)
+	}
+	if strings.Contains(string(out), "alterminal") {
+		t.Fatalf("login not removed:\n%s", out)
+	}
+	if !strings.Contains(string(out), "preferences:") {
+		t.Fatalf("preferences section lost:\n%s", out)
+	}
+}
+
+func TestSaveConfigFileAtomicAndMode(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "teai", "config.yml")
+	if err := SaveConfigFile(path, []byte("logins: []\n")); err != nil {
+		t.Fatal(err)
+	}
+	info, err := os.Stat(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info.Mode().Perm() != 0o600 {
+		t.Fatalf("perm = %v, want 0600", info.Mode().Perm())
+	}
+	// 再寫一次（覆蓋既有檔），不留暫存殘檔。
+	if err := SaveConfigFile(path, []byte("logins: []\n# v2\n")); err != nil {
+		t.Fatal(err)
+	}
+	entries, _ := os.ReadDir(filepath.Dir(path))
+	if len(entries) != 1 {
+		for _, e := range entries {
+			t.Logf("leftover: %s", e.Name())
+		}
+		t.Fatalf("want exactly 1 file, got %d", len(entries))
+	}
+	data, _ := os.ReadFile(path)
+	if !bytes.Contains(data, []byte("# v2")) {
+		t.Fatalf("overwrite failed: %s", data)
+	}
+}
+
+func TestSplitJoinLinesRoundTrip(t *testing.T) {
+	original := "a\nb\n"
+	got := string(joinLines(splitLines([]byte(original))))
+	if got != original {
+		t.Fatalf("round trip: %q", got)
+	}
+	if joinLines(splitLines(nil)) != nil {
+		t.Fatal("nil input should stay nil")
+	}
+}
+
+func TestYamlScalarQuoting(t *testing.T) {
+	cases := map[string]string{
+		"https://gitea.alterminal.com": "https://gitea.alterminal.com", // 含 : 與 / 的純量在 YAML 合法，不必引號
+		"tok-abc_123":                  "tok-abc_123",
+		"has space":                    `"has space"`,
+		"ceo":                          "ceo",
+	}
+	for in, want := range cases {
+		if got := yamlScalar(in); got != want {
+			t.Errorf("yamlScalar(%q) = %s, want %s", in, got, want)
+		}
+	}
+}

internal/workflow/giteaapi.go

@@ -122,3 +122,103 @@ func (a *APIClient) ListComments(owner, repo string, number int64) ([]Comment, e
 	}
 	return comments, nil
 }
+
+// ── StalledSource 面向（#7 CLI 接線）────────────────────────────────────
+// APIClient 在 Client 之外同時實作 StalledSource（Source + CurrentUser +
+// GetIssue），讓 stalled／xrefs 命令與既有命令共用同一個 HTTP 用戶端。
+// 清單類方法直接委派 Client 同名操作，語義一致（type=issues、state=open）。
+
+// GetIssue 單一 issue 查詢（PR 亦經此端點，帶 pull_request 標記）；
+// 失敗（含 404）回 *gitea.ErrAPI，由 CLI 映射結束碼 3。
+func (a *APIClient) GetIssue(owner, repo string, number int64) (Issue, error) {
+	var issue Issue
+	path := "/repos/" + url.PathEscape(owner) + "/" + url.PathEscape(repo) +
+		"/issues/" + strconv.FormatInt(number, 10)
+	if err := a.Client.GetJSON(context.Background(), path, &issue); err != nil {
+		return Issue{}, err
+	}
+	return issue, nil
+}
+
+// TryGetIssue 寬容版單一 issue 查詢：失敗（含 404）回 (零值, false, nil)，
+// 供 stalled 父追蹤項掃描靜默略過不存在的子項（Source 介面契約）。
+func (a *APIClient) TryGetIssue(owner, repo string, number int64) (Issue, bool, error) {
+	issue, err := a.GetIssue(owner, repo, number)
+	if err != nil {
+		return Issue{}, false, nil
+	}
+	return issue, true, nil
+}
+
+// IssueTimeline 回傳 issue 的 timeline 事件（Source 面向；對應 gitea.py
+// _direct_last_activity 拉取的 repos/{o}/{r}/issues/{n}/timeline）。
+// 分頁由 ListAll 處理（與 gitea.py api_get_list 的 limit=50 逐頁一致）。
+func (a *APIClient) IssueTimeline(owner, repo string, number int64) ([]TimelineEvent, error) {
+	var events []TimelineEvent
+	path := "/repos/" + url.PathEscape(owner) + "/" + url.PathEscape(repo) +
+		"/issues/" + strconv.FormatInt(number, 10) + "/timeline"
+	if err := a.Client.ListAll(context.Background(), path, gitea.ListOptions{}, &events); err != nil {
+		return nil, err
+	}
+	return events, nil
+}
+
+// MyOrganizations 委派 ListOrgs（Source 面向）。
+func (a *APIClient) MyOrganizations() ([]string, error) { return a.ListOrgs() }
+
+// OrganizationRepositories 委派 ListOrgRepos（Source 面向）。
+func (a *APIClient) OrganizationRepositories(org string) ([]Repo, error) {
+	return a.ListOrgRepos(org)
+}
+
+// OpenIssues 委派 ListIssues（Source 面向；已排除 PR）。
+func (a *APIClient) OpenIssues(owner, repo string) ([]Issue, error) {
+	return a.ListIssues(owner, repo)
+}
+
+// OpenPulls 委派 ListPulls（Source 面向）。
+func (a *APIClient) OpenPulls(owner, repo string) ([]PullRequest, error) {
+	return a.ListPulls(owner, repo)
+}
+
+// IssueComments 委派 ListComments（Source 面向）。
+func (a *APIClient) IssueComments(owner, repo string, number int64) ([]Comment, error) {
+	return a.ListComments(owner, repo, number)
+}
+
+// ── MilestoneSource 面向（#31 跨倉庫里程碑總覽）────────────────────────
+// APIClient 在 StalledSource 之外另實作 MilestoneSource，讓 milestones
+// 總覽命令與既有命令共用同一個 HTTP 用戶端；查詢參數對照 gitea.py 的
+// list_open_milestones_for_repository／_milestone_open_issues。
+
+// OpenMilestones 回傳倉庫的 open 里程碑（GET /repos/{o}/{r}/milestones?state=open）。
+func (a *APIClient) OpenMilestones(owner, repo string) ([]Milestone, error) {
+	var ms []Milestone
+	path := "/repos/" + url.PathEscape(owner) + "/" + url.PathEscape(repo) + "/milestones"
+	opts := gitea.ListOptions{Extra: url.Values{"state": {"open"}}}
+	if err := a.Client.ListAll(context.Background(), path, opts, &ms); err != nil {
+		return nil, err
+	}
+	return ms, nil
+}
+
+// MilestoneOpenIssues 回傳掛在指定里程碑（依名稱過濾，Gitea 以
+// milestones=<title> 查詢）的 open 條目。刻意**不**帶 type=issues——
+// PR 亦屬里程碑條目，保留兩者供覆蓋檢查（同 gitea.py
+// _milestone_open_issues；PR 帶 pull_request 標記由 workflow 判別）。
+func (a *APIClient) MilestoneOpenIssues(owner, repo, milestoneTitle string) ([]Issue, error) {
+	var issues []Issue
+	path := "/repos/" + url.PathEscape(owner) + "/" + url.PathEscape(repo) + "/issues"
+	opts := gitea.ListOptions{Extra: url.Values{
+		"state":      {"open"},
+		"milestones": {milestoneTitle},
+	}}
+	if err := a.Client.ListAll(context.Background(), path, opts, &issues); err != nil {
+		return nil, err
+	}
+	return issues, nil
+}
+
+// 編譯期確認 APIClient 同時實作 Client、StalledSource 與 MilestoneSource。
+var _ StalledSource = (*APIClient)(nil)
+var _ MilestoneSource = (*APIClient)(nil)

internal/workflow/milestones.go

@@ -0,0 +1,256 @@
+// milestones.go — 跨倉庫里程碑總覽（teai #31；gitea.py milestones 的對應實作）。
+//
+// 各倉庫 open milestone 概況（管理者巡邏用，agents AGENTS.md 10.1）：期限近者
+// 在前的排序、逾期判定、未分派條目摘要與活躍度（updated_at 取里程碑本身與
+// 其 open 條位的最大值）。判定與輸出規則以 AGENTS.md 為單一來源，行為基準是
+// gitea.py 的 list_milestone_overview，本檔只實作、不改義。
+package workflow
+
+import (
+	"fmt"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Milestone 是里程碑物件（僅取總覽會用到的欄位）。
+// ID 與 DueOn 用指標：Gitea 回 null／缺漏時輸出 null
+// （對應 gitea.py milestone.get("id")／get("due_on") 的 None 語義）。
+type Milestone struct {
+	ID           *int64  `json:"id"`
+	Title        string  `json:"title"`
+	State        string  `json:"state"`
+	DueOn        *string `json:"due_on"`
+	UpdatedAt    string  `json:"updated_at"`
+	OpenIssues   int64   `json:"open_issues"`
+	ClosedIssues int64   `json:"closed_issues"`
+}
+
+// MilestoneSource 是跨倉庫里程碑總覽需要的資料源（CLI 層以 API 實作；
+// 測試注入假資料，與 Source／StalledSource 同模式）。
+type MilestoneSource interface {
+	// MyOrganizations 回傳目前帳號所屬組織清單。
+	MyOrganizations() ([]string, error)
+	// OrganizationRepositories 回傳組織的倉庫清單。
+	OrganizationRepositories(org string) ([]Repo, error)
+	// OpenMilestones 回傳倉庫的 open 里程碑。
+	OpenMilestones(owner, repo string) ([]Milestone, error)
+	// MilestoneOpenIssues 回傳掛在指定里程碑（依名稱過濾）的 open
+	// issue 與 PR。刻意不設 type 過濾——兩者都保留供覆蓋檢查
+	//（同 gitea.py _milestone_open_issues 的查詢參數；PR 帶
+	// pull_request 標記，由本套件判別）。
+	MilestoneOpenIssues(owner, repo, milestoneTitle string) ([]Issue, error)
+}
+
+// UnassignedEntry 是里程碑 open 條目中未分派者的摘要。
+type UnassignedEntry struct {
+	Type   string
+	Number int64
+	Title  string
+	URL    string
+	// Author 僅 pull 條目輸出（且作者已知時；對應 gitea.py 只在
+	// _pr_author_username 非空時放 author 鍵）。
+	Author string
+}
+
+// MarshalJSON 輸出鍵集與鍵序與 gitea.py 一致的物件。
+func (u UnassignedEntry) MarshalJSON() ([]byte, error) {
+	var b strings.Builder
+	b.WriteString(`{"type":`)
+	writeJSON(&b, u.Type)
+	b.WriteString(`,"number":`)
+	fmt.Fprintf(&b, "%d", u.Number)
+	b.WriteString(`,"title":`)
+	writeJSON(&b, u.Title)
+	b.WriteString(`,"url":`)
+	writeJSON(&b, u.URL)
+	if u.Author != "" {
+		b.WriteString(`,"author":`)
+		writeJSON(&b, u.Author)
+	}
+	b.WriteString(`}`)
+	return []byte(b.String()), nil
+}
+
+// MilestoneEntry 是總覽的單筆輸出（欄位對應 gitea.py list_milestone_overview
+// 的 dict 鍵序：repo、id、title、url、open_issues、closed_issues、due_on、
+// due_hours、overdue、unassigned、updated_at）。
+type MilestoneEntry struct {
+	Repo         string
+	ID           *int64
+	Title        string
+	URL          string
+	OpenIssues   int64
+	ClosedIssues int64
+	DueOn        *string
+	DueHours     *float64
+	Overdue      bool
+	Unassigned   []UnassignedEntry
+	UpdatedAt    *string
+}
+
+// MarshalJSON 輸出鍵集與鍵序與 gitea.py 完全一致的物件
+// （與 Item／stalled 的做法相同：手寫鍵序，null／浮點格式對齊 Python）。
+func (e MilestoneEntry) MarshalJSON() ([]byte, error) {
+	var b strings.Builder
+	b.WriteString(`{"repo":`)
+	writeJSON(&b, e.Repo)
+	b.WriteString(`,"id":`)
+	if e.ID != nil {
+		fmt.Fprintf(&b, "%d", *e.ID)
+	} else {
+		b.WriteString("null")
+	}
+	b.WriteString(`,"title":`)
+	writeJSON(&b, e.Title)
+	b.WriteString(`,"url":`)
+	writeJSON(&b, e.URL)
+	b.WriteString(`,"open_issues":`)
+	fmt.Fprintf(&b, "%d", e.OpenIssues)
+	b.WriteString(`,"closed_issues":`)
+	fmt.Fprintf(&b, "%d", e.ClosedIssues)
+	b.WriteString(`,"due_on":`)
+	writeJSON(&b, e.DueOn)
+	b.WriteString(`,"due_hours":`)
+	if e.DueHours != nil {
+		// Python round(x, 1) 的 json 輸出是 48.0／10.4（定點一位小數）。
+		b.WriteString(strconv.FormatFloat(round1(*e.DueHours), 'f', 1, 64))
+	} else {
+		b.WriteString("null")
+	}
+	b.WriteString(`,"overdue":`)
+	b.WriteString(strconv.FormatBool(e.Overdue))
+	b.WriteString(`,"unassigned":`)
+	writeJSON(&b, e.Unassigned)
+	b.WriteString(`,"updated_at":`)
+	writeJSON(&b, e.UpdatedAt)
+	b.WriteString(`}`)
+	return []byte(b.String()), nil
+}
+
+// MilestoneOverview 收集跨組織各倉庫的 open 里程碑概況，依（due_on，
+// 無則視為最遠）由近到遠排序（穩定排序：同 due_on 者保持掃描順序，
+// 對應 Python list.sort 的穩定性）。webBase 是站點網址前綴
+// （scheme://host），空字串時 url 欄位輸出 ""（同 gitea.py 在
+// GITEA_WEB_DOMAIN 缺漏時的行為）。
+func MilestoneOverview(src MilestoneSource, webBase string, now time.Time) ([]MilestoneEntry, error) {
+	orgs, err := src.MyOrganizations()
+	if err != nil {
+		return nil, err
+	}
+	out := []MilestoneEntry{}
+	for _, org := range orgs {
+		repos, err := src.OrganizationRepositories(org)
+		if err != nil {
+			return nil, err
+		}
+		for _, repo := range repos {
+			if repo.Name == "" || repo.Empty {
+				continue
+			}
+			ms, err := src.OpenMilestones(org, repo.Name)
+			if err != nil {
+				return nil, err
+			}
+			for i := range ms {
+				entry, err := milestoneEntry(src, org, repo.Name, &ms[i], webBase, now)
+				if err != nil {
+					return nil, err
+				}
+				out = append(out, entry)
+			}
+		}
+	}
+	// gitea.py 的排序鍵：(due_on is None, due_on or "")——有期限者在前、
+	// 期限近者在前；無期限者在後。
+	sort.SliceStable(out, func(a, bb int) bool {
+		x, y := out[a].DueOn, out[bb].DueOn
+		if (x == nil) != (y == nil) {
+			return y == nil
+		}
+		if x != nil {
+			return *x < *y
+		}
+		return false
+	})
+	return out, nil
+}
+
+// milestoneEntry 計算單一里程碑的總覽欄位（對應 gitea.py 迴圈體）。
+func milestoneEntry(src MilestoneSource, org, repo string, m *Milestone, webBase string, now time.Time) (MilestoneEntry, error) {
+	// due_hours／overdue：due_on 缺漏或無法解析 → null／false。
+	// Python 以未捨入值判定 overdue（round 只作用於輸出），
+	// 邊界（如 0.04 小時 → overdue=true、due_hours=0.0）保持一致。
+	var dueHours *float64
+	overdue := false
+	if m.DueOn != nil {
+		if due, ok := parseMoment(*m.DueOn); ok {
+			raw := now.Sub(due).Hours()
+			dueHours = &raw
+			overdue = raw > 0
+		}
+	}
+	openEntries, err := src.MilestoneOpenIssues(org, repo, m.Title)
+	if err != nil {
+		return MilestoneEntry{}, err
+	}
+	// 未分派條目摘要（assignees 為空者）；updated_at 取里程碑本身與
+	// 各 open 條目 updated_at 的最大值（供巡邏判斷活躍度）。
+	unassigned := []UnassignedEntry{}
+	moments := []time.Time{}
+	if updated, ok := parseMoment(m.UpdatedAt); ok {
+		moments = append(moments, updated)
+	}
+	for i := range openEntries {
+		entry := &openEntries[i]
+		if updated, ok := parseMoment(entry.UpdatedAt); ok {
+			moments = append(moments, updated)
+		}
+		if len(AssigneeNames(entry)) > 0 {
+			continue
+		}
+		summary := UnassignedEntry{
+			Type:   "issue",
+			Number: entry.issueNumber(),
+			Title:  entry.Title,
+			URL:    entry.WebURL(),
+		}
+		if entry.PullRequest != nil {
+			summary.Type = "pull"
+			if author := entry.User.Name(); author != "" {
+				summary.Author = author
+			}
+		}
+		unassigned = append(unassigned, summary)
+	}
+	var updatedAt *string
+	if len(moments) > 0 {
+		s := FormatMoment(maxTime(moments))
+		updatedAt = &s
+	}
+	return MilestoneEntry{
+		Repo:         org + "/" + repo,
+		ID:           m.ID,
+		Title:        m.Title,
+		URL:          milestoneURL(webBase, org, repo, m.ID),
+		OpenIssues:   m.OpenIssues,
+		ClosedIssues: m.ClosedIssues,
+		DueOn:        m.DueOn,
+		DueHours:     dueHours,
+		Overdue:      overdue,
+		Unassigned:   unassigned,
+		UpdatedAt:    updatedAt,
+	}, nil
+}
+
+// milestoneURL 組里程碑網頁網址；webBase 空或 id 缺漏回 ""
+// （對應 gitea.py _milestone_url 的兩個空值條件。Python 原版不做
+// URL 跳脫——一般組織／倉庫名皆為安全字元，這裡保持一致以求位元組相容）。
+func milestoneURL(webBase, org, repo string, id *int64) string {
+	if webBase == "" || id == nil {
+		return ""
+	}
+	return strings.TrimRight(webBase, "/") + "/" + org + "/" + repo +
+		"/milestone/" + strconv.FormatInt(*id, 10)
+}

internal/workflow/milestones_test.go

@@ -0,0 +1,262 @@
+// milestones_test.go — MilestoneOverview 的單元測試（#31）。
+//
+// 資料源注入假實作（離線可測）；鍵序、null 表示、排序與 overdue
+// 判定對照 gitea.py list_milestone_overview 的 Python 語義。
+package workflow
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+)
+
+// fakeMilestoneSource 以記憶體資料實作 MilestoneSource。
+type fakeMilestoneSource struct {
+	orgs       []string
+	repos      map[string][]Repo
+	milestones map[string][]Milestone
+	openIssues map[string][]Issue // key: owner/repo?milestone=<title>
+}
+
+func (f *fakeMilestoneSource) MyOrganizations() ([]string, error) { return f.orgs, nil }
+func (f *fakeMilestoneSource) OrganizationRepositories(org string) ([]Repo, error) {
+	return f.repos[org], nil
+}
+func (f *fakeMilestoneSource) OpenMilestones(owner, repo string) ([]Milestone, error) {
+	return f.milestones[owner+"/"+repo], nil
+}
+func (f *fakeMilestoneSource) MilestoneOpenIssues(owner, repo, title string) ([]Issue, error) {
+	return f.openIssues[owner+"/"+repo+"?milestone="+title], nil
+}
+
+func msPtr(s string) *string { return &s }
+func idPtr(i int64) *int64   { return &i }
+
+// newMilestoneFixture 建構情境：alterminal 兩倉庫、三里程碑
+// （teai 有期限將至、agents 有逾期與無期限）。
+func newMilestoneFixture() *fakeMilestoneSource {
+	return &fakeMilestoneSource{
+		orgs: []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": {
+			{Name: "agents", HasPullRequests: boolPtr(true)},
+			{Name: "teai", HasPullRequests: boolPtr(true)},
+			{Name: "empty-repo", Empty: true}, // 空倉庫應跳過
+		}},
+		milestones: map[string][]Milestone{
+			"alterminal/agents": {
+				{ID: idPtr(7), Title: "MVP", State: "open",
+					DueOn: msPtr("2026-09-09T00:00:00Z"), UpdatedAt: "2026-09-01T00:00:00Z",
+					OpenIssues: 3, ClosedIssues: 1},
+				{ID: idPtr(8), Title: "v1", State: "open",
+					DueOn: nil, UpdatedAt: "2026-09-02T00:00:00Z",
+					OpenIssues: 1, ClosedIssues: 0},
+			},
+			"alterminal/teai": {
+				{ID: idPtr(3), Title: "CLI", State: "open",
+					DueOn: msPtr("2026-09-12T00:00:00Z"), UpdatedAt: "2026-09-05T00:00:00Z",
+					OpenIssues: 2, ClosedIssues: 5},
+			},
+		},
+		openIssues: map[string][]Issue{
+			// agents MVP：一個未分派 issue、一個未分派 PR、一個已分派 issue。
+			"alterminal/agents?milestone=MVP": {
+				{Number: 31, Title: "總覽命令", State: "open",
+					UpdatedAt:  "2026-09-10T01:00:00Z",
+					Repository: &Repository{FullName: "alterminal/agents"},
+					HTMLURL:    "https://gitea.alterminal.com/alterminal/agents/issues/31"},
+				{Number: 32, Title: "文件", State: "open",
+					UpdatedAt:   "2026-09-08T00:00:00Z",
+					Repository:  &Repository{FullName: "alterminal/agents"},
+					HTMLURL:     "https://gitea.alterminal.com/alterminal/agents/pulls/32",
+					PullRequest: &pullMarker{}, User: &User{UserName: "alex"}},
+				{Number: 33, Title: "已分派", State: "open",
+					UpdatedAt:  "2026-09-07T00:00:00Z",
+					Repository: &Repository{FullName: "alterminal/agents"},
+					HTMLURL:    "https://gitea.alterminal.com/alterminal/agents/issues/33",
+					Assignee:   &User{UserName: "queena"}},
+			},
+			// agents v1（無期限）：條目比里程碑本身新 → updated_at 取條目。
+			"alterminal/agents?milestone=v1": {
+				{Number: 40, Title: "無人理", State: "open",
+					UpdatedAt:  "2026-09-09T23:30:00Z",
+					Repository: &Repository{FullName: "alterminal/agents"},
+					HTMLURL:    "https://gitea.alterminal.com/alterminal/agents/issues/40"},
+			},
+		},
+	}
+}
+
+// TestMilestoneOverviewSortAndOverdue 驗證排序（期限近者在前、無期限在後）
+// 與 overdue／due_hours 計算。
+func TestMilestoneOverviewSortAndOverdue(t *testing.T) {
+	now := time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC)
+	entries, err := MilestoneOverview(newMilestoneFixture(), "https://gitea.alterminal.com", now)
+	if err != nil {
+		t.Fatalf("MilestoneOverview: %v", err)
+	}
+	if len(entries) != 3 {
+		t.Fatalf("應有 3 筆（空倉庫跳過），得到 %d", len(entries))
+	}
+	// 排序：MVP（2026-09-09，已過期）→ CLI（2026-09-12）→ v1（無期限）。
+	wantOrder := []string{"alterminal/agents#MVP", "alterminal/teai#CLI", "alterminal/agents#v1"}
+	for i, want := range wantOrder {
+		got := entries[i].Repo + "#" + entries[i].Title
+		if got != want {
+			t.Errorf("第 %d 筆應為 %s，得到 %s", i, want, got)
+		}
+	}
+	// MVP：due 2026-09-09T00:00Z、now 09-10T08:00Z → 32 小時、逾期。
+	if !entries[0].Overdue {
+		t.Errorf("MVP 應逾期")
+	}
+	if entries[0].DueHours == nil || *entries[0].DueHours != 32.0 {
+		t.Errorf("MVP due_hours 應 32.0，得到 %v", entries[0].DueHours)
+	}
+	// CLI：未到期。
+	if entries[1].Overdue {
+		t.Errorf("CLI 不應逾期")
+	}
+	// v1：無期限 → null。
+	if entries[2].DueOn != nil || entries[2].DueHours != nil || entries[2].Overdue {
+		t.Errorf("v1 無期限應為 null/false，得到 %+v", entries[2])
+	}
+}
+
+// TestMilestoneOverviewUnassigned 驗證未分派條目摘要（issue 無 author、
+// pull 帶 author）與 updated_at 取最大值。
+func TestMilestoneOverviewUnassigned(t *testing.T) {
+	now := time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC)
+	entries, err := MilestoneOverview(newMilestoneFixture(), "https://gitea.alterminal.com", now)
+	if err != nil {
+		t.Fatalf("MilestoneOverview: %v", err)
+	}
+	var mvp *MilestoneEntry
+	for i := range entries {
+		if entries[i].Title == "MVP" {
+			mvp = &entries[i]
+		}
+	}
+	if mvp == nil {
+		t.Fatalf("找不到 MVP")
+	}
+	// 未分派：#31（issue）、#32（PR, author=alex）；#33 已分派不列。
+	if len(mvp.Unassigned) != 2 {
+		t.Fatalf("MVP 應有 2 筆未分派，得到 %d：%+v", len(mvp.Unassigned), mvp.Unassigned)
+	}
+	if mvp.Unassigned[0].Type != "issue" || mvp.Unassigned[0].Number != 31 {
+		t.Errorf("第一筆未分派應為 issue #31，得到 %+v", mvp.Unassigned[0])
+	}
+	if mvp.Unassigned[1].Type != "pull" || mvp.Unassigned[1].Number != 32 || mvp.Unassigned[1].Author != "alex" {
+		t.Errorf("第二筆未分派應為 pull #32（author=alex），得到 %+v", mvp.Unassigned[1])
+	}
+	// updated_at：max(里程碑 09-01, #31 09-10T01:00Z) → 後者。
+	if mvp.UpdatedAt == nil || *mvp.UpdatedAt != "2026-09-10T01:00:00+00:00" {
+		t.Errorf("MVP updated_at 應取條目最大值 2026-09-10T01:00:00+00:00，得到 %v", mvp.UpdatedAt)
+	}
+	// url 組法。
+	if mvp.URL != "https://gitea.alterminal.com/alterminal/agents/milestone/7" {
+		t.Errorf("MVP url 應為 milestone/7，得到 %s", mvp.URL)
+	}
+}
+
+// TestMilestoneOverviewJSONKeys 驗證 JSON 鍵集與鍵序與 gitea.py 一致，
+// 以及 null／陣列空表示（unassigned 空 → []）。
+func TestMilestoneOverviewJSONKeys(t *testing.T) {
+	now := time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC)
+	entries, err := MilestoneOverview(newMilestoneFixture(), "", now)
+	if err != nil {
+		t.Fatalf("MilestoneOverview: %v", err)
+	}
+	// v1：無期限、無未分派條目 → due_on/due_hours/updated_at 的 null 表示、
+	// unassigned=[]、webBase 空 → url=""。
+	var v1 *MilestoneEntry
+	for i := range entries {
+		if entries[i].Title == "v1" {
+			v1 = &entries[i]
+		}
+	}
+	if v1 == nil {
+		t.Fatalf("找不到 v1")
+	}
+	// 手寫期望 JSON（縮排 2、鍵序照 gitea.py dict 實字序）。
+	b, err := json.Marshal(v1)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	// 以逐鍵比對為準（MarshalIndent 因自訂 MarshalJSON 不縮排內層）。
+	var obj map[string]json.RawMessage
+	if err := json.Unmarshal(b, &obj); err != nil {
+		t.Fatalf("Unmarshal: %v", err)
+	}
+	wantKeys := []string{"repo", "id", "title", "url", "open_issues", "closed_issues",
+		"due_on", "due_hours", "overdue", "unassigned", "updated_at"}
+	// 鍵序：json.Unmarshal 到 map 會失序；改檢查原始字串的鍵出現順序。
+	pos := -1
+	for _, k := range wantKeys {
+		i := strings.Index(string(b), `"`+k+`":`)
+		if i < 0 {
+			t.Fatalf("輸出缺少鍵 %q：%s", k, b)
+		}
+		if i < pos {
+			t.Fatalf("鍵 %q 順序錯誤：%s", k, b)
+		}
+		pos = i
+	}
+	for _, kv := range []struct {
+		key  string
+		want string
+	}{
+		{"repo", `"alterminal/agents"`},
+		{"due_on", `null`},
+		{"due_hours", `null`},
+		{"overdue", `false`},
+		{"url", `""`},
+	} {
+		if got := string(obj[kv.key]); got != kv.want {
+			t.Errorf("%s 應為 %s，得到 %s", kv.key, kv.want, got)
+		}
+	}
+	if !strings.Contains(string(b), `"number":40`) {
+		t.Errorf("未分派條目應含 number 40：%s", b)
+	}
+	// pull 條目的 author 鍵：有作者才輸出（無則不該出現 "author"）。
+	if strings.Contains(string(obj["unassigned"]), `"author"`) {
+		t.Errorf("issue 條目不應有 author 鍵：%s", obj["unassigned"])
+	}
+}
+
+// TestMilestoneOverviewDueHoursRounding 驗證 due_hours 捨入到一位小數，
+// 且 overdue 以未捨入值判定（0.04h → 0.0 但 overdue=true）。
+func TestMilestoneOverviewDueHoursRounding(t *testing.T) {
+	src := &fakeMilestoneSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": {{Name: "r"}}},
+		milestones: map[string][]Milestone{
+			"alterminal/r": {
+				{ID: idPtr(1), Title: "edge", State: "open",
+					DueOn: msPtr("2026-09-10T07:57:36Z"), UpdatedAt: "2026-09-10T07:00:00Z"},
+			},
+		},
+		openIssues: map[string][]Issue{},
+	}
+	now := time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC)
+	entries, err := MilestoneOverview(src, "", now)
+	if err != nil {
+		t.Fatalf("MilestoneOverview: %v", err)
+	}
+	if len(entries) != 1 {
+		t.Fatalf("應有 1 筆，得到 %d", len(entries))
+	}
+	// 144 秒 = 0.04 小時 → round1 → 0.0；未捨入 > 0 → overdue=true。
+	b, err := json.Marshal(entries[0])
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	if !strings.Contains(string(b), `"due_hours":0.0`) {
+		t.Errorf("due_hours 應捨入為 0.0：%s", b)
+	}
+	if !strings.Contains(string(b), `"overdue":true`) {
+		t.Errorf("overdue 應以未捨入值判定為 true：%s", b)
+	}
+}

internal/workflow/scan.go

@@ -9,8 +9,17 @@ import (
 	"sort"
 )
 
+const (
 	// AgentsTeamName 是工作流團隊的名稱（AGENTS.md：調度成員由 Agents 團隊決定）。
-const AgentsTeamName = "Agents"
+	AgentsTeamName = "Agents"
+	// SupervisorTeamName 是管理者團隊的名稱；成員角色為 supervisor。
+	SupervisorTeamName = "Supervisor"
+
+	// RoleSupervisor 是 Supervisor 團隊成員的角色值。
+	RoleSupervisor = "supervisor"
+	// RoleWorker 是 Agents 團隊成員的角色值。
+	RoleWorker = "worker"
+)
 
 // Client 抽象 teai 需要的 Gitea API 讀取操作（僅唯讀）。
 // #5 的 internal/gitea HTTP 用戶端實作此介面；workflow 不依賴 HTTP 細節。
@@ -49,7 +58,7 @@ type PullItem struct {
 	Pull  PullRequest
 }
 
-// Scanner 在 Client 之上組合出各命令的資料（whoami/orgs/members/mine/pulls/next）。
+// Scanner 在 Client 之上組合出各命令的資料（whoami/role/orgs/members/mine/pulls/next）。
 type Scanner struct {
 	Client Client
 }
@@ -59,6 +68,63 @@ func (s *Scanner) Whoami() (string, error) {
 	return s.Client.CurrentUser()
 }
 
+// Role 依目前帳號所屬團隊回傳角色：Supervisor 團隊為 supervisor，
+// Agents 團隊為 worker。同時屬於兩者時以 supervisor 為準。
+// 兩者都不屬於時回空字串（CLI 輸出 null）。
+func (s *Scanner) Role() (string, error) {
+	username, err := s.Whoami()
+	if err != nil {
+		return "", err
+	}
+	orgs, err := s.Orgs()
+	if err != nil {
+		return "", err
+	}
+	inAgents := false
+	for _, org := range orgs {
+		teams, err := s.Client.ListTeams(org)
+		if err != nil {
+			return "", err
+		}
+		for _, team := range teams {
+			switch team.Name {
+			case SupervisorTeamName, AgentsTeamName:
+			default:
+				continue
+			}
+			ok, err := s.usernameInTeam(team.ID, username)
+			if err != nil {
+				return "", err
+			}
+			if !ok {
+				continue
+			}
+			if team.Name == SupervisorTeamName {
+				return RoleSupervisor, nil
+			}
+			inAgents = true
+		}
+	}
+	if inAgents {
+		return RoleWorker, nil
+	}
+	return "", nil
+}
+
+// usernameInTeam 檢查帳號是否為該團隊成員。
+func (s *Scanner) usernameInTeam(teamID int64, username string) (bool, error) {
+	members, err := s.Client.ListTeamMembers(teamID)
+	if err != nil {
+		return false, err
+	}
+	for _, m := range members {
+		if m == username {
+			return true, nil
+		}
+	}
+	return false, nil
+}
+
 // Orgs 回傳目前帳號所屬的組織（去重、排序）。
 func (s *Scanner) Orgs() ([]string, error) {
 	names, err := s.Client.ListOrgs()
@@ -136,7 +202,11 @@ func (s *Scanner) Members(hasWork bool) ([]string, error) {
 	return out, nil
 }
 
-// iterOrgRepos 產出 (org, repoName)；空倉庫跳過（沒有內容可掃）。
+// iterOrgRepos 產出 (org, repoName)。空倉庫（empty）**不**跳過：Gitea 允許
+// 空倉庫持有 open issue（如「初始化項目」型工作），gitea.py 的
+// for_all_repositories（list_my_followup_issues／for_all_organizations）
+// 掃 issue 時不檢查 empty；只有 PR 掃描（iterOpenPulls）、stalled 與
+// milestone overview 才跳過空倉庫。
 func (s *Scanner) iterOrgRepos() ([][2]string, error) {
 	orgs, err := s.Orgs()
 	if err != nil {
@@ -149,7 +219,7 @@ func (s *Scanner) iterOrgRepos() ([][2]string, error) {
 			return nil, err
 		}
 		for _, repo := range repos {
-			if repo.Name == "" || repo.Empty {
+			if repo.Name == "" {
 				continue
 			}
 			out = append(out, [2]string{org, repo.Name})
@@ -198,6 +268,16 @@ type orgIssue struct {
 	Issue Issue
 }
 
+// commentsFor 取回 issue／PR 的留言；number 缺漏（0）時直接視為無留言，
+// 不打 API（gitea.py 在 number 為 None 時跳過留言檢查的語義——
+// 避免拿 0 去 issues/0/comments 觸發 404 中斷整個掃描）。
+func (s *Scanner) commentsFor(owner, repo string, number int64) ([]Comment, error) {
+	if number <= 0 {
+		return nil, nil
+	}
+	return s.Client.ListComments(owner, repo, number)
+}
+
 // collectMemberIssues 跨組織收集分派給 members（至少一人）且最後一則留言
 // 不是 assignee 的 open issues（gitea.py 的 for_all_organizations）。
 func (s *Scanner) collectMemberIssues(members []string) ([]orgIssue, error) {
@@ -217,7 +297,7 @@ func (s *Scanner) collectMemberIssues(members []string) ([]orgIssue, error) {
 			if !AssigneeOverlaps(issue, members) {
 				continue
 			}
-			comments, err := s.Client.ListComments(owner, repo, issue.issueNumber())
+			comments, err := s.commentsFor(owner, repo, issue.issueNumber())
 			if err != nil {
 				return nil, err
 			}
@@ -275,7 +355,7 @@ func (s *Scanner) Pulls(mine, reviewer bool) ([]PullItem, error) {
 	for _, rp := range repoPulls {
 		for i := range rp.Pulls {
 			pr := &rp.Pulls[i]
-			comments, err := s.Client.ListComments(rp.Owner, rp.Repo, pr.Number)
+			comments, err := s.commentsFor(rp.Owner, rp.Repo, pr.Number)
 			if err != nil {
 				return nil, err
 			}
@@ -331,7 +411,7 @@ func (s *Scanner) usernamesWithUnfinishedWork(members []string) (map[string]bool
 	for _, rp := range repoPulls {
 		for i := range rp.Pulls {
 			pr := &rp.Pulls[i]
-			comments, err := s.Client.ListComments(rp.Owner, rp.Repo, pr.Number)
+			comments, err := s.commentsFor(rp.Owner, rp.Repo, pr.Number)
 			if err != nil {
 				return nil, err
 			}

internal/workflow/scan_test.go

@@ -164,6 +164,51 @@ func TestNextLayerFallbackToIssue(t *testing.T) {
 	}
 }
 
+// TestNextPicksIssueInEmptyRepo 回歸測試（#43）：空倉庫（empty=true）中
+// 分派給目前帳號的 open issue 應被第三層拾取——gitea.py 的
+// for_all_repositories 掃 issue 不跳過空倉庫（「初始化項目」型工作）。
+func TestNextPicksIssueInEmptyRepo(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.repos["alterminal"] = []Repo{
+		{Name: "teai"},
+		{Name: "colony-tick-demo", Empty: true},
+	}
+	fc.issues["alterminal/colony-tick-demo"] = []Issue{
+		{
+			Number: 1, Title: "初始化項目", UpdatedAt: "2026-09-08T00:00:00Z",
+			Assignees:  []User{*mkUser("alex")},
+			Repository: &Repository{FullName: "alterminal/colony-tick-demo"},
+			HTMLURL:    "https://gitea.alterminal.com/alterminal/colony-tick-demo/issues/1",
+		},
+	}
+	work, err := s.Next()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if work == nil || work.Type != "issue" || work.Number != 1 || work.Repo != "alterminal/colony-tick-demo" {
+		t.Errorf("應拾取空倉庫中的 issue #1，得到 %+v", work)
+	}
+}
+
+// TestMineIncludesEmptyRepoIssues 回歸測試（#43）：mine 同樣不因倉庫為空而漏列。
+func TestMineIncludesEmptyRepoIssues(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.repos["alterminal"] = []Repo{
+		{Name: "teai"},
+		{Name: "colony-tick-demo", Empty: true},
+	}
+	fc.issues["alterminal/colony-tick-demo"] = []Issue{
+		{Number: 1, Title: "初始化項目", UpdatedAt: "2026-09-08T00:00:00Z", Assignees: []User{*mkUser("alex")}},
+	}
+	issues, err := s.Mine()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(issues) != 1 || issues[0].Num() != 1 {
+		t.Errorf("mine 應列出空倉庫中的 issue #1，得到 %d 件", len(issues))
+	}
+}
+
 func TestNextNone(t *testing.T) {
 	s, _ := newTestScanner()
 	work, err := s.Next()
@@ -243,6 +288,91 @@ func TestErrorPropagation(t *testing.T) {
 	}
 }
 
+func TestRoleWorker(t *testing.T) {
+	s, _ := newTestScanner()
+	got, err := s.Role()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != RoleWorker {
+		t.Errorf("Agents 團隊成員應為 worker，得到 %q", got)
+	}
+}
+
+func TestRoleSupervisor(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.teams["alterminal"] = []Team{
+		{ID: 1, Name: "Agents"},
+		{ID: 2, Name: "Supervisor"},
+	}
+	fc.teamMembers[2] = []string{"alex"}
+	got, err := s.Role()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != RoleSupervisor {
+		t.Errorf("Supervisor 團隊成員應為 supervisor，得到 %q", got)
+	}
+}
+
+func TestRoleSupervisorTakesPrecedence(t *testing.T) {
+	s, fc := newTestScanner()
+	// alex 同時在 Agents（newTestScanner 預設）與 Supervisor。
+	fc.teams["alterminal"] = []Team{
+		{ID: 1, Name: "Agents"},
+		{ID: 2, Name: "Supervisor"},
+	}
+	fc.teamMembers[2] = []string{"alex", "ceo"}
+	got, err := s.Role()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != RoleSupervisor {
+		t.Errorf("同時屬於兩者時應為 supervisor，得到 %q", got)
+	}
+}
+
+func TestRoleNone(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.currentUser = "outsider"
+	got, err := s.Role()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != "" {
+		t.Errorf("不在 Supervisor／Agents 應回空字串，得到 %q", got)
+	}
+}
+
+func TestRoleWorkerWhenSupervisorExists(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.teams["alterminal"] = []Team{
+		{ID: 1, Name: "Agents"},
+		{ID: 2, Name: "Supervisor"},
+	}
+	fc.teamMembers[2] = []string{"ceo"}
+	got, err := s.Role()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got != RoleWorker {
+		t.Errorf("只在 Agents、不在 Supervisor 應為 worker，得到 %q", got)
+	}
+}
+
+func TestRoleErrorPropagation(t *testing.T) {
+	s, fc := newTestScanner()
+	fc.failOn["teams"] = errors.New("boom")
+	if _, err := s.Role(); err == nil {
+		t.Errorf("ListTeams 錯誤應向上傳播")
+	}
+	delete(fc.failOn, "teams")
+	fc.failOn["members"] = errors.New("boom")
+	if _, err := s.Role(); err == nil {
+		t.Errorf("ListTeamMembers 錯誤應向上傳播")
+	}
+}
+
 func TestPullsDefault(t *testing.T) {
 	s, fc := newTestScanner()
 	fc.pulls["alterminal/teai"] = []PullRequest{

internal/workflow/stalled_entry_test.go

@@ -0,0 +1,334 @@
+// stalled_entry_test.go — RunStalled／ResolveIssueXrefs 高階入口的單元測試
+// （#7 CLI 接線；資料源注入假實作，離線可測）。
+package workflow
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+	"testing"
+	"time"
+)
+
+// fakeStalledSource 包 fakeSource 補上 StalledSource 面向。
+type fakeStalledSource struct {
+	*fakeSource
+	username string
+	// getIssueErr 模擬 GetIssue 失敗（xrefs 的 404 路徑）。
+	getIssueErr error
+	// timeline[owner/repo/number]：issue timeline 事件（無則回空清單，
+	// 模擬 API 成功但無事件；timelineErr 模擬拉取失敗）。
+	timeline    map[string][]TimelineEvent
+	timelineErr map[string]error
+}
+
+func (f *fakeStalledSource) CurrentUser() (string, error) { return f.username, nil }
+
+func (f *fakeStalledSource) IssueTimeline(owner, repo string, number int64) ([]TimelineEvent, error) {
+	key := fmt.Sprintf("%s/%s/%d", owner, repo, number)
+	if err := f.timelineErr[key]; err != nil {
+		return nil, err
+	}
+	return f.timeline[key], nil
+}
+
+func (f *fakeStalledSource) GetIssue(owner, repo string, number int64) (Issue, error) {
+	if f.getIssueErr != nil {
+		return Issue{}, f.getIssueErr
+	}
+	i, ok := f.issues[owner+"/"+repo][number]
+	if !ok {
+		return Issue{}, &notFoundError{}
+	}
+	return i, nil
+}
+
+type notFoundError struct{}
+
+func (e *notFoundError) Error() string { return "404" }
+
+// newStalledFixture 建構掃描情境：alterminal 組織兩個倉庫，
+// agents#1 是父追蹤項（引用 teai#2），teai#2 有較新留言。
+func newStalledFixture() *fakeStalledSource {
+	return &fakeStalledSource{
+		fakeSource: &fakeSource{
+			orgs: []string{"alterminal"},
+			repos: map[string][]Repo{"alterminal": {
+				{Name: "agents", HasPullRequests: boolPtr(true)},
+				{Name: "teai", HasPullRequests: boolPtr(true)},
+			}},
+			issues: map[string]map[int64]Issue{
+				"alterminal/agents": {
+					1: {Number: 1, Title: "父追蹤項", State: "open",
+						Body: "子項：teai#2", CreatedAt: iso(-600), UpdatedAt: iso(-600),
+						Repository: &Repository{FullName: "alterminal/agents"}},
+				},
+				"alterminal/teai": {
+					2: {Number: 2, Title: "子項", State: "open",
+						CreatedAt: iso(-500), UpdatedAt: iso(-90),
+						Repository: &Repository{FullName: "alterminal/teai"}},
+				},
+			},
+			pulls: map[string][]PullRequest{},
+			comments: map[string][]Comment{
+				"alterminal/teai/2": {
+					{CreatedAt: iso(-90), User: &User{UserName: "alex"}, Body: "推進中"},
+				},
+			},
+		},
+		username: "ceo",
+	}
+}
+
+// TestRunStalledParentTracking 驗證 RunStalled：父追蹤項把子項活動
+// 計入 last_activity（reason=parent-tracking），且門檻預設與覆寫皆可。
+func TestRunStalledParentTracking(t *testing.T) {
+	src := newStalledFixture()
+	// 預設 4 小時門檻：子項 90 分鐘前有活動 → 父項 last_activity 同步，
+	// 未過門檻，清單為空。
+	items, err := RunStalled(src, 0, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if len(items) != 0 {
+		t.Fatalf("預設門檻下不應有停滯項，得到 %d 筆", len(items))
+	}
+	// 門檻降到 1 小時：父追蹤項 last_activity 取子項活動（-90m）→
+	// 停滯 1.5h 列入（reason=parent-tracking、附 child_activity）；
+	// 子項 teai#2 本身也停滯 1.5h（no-assignee）。
+	items, err = RunStalled(src, 1, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if len(items) != 2 {
+		t.Fatalf("應有兩筆（父追蹤項＋子項），得到 %d：%+v", len(items), items)
+	}
+	var parent *Item
+	for i := range items {
+		if items[i].Number == 1 {
+			parent = &items[i]
+		}
+	}
+	if parent == nil {
+		t.Fatalf("找不到 agents#1：%+v", items)
+	}
+	if parent.Reason != "parent-tracking" || parent.Repo != "alterminal/agents" {
+		t.Fatalf("agents#1 應為 parent-tracking，得到 %s（%s）", parent.Reason, parent.Repo)
+	}
+	if len(parent.ChildActivity) == 0 {
+		t.Fatalf("parent-tracking 應附 child_activity")
+	}
+	if parent.StalledHours != 1.5 {
+		t.Fatalf("last_activity 應取子項活動（-90m → 1.5h），得到 %.1f", parent.StalledHours)
+	}
+}
+
+// TestRunStalledNudgeCooldown 驗證催促冷卻：最後留言出自目前帳號
+// 且在 24 小時內 → 不列入；冷卻過後再出現。
+func TestRunStalledNudgeCooldown(t *testing.T) {
+	src := newStalledFixture()
+	setIssueBody(src, "alterminal", "agents", 1, "") // 移除子項引用
+	src.comments["alterminal/agents/1"] = []Comment{
+		{CreatedAt: iso(-2), User: &User{UserName: "ceo"}},
+	}
+	findOne := func(items []Item) bool {
+		for _, it := range items {
+			if it.Repo == "alterminal/agents" && it.Number == 1 {
+				return true
+			}
+		}
+		return false
+	}
+	items, err := RunStalled(src, 1, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if findOne(items) {
+		t.Fatalf("催促冷卻期內（2 小時前留言）agents#1 不應列入，得到 %+v", items)
+	}
+	src.comments["alterminal/agents/1"] = []Comment{
+		{CreatedAt: iso(-30 * 60), User: &User{UserName: "ceo"}},
+	}
+	items, err = RunStalled(src, 1, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if !findOne(items) {
+		t.Fatalf("冷卻（24h）過後 agents#1 應再出現，得到 %+v", items)
+	}
+}
+
+// TestResolveIssueXrefs 驗證 xrefs 入口：內文與留言的引用解析、
+// 去重、出處標記與單段 repo 的存在性邊界。
+func TestResolveIssueXrefs(t *testing.T) {
+	src := newStalledFixture()
+	setIssueBody(src, "alterminal", "agents", 1, "看 teai#2 與 #7，另見 alterminal/teai#2")
+	src.comments["alterminal/agents/1"] = []Comment{
+		{Body: "teai#2 已處理", User: &User{UserName: "alex"}, CreatedAt: iso(-10)},
+		{Body: "nope#9 不存在", User: &User{UserName: "max"}, CreatedAt: iso(-5)},
+	}
+	// fixture 的組織倉庫只有 agents → teai#2 單段不解析（repo 不在
+	// alterminal 組織清單）；補上 teai 倉庫讓單段解析成立。
+	src.repos["alterminal"] = []Repo{
+		{Name: "agents", HasPullRequests: boolPtr(true)},
+		{Name: "teai", HasPullRequests: boolPtr(true)},
+	}
+	hits, err := ResolveIssueXrefs(src, "alterminal", "agents", 1)
+	if err != nil {
+		t.Fatalf("ResolveIssueXrefs: %v", err)
+	}
+	want := []XrefHit{
+		{Owner: "alterminal", Repo: "teai", Number: 2, Source: "body"},
+		{Owner: "alterminal", Repo: "agents", Number: 7, Source: "body"},
+	}
+	if len(hits) != len(want) {
+		t.Fatalf("應解析出 %d 筆（留言重複的 teai#2 去重、nope#9 略過），得到 %d：%+v",
+			len(want), len(hits), hits)
+	}
+	for i := range want {
+		if hits[i] != want[i] {
+			t.Fatalf("hits[%d] = %+v, want %+v", i, hits[i], want[i])
+		}
+	}
+}
+
+// TestResolveIssueXrefsCommentSource 驗證出處：僅出現在留言的引用
+// 標記為 comment。
+func TestResolveIssueXrefsCommentSource(t *testing.T) {
+	src := newStalledFixture()
+	setIssueBody(src, "alterminal", "agents", 1, "內文無引用")
+	src.comments["alterminal/agents/1"] = []Comment{
+		{Body: "追蹤 #9", User: &User{UserName: "alex"}, CreatedAt: iso(-10)},
+	}
+	hits, err := ResolveIssueXrefs(src, "alterminal", "agents", 1)
+	if err != nil {
+		t.Fatalf("ResolveIssueXrefs: %v", err)
+	}
+	if len(hits) != 1 || hits[0].Source != "comment" || hits[0].Number != 9 {
+		t.Fatalf("應輸出一筆 source=comment 的 #9，得到 %+v", hits)
+	}
+}
+
+// TestResolveIssueXrefsGetError 驗證 GetIssue 失敗（如 404）層層回傳，
+// 由 CLI 映射結束碼。
+func TestResolveIssueXrefsGetError(t *testing.T) {
+	src := newStalledFixture()
+	src.getIssueErr = &notFoundError{}
+	if _, err := ResolveIssueXrefs(src, "alterminal", "agents", 1); err == nil {
+		t.Fatalf("GetIssue 失敗應回傳錯誤")
+	}
+}
+
+func boolPtr(b bool) *bool { return &b }
+
+// setIssueBody 修改 map 內 issue 的內文（map 元素不可定址，需整體重塞）。
+func setIssueBody(src *fakeStalledSource, owner, repo string, number int64, body string) {
+	key := owner + "/" + repo
+	issue := src.issues[key][number]
+	issue.Body = body
+	src.issues[key][number] = issue
+}
+
+// TestResolveIssueXrefsEmptyBody 驗證無引用時輸出空（CLI 印 []）。
+func TestResolveIssueXrefsEmptyBody(t *testing.T) {
+	src := newStalledFixture()
+	setIssueBody(src, "alterminal", "agents", 1, strings.Repeat("無引用內文", 3))
+	delete(src.comments, "alterminal/agents/1")
+	hits, err := ResolveIssueXrefs(src, "alterminal", "agents", 1)
+	if err != nil {
+		t.Fatalf("ResolveIssueXrefs: %v", err)
+	}
+	if len(hits) != 0 {
+		t.Fatalf("無引用應輸出空清單，得到 %+v", hits)
+	}
+	_ = time.Now // time 僅供 iso/at 使用；保留 import。
+}
+
+// TestRunStalledChildXrefRefresh 回歸測試（agents #38、teai #34）：
+// 子項 updated_at 被跨 issue 引用（comment_ref）刷新時，子項有效活動
+// 應經 directLastActivity 排除引用事件後採計，父追蹤項的停滯時鐘
+// 不被虛假刷新。
+func TestRunStalledChildXrefRefresh(t *testing.T) {
+	src := newStalledFixture()
+	// 子項 teai#2：直接活動為 created(-500) 與留言(-90)，
+	// updated_at 卻是 -10（他處留言提及刷新）。
+	issue := src.issues["alterminal/teai"][2]
+	issue.UpdatedAt = iso(-10)
+	src.issues["alterminal/teai"][2] = issue
+	// timeline：-10 的刷新是 comment_ref（引用事件，排除），
+	// -90 有直接事件（label）可對應 → 有效活動 -90。
+	src.timeline = map[string][]TimelineEvent{
+		"alterminal/teai/2": {
+			{Type: "label", CreatedAt: iso(-90)},
+			{Type: "comment_ref", CreatedAt: iso(-10)},
+		},
+	}
+	// 門檻 1 小時：父項 last_activity 取子項有效活動 -90 → 停滯 1.5h 列入；
+	// 若誤採被刷新的 -10，父項與子項都不會列入。
+	items, err := RunStalled(src, 1, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if len(items) != 2 {
+		t.Fatalf("應有兩筆（父追蹤項＋子項），得到 %d：%+v", len(items), items)
+	}
+	var parent *Item
+	for i := range items {
+		if items[i].Repo == "alterminal/agents" && items[i].Number == 1 {
+			parent = &items[i]
+		}
+	}
+	if parent == nil {
+		t.Fatalf("找不到 agents#1：%+v", items)
+	}
+	if parent.Reason != "parent-tracking" {
+		t.Fatalf("agents#1 應為 parent-tracking，得到 %s", parent.Reason)
+	}
+	if parent.StalledHours != 1.5 {
+		t.Fatalf("父項停滯應以子項有效活動（-90m → 1.5h）計，得到 %.1f", parent.StalledHours)
+	}
+}
+
+// TestRunStalledTimelineAllXrefFallback 回歸測試（agents #40、teai #34）：
+// issue 自身 updated_at 晚於全部已知直接活動、且 timeline 全為引用事件時，
+// 回退已知直接活動的最晚時刻（不高估活動、不低估停滯）；
+// timeline 拉取失敗則保守沿用 updated_at。
+func TestRunStalledTimelineAllXrefFallback(t *testing.T) {
+	src := newStalledFixture()
+	setIssueBody(src, "alterminal", "agents", 1, "") // 移除父項引用，teai#2 獨立判定
+	delete(src.comments, "alterminal/teai/2")
+	// agents#1 給一則近期留言，避免本身停滯（10h）干擾本測試的斷言。
+	src.comments["alterminal/agents/1"] = []Comment{
+		{CreatedAt: iso(-10), User: &User{UserName: "alex"}},
+	}
+	// teai#2：僅有 created(-500) 此一已知直接活動，
+	// updated_at -10 完全由他處提及刷新。
+	issue := src.issues["alterminal/teai"][2]
+	issue.UpdatedAt = iso(-10)
+	src.issues["alterminal/teai"][2] = issue
+	// 情境一：timeline 全為引用事件 → 回退 knownMax（created -500）
+	// → 停滯 8.3h，超過預設門檻 4h，列入。
+	src.timeline = map[string][]TimelineEvent{
+		"alterminal/teai/2": {{Type: "issue_ref", CreatedAt: iso(-10)}},
+	}
+	items, err := RunStalled(src, 0, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if len(items) != 1 || items[0].Number != 2 {
+		t.Fatalf("全引用事件應回退直接活動 → teai#2 停滯 8.3h 列入，得到 %+v", items)
+	}
+	if items[0].StalledHours != 8.3 {
+		t.Fatalf("回退 created(-500) → 停滯應 8.3h，得到 %.1f", items[0].StalledHours)
+	}
+	// 情境二：timeline 拉取失敗 → 保守沿用 updated_at(-10) → 0.2h 未達門檻，不列入。
+	src.timeline = nil
+	src.timelineErr = map[string]error{"alterminal/teai/2": errors.New("boom")}
+	items, err = RunStalled(src, 0, at(0))
+	if err != nil {
+		t.Fatalf("RunStalled: %v", err)
+	}
+	if len(items) != 0 {
+		t.Fatalf("timeline 失敗應保守沿用 updated_at → 不列入，得到 %+v", items)
+	}
+}

internal/workflow/types.go

@@ -3,6 +3,8 @@ package workflow
 import (
 	"encoding/json"
 	"regexp"
+	"strings"
+	"time"
 )
 
 // User 是 Gitea API 的使用者物件（僅取工作流判斷會用到的欄位）。
@@ -65,6 +67,7 @@ type PRRef struct {
 
 // Comment 是 issue／PR 的討論留言（PR 的留言也走 issues comments 端點）。
 type Comment struct {
+	Body      string `json:"body"`
 	CreatedAt string `json:"created_at"`
 	User      *User  `json:"user"`
 }
@@ -82,6 +85,9 @@ type Issue struct {
 	Number      int64       `json:"number"`
 	Index       int64       `json:"index"`
 	Title       string      `json:"title"`
+	State       string      `json:"state"`
+	Body        string      `json:"body"`
+	ClosedAt    string      `json:"closed_at"`
 	HTMLURL     string      `json:"html_url"`
 	URL         string      `json:"url"`
 	UpdatedAt   string      `json:"updated_at"`
@@ -216,3 +222,21 @@ func (p *PullRequest) FullName() string {
 	}
 	return repoFullNameFromURL(p.WebURL())
 }
+
+// parseMoment 對應 gitea.py 的 _parse_iso8601：剖析 ISO8601 字串（Z 後綴、
+// 小數秒、時區偏移皆可；無時區視為 UTC），失敗回 (零值, false)。
+// 保留原時區偏移、不轉 UTC——Python datetime.isoformat() 會原樣輸出
+// 「+08:00」這類偏移，轉了 UTC 輸出就變 +00:00，與基準位元組不相容。
+// stalled 掃描的時刻判斷（last_activity、催促冷卻）都以這裡的語義為準。
+func parseMoment(value string) (time.Time, bool) {
+	text := strings.TrimSpace(value)
+	if text == "" {
+		return time.Time{}, false
+	}
+	for _, layout := range []string{time.RFC3339Nano, time.RFC3339, "2006-01-02T15:04:05", "2006-01-02"} {
+		if t, err := time.Parse(layout, text); err == nil {
+			return t, true
+		}
+	}
+	return time.Time{}, false
+}

internal/workflow/workflow.go

@@ -0,0 +1,730 @@
+// 套件 workflow 實作 gitea.py 工作流的核心判定邏輯（teai issue #7）。
+//
+// 行為基準是 alterminal/agents 的 scripts/lib/gitea.py：xref 解析
+// （#N、repo#N、owner/repo#N）與 stalled 停滯掃描（reason 分類、催促冷卻、
+// 父追蹤項把子項活動計入 last_activity）。判定規則以 AGENTS.md 為準，
+// 本套件只實作、不改義。
+//
+// 資料以 Source 介面注入：CLI 層負責拉取 API，測試用假資料源，
+// 邏輯本身離線可測（README 設計原則 4：可直接替換原型、交叉驗證）。
+package workflow
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+)
+
+// 常數與 gitea.py 保持一致（STALLED_DEFAULT_HOURS、NUDGE_COOLDOWN_HOURS）。
+const (
+	// StalledDefaultHours 是 stalled 掃描的預設門檻（小時）。
+	StalledDefaultHours = 4.0
+	// NudgeCooldownHours 是「最後留言出自目前帳號」項目的催促冷卻（小時）。
+	NudgeCooldownHours = 24.0
+)
+
+// xrefTimelineTypes 對應 gitea.py 的 XREF_TIMELINE_TYPES：他處留言／issue
+// 提及本編號時產生的 timeline 引用事件。這類事件會刷新 updated_at，但不是
+// 本 issue 的直接活動，directLastActivity 會予以排除（agents issue #34）。
+var xrefTimelineTypes = map[string]bool{"comment_ref": true, "issue_ref": true}
+
+// xrefPattern 對應 gitea.py 的 XREF_PATTERN：#N、repo#N、owner/repo#N。
+//
+// 前面不得是文數字／底線／斜線（避免切進 alterminal/bear#47 的後半段）；
+// owner/repo 兩段之間必須有斜線（避免把 bear-cli#10 誤判成 cli#10）。
+// Go 的 regexp 不支援 lookbehind，改在掃描時檢查前一字元。
+var xrefPattern = regexp.MustCompile(`([A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)?)?#(\d+)`)
+
+// Item 是 stalled 掃描的單筆輸出（欄位對應 gitea.py 的 find_stalled_work）。
+type Item struct {
+	Type           string
+	Repo           string
+	Number         int64
+	Title          string
+	URL            string
+	Assignees      []string
+	Author         string
+	Reviewers      []string
+	LastCommentBy  string
+	LastActivityAt time.Time
+	StalledHours   float64
+	Reason         string
+	ChildActivity  []Child
+}
+
+// MarshalJSON 輸出鍵集與鍵序與 gitea.py 完全一致的物件：
+// issue 帶 assignees；pull 帶 author 與 reviewers；
+// child_activity 僅在有子項摘要時輸出。
+func (i Item) MarshalJSON() ([]byte, error) {
+	var b strings.Builder
+	b.WriteString(`{"type":`)
+	writeJSON(&b, i.Type)
+	b.WriteString(`,"repo":`)
+	writeJSON(&b, i.Repo)
+	b.WriteString(`,"number":`)
+	fmt.Fprintf(&b, "%d", i.Number)
+	b.WriteString(`,"title":`)
+	writeJSON(&b, i.Title)
+	b.WriteString(`,"url":`)
+	writeJSON(&b, i.URL)
+	if i.Type == "pull" {
+		b.WriteString(`,"author":`)
+		writeJSON(&b, i.Author)
+		b.WriteString(`,"reviewers":`)
+		writeJSON(&b, i.Reviewers)
+	} else {
+		b.WriteString(`,"assignees":`)
+		writeJSON(&b, i.Assignees)
+	}
+	b.WriteString(`,"last_comment_by":`)
+	writeJSON(&b, i.LastCommentBy)
+	b.WriteString(`,"last_activity_at":`)
+	writeJSON(&b, FormatMoment(i.LastActivityAt))
+	b.WriteString(`,"stalled_hours":`)
+	// Python round(x, 1) 的 json 輸出是 48.0／10.4（repr 帶 .0）；
+	// %g 會輸出 48，極大值還會變 1e+06，改定點一位小數。
+	b.WriteString(strconv.FormatFloat(i.StalledHours, 'f', 1, 64))
+	b.WriteString(`,"reason":`)
+	writeJSON(&b, i.Reason)
+	if len(i.ChildActivity) > 0 {
+		b.WriteString(`,"child_activity":`)
+		writeJSON(&b, i.ChildActivity)
+	}
+	b.WriteString(`}`)
+	return []byte(b.String()), nil
+}
+
+// FormatMoment 輸出與 Python datetime.isoformat() 一致的時刻字串
+// （UTC 以 +00:00 表示，不用 Z；秒以下省略）。
+func FormatMoment(t time.Time) string {
+	if t.Nanosecond() != 0 {
+		return t.Format("2006-01-02T15:04:05.999999999-07:00")
+	}
+	return t.Format("2006-01-02T15:04:05-07:00")
+}
+
+// writeJSON 以停用 HTML 轉義的編碼器輸出：Python json.dumps（ensure_ascii=False）
+// 不會把 <、>、& 轉成 \u003c 等逸出，json.Marshal 預設會，造成位元組不相容。
+// Encoder 會在結尾補換行， trim 掉。
+func writeJSON(b *strings.Builder, v any) {
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(v); err != nil {
+		return
+	}
+	b.Write(bytes.TrimSuffix(buf.Bytes(), []byte{'\n'}))
+}
+
+// Child 是父追蹤項的子項活動摘要。
+type Child struct {
+	Repo   string `json:"repo"`
+	Number int64  `json:"number"`
+	Title  string `json:"title"`
+	State  string `json:"state"`
+	// LastActivityAt 用指標：子項無可解析時刻時 Python 輸出 null（不是 ""）。
+	LastActivityAt *string `json:"last_activity_at"`
+}
+
+// XrefTarget 是解析後的引用目標（owner、repo、number）。
+type XrefTarget struct {
+	Owner  string
+	Repo   string
+	Number int64
+}
+
+// Source 是 stalled 掃描需要的資料源（CLI 層以 API 實作；測試注入假資料）。
+type Source interface {
+	// MyOrganizations 回傳目前帳號所屬組織清單。
+	MyOrganizations() ([]string, error)
+	// OrganizationRepositories 回傳組織的倉庫清單。
+	OrganizationRepositories(org string) ([]Repo, error)
+	// OpenIssues 回傳倉庫的 open issues（Gitea 會混入 PR，由掃描端過濾）。
+	OpenIssues(owner, repo string) ([]Issue, error)
+	// OpenPulls 回傳倉庫的 open pull requests。
+	OpenPulls(owner, repo string) ([]PullRequest, error)
+	// IssueComments 回傳 issue／PR 的留言。
+	IssueComments(owner, repo string, number int64) ([]Comment, error)
+	// TryGetIssue 寬容版單一 issue 查詢：失敗（含 404）回 (零值, false, nil)。
+	TryGetIssue(owner, repo string, number int64) (Issue, bool, error)
+	// IssueTimeline 回傳 issue 的 timeline 事件（GET /repos/{o}/{r}/issues/{n}/timeline，
+	// 分頁）。directLastActivity 用來排除跨 issue 引用事件（agents issue #34）。
+	IssueTimeline(owner, repo string, number int64) ([]TimelineEvent, error)
+}
+
+// iterXrefs 產出文字中的 (prefix, number) 配對（對應 _iter_issue_xrefs）。
+//
+// Python 原版以 lookbehind (?<![\w/#]) 在匹配起點檢查前一「字元」，
+// 且 \w 採 Unicode（中日韓、全形數字都算）。Go regexp 不支援 lookbehind，
+// 改為掃描時檢查起點前一 rune：是文數字（Unicode）／底線／斜線／# 者略過，
+// 並從起點的下一個 rune 重試——與 Python finditer 的逐位置語義一致，
+// 否則「修復bear-cli#9」這種寫法會整段被丟棄（Python 只匹配後半 cli#9）。
+func iterXrefs(text string) [][2]string {
+	var out [][2]string
+	pos := 0
+	for pos <= len(text) {
+		m := xrefPattern.FindStringIndex(text[pos:])
+		if m == nil {
+			break
+		}
+		start, end := pos+m[0], pos+m[1]
+		if start > 0 {
+			prev, _ := utf8.DecodeLastRuneInString(text[:start])
+			if isWordChar(prev) || prev == '/' || prev == '#' {
+				_, size := utf8.DecodeRuneInString(text[start:])
+				pos = start + size
+				continue
+			}
+		}
+		match := text[start:end]
+		i := strings.IndexByte(match, '#')
+		prefix := match[:i]
+		number := match[i+1:]
+		out = append(out, [2]string{prefix, number})
+		pos = end
+	}
+	return out
+}
+
+// isWordChar 對應 Python \w（Unicode）：字母／數字／底線。
+// 前一版只認 ASCII，中文緊鄰 #N 時（「修復#12」）與 Python 行為分歧。
+func isWordChar(r rune) bool {
+	return r == '_' || unicode.IsLetter(r) || unicode.IsDigit(r)
+}
+
+// ResolveXrefTargets 把內文／留言中的引用解析成目標清單（對應 _resolve_xref_targets）。
+//
+// 單段 #N 指向父項所在倉庫；單段 repo#N 需 repo 存在於父項所屬組織
+// （「PR#50」這類寫法因 repo 不存在而自動略過）；owner/repo#N 需 owner
+// 為目前帳號所屬組織（跨倉庫子項，如 bear-cli#9 → bear#35 的同組織判定）。
+// 去重、保留出現順序。
+func ResolveXrefTargets(org, repo string, texts []string, myOrgs map[string]bool, orgRepos func(org string) ([]string, error)) ([]XrefTarget, error) {
+	var resolved []XrefTarget
+	seen := map[XrefTarget]bool{}
+	var orgRepoSet map[string]bool
+	for _, text := range texts {
+		for _, pair := range iterXrefs(text) {
+			prefix, numberStr := pair[0], pair[1]
+			var number int64
+			if _, err := fmt.Sscanf(numberStr, "%d", &number); err != nil || number <= 0 {
+				continue
+			}
+			var target XrefTarget
+			switch {
+			case strings.Contains(prefix, "/"):
+				parts := strings.SplitN(prefix, "/", 2)
+				owner, name := parts[0], parts[1]
+				if owner != "" && name != "" && myOrgs[owner] {
+					target = XrefTarget{owner, name, number}
+				}
+			case prefix != "":
+				if orgRepoSet == nil {
+					names, err := orgRepos(org)
+					if err != nil {
+						return nil, err
+					}
+					orgRepoSet = map[string]bool{}
+					for _, n := range names {
+						orgRepoSet[n] = true
+					}
+				}
+				if orgRepoSet[prefix] {
+					target = XrefTarget{org, prefix, number}
+				}
+			default:
+				target = XrefTarget{org, repo, number}
+			}
+			if target != (XrefTarget{}) && !seen[target] {
+				seen[target] = true
+				resolved = append(resolved, target)
+			}
+		}
+	}
+	return resolved, nil
+}
+
+// childActivity 計算父追蹤項的子項活動（對應 _child_activity）。
+//
+// 只採計向下引用：子項建立時間需晚於父項（父項內文回指更早的規劃 issue
+// 是上行引用，不採計）。資料源失敗（含編號不存在）靜默略過，不影響掃描。
+func childActivity(src Source, org, repo string, parent Issue, comments []Comment, myOrgs map[string]bool, orgRepos func(string) ([]string, error)) (moments []time.Time, children []Child) {
+	texts := []string{parent.Body}
+	for _, c := range comments {
+		texts = append(texts, c.Body)
+	}
+	targets, err := ResolveXrefTargets(org, repo, texts, myOrgs, orgRepos)
+	if err != nil {
+		return nil, nil
+	}
+	for _, t := range targets {
+		child, ok, gerr := src.TryGetIssue(t.Owner, t.Repo, t.Number)
+		if gerr != nil || !ok {
+			continue
+		}
+		if t.Owner == org && t.Repo == repo && child.issueNumber() == parent.issueNumber() {
+			continue // 自我引用
+		}
+		parentCreated, pcOK := parseMoment(parent.CreatedAt)
+		childCreated, ccOK := parseMoment(child.CreatedAt)
+		if pcOK && ccOK && !childCreated.After(parentCreated) {
+			continue // 上行引用（父項回指更早或同時的 issue）；時間未知則不排除
+		}
+		// 子項的直接活動：created_at、state 變更（closed_at）、留言（agents #32）。
+		// 原始 updated_at 不放入已知活動，另經 directLastActivity 核對後採計
+		//（與 considerIssue／considerPull 對本 issue 自身的處理同構）。
+		var ms []time.Time
+		if m, ok := parseMoment(child.CreatedAt); ok {
+			ms = append(ms, m)
+		}
+		if m, ok := parseMoment(child.ClosedAt); ok {
+			ms = append(ms, m)
+		}
+		if cs, cerr := src.IssueComments(t.Owner, t.Repo, t.Number); cerr == nil {
+			for _, c := range cs {
+				if m, ok := parseMoment(c.CreatedAt); ok {
+					ms = append(ms, m)
+				}
+			}
+		}
+		if childUpdated, ok := parseMoment(child.UpdatedAt); ok {
+			// 子項 updated_at 可能被 comment_ref／issue_ref 引用事件刷新
+			//（agents #38）：走與本 issue 自身相同的 directLastActivity 排除
+			// 邏輯（同源判定，不漂移）；timeline 失敗時保守沿用 updated_at。
+			if d, ok := directLastActivity(src, t.Owner, t.Repo, t.Number, childUpdated, true, ms); ok {
+				ms = append(ms, d)
+			}
+		}
+		var last *string
+		if len(ms) > 0 {
+			latest := maxTime(ms)
+			moments = append(moments, latest)
+			// 與 Item 相同用 FormatMoment（Python isoformat：UTC 記 +00:00）；
+			// RFC3339 對 UTC 會輸出 Z，與基準不相容。
+			s := FormatMoment(latest)
+			last = &s
+		}
+		children = append(children, Child{
+			Repo:           t.Owner + "/" + t.Repo,
+			Number:         child.Number,
+			Title:          child.Title,
+			State:          child.State,
+			LastActivityAt: last,
+		})
+	}
+	return moments, children
+}
+
+// TimelineEvent 是 issue timeline 的單一事件（僅取判斷所需欄位；
+// 對應 gitea.py _direct_last_activity 讀取的 timeline 物件）。
+type TimelineEvent struct {
+	Type      string `json:"type"`
+	CreatedAt string `json:"created_at"`
+}
+
+// directLastActivity 排除跨 issue 引用事件後，本 issue 的最後直接活動時刻
+// （對應 gitea.py 的 _direct_last_activity；agents issues #34/#38/#40）。
+//
+// 他處留言／issue 提及本編號（comment_ref／issue_ref）也會刷新 updated_at，
+// 直接採用會虛假刷新停滯時鐘（false negative）並低估 stalled_hours。
+// updated_at 不晚於已知直接活動（留言、created_at、#32 納入的子項活動）時，
+// updated_at 本身可信，不必多打一次 timeline API；只有 updated_at 晚於全部
+// 已知活動時才拉 timeline 核對：排除引用類事件後取最晚事件時刻；若最晚的
+// 都是引用事件（本 issue 無直接活動可對應 updated_at），則回退已知直接活動
+// 的最晚時刻（agents #40）。timeline 拉取失敗時沿用 updated_at（不中斷掃描、
+// 寧可少報不誤報缺失活動）。
+func directLastActivity(src Source, org, repo string, number int64, updatedAt time.Time, hasUpdated bool, known []time.Time) (time.Time, bool) {
+	if !hasUpdated {
+		return time.Time{}, false
+	}
+	var knownMax *time.Time
+	for i := range known {
+		if known[i].IsZero() {
+			continue
+		}
+		if knownMax == nil || known[i].After(*knownMax) {
+			m := known[i]
+			knownMax = &m
+		}
+	}
+	if knownMax == nil || !updatedAt.After(*knownMax) {
+		return updatedAt, true
+	}
+	timeline, err := src.IssueTimeline(org, repo, number)
+	if err != nil {
+		return updatedAt, true
+	}
+	var moments []time.Time
+	for _, e := range timeline {
+		if xrefTimelineTypes[e.Type] {
+			continue
+		}
+		if m, ok := parseMoment(e.CreatedAt); ok {
+			moments = append(moments, m)
+		}
+	}
+	if len(moments) == 0 {
+		// timeline 全為引用事件：updated_at 完全由他處提及刷新，本 issue 沒有
+		// 可對應的直接活動。回退已知直接活動的最晚時刻，避免把被刷新的
+		// updated_at 當活動、低估停滯時數（agents #40）；連已知活動都沒有時才
+		// 保守沿用 updated_at（不中斷掃描、寧可少報不誤報缺失活動）。
+		if knownMax != nil {
+			return *knownMax, true
+		}
+		return updatedAt, true
+	}
+	latest := maxTime(moments)
+	if latest.Before(updatedAt) {
+		return latest, true
+	}
+	return updatedAt, true
+}
+
+func maxTime(ts []time.Time) time.Time {
+	best := ts[0]
+	for _, t := range ts[1:] {
+		if t.After(best) {
+			best = t
+		}
+	}
+	return best
+}
+
+// ScanStalled 掃描跨組織的停滯 open issues／PR（對應 find_stalled_work）。
+//
+// 判定：最後活動（留言時間與本身 updated_at 取較晚者，父追蹤項再加計
+// 子項活動）距今超過 threshold 小時。刻意包含拾取死角形態：最後一則留言
+// 出自 assignee／PR 作者本人且超過時限——工作休眠、無人催促。最後留言
+// 出自目前帳號（username）的項目在冷卻期間不列入（已催促過）；冷卻後
+// 仍停滯會再出現。輸出依停滯時間由長到短排序。
+func ScanStalled(src Source, username string, threshold float64, now time.Time) ([]Item, error) {
+	orgs, err := src.MyOrganizations()
+	if err != nil {
+		return nil, err
+	}
+	myOrgs := make(map[string]bool, len(orgs))
+	for _, o := range orgs {
+		myOrgs[o] = true
+	}
+	orgRepos := func(org string) ([]string, error) {
+		repos, err := src.OrganizationRepositories(org)
+		if err != nil {
+			return nil, err
+		}
+		names := make([]string, 0, len(repos))
+		for _, r := range repos {
+			if r.Name != "" {
+				names = append(names, r.Name)
+			}
+		}
+		return names, nil
+	}
+	var items []Item
+	for _, org := range orgs {
+		repos, err := src.OrganizationRepositories(org)
+		if err != nil {
+			continue
+		}
+		for _, r := range repos {
+			if r.Name == "" || r.Empty {
+				continue
+			}
+			// 停用 PR 的倉庫沒有 PR 可掃；issues 照常（gitea.py _iter_open_issues 不檢查此欄位）。
+			scanPulls := r.HasPullRequests == nil || *r.HasPullRequests
+			issues, err := src.OpenIssues(org, r.Name)
+			if err != nil {
+				continue
+			}
+			for _, issue := range issues {
+				if issue.PullRequest != nil {
+					continue
+				}
+				comments, err := src.IssueComments(org, r.Name, issue.Number)
+				if err != nil {
+					continue
+				}
+				item, ok := considerIssue(src, org, r.Name, issue, comments, username, threshold, now, myOrgs, orgRepos)
+				if ok {
+					items = append(items, item)
+				}
+			}
+			if !scanPulls {
+				continue
+			}
+			pulls, err := src.OpenPulls(org, r.Name)
+			if err != nil {
+				continue
+			}
+			for _, pr := range pulls {
+				comments, err := src.IssueComments(org, r.Name, pr.Number)
+				if err != nil {
+					continue
+				}
+				if item, ok := considerPull(src, org, r.Name, pr, comments, username, threshold, now); ok {
+					items = append(items, item)
+				}
+			}
+		}
+	}
+	sort.SliceStable(items, func(i, j int) bool {
+		return items[i].StalledHours > items[j].StalledHours
+	})
+	return items, nil
+}
+
+// considerIssue 對單一 issue 套用停滯判定（對應 _consider 的 issue 分支）。
+func considerIssue(src Source, org, repo string, issue Issue, comments []Comment, username string, threshold float64, now time.Time, myOrgs map[string]bool, orgRepos func(string) ([]string, error)) (Item, bool) {
+	childMoments, children := childActivity(src, org, repo, issue, comments, myOrgs, orgRepos)
+	assignees := AssigneeNames(&issue)
+	// 已知直接活動：留言、created_at、#32 納入的子項活動。
+	var known []time.Time
+	if m, ok := parseMoment(issue.CreatedAt); ok {
+		known = append(known, m)
+	}
+	for _, c := range comments {
+		if m, ok := parseMoment(c.CreatedAt); ok {
+			known = append(known, m)
+		}
+	}
+	known = append(known, childMoments...)
+	// 跨 issue 引用（comment_ref／issue_ref）也會刷新 updated_at（agents #34）：
+	// updated_at 晚於全部已知直接活動時，先排除引用事件核對後才採用，
+	// 避免停滯時鐘被虛假刷新或低估 stalled_hours。
+	var moments []time.Time
+	if m, ok := parseMoment(issue.UpdatedAt); ok {
+		if d, ok2 := directLastActivity(src, org, repo, issue.issueNumber(), m, ok, known); ok2 {
+			moments = append(moments, d)
+		}
+	}
+	moments = append(moments, known...)
+	if len(moments) == 0 {
+		return Item{}, false
+	}
+	lastActivity := maxTime(moments)
+	stalled := now.Sub(lastActivity).Hours()
+	if stalled < threshold {
+		return Item{}, false
+	}
+	last := LastComment(comments)
+	lastCommentBy := ""
+	if last != nil {
+		lastCommentBy = last.Author()
+	}
+	if lastCommentBy == username {
+		if m, ok := parseMoment(last.CreatedAt); ok && now.Sub(m).Hours() < NudgeCooldownHours {
+			return Item{}, false
+		}
+	}
+	reason := "waiting-outside"
+	switch {
+	case len(assignees) == 0:
+		reason = "no-assignee"
+	case lastCommentBy != "" && containsString(assignees, lastCommentBy):
+		reason = "assignee-idle"
+	case lastCommentBy == "":
+		reason = "no-commenter"
+	}
+	if len(children) > 0 {
+		// 父追蹤項一律標 parent-tracking（agents #44，與 gitea.py 同步）：
+		// 有 open 子項在推進時，父項留言閒置屬等待子項；子項全關閉時只剩
+		// 父項收尾（回報驗收並關閉），兩者都不是 assignee 停滯。統一標記
+		// 讓「父項收尾」規則能正確匹配，不退回通用原因（如 assignee-idle）。
+		reason = "parent-tracking"
+	}
+	item := Item{
+		Type: "issue", Repo: issue.FullName(), Number: issue.issueNumber(),
+		Title: issue.Title, URL: issue.WebURL(),
+		Assignees:     assignees,
+		LastCommentBy: lastCommentBy, LastActivityAt: lastActivity,
+		StalledHours: round1(stalled), Reason: reason,
+	}
+	if len(children) > 0 {
+		item.ChildActivity = children
+	}
+	return item, true
+}
+
+// considerPull 對單一 PR 套用停滯判定（對應 _consider 的 pull 分支）。
+func considerPull(src Source, org, repo string, pr PullRequest, comments []Comment, username string, threshold float64, now time.Time) (Item, bool) {
+	reviewers := ReviewerNames(&pr)
+	author := pr.Author()
+	// 已知直接活動：留言、created_at。
+	var known []time.Time
+	if m, ok := parseMoment(pr.CreatedAt); ok {
+		known = append(known, m)
+	}
+	for _, c := range comments {
+		if m, ok := parseMoment(c.CreatedAt); ok {
+			known = append(known, m)
+		}
+	}
+	// 跨 issue 引用也會刷新 PR 的 updated_at（agents #34）：與 issue 同一道
+	// directLastActivity 排除邏輯（同源判定，不漂移）。
+	var moments []time.Time
+	if m, ok := parseMoment(pr.UpdatedAt); ok {
+		if d, ok2 := directLastActivity(src, org, repo, pr.Number, m, ok, known); ok2 {
+			moments = append(moments, d)
+		}
+	}
+	moments = append(moments, known...)
+	if len(moments) == 0 {
+		return Item{}, false
+	}
+	lastActivity := maxTime(moments)
+	stalled := now.Sub(lastActivity).Hours()
+	if stalled < threshold {
+		return Item{}, false
+	}
+	last := LastComment(comments)
+	lastCommentBy := ""
+	if last != nil {
+		lastCommentBy = last.Author()
+	}
+	if lastCommentBy == username {
+		if m, ok := parseMoment(last.CreatedAt); ok && now.Sub(m).Hours() < NudgeCooldownHours {
+			return Item{}, false
+		}
+	}
+	reason := "no-commenter"
+	switch {
+	case len(reviewers) == 0:
+		reason = "no-reviewer"
+	case lastCommentBy == author:
+		reason = "author-idle"
+	case lastCommentBy != "" && containsString(reviewers, lastCommentBy):
+		reason = "reviewer-idle"
+	}
+	item := Item{
+		Type: "pull", Repo: pr.FullName(), Number: pr.Number,
+		Title: pr.Title, URL: pr.WebURL(),
+		Author: author, Reviewers: reviewers,
+		LastCommentBy: lastCommentBy, LastActivityAt: lastActivity,
+		StalledHours: round1(stalled), Reason: reason,
+	}
+	return item, true
+}
+
+// round1 舍入到小數一位（對應 Python round(x, 1)）。
+// 經 strconv 的十進位正確舍入（半偶數），與 Python 的浮點 round 行為一致，
+// 避免 (x*10+0.5) 截斷在 .x5 邊界產生偏差。
+func round1(v float64) float64 {
+	r, err := strconv.ParseFloat(strconv.FormatFloat(v, 'f', 1, 64), 64)
+	if err != nil {
+		return v
+	}
+	return r
+}
+
+// ── CLI 接線用的高階入口（#7：teai stalled／teai xrefs）─────────────────
+
+// StalledSource 是 stalled／xrefs 命令需要的完整資料源：
+// Source（掃描用讀取）加上目前帳號與單一 issue 查詢。
+// APIClient（giteaapi.go）實作此介面；測試以假資料源注入。
+type StalledSource interface {
+	Source
+	// CurrentUser 回傳目前帳號名（催促冷卻判定用）。
+	CurrentUser() (string, error)
+	// GetIssue 嚴格版單一 issue／PR 查詢；失敗回錯誤（xrefs 命令用，
+	// 404 應回 ErrAPI 由 CLI 映射結束碼 3）。
+	GetIssue(owner, repo string, number int64) (Issue, error)
+}
+
+// RunStalled 是 teai stalled 的核心：解析目前帳號後跑 ScanStalled。
+// hours <= 0 時採 StalledDefaultHours（對應 gitea.py stalled [--hours N]
+// 的預設 4 小時）；旗標層已先攔下非正數，這裡是防禦。
+func RunStalled(src StalledSource, hours float64, now time.Time) ([]Item, error) {
+	if hours <= 0 {
+		hours = StalledDefaultHours
+	}
+	username, err := src.CurrentUser()
+	if err != nil {
+		return nil, err
+	}
+	return ScanStalled(src, username, hours, now)
+}
+
+// XrefHit 是 teai xrefs 的單筆輸出：解析後的目標加上出處
+// （README 規格："body"＝內文、"comment"＝留言）。
+type XrefHit struct {
+	Owner  string `json:"owner"`
+	Repo   string `json:"repo"`
+	Number int64  `json:"number"`
+	Source string `json:"source"`
+}
+
+// ResolveIssueXrefs 是 teai xrefs 的核心：取回單一 issue／PR 的內文與
+// 全部留言，解析其中的 #N、repo#N、owner/repo#N 引用（規則同
+// ResolveXrefTargets：單段 repo 僅在父項所屬組織有該倉庫時解析、
+// owner/repo#N 僅在 owner 為所屬組織時解析），去重並保留出現順序，
+// 每筆附首次出現的出處（內文先於留言）。stalled 的父追蹤項判定
+// 內部用同一套解析，不重複實作。
+func ResolveIssueXrefs(src StalledSource, owner, repo string, number int64) ([]XrefHit, error) {
+	issue, err := src.GetIssue(owner, repo, number)
+	if err != nil {
+		return nil, err
+	}
+	comments, err := src.IssueComments(owner, repo, number)
+	if err != nil {
+		return nil, err
+	}
+	orgs, err := src.MyOrganizations()
+	if err != nil {
+		return nil, err
+	}
+	myOrgs := make(map[string]bool, len(orgs))
+	for _, o := range orgs {
+		myOrgs[o] = true
+	}
+	// 組織倉庫清單跨呼叫快取，避免逐則留言重打 API。
+	orgRepoCache := map[string][]string{}
+	orgRepos := func(org string) ([]string, error) {
+		if names, ok := orgRepoCache[org]; ok {
+			return names, nil
+		}
+		repos, err := src.OrganizationRepositories(org)
+		if err != nil {
+			return nil, err
+		}
+		names := make([]string, 0, len(repos))
+		for _, r := range repos {
+			if r.Name != "" {
+				names = append(names, r.Name)
+			}
+		}
+		orgRepoCache[org] = names
+		return names, nil
+	}
+	type sourceText struct {
+		text   string
+		source string
+	}
+	texts := []sourceText{{issue.Body, "body"}}
+	for _, c := range comments {
+		texts = append(texts, sourceText{c.Body, "comment"})
+	}
+	var hits []XrefHit
+	seen := map[XrefTarget]bool{}
+	for _, t := range texts {
+		targets, err := ResolveXrefTargets(owner, repo, []string{t.text}, myOrgs, orgRepos)
+		if err != nil {
+			return nil, err
+		}
+		for _, target := range targets {
+			if seen[target] {
+				continue
+			}
+			seen[target] = true
+			hits = append(hits, XrefHit{
+				Owner: target.Owner, Repo: target.Repo,
+				Number: target.Number, Source: t.source,
+			})
+		}
+	}
+	return hits, nil
+}

internal/workflow/workflow_test.go

@@ -0,0 +1,597 @@
+// workflow 套件的單元測試（teai issue #7 驗收：xref 邊界案例與 stalled 判定）。
+//
+// fakeSource 以假資料實作 Source 介面，邏輯離線可測；
+// 語義對照組是 alterminal/agents scripts/lib/gitea.py。
+package workflow
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+	"testing"
+	"time"
+)
+
+func at(minutes int) time.Time {
+	return time.Date(2026, 9, 10, 8, 0, 0, 0, time.UTC).Add(time.Duration(minutes) * time.Minute)
+}
+
+// fakeSource 是注入假資料的 Source。
+type fakeSource struct {
+	orgs  []string
+	repos map[string][]Repo
+	// issues[owner/repo][number]
+	issues map[string]map[int64]Issue
+	// pulls[owner/repo]
+	pulls map[string][]PullRequest
+	// comments[owner/repo/number]
+	comments map[string][]Comment
+	// timelines[owner/repo/number]：issue timeline 事件（nil → 空 timeline）。
+	timelines map[string][]TimelineEvent
+}
+
+func (f *fakeSource) MyOrganizations() ([]string, error) { return f.orgs, nil }
+
+func (f *fakeSource) OrganizationRepositories(org string) ([]Repo, error) {
+	return f.repos[org], nil
+}
+
+func (f *fakeSource) OpenIssues(owner, repo string) ([]Issue, error) {
+	var out []Issue
+	for _, i := range f.issues[owner+"/"+repo] {
+		if i.State == "closed" {
+			continue // 對齊真實 API：OpenIssues 只回 open；closed 條目僅供 TryGetIssue 解引用。
+		}
+		out = append(out, i)
+	}
+	// 對齊真實 API：issues 依 id（=number）遞增回傳，消除 map 迭代隨機性。
+	sort.Slice(out, func(a, b int) bool { return out[a].Number < out[b].Number })
+	return out, nil
+}
+
+func (f *fakeSource) OpenPulls(owner, repo string) ([]PullRequest, error) {
+	return f.pulls[owner+"/"+repo], nil
+}
+
+func (f *fakeSource) IssueComments(owner, repo string, number int64) ([]Comment, error) {
+	return f.comments[fmt.Sprintf("%s/%s/%d", owner, repo, number)], nil
+}
+
+func (f *fakeSource) IssueTimeline(owner, repo string, number int64) ([]TimelineEvent, error) {
+	return f.timelines[fmt.Sprintf("%s/%s/%d", owner, repo, number)], nil
+}
+
+func (f *fakeSource) TryGetIssue(owner, repo string, number int64) (Issue, bool, error) {
+	i, ok := f.issues[owner+"/"+repo][number]
+	if !ok {
+		return Issue{}, false, nil
+	}
+	return i, true, nil
+}
+
+func repoWith(name string, hasPR bool) []Repo {
+	h := hasPR
+	return []Repo{{Name: name, HasPullRequests: &h}}
+}
+
+// iso 把相對分鐘轉成 parseMoment 可剖析的 ISO8601 字串（假資料用）。
+func iso(minutes int) string { return FormatMoment(at(minutes)) }
+
+func mustResolve(t *testing.T, org, repo string, texts []string, myOrgs map[string]bool, orgRepos func(string) ([]string, error)) []XrefTarget {
+	t.Helper()
+	targets, err := ResolveXrefTargets(org, repo, texts, myOrgs, orgRepos)
+	if err != nil {
+		t.Fatalf("ResolveXrefTargets: %v", err)
+	}
+	return targets
+}
+
+// TestIterXrefsEdges 驗證 regex 邊界：lookbehind 等價實作與兩段式斜線限制。
+func TestIterXrefsEdges(t *testing.T) {
+	cases := []struct {
+		name string
+		text string
+		want [][2]string
+	}{
+		{"單段 #N", "父項：#3。", [][2]string{{"3"}, {"", "3"}}[1:]},
+		{"單段 repo#N 存在", "見 agents#10", [][2]string{{"agents", "10"}}},
+		{"PR#50 寫法不是 repo", "PR#50 與 issue#49", [][2]string{{"PR", "50"}, {"issue", "49"}}},
+		{"owner/repo#N", "alterminal/agents#32", [][2]string{{"alterminal/agents", "32"}}},
+		{"斜線後不切半段", "alterminal/bear#47 只應匹配整段", [][2]string{{"alterminal/bear", "47"}}},
+		{"連字號 repo 名", "bear-cli#9", [][2]string{{"bear-cli", "9"}}},
+		{"路徑後的 #N 不匹配", "see https://x/a/#frag not #5", [][2]string{{"", "5"}}},
+		// Python \w 是 Unicode：CJK 緊鄰 #N 時整體視為 \w，lookbehind 擋下。
+		{"CJK 緊鄰 #N 略過", "修復#12的問題，見 #5", [][2]string{{"", "5"}}},
+		{"CJK 緊鄰 repo#N 整段略過", "修復agents#12", nil},
+		{"CJK 緊鄰連字號 repo 匹配後半", "修復bear-cli#9 見 #5", [][2]string{{"cli", "9"}, {"", "5"}}},
+		{"連續井號", "##5", nil},
+		{"全形數字後 #N", "１２#5", nil},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := iterXrefs(tc.text)
+			if len(got) != len(tc.want) {
+				t.Fatalf("iterXrefs(%q) = %v, want %v", tc.text, got, tc.want)
+			}
+			for i := range got {
+				if got[i] != tc.want[i] {
+					t.Fatalf("iterXrefs(%q)[%d] = %v, want %v", tc.text, i, got[i], tc.want[i])
+				}
+			}
+		})
+	}
+}
+
+// TestResolveXrefTargets 驗證三種形態的解析與單段 repo 的存在性邊界（#7 驗收）。
+func TestResolveXrefTargets(t *testing.T) {
+	myOrgs := map[string]bool{"alterminal": true}
+	orgRepos := func(string) ([]string, error) { return []string{"agents", "teai", "bear-cli"}, nil }
+	texts := []string{"父項：#3，子項 teai#7，跨倉 alterminal/bear#35，不存在 nope#9，PR#50"}
+
+	got := mustResolve(t, "alterminal", "agents", texts, myOrgs, orgRepos)
+	want := []XrefTarget{
+		{Owner: "alterminal", Repo: "agents", Number: 3},
+		{Owner: "alterminal", Repo: "teai", Number: 7},
+		{Owner: "alterminal", Repo: "bear", Number: 35},
+	}
+	if len(got) != len(want) {
+		t.Fatalf("got %v, want %v", got, want)
+	}
+	for i := range want {
+		if got[i] != want[i] {
+			t.Fatalf("got[%d] %v, want %v", i, got[i], want[i])
+		}
+	}
+}
+
+// TestResolveXrefTargetsOwnerNotMyOrg owner/repo#N 的 owner 非所屬組織 → 不解析。
+func TestResolveXrefTargetsOwnerNotMyOrg(t *testing.T) {
+	myOrgs := map[string]bool{"alterminal": true}
+	orgRepos := func(string) ([]string, error) { return nil, nil }
+	got := mustResolve(t, "alterminal", "agents", []string{"other/repo#1"}, myOrgs, orgRepos)
+	if len(got) != 0 {
+		t.Fatalf("owner 非所屬組織應略過，got %v", got)
+	}
+}
+
+// TestResolveXrefTargetsDedup 同一目標重複出現只保留第一個。
+func TestResolveXrefTargetsDedup(t *testing.T) {
+	myOrgs := map[string]bool{"alterminal": true}
+	orgRepos := func(string) ([]string, error) { return []string{"teai"}, nil }
+	got := mustResolve(t, "alterminal", "agents", []string{"#7 又 teai#7"}, myOrgs, orgRepos)
+	if len(got) != 2 {
+		t.Fatalf("應兩筆（#7 同倉庫、teai#7 跨倉庫），got %v", got)
+	}
+}
+
+// TestScanStalledIssueReasons 驗證 issue 的 reason 分類與排序。
+func TestScanStalledIssueReasons(t *testing.T) {
+	now := at(0)
+	src := &fakeSource{
+		orgs: []string{"alterminal"},
+		repos: map[string][]Repo{
+			"alterminal": repoWith("agents", true),
+		},
+		issues: map[string]map[int64]Issue{
+			"alterminal/agents": {
+				1: {Number: 1, Title: "無分派者", State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-600), Repository: &Repository{FullName: "alterminal/agents"}, URL: "u1"},
+				2: {Number: 2, Title: "分派者自己最後留言", State: "open", User: &User{UserName: "ceo"}, CreatedAt: iso(-600), UpdatedAt: iso(-300), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/agents"}, URL: "u2"},
+				3: {Number: 3, Title: "無留言", State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-300), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/agents"}, URL: "u3"},
+				4: {Number: 4, Title: "等外部回應", State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-300), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/agents"}, URL: "u4"},
+				5: {Number: 5, Title: "太新不在門檻內", State: "open", CreatedAt: iso(-30), UpdatedAt: iso(-30), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/agents"}, URL: "u5"},
+			},
+		},
+		comments: map[string][]Comment{
+			"alterminal/agents/2": {{User: &User{UserName: "ceo"}, CreatedAt: iso(-300)}},
+			"alterminal/agents/4": {{User: &User{UserName: "dan"}, CreatedAt: iso(-300)}},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	// 1: no-assignee（10h）、2: assignee-idle（5h）、3: no-commenter（5h）、4: waiting-outside（5h）、5: 不列入
+	if len(got) != 4 {
+		t.Fatalf("應 4 筆，got %d：%v", len(got), got)
+	}
+	byNumber := map[int64]Item{}
+	for _, it := range got {
+		byNumber[it.Number] = it
+	}
+	for n, wantReason := range map[int64]string{1: "no-assignee", 2: "assignee-idle", 3: "no-commenter", 4: "waiting-outside"} {
+		if byNumber[n].Reason != wantReason {
+			t.Errorf("issue %d reason = %q, want %q", n, byNumber[n].Reason, wantReason)
+		}
+	}
+	if got[0].Number != 1 || got[0].StalledHours != 10 {
+		t.Errorf("排序應由長到短，首筆 issue 1（10h），got %v", got[0])
+	}
+	if byNumber[2].LastCommentBy != "ceo" {
+		t.Errorf("issue 2 last_comment_by 應為 ceo，got %q", byNumber[2].LastCommentBy)
+	}
+}
+
+// TestScanStalledNudgeCooldown 最後留言出自掃描者本人 → 24 小時內冷卻不列入。
+func TestScanStalledNudgeCooldown(t *testing.T) {
+	now := at(0)
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": repoWith("agents", true)},
+		issues: map[string]map[int64]Issue{
+			"alterminal/agents": {
+				1: {Number: 1, State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-600), Assignees: []User{{UserName: "max"}}, Repository: &Repository{FullName: "alterminal/agents"}},
+			},
+		},
+		comments: map[string][]Comment{
+			// admin（掃描者）10 小時前催促過 → 冷卻中，不列入。
+			"alterminal/agents/1": {{User: &User{UserName: "admin"}, CreatedAt: iso(-600)}},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 0 {
+		t.Fatalf("催促冷卻中的項目不應列入，got %v", got)
+	}
+	// 冷卻過了（25 小時前催促）→ 重新列入。
+	src.comments["alterminal/agents/1"] = []Comment{{User: &User{UserName: "admin"}, CreatedAt: iso(-1500)}}
+	got, err = ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 1 || got[0].Reason != "waiting-outside" {
+		t.Fatalf("冷卻後應重新列入，got %v", got)
+	}
+}
+
+// TestScanStalledParentWrapup（teai #47，同步 agents #44）：子項全關閉的父追蹤項
+// 不退回通用原因（assignee-idle），一律標 parent-tracking——「父項收尾」情境。
+func TestScanStalledParentWrapup(t *testing.T) {
+	now := at(0)
+	// 父項 3 最後留言來自 assignee ceo（舊行為會誤標 assignee-idle）；
+	// 唯一子項 7 已關閉，父子最後活動皆 5 小時前。
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": repoWith("teai", true)},
+		issues: map[string]map[int64]Issue{
+			"alterminal/teai": {
+				3: {Number: 3, Title: "父", State: "open", Body: "子項：#7", CreatedAt: iso(-700), UpdatedAt: iso(-300), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/teai"}},
+				7: {Number: 7, Title: "子", State: "closed", CreatedAt: iso(-650), UpdatedAt: iso(-300), Repository: &Repository{FullName: "alterminal/teai"}},
+			},
+		},
+		comments: map[string][]Comment{
+			"alterminal/teai/3": {{User: &User{UserName: "ceo"}, CreatedAt: iso(-300)}},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	var parent *Item
+	for i := range got {
+		if got[i].Number == 3 {
+			parent = &got[i]
+		}
+	}
+	if parent == nil {
+		t.Fatalf("父項 3 應列入（5h 無活動），got %v", got)
+	}
+	if parent.Reason != "parent-tracking" {
+		t.Errorf("子項全關閉的父項 reason = %q, want parent-tracking", parent.Reason)
+	}
+	if len(parent.ChildActivity) == 0 {
+		t.Errorf("父項 3 應附 child_activity，got %v", parent.ChildActivity)
+	}
+}
+
+// TestScanStalledParentTracking 父追蹤項：子項活動計入 last_activity、reason 標記。
+func TestScanStalledParentTracking(t *testing.T) {
+	now := at(0)
+	// 父項與子項都 5 小時沒動：父項 last_activity 計入子項活動後同為 5h，
+	// 應以 parent-tracking 列入並附子項摘要；子項本身則是 assignee-idle。
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": repoWith("teai", true)},
+		issues: map[string]map[int64]Issue{
+			"alterminal/teai": {
+				3: {Number: 3, Title: "父", State: "open", Body: "子項：#7", CreatedAt: iso(-700), UpdatedAt: iso(-300), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/teai"}},
+				7: {Number: 7, Title: "子", State: "open", CreatedAt: iso(-650), UpdatedAt: iso(-300), Assignees: []User{{UserName: "max"}}, Repository: &Repository{FullName: "alterminal/teai"}},
+			},
+		},
+		comments: map[string][]Comment{
+			"alterminal/teai/7": {{User: &User{UserName: "max"}, CreatedAt: iso(-300)}},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	var parent3, child7 *Item
+	for i := range got {
+		switch got[i].Number {
+		case 3:
+			parent3 = &got[i]
+		case 7:
+			child7 = &got[i]
+		}
+	}
+	if child7 == nil {
+		t.Fatalf("子項 7 應列入（5h 無活動），got %v", got)
+	}
+	if child7.Reason != "assignee-idle" {
+		t.Errorf("子項 7 reason = %q, want assignee-idle", child7.Reason)
+	}
+	if parent3 == nil {
+		t.Fatalf("父項 3 應列入，got %v", got)
+	}
+	if parent3.Reason != "parent-tracking" {
+		t.Errorf("父項 3 reason = %q, want parent-tracking", parent3.Reason)
+	}
+	if len(parent3.ChildActivity) != 1 || parent3.ChildActivity[0].Number != 7 {
+		t.Errorf("父項 3 應附子項摘要，got %v", parent3.ChildActivity)
+	}
+	if parent3.StalledHours != 5 {
+		t.Errorf("父項 3 stalled_hours = %v, want 5", parent3.StalledHours)
+	}
+
+	// 子項 1 小時前恢復活動 → 父項 last_activity 跟著更新，未達門檻不列入；
+	// 子項本身也不停滯。整份輸出應為空。
+	child := src.issues["alterminal/teai"][7]
+	child.UpdatedAt = iso(-60)
+	src.issues["alterminal/teai"][7] = child
+	src.comments["alterminal/teai/7"] = []Comment{{User: &User{UserName: "max"}, CreatedAt: iso(-60)}}
+	got, err = ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 0 {
+		t.Fatalf("子項推進中 → 父項不應誤報停滯，got %v", got)
+	}
+}
+
+// TestScanStalledParentTrackingNotChild 上行引用：引用對象早於父項 → 非子項，不採計。
+func TestScanStalledParentTrackingNotChild(t *testing.T) {
+	now := at(0)
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": repoWith("teai", true)},
+		issues: map[string]map[int64]Issue{
+			"alterminal/teai": {
+				47: {Number: 47, State: "open", Body: "規劃見 #39（更早）", CreatedAt: iso(-700), UpdatedAt: iso(-600), Assignees: []User{{UserName: "ceo"}}, Repository: &Repository{FullName: "alterminal/teai"}},
+				39: {Number: 39, State: "open", CreatedAt: iso(-2000), UpdatedAt: iso(-60), Repository: &Repository{FullName: "alterminal/teai"}},
+			},
+		},
+	}
+	// timeline：#47 的 updated_at 對應直接事件（assignees）、#39 對應 label
+	//（agents #34 後 updated_at 需經 timeline 核對才採計；直接事件可對應 → 採用）。
+	// 必須在 ScanStalled 之前設定——掃描當下讀不到的事後修改無效。
+	src.timelines = map[string][]TimelineEvent{
+		"alterminal/teai/47": {{Type: "assignees", CreatedAt: iso(-600)}},
+		"alterminal/teai/39": {{Type: "label", CreatedAt: iso(-60)}},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	// #39 是上行引用，不採計 → 父項 47 停滯 10h（assignee-idle：ceo 分派、無留言）→ no-commenter。
+	var n47 *Item
+	for i := range got {
+		if got[i].Number == 47 {
+			n47 = &got[i]
+		}
+	}
+	if n47 == nil {
+		t.Fatalf("上行引用不採計 → 47 應停滯列入，got %v", got)
+	}
+	if n47.Reason != "no-commenter" {
+		t.Errorf("47 reason = %q, want no-commenter", n47.Reason)
+	}
+	if len(n47.ChildActivity) != 0 {
+		t.Errorf("上行引用不應產生子項摘要，got %v", n47.ChildActivity)
+	}
+	// #39 本身 updated 1 小時前 → 不列入。
+	for _, it := range got {
+		if it.Number == 39 {
+			t.Errorf("39 未達門檻不應列入：%v", it)
+		}
+	}
+}
+
+// TestScanStalledPullReasons 驗證 PR 的 reason 分類。
+func TestScanStalledPullReasons(t *testing.T) {
+	now := at(0)
+	h := true
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": {{Name: "teai", HasPullRequests: &h}}},
+		pulls: map[string][]PullRequest{
+			"alterminal/teai": {
+				{Number: 10, User: &User{UserName: "max"}, CreatedAt: iso(-600), UpdatedAt: iso(-600)},
+				{Number: 11, User: &User{UserName: "max"}, CreatedAt: iso(-600), UpdatedAt: iso(-300), RequestedReviewers: []User{{UserName: "ceo"}}},
+				{Number: 12, User: &User{UserName: "max"}, CreatedAt: iso(-600), UpdatedAt: iso(-300), RequestedReviewers: []User{{UserName: "ceo"}}},
+				{Number: 13, User: &User{UserName: "max"}, CreatedAt: iso(-600), UpdatedAt: iso(-300), RequestedReviewers: []User{{UserName: "ceo"}}},
+			},
+		},
+		comments: map[string][]Comment{
+			"alterminal/teai/11": {{User: &User{UserName: "max"}, CreatedAt: iso(-300)}}, // author-idle
+			"alterminal/teai/12": {{User: &User{UserName: "ceo"}, CreatedAt: iso(-300)}}, // reviewer-idle
+			"alterminal/teai/13": {{User: &User{UserName: "dan"}, CreatedAt: iso(-300)}}, // no-commenter（外部留言）
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	byNumber := map[int64]Item{}
+	for _, it := range got {
+		byNumber[it.Number] = it
+	}
+	for n, wantReason := range map[int64]string{10: "no-reviewer", 11: "author-idle", 12: "reviewer-idle", 13: "no-commenter"} {
+		item, ok := byNumber[n]
+		if !ok {
+			t.Fatalf("PR %d 應列入，got %v", n, got)
+		}
+		if item.Reason != wantReason {
+			t.Errorf("PR %d reason = %q, want %q", n, item.Reason, wantReason)
+		}
+	}
+	if len(got) != 4 {
+		t.Fatalf("應 4 筆，got %d", len(got))
+	}
+	if byNumber[10].Author != "max" {
+		t.Errorf("PR 10 author 應為 max，got %q", byNumber[10].Author)
+	}
+}
+
+// TestScanStalledNoPullsFlag 停用 PR 的倉庫仍掃 issues，只跳過 PR。
+func TestScanStalledNoPullsFlag(t *testing.T) {
+	now := at(0)
+	h := false
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": {{Name: "docs", HasPullRequests: &h}}},
+		issues: map[string]map[int64]Issue{
+			"alterminal/docs": {
+				1: {Number: 1, State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-600), Repository: &Repository{FullName: "alterminal/docs"}},
+			},
+		},
+		pulls: map[string][]PullRequest{
+			// 即使假資料有 PR，flag 關閉也不應掃。
+			"alterminal/docs": {{Number: 2, User: &User{UserName: "max"}, CreatedAt: iso(-600), UpdatedAt: iso(-600)}},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 1 || got[0].Number != 1 || got[0].Type != "issue" {
+		t.Fatalf("應只有 issue 1，got %v", got)
+	}
+}
+
+// TestScanStalledSkipsPRsInIssues 確認 /issues 混入的 PR 會被過濾。
+func TestScanStalledSkipsPRsInIssues(t *testing.T) {
+	now := at(0)
+	src := &fakeSource{
+		orgs:  []string{"alterminal"},
+		repos: map[string][]Repo{"alterminal": repoWith("teai", true)},
+		issues: map[string]map[int64]Issue{
+			"alterminal/teai": {
+				1: {Number: 1, State: "open", CreatedAt: iso(-600), UpdatedAt: iso(-600), Repository: &Repository{FullName: "alterminal/teai"}, PullRequest: &pullMarker{}},
+			},
+		},
+	}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 0 {
+		t.Fatalf("/issues 混入的 PR 應過濾，got %v", got)
+	}
+}
+
+// TestItemJSON 與 gitea.py 的 JSON 位元組相容（鍵序、HTML 不轉義、48.0、null）。
+func TestItemJSON(t *testing.T) {
+	ts := at(-600)
+	activity := FormatMoment(ts)
+	item := Item{
+		Type: "issue", Repo: "alterminal/teai", Number: 7, Title: "R,D <v2> & 規劃", URL: "u",
+		Assignees: []string{"ceo"}, LastCommentBy: "max",
+		LastActivityAt: ts, StalledHours: 48, Reason: "assignee-idle",
+		ChildActivity: []Child{
+			{Repo: "alterminal/teai", Number: 3, Title: "父", State: "open", LastActivityAt: &activity},
+			{Repo: "alterminal/teai", Number: 4, Title: "無時刻", State: "open"},
+		},
+	}
+	// json.Marshal 會把 <、>、& 重新轉義，必須用停用 HTML 轉義的編碼器。
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(item); err != nil {
+		t.Fatalf("Encode: %v", err)
+	}
+	got := strings.TrimSuffix(buf.String(), "\n")
+	want := `{"type":"issue","repo":"alterminal/teai","number":7,"title":"R,D <v2> & 規劃","url":"u","assignees":["ceo"],"last_comment_by":"max","last_activity_at":"2026-09-09T22:00:00+00:00","stalled_hours":48.0,"reason":"assignee-idle","child_activity":[{"repo":"alterminal/teai","number":3,"title":"父","state":"open","last_activity_at":"2026-09-09T22:00:00+00:00"},{"repo":"alterminal/teai","number":4,"title":"無時刻","state":"open","last_activity_at":null}]}`
+	if got != want {
+		t.Fatalf("JSON 位元組不相容:\n got %s\nwant %s", got, want)
+	}
+}
+
+// TestPullJSON：pull 的鍵序（author、reviewers）與非整數 stalled_hours。
+func TestPullJSON(t *testing.T) {
+	item := Item{
+		Type: "pull", Repo: "alterminal/teai", Number: 12, Title: "t", URL: "u",
+		Author: "ceo", Reviewers: []string{"queena"},
+		LastActivityAt: at(-600), StalledHours: 10.44, Reason: "reviewer-idle",
+	}
+	b, err := json.Marshal(item)
+	if err != nil {
+		t.Fatalf("Marshal: %v", err)
+	}
+	got := string(b)
+	want := `{"type":"pull","repo":"alterminal/teai","number":12,"title":"t","url":"u","author":"ceo","reviewers":["queena"],"last_comment_by":"","last_activity_at":"2026-09-09T22:00:00+00:00","stalled_hours":10.4,"reason":"reviewer-idle"}`
+	if got != want {
+		t.Fatalf("JSON 位元組不相容:\n got %s\nwant %s", got, want)
+	}
+}
+
+// TestScanStalledEmpty 無停滯項目 → 空輸出（CLI 層輸出 []）。
+func TestScanStalledEmpty(t *testing.T) {
+	now := at(0)
+	src := &fakeSource{orgs: []string{"alterminal"}, repos: map[string][]Repo{"alterminal": repoWith("teai", true)}}
+	got, err := ScanStalled(src, "admin", 4.0, now)
+	if err != nil {
+		t.Fatalf("ScanStalled: %v", err)
+	}
+	if len(got) != 0 {
+		t.Fatalf("應空，got %v", got)
+	}
+}
+
+// TestScanStalledOrgError 組織層錯誤應回傳（不靜默）。
+func TestScanStalledOrgError(t *testing.T) {
+	src := &errSource{}
+	if _, err := ScanStalled(src, "admin", 4.0, at(0)); err == nil {
+		t.Fatal("組織清單失敗應回傳錯誤")
+	}
+}
+
+type errSource struct{}
+
+func (errSource) MyOrganizations() ([]string, error) { return nil, errors.New("boom") }
+func (e errSource) OrganizationRepositories(string) ([]Repo, error) {
+	return nil, errors.New("boom")
+}
+func (e errSource) OpenIssues(string, string) ([]Issue, error)      { return nil, errors.New("boom") }
+func (e errSource) OpenPulls(string, string) ([]PullRequest, error) { return nil, errors.New("boom") }
+func (e errSource) IssueComments(string, string, int64) ([]Comment, error) {
+	return nil, errors.New("boom")
+}
+func (e errSource) TryGetIssue(string, string, int64) (Issue, bool, error) {
+	return Issue{}, false, errors.New("boom")
+}
+func (e errSource) IssueTimeline(string, string, int64) ([]TimelineEvent, error) {
+	return nil, errors.New("boom")
+}
+
+// TestRound1 round1 十進位舍入到一位小數（與 Python round(x,1) 半偶數一致）。
+func TestRound1(t *testing.T) {
+	cases := []struct {
+		in   float64
+		want float64
+	}{
+		{10.44, 10.4}, {10.46, 10.5}, {10.0, 10.0},
+		// 半偶數（與 Python round(x,1) 對二進位真值的行為一致）：
+		// 10.45、5.25、5.15 的二進位真值都略低於表值 → 舍到偶數位。
+		{10.45, 10.4}, {0.05, 0.1}, {5.25, 5.2}, {5.15, 5.2},
+	}
+	for _, tc := range cases {
+		if got := round1(tc.in); got != tc.want {
+			t.Errorf("round1(%v) = %v, want %v", tc.in, got, tc.want)
+		}
+	}
+}