合併 main（4a34def）並把 exitcode_test.go 四處 extractGlobals 呼叫補上第三參數 nil（#20）

衝突原因：#13（本分支 927855d）與 #16（main 7badd9e）各自實作了
同一問題（帶旗標命令被全域剖析攔下）的抽取式修正。採 main 現行
架構（dispatch 內 extractGlobals）為準，並保留本分支的：

- runVersion 參數檢查（version 不接受參數，TestWiringVersionRejectsArgs）
- workflow 命令與接線層測試（workflow_commands_test.go）

go build／vet／gofmt 綠；單元測試僅餘 main 既有回歸
（3 個 login 測試，#16 合併後即失敗，與本 PR 無關）。

README.md

@@ -1,12 +1,13 @@
 # teai
 
-teai 是 Gitea 的命令列（CLI）輔助工具，補足官方 `tea` CLI 缺少的功能。
+teai 是 Gitea 的命令列（CLI）工具，以更完整、更可靠的方式操作 Gitea。
 名稱取「**te**a + **AI**」：這套工具主要為了讓 AI agent 能以更完整、更可靠的
 方式操作 Gitea（查詢、回覆、審核、自動化……）。
 
 - **語言：** 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）進行中
+- **範圍（#3）：** 不避開 tea 已有的功能；單一工具涵蓋完整操作
 
 ## 安裝與建置
 
@@ -23,14 +24,14 @@ go build -o teai ./cmd/teai
 
 ### 設計原則
 
-1. **與 tea 互補，不重複**：`tea` 已有的功能（clone、issues、pulls、labels、milestones、release、api……）一律用 `tea`。teai 只做 tea 做不到的事：跨倉庫／跨組織聚合、工作流判定（跟進／審核／停滯）、機器可讀輸出。
+1. **功能自主完整（#3）**：teai 自行實作完整的功能集，**不**以「tea 已有」為由略過（tea 本身存在諸多問題，見 #3）。除了 gitea.py 工作流（跨倉庫／跨組織聚合、工作流判定、機器可讀輸出），也涵蓋日常操作（issues／pulls／labels／milestones／release……），tea 只是相容參考與對照組。由單一二進位檔提供一致介面，避免多工具拼接。
 2. **規則單一來源**：「最後一則留言不是自己」等工作流判定規則以 `AGENTS.md` 為準，teai 只實作、不改義。規則要變更，先改 AGENTS.md，teai 跟著改。
 3. **機器可讀優先**：預設輸出 JSON；`--output table` 僅供人工抽查。
 4. **可直接替換原型**：`gitea.py` 的每個子命令在 teai 都有語義相同的對應命令，可交叉驗證、平滑遷移。
 5. **認證沿用 tea**：讀 `tea` 的登入組態（`TEA_CONFIG` 或 `~/.config/tea/config.yml`），不另建認證體系。
 6. **安全預設**：查詢類唯讀；寫入類命令（#8 起）一律要求明確 `--yes`，未確認時不發出任何請求、不產生任何遠端變更。
 
-### 日常操作（tea 對等指令；#8）
+### 日常操作（tea 對等指令；#3 不避開 tea 已有功能；#8 已實作）
 
 issues／pulls／labels／milestones／releases／repos／api 的日常操作，自行實作、輸出一致 JSON、共用同一套認證與全域選項。介面語義以 `tea`／Gitea API 為相容參考。已實作：
 
@@ -79,6 +80,7 @@ teai [全域選項] <命令> [參數]
 
 | 命令 | 對應 gitea.py | 說明 |
 | --- | --- | --- |
+| `teai login list\|add\|default\|remove` | — | 管理 tea 相容登入組態（見下） |
 | `teai whoami` | `get_current_username` | 目前帳號 |
 | `teai orgs` | `for_all_organizations` | 我所屬的組織 |
 | `teai members [--has-work]` | `members [--has-work]` | Agents 團隊成員；`--has-work` 只列有未完成工作者 |
@@ -117,6 +119,25 @@ teai next --output table  # 人類可讀
 }
 ```
 
+### `teai login` — 管理登入
+
+teai 與 tea 共用同一份組態檔（`--config`／`TEA_CONFIG`，預設 `~/.config/tea/config.yml`）。
+寫入採行級編輯：只動目標項目的行，未知欄位（`ssh_*` 等）與 `preferences` 區段逐字保留，
+不改壞 tea 也在使用的檔案；檔案權限 `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
@@ -215,6 +236,15 @@ teai whoami               # 目前帳號（讀 tea 組態）
 | `mine` | `teai mine` | 相同 |
 | （底線函式） | `internal/` 套件 | 不設 CLI 命令；`xrefs` 為其邏輯的公開化 |
 
+已知輸出差異（刻意保留，機器可讀優先）：
+
+- **空清單**：`gitea.py` 的 `_dump` 對空清單**不輸出任何內容**；teai 的清單類命令
+  （`mine`／`pulls`）空清單輸出 `[]`。對 JSON 消費者來說 `[]` 比「無輸出」更明確，
+  交叉驗證時以此差異為準。`next` 兩者語義相同（無工作 → `null`／「沒有未完成的工作」）。
+- **全域選項位置**：teai 的全域選項（`--output` 等）可出現在命令之前或之後，
+  且可與命令旗標交錯（`teai members --has-work --output table`）；
+  gitea.py 的旗標剖析較寬鬆，兩者命令列介面以此行為對齊。
+
 遷移策略：
 
 1. 以 gitea.py 為行為基準：同帳號同時跑兩者，輸出應一致（交叉驗證）。

internal/cli/cli.go

@@ -89,6 +89,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 +150,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 +218,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 +325,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)
@@ -339,8 +377,11 @@ func exitCodeFor(err error) ExitCode {
 	return ExitInternal
 }
 
-// runVersion 輸出版本資訊。
+// runVersion 輸出版本資訊；不接受任何參數。
 func runVersion(env *Env, args []string) error {
+	if len(args) > 0 {
+		return &ErrUsage{Msg: "version 不接受參數"}
+	}
 	fmt.Fprintf(env.Out, "teai version %s\n", Version)
 	return nil
 }

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_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)
@@ -235,7 +237,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/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/login.go

@@ -0,0 +1,365 @@
+// login.go — teai login 指令：管理 tea 相容的登入組態。
+//
+// teai 與 tea 共用同一份組態檔（README 設計原則 5），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／TEA_CONFIG 優先，其次
+// ~/.config/tea/config.yml。找不到可用路徑回空字串。
+func loginConfigPath(g Globals) string {
+	if p := strings.TrimSpace(g.ConfigPath); p != "" {
+		return expandHome(p)
+	}
+	if p := os.Getenv("TEA_CONFIG"); strings.TrimSpace(p) != "" {
+		return expandHome(strings.TrimSpace(p))
+	}
+	home, err := os.UserHomeDir()
+	if err != nil || home == "" {
+		return ""
+	}
+	return filepath.Join(home, ".config", "tea", "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 := fs.Parse(args); err != nil {
+		return &ErrUsage{Msg: err.Error()}
+	}
+	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 := fs.Parse(args); err != nil {
+		return &ErrUsage{Msg: err.Error()}
+	}
+	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.SaveTeaConfigFile(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 := fs.Parse(args); err != nil {
+		return &ErrUsage{Msg: err.Error()}
+	}
+	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 := fs.Parse(args); err != nil {
+		return &ErrUsage{Msg: err.Error()}
+	}
+	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.SaveTeaConfigFile(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 主機作為登入名稱（同 tea 的習慣）。
+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,292 @@
+// 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("TEA_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())
+	}
+}
+
+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)
+	}
+}

internal/cli/workflow_commands.go

@@ -31,6 +31,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 +63,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
 	}
@@ -77,7 +82,7 @@ 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
 	}
@@ -106,7 +111,7 @@ func runMembers(env *Env, args []string) error {
 	if fs.NArg() != 0 {
 		return &ErrUsage{Msg: "members 不接受位置參數"}
 	}
-	s, err := newWorkflowClient(env)
+	s, err := newScannerFunc(env)
 	if err != nil {
 		return err
 	}
@@ -126,7 +131,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
 	}
@@ -166,7 +171,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 +204,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,233 @@
+// 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)
+	}
+}
+
+// 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/gitea/config.go

@@ -0,0 +1,421 @@
+// config.go — tea 相容登入組態的讀取與行級編輯。
+//
+// teai 與 tea 共用同一份組態檔（README 設計原則 5），因此寫入採「行級編輯」：
+// 只修改目標登入項目的所屬行，其餘內容（未知欄位、註解、preferences 區段、
+// 空行與縮排）逐字保留，避免改壞 tea 也在使用的檔案。新增項目依 tea 實際
+// 寫出的欄位順序輸出，讓檔案外觀與 tea 一致。
+//
+// token 值只會進出這個套件的資料結構與組態檔本身，永遠不出現在錯誤訊息。
+package gitea
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"regexp"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+// LoginEntry 是組態檔中的一筆登入資料（編輯用，含 tea 的 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 清單與各項目的行範圍。
+// 只認識 tea 實際寫出的格式：頂層 `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 回傳項目內屬性行的縮排（項目縮排 + 兩格，tea 的格式）。
+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（保留其他欄位與行）；不存在則
+// 依 tea 的欄位順序插入新項目。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 產生 tea 格式的新登入項目（欄位順序與 tea 實際寫出的一致）。
+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 + `ssh_host: ""`,
+		f + `ssh_key: ""`,
+		f + "insecure: false",
+		f + `ssh_certificate_principal: ""`,
+		f + "ssh_agent: false",
+		f + `ssh_key_agent_pub: ""`,
+		f + "version_check: false",
+		f + "user: " + yamlScalar(user),
+		f + "created: 0",
+	}
+}
+
+// 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)
+}
+
+// SaveTeaConfigFile 把組態內容原子寫入 path：先寫同目錄暫存檔（0600），
+// 再 rename 取代，避免半寫入狀態。必要時建立上層目錄（0700）。
+func SaveTeaConfigFile(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,263 @@
+// config_test.go 驗證 tea 相容組態的行級編輯：新增、更新、設預設、
+// 移除，以及「未知欄位與其他區段逐字保留」的關鍵性質。
+package gitea
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// realWorldTeaConfig 是 tea 實際寫出的組態（含 ssh_* 等未知欄位與 preferences）。
+const realWorldTeaConfig = `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(realWorldTeaConfig))
+	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(realWorldTeaConfig), 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(realWorldTeaConfig), 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)
+	}
+	// tea 的欄位順序仍在。
+	s := string(out)
+	if !strings.Contains(s, "    - name: second\n") {
+		t.Fatalf("new item not appended in tea style:\n%s", 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)
+	}
+}
+
+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(realWorldTeaConfig), "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(realWorldTeaConfig), "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 TestSaveTeaConfigFileAtomicAndMode(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "tea", "config.yml")
+	if err := SaveTeaConfigFile(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 := SaveTeaConfigFile(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/scan.go

@@ -198,6 +198,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 +227,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 +285,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 +341,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
 			}