feat(channels): credits_pool_reason —— 区分「真的用尽」与「查不到」

## 为什么需要（参考同款修复，用户报障 2026-09-29）
把两者混成一句"额度都已用尽"会让**一次网络抖动伪装成钱花完了** —— 用户于是
去解锁永久积分、或白等到明天，而号里其实有钱。两者的**正确动作完全相反**：
  exhausted → 等额度重置
  unknown   → 稍后重试 / 查网络与凭据（**不要**动永久积分锁定）
  locked    → 可解锁永久积分（同样不是"用尽"）

我们此前**没有**这个出口：`credits_balances` 只报逐账号错误，调用方拿不到
"为什么整池不可用"的结论，只能自己猜。

## 实现
新增 `channels/credits/pool_reason`，返回 `reason` ∈
`no_accounts | unknown | usable | locked | exhausted` + 可读 detail。
判定优先级（顺序即语义）：
  no_accounts（无启用账号）
  → unknown（平台未声明余额端点 —— **无法判定 ≠ 用尽**）
  → usable（有可用账号）
  → unknown（**有查询失败** —— 不能当成用尽）
  → locked（锁定且只剩永久积分）
  → exhausted（都查到了且确为 0）

## 判据（6 条 + 变异 2/2）
internal/core/channels_pool_reason_test.go
- 余额确为 0 → exhausted
- 查询失败 → unknown（且说明必须点明"查询失败"）
- 无启用账号 → no_accounts
- 有钱 → usable
- 无余额端点 → unknown（不编造用尽）
- 锁定且只剩永久积分 → locked，且**解锁后同一份余额变 usable**
  （证明 locked ≠ exhausted）
变异：查询失败也报 exhausted → 报红；locked 混同 exhausted → 报红。

## 踩到的坑（都是我的判据/夹具问题，非实现）
① 夹具用扁平 `{"total":100}`，而 buddy 的余额是**深层嵌套**
   `data.Response.Data.Accounts[]`（每包含 Status/CycleCapacityRemain/
   DeductionEndTime）—— 夹具形状不对导致全部走 unknown。
② `addAccount` 写死 platform="buddy"，于是"无余额端点"那条用例在 minimax 上
   其实没有账号，命中优先级更高的 no_accounts（**正确**行为）却被判成错。
   加 `addAccountOn(platform, id)` 修正。
③ Lua 里嵌套引号：`"（...不是"额度用尽"）"` 语法错 ⇒ 改用中文引号「」。

internal/core/channels_clear_credentialless_test.go

@@ -0,0 +1,235 @@
+package core
+
+import (
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ 无凭据账号的批量清理：**只删没有凭据的**，有凭据的一律不动。
+//
+// 场景（真实发生）：`account_add` 允许不带凭据创建账号（设计如此 —— 先建占位、
+// 登录补齐），于是登录没走完时留下"只有元数据、永远不可用"的账号，占着账号计数，
+// 让"这个平台到底能不能用"难以判断。实测生产 13 个账号里只有 1 个真可用
+// （codearts 10 + trae 2 全是占位）。
+//
+// 判据看的是**清理后的真实池状态**，而不是"函数被调用过"。
+func TestAccountClearCredentiallessOnlyRemovesEmptyOnes(t *testing.T) {
+	h := newAccountCleanupHarness(t)
+
+	// ① 默认 dry_run：必须**不删**任何东西
+	pre, err := h.ps.Call("channels", "account_clear_credentialless", map[string]interface{}{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	preJ := jsonOf(t, pre)
+	if preJ["dry_run"] != true {
+		t.Fatalf("默认必须 dry_run（破坏性操作不能默认执行），实得 %v", preJ["dry_run"])
+	}
+	// 夹具放了 4 个 codearts（3 空壳 + 1 有凭据）
+	if got := len(accountIDs(t, h, "codearts")); got != 4 {
+		t.Fatalf("dry_run 不该删任何账号，codearts 仍有 %d 个（want 4）", got)
+	}
+	// 不传 platform ⇒ 全部平台：codearts 3 空壳 + trae 2 空壳 = 5
+	if wd, _ := preJ["would_delete"].(float64); int(wd) != 5 {
+		t.Fatalf("预演应报告将删 5 个（全平台），实得 %v", preJ["would_delete"])
+	}
+	if kc, _ := preJ["kept_with_credential"].(float64); int(kc) != 1 {
+		t.Fatalf("应报告保留 1 个有凭据账号，实得 %v", preJ["kept_with_credential"])
+	}
+
+	// ② 真执行：删无凭据的，**保留有凭据的**
+	if _, err := h.ps.Call("channels", "account_clear_credentialless",
+		map[string]interface{}{"dry_run": false}); err != nil {
+		t.Fatal(err)
+	}
+	if got := len(accountIDs(t, h, "codearts")); got != 1 {
+		t.Fatalf("应只剩 1 个有凭据账号，实得 %d", got)
+	}
+	// ★ 关键：留下的必须是**有凭据的那个**
+	left := accountIDs(t, h, "codearts")
+	if len(left) != 1 || left[0] != "withcred" {
+		t.Fatalf("留下的必须是有凭据的账号 withcred，实得 %v", left)
+	}
+	// 有凭据的账号其凭据也必须仍在（不能被误删）
+	if !h.hasCredential("withcred") {
+		t.Fatal("有凭据账号的凭据被误删了")
+	}
+	t.Logf("✓ 删 3 保 1，且有凭据账号的凭据完好")
+}
+
+// 指定平台时只动那个平台，别的不碰。
+func TestAccountClearCredentiallessScopedToPlatform(t *testing.T) {
+	h := newAccountCleanupHarness(t)
+
+	if _, err := h.ps.Call("channels", "account_clear_credentialless",
+		map[string]interface{}{"platform": "codearts", "dry_run": false}); err != nil {
+		t.Fatal(err)
+	}
+	// codearts 被清（剩 1），trae 的 2 个占位**不该被动**
+	if got := len(accountIDs(t, h, "codearts")); got != 1 {
+		t.Fatalf("codearts 应剩 1，实得 %d", got)
+	}
+	if got := len(accountIDs(t, h, "trae")); got != 2 {
+		t.Fatalf("指定 platform=codearts 时不该动 trae（应仍 2），实得 %d", got)
+	}
+	t.Log("✓ 平台范围隔离正确")
+}
+
+// 未知平台必须报错，不能静默当成"全部平台"（否则会误删别的平台）。
+func TestAccountClearCredentiallessRejectsUnknownPlatform(t *testing.T) {
+	h := newAccountCleanupHarness(t)
+	res, err := h.ps.Call("channels", "account_clear_credentialless",
+		map[string]interface{}{"platform": "no-such-platform", "dry_run": false})
+	if err != nil {
+		t.Fatal(err)
+	}
+	j := jsonOf(t, res)
+	if j["error"] == nil {
+		t.Fatalf("未知平台必须报错（否则会误删全部平台），实得 %v", j)
+	}
+	// 且什么都没删
+	if got := len(accountIDs(t, h, "codearts")); got != 4 {
+		t.Fatalf("报错时不该删任何东西，codearts 实得 %d（want 4）", got)
+	}
+}
+
+// ── harness ──
+
+type accountCleanupHarness struct {
+	t  *testing.T
+	ps *lua.Plugins
+}
+
+func newAccountCleanupHarness(t *testing.T) *accountCleanupHarness {
+	t.Helper()
+	c := kernelTestCore(t)
+	ps := c.Plugins()
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ps.LoadSource("channels", src); err != nil {
+		t.Fatal(err)
+	}
+	h := &accountCleanupHarness{t: t, ps: ps}
+	// 3 个无凭据占位 + 1 个有凭据账号（codearts）；另 2 个 trae 占位
+	for _, id := range []string{"empty1", "empty2", "empty3"} {
+		h.add("codearts", id, "")
+	}
+	h.add("codearts", "withcred", `{"access_key_id":"AK","secret_access_key":"SK"}`)
+	h.add("trae", "tempty1", "")
+	h.add("trae", "tempty2", "")
+	return h
+}
+
+func (h *accountCleanupHarness) add(platform, id, cred string) {
+	h.t.Helper()
+	args := map[string]interface{}{"platform": platform, "account_id": id}
+	if cred != "" {
+		args["credential"] = cred
+	}
+	if _, err := h.ps.Call("channels", "account_add", args); err != nil {
+		h.t.Fatalf("account_add(%s/%s): %v", platform, id, err)
+	}
+}
+
+func (h *accountCleanupHarness) hasCredential(accountID string) bool {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "account_list",
+		map[string]interface{}{"platform": "codearts"})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	for _, a := range accountsOf(h.t, res) {
+		if a["id"] == accountID {
+			return a["has_credential"] == true
+		}
+	}
+	return false
+}
+
+// jsonOf 取插件调用返回的 {json:{...}} 里那层 json。
+func jsonOf(t *testing.T, got interface{}) map[string]interface{} {
+	t.Helper()
+	m, ok := got.(map[string]interface{})
+	if !ok {
+		t.Fatalf("返回值不是对象: %#v", got)
+	}
+	j, ok := m["json"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("返回值缺 json 层: %#v", m)
+	}
+	return j
+}
+
+// accountsOf 取 account_list 返回的账号数组。
+func accountsOf(t *testing.T, got interface{}) []map[string]interface{} {
+	t.Helper()
+	j := jsonOf(t, got)
+	arr, _ := j["accounts"].([]interface{})
+	out := make([]map[string]interface{}, 0, len(arr))
+	for _, e := range arr {
+		if m, ok := e.(map[string]interface{}); ok {
+			out = append(out, m)
+		}
+	}
+	return out
+}
+
+// accountIDs 列某平台的账号 id。
+func accountIDs(t *testing.T, h *accountCleanupHarness, platform string) []string {
+	t.Helper()
+	res, err := h.ps.Call("channels", "account_list",
+		map[string]interface{}{"platform": platform})
+	if err != nil {
+		t.Fatalf("account_list(%s): %v", platform, err)
+	}
+	var out []string
+	for _, a := range accountsOf(t, res) {
+		if id, ok := a["id"].(string); ok {
+			out = append(out, id)
+		}
+	}
+	return out
+}
+
+// ★ 字符串 body（真实 HTTP 路径）+ 不传 platform 时，dry_run 必须被尊重。
+//
+// 反例（实测踩到，我自己写的）：照其它 handler 写
+//
+//	`if args.platform == nil then args = req end`
+//
+// —— 而"不传 platform"在本函数里是**合法用法**（清全部平台），于是 args 被换成
+// HandlerRequest，body 里解出来的 dry_run 就丢了 ⇒ 传 dry_run=false 却被当成
+// 未传，静默只预演。**破坏性操作里最糟的形态**：操作者以为执行了、实际没执行。
+//
+// 夹具必须用**字符串 body**（我第一版传 map，走不到这条路径，所以没咬住）。
+func TestAccountClearCredentiallessRespectsDryRunViaStringBody(t *testing.T) {
+	h := newAccountCleanupHarness(t)
+
+	// 不带 platform + dry_run=false，且 body 是**字符串**（HTTP 真实形态）
+	res, err := h.ps.InvokeHandler("channels", "account_clear_credentialless",
+		&lua.HandlerRequest{Method: "POST", Body: `{"dry_run":false}`})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if res.Status != 200 {
+		t.Fatalf("status=%d body=%v", res.Status, res.Body)
+	}
+	j, _ := res.JSON.(map[string]interface{})
+	if j["dry_run"] == true {
+		t.Fatalf("字符串 body 里传了 dry_run=false 却被当成未传（回退吃掉 body）: %v", j)
+	}
+	if j["deleted"] == nil {
+		t.Fatalf("dry_run=false 时必须真的执行（应有 deleted 字段）: %v", j)
+	}
+	// 全平台的 5 个空壳都被删（codearts 3 + trae 2）
+	if got := len(accountIDs(t, h, "codearts")); got != 1 {
+		t.Fatalf("codearts 应剩 1（有凭据那个），实得 %d", got)
+	}
+	if got := len(accountIDs(t, h, "trae")); got != 0 {
+		t.Fatalf("trae 的 2 个空壳应被删，实得 %d", got)
+	}
+	t.Logf("✓ 字符串 body 且无 platform 时 dry_run=false 生效: deleted=%v", j["deleted"])
+}

internal/core/channels_pool_reason_test.go

@@ -0,0 +1,225 @@
+package core
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ 「为什么没有可用账号」必须区分**真的用尽**与**查不到**。
+//
+// 参考的同款修复（用户报障 2026-09-29）：混成一句"额度都已用尽"会让
+// **一次网络抖动伪装成钱花完了** —— 用户于是去解锁永久积分、或白等到明天，
+// 而号里其实有钱。两者的**正确动作完全相反**：
+//
+//	exhausted → 等额度重置
+//	unknown   → 稍后重试 / 查网络与凭据（**不要**动永久积分锁定）
+//
+// 判据看的是**报出的 reason**（用户据此决定做什么），不是内部计数。
+func TestCreditsPoolReasonDistinguishesExhaustedFromUnknown(t *testing.T) {
+	t.Run("账号都查到了余额但为 0 → exhausted", func(t *testing.T) {
+		h := newPoolReasonHarness(t)
+		h.addAccount("a1")
+		h.serveBalance(0, 0)
+		got := h.reason()
+		if got["reason"] != "exhausted" {
+			t.Fatalf("余额确为 0 时应报 exhausted（用户该等重置），实得 %v：%v",
+				got["reason"], got["detail"])
+		}
+	})
+
+	t.Run("余额查询失败 → unknown（不能伪装成用尽）", func(t *testing.T) {
+		h := newPoolReasonHarness(t)
+		h.addAccount("a1")
+		h.serveBalanceError(500)
+		got := h.reason()
+		if got["reason"] != "unknown" {
+			t.Fatalf("查询失败必须报 unknown —— 报 exhausted 会让网络抖动伪装成钱花完了"+
+				"（用户会去解锁永久积分或白等），实得 %v：%v", got["reason"], got["detail"])
+		}
+		if d, _ := got["detail"].(string); !strings.Contains(d, "查询失败") {
+			t.Fatalf("说明必须点明是查询失败，实得 %q", d)
+		}
+	})
+
+	t.Run("没有启用的账号 → no_accounts", func(t *testing.T) {
+		h := newPoolReasonHarness(t)
+		got := h.reason()
+		if got["reason"] != "no_accounts" {
+			t.Fatalf("无账号时应报 no_accounts，实得 %v", got["reason"])
+		}
+	})
+
+	t.Run("有可用账号 → usable", func(t *testing.T) {
+		h := newPoolReasonHarness(t)
+		h.addAccount("a1")
+		h.serveBalance(100, 0)
+		got := h.reason()
+		if got["reason"] != "usable" {
+			t.Fatalf("有钱时应报 usable，实得 %v", got["reason"])
+		}
+		if u, _ := got["usable"].(float64); int(u) != 1 {
+			t.Fatalf("usable 应为 1，实得 %v", got["usable"])
+		}
+	})
+
+	t.Run("平台无余额端点 → unknown（不编造用尽）", func(t *testing.T) {
+		h := newPoolReasonHarness(t)
+		// ⚠ 必须有**启用的账号**：判定的优先级是
+		//   no_accounts → 无余额端点 → usable → unknown/exhausted
+		// 我第一版在这条用例里忘了加账号，于是命中 no_accounts（优先级更高，
+		// 那是**正确**行为），把正确的实现判成了错。
+		h.addAccountOn("minimax", "m1")
+		// minimax 未声明 balance 端点
+		got := h.reasonOn("minimax")
+		if got["reason"] != "unknown" {
+			t.Fatalf("无余额端点时应报 unknown（无法判定 ≠ 用尽），实得 %v：%v",
+				got["reason"], got["detail"])
+		}
+		if d, _ := got["detail"].(string); !strings.Contains(d, "无法判定") {
+			t.Fatalf("说明必须点明无法判定，实得 %q", d)
+		}
+	})
+}
+
+// 锁定永久积分时，只剩永久积分的账号不可用，且必须报 **locked** 而不是 exhausted
+// （用户动作不同：解锁 vs 等重置）。
+func TestCreditsPoolReasonReportsLockedNotExhausted(t *testing.T) {
+	h := newPoolReasonHarness(t)
+	h.addAccount("a1")
+	// total_fn 取包列表：只有永久积分（到期未知）
+	h.serveBalance(0, 50)
+	if _, err := h.ps.Call("channels", "__set_lock_permanent_probe",
+		map[string]interface{}{"lock": true}); err != nil {
+		t.Fatal(err)
+	}
+	got := h.reason()
+	if got["reason"] != "locked" {
+		t.Fatalf("锁定且只剩永久积分时应报 locked（用户可解锁），实得 %v：%v",
+			got["reason"], got["detail"])
+	}
+	// 解锁后同一份余额应为 usable（证明 locked 不是"用尽"）
+	if _, err := h.ps.Call("channels", "__set_lock_permanent_probe",
+		map[string]interface{}{"lock": false}); err != nil {
+		t.Fatal(err)
+	}
+	h.serveBalance(0, 50)
+	if got2 := h.reason(); got2["reason"] != "usable" {
+		t.Fatalf("解锁后同一份余额应可用（证明 locked ≠ exhausted），实得 %v", got2["reason"])
+	}
+}
+
+// ── harness ──
+
+type poolReasonHarness struct {
+	t       *testing.T
+	ps      *lua.Plugins
+	ts      *httptest.Server
+	body    atomic.Value
+	fail    atomic.Bool
+	hasAcct atomic.Bool
+}
+
+func newPoolReasonHarness(t *testing.T) *poolReasonHarness {
+	t.Helper()
+	h := &poolReasonHarness{t: t}
+	// buddy 的真实形态：包列表嵌在 data.Response.Data.Accounts
+	h.body.Store(buddyPkgBody(0, 0))
+	h.ts = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if h.fail.Load() {
+			w.WriteHeader(500)
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		fmt.Fprint(w, h.body.Load().(string))
+	}))
+	t.Cleanup(h.ts.Close)
+
+	c := kernelTestCore(t)
+	ps := c.Plugins()
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ps.LoadSource("channels", src); err != nil {
+		t.Fatal(err)
+	}
+	h.ps = ps
+	// buddy 的余额端点指到假上游，并让 total_fn 走包列表分桶
+	if _, err := ps.Call("channels", "set_endpoints", map[string]interface{}{
+		"platform": "buddy",
+		"balance":  map[string]interface{}{"url": h.ts.URL},
+	}); err != nil {
+		t.Logf("set_endpoints(balance) 未支持: %v", err)
+	}
+	return h
+}
+
+func (h *poolReasonHarness) addAccount(id string) {
+	h.t.Helper()
+	h.addAccountOn("buddy", id)
+}
+
+// addAccountOn：往指定平台加账号（我第一版把它写死成 buddy，导致
+// "平台无余额端点"那条用例其实没有该平台的账号，命中了优先级更高的
+// no_accounts —— 判据写错而非实现错）。
+func (h *poolReasonHarness) addAccountOn(platform, id string) {
+	h.t.Helper()
+	if _, err := h.ps.Call("channels", "account_add", map[string]interface{}{
+		"platform": platform, "account_id": id,
+		"credential": `{"access_token":"AT","uid":"u1"}`,
+	}); err != nil {
+		h.t.Fatalf("account_add(%s): %v", platform, err)
+	}
+	h.hasAcct.Store(true)
+}
+
+// serveBalance 直接给"临时/永久"两个桶的金额（内部拼成 buddy 的真实包列表）。
+func (h *poolReasonHarness) serveBalance(expiring, permanent int) {
+	h.fail.Store(false)
+	h.body.Store(buddyPkgBody(expiring, permanent))
+}
+
+// buddyPkgBody 拼一份 buddy 真实形态的余额响应：
+// 包列表在 data.Response.Data.Accounts，每包有 Status / CycleCapacityRemain /
+// DeductionEndTime（毫秒）。到期时间落在窗口内 → 临时桶；未知（0）→ 永久桶。
+func buddyPkgBody(expiring, permanent int) string {
+	pkgs := []string{}
+	if expiring > 0 {
+		// 3 天到期（< 15 天窗口）
+		endMs := (time.Now().Unix() + 3*86400) * 1000
+		pkgs = append(pkgs, fmt.Sprintf(
+			`{"Status":1,"CycleCapacityRemain":%d,"DeductionEndTime":%d}`, expiring, endMs))
+	}
+	if permanent > 0 {
+		// DeductionEndTime=0（未知）⇒ 永久桶
+		pkgs = append(pkgs, fmt.Sprintf(
+			`{"Status":1,"CycleCapacityRemain":%d,"DeductionEndTime":0}`, permanent))
+	}
+	return `{"data":{"Response":{"Data":{"Accounts":[` + strings.Join(pkgs, ",") + `]}}}}`
+}
+
+func (h *poolReasonHarness) serveBalanceError(code int) {
+	h.fail.Store(true)
+}
+
+func (h *poolReasonHarness) reason() map[string]interface{} {
+	h.t.Helper()
+	return h.reasonOn("buddy")
+}
+
+func (h *poolReasonHarness) reasonOn(platform string) map[string]interface{} {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "credits_pool_reason",
+		map[string]interface{}{"platform": platform})
+	if err != nil {
+		h.t.Fatalf("credits_pool_reason: %v", err)
+	}
+	return jsonOf(h.t, res)
+}

internal/core/channels_trae_catalog_test.go

@@ -0,0 +1,230 @@
+package core
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ TRAE 的 batch 模型目录解析：两个**真实缺陷**必须在移植时一起带上
+// （参考 parseTraeBatchModelList 的注释记录了它们）。
+//
+// ① **通道白名单是「准入」而不只是「排序」**（issue IKJOZ7）：
+//
+//	22 个 function 里有一半在本插件推理端点下不可调用（实测 chat→4023
+//	model unknown、builder→4001、inline_chat→3003）。旧实现只把白名单用于
+//	"同模型择优"，于是"目录声明什么就发什么" ⇒ 用户选中那些模型必然失败，
+//	且错误指向**模型**，极易被误判成"这个模型坏了"。
+//
+// ② **空档位不得覆盖有档位**（issue IKI7WT/IKILR7）：
+//
+//	旧实现无条件"后覆盖前"，假设（后面的配置更全）与真实数据**相反** ——
+//	上游把空档位的 solo_work_lite 排在最后，实测 13 个模型因此丢掉
+//	reasoning_effort_config，全部显示"未提供推理等级"。
+func TestTraeBatchModelCatalogAdmissionAndReasoningProvenance(t *testing.T) {
+	var mu sync.Mutex
+	var gotBody string
+	h := newTraeCatalogHarness(t, func(body string) {
+		mu.Lock()
+		gotBody = body
+		mu.Unlock()
+	})
+
+	ids := catalogIDs(t, h, "trae")
+	joined := strings.Join(ids, ",")
+
+	// ① 白名单准入：不可调用通道里的模型必须**被丢弃**
+	if strings.Contains(joined, "only-in-bad-channel") {
+		t.Fatalf("不可调用通道（chat/builder/inline_chat）里的模型必须整组丢弃，"+
+			"否则用户选中它必然失败且错误指向模型：%v", ids)
+	}
+	// 但通用通道里的模型要在
+	if !strings.Contains(joined, "glm-5.2") {
+		t.Fatalf("可调用通道里的模型不该被丢：%v", ids)
+	}
+
+	// ② 空档位不得覆盖有档位：同一模型在 solo_agent（有档位）与
+	//    solo_work_lite（空档位，**排在后面**）都出现 ⇒ 必须保留有档位那条。
+	//    判据看**报出的档位**，不是"哪条被选中"这类内部信号。
+	if !h.modelHasReasoningOptions("glm-5.2") {
+		t.Fatalf("glm-5.2 的思考档位被空档位条目覆盖了 —— 上游把空档位的"+
+			"solo_work_lite 排在最后，无条件后覆盖前会让模型显示"+
+			"「未提供推理等级」（issue IKI7WT/IKILR7）：%v", ids)
+	}
+
+	// ③ 请求体必须传**全部 22 个 function**（与真实 IDE 一致）——
+	//    只传聊天通道会让非聊天通道条目在响应里位置错乱甚至被跳过。
+	mu.Lock()
+	b := gotBody
+	mu.Unlock()
+	if b == "" {
+		t.Fatal("未捕获到目录请求体")
+	}
+	for _, want := range []string{"ui_builder_v2", "inline_chat", "system_diagnosis", "show_custom_model"} {
+		if !strings.Contains(b, want) {
+			t.Fatalf("目录请求体必须与真实 IDE 一致传全部 function（缺 %q）：%s", want, b)
+		}
+	}
+}
+
+// 四条硬性过滤：usage / config_switch / is_invisible_to_user / 必须有 function。
+func TestTraeBatchModelCatalogHardFilters(t *testing.T) {
+	h := newTraeCatalogHarness(t, nil)
+	ids := catalogIDs(t, h, "trae")
+	joined := strings.Join(ids, ",")
+	for _, bad := range []string{"summary-model", "disabled-model", "hidden-model", "custom-flag-model"} {
+		if strings.Contains(joined, bad) {
+			t.Errorf("%s 应被硬性过滤掉（usage/switch/invisible）：%v", bad, ids)
+		}
+	}
+	// ⚠ 判据是**标志的值**，不是模型名：名字带 custom_model_ 前缀但标志为 false
+	// 的条目必须保留（参考实测：曾据此把 qwen3.8-flash 误记为应剔除，它其实可用）。
+	if !strings.Contains(joined, "custom_model_prefix_but_ok") {
+		t.Errorf("is_custom_model=false 的条目必须保留（判据是标志值而非模型名）：%v", ids)
+	}
+	// ⚠ 我第一版把 no-function-model 放进 solo_agent 的 config_info_list 里，
+	// 却断言它应被丢弃 —— 那是**夹具写错**：它在合法组内，保留才是对的。
+	// 「未声明 function」指的是**整个 function_configs 组**没有 function 字段。
+	if !strings.Contains(joined, "no-function-model") {
+		t.Errorf("合法组内的条目不该被丢：%v", ids)
+	}
+	t.Logf("✓ 过滤后目录: %v", ids)
+}
+
+// ── harness：假上游返回一份 batch_get_detail_param 形态的目录 ──
+
+type traeCatalogHarness struct {
+	t  *testing.T
+	ps *lua.Plugins
+}
+
+func newTraeCatalogHarness(t *testing.T, onBody func(string)) *traeCatalogHarness {
+	t.Helper()
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		b, _ := io.ReadAll(r.Body)
+		if onBody != nil {
+			onBody(string(b))
+		}
+		w.Header().Set("Content-Type", "application/json")
+		// 三个通道：
+		//   solo_agent（**可调用**，白名单内）—— glm-5.2 **有**档位
+		//   solo_work_lite（白名单内，**排在后面**）—— glm-5.2 **空档位**
+		//   inline_chat（**白名单外**）—— 只列出 only-in-bad-channel
+		fmt.Fprint(w, `{"function_configs":[`+
+			// ① solo_agent：glm-5.2 有档位；另有三个必被硬性过滤的条目
+			`{"function":"solo_agent","config_info_list":[`+
+			`{"config_name":"glm-5.2","usage":"chat_completion","config_switch":true,`+
+			`"reasoning_effort_config":{"support_thinking":true,"options":["high","low"]}},`+
+			`{"config_name":"summary-model","usage":"summary","config_switch":true},`+
+			`{"config_name":"disabled-model","usage":"chat_completion","config_switch":false},`+
+			`{"config_name":"hidden-model","usage":"chat_completion","config_switch":true,"is_invisible_to_user":true},`+
+			`{"config_name":"no-function-model","usage":"chat_completion","config_switch":true},`+
+			// is_custom_model=true ⇒ 上游以流内 4001 拒绝（"仅可见但不可调用"）
+			`{"config_name":"custom-flag-model","usage":"chat_completion","config_switch":true,`+
+			`"display_config":{"is_custom_model":true}},`+
+			// 对照组：名字带 custom_model_ 前缀但**标志为 false** ⇒ 必须**保留**
+			// （参考点名：判据是标志的值，不是模型名）
+			`{"config_name":"custom_model_prefix_but_ok","usage":"chat_completion","config_switch":true,`+
+			`"display_config":{"is_custom_model":false}}`+
+			`]},`+
+			// ② solo_work_lite 排在**后面**：glm-5.2 在这里**没有**档位配置
+			`{"function":"solo_work_lite","config_info_list":[`+
+			`{"config_name":"glm-5.2","usage":"chat_completion","config_switch":true}`+
+			`]},`+
+			// ③ 白名单外通道：整组必须被丢弃
+			`{"function":"inline_chat","config_info_list":[`+
+			`{"config_name":"only-in-bad-channel","usage":"chat_completion","config_switch":true}`+
+			`]}`+
+			`]}`)
+	}))
+	t.Cleanup(ts.Close)
+
+	c := kernelTestCore(t)
+	ps := c.Plugins()
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := ps.LoadSource("channels", src); err != nil {
+		t.Fatal(err)
+	}
+	h := &traeCatalogHarness{t: t, ps: ps}
+	// 把目录端点指到假上游
+	if _, err := ps.Call("channels", "set_endpoints", map[string]interface{}{
+		"platform":      "trae",
+		"models_remote": map[string]interface{}{"endpoint0": ts.URL},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	// 塞一个 TRAE 账号（目录请求需要凭据）
+	if _, err := ps.Call("channels", "account_add", map[string]interface{}{
+		"platform":   "trae",
+		"account_id": "cat-trae",
+		"credential": `{"access_token":"AT","uid":"u1","refresh_token":"RT"}`,
+	}); err != nil {
+		t.Fatal(err)
+	}
+	return h
+}
+
+func catalogIDs(t *testing.T, h *traeCatalogHarness, platform string) []string {
+	t.Helper()
+	if _, err := h.ps.Call("channels", "model_refresh",
+		map[string]interface{}{"platform": platform}); err != nil {
+		t.Fatalf("model_refresh: %v", err)
+	}
+	res, err := h.ps.Call("channels", "model_list", map[string]interface{}{"platform": platform})
+	if err != nil {
+		t.Fatal(err)
+	}
+	j := jsonOf(t, res)
+	var out []string
+	arr, _ := j["models"].([]interface{})
+	for _, e := range arr {
+		if m, ok := e.(map[string]interface{}); ok {
+			if id, ok := m["id"].(string); ok {
+				out = append(out, id)
+			}
+		}
+	}
+	return out
+}
+
+// modelHasReasoningOptions 查某模型是否被报出思考档位（走 model_list 的字段）。
+func (h *traeCatalogHarness) modelHasReasoningOptions(modelID string) bool {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "model_list", map[string]interface{}{"platform": "trae"})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	j := jsonOf(h.t, res)
+	arr, _ := j["models"].([]interface{})
+	for _, e := range arr {
+		m, ok := e.(map[string]interface{})
+		if !ok {
+			continue
+		}
+		if m["id"] != modelID {
+			continue
+		}
+		// 档位的真实出口：model_list 把远端目录解出的档位放在
+		// `remote.efforts`（并镜像到顶层 efforts），另有 reasoning=true。
+		for _, k := range []string{"efforts", "reasoning_options", "reasoningOptions"} {
+			if v, ok := m[k].([]interface{}); ok && len(v) > 0 {
+				return true
+			}
+		}
+		if rm, ok := m["remote"].(map[string]interface{}); ok {
+			if v, ok := rm["efforts"].([]interface{}); ok && len(v) > 0 {
+				return true
+			}
+		}
+	}
+	return false
+}

internal/core/channels_zcode_3012_test.go

@@ -0,0 +1,285 @@
+package core
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// ★ ZCode 3012 的判据必须是**多形态**的，且误判不是"文案不好看"——
+// 领取路径会据此**短路**（跳过本可领取的 plan），而限流与风控的用户动作
+// **完全相反**（稍后重试 vs 别重试）。
+//
+// 本判据逐行搬自参考 zcode-diagnostics.ts 的对抗性审计实测矩阵
+// （2026-10-05 自审 + 审计打出的真实缺陷）。
+//
+// 为什么用**共用模块**验：这段逻辑被领取路径（插件主体）与推理路径
+// （channels-zcode 适配器）共用，任一侧漂移都会让"请勿连续重试"只出现在
+// 一条路径上。判据直接打共用模块的导出，两边用的是同一份源码文本。
+func TestZcode3012ClassificationMatrix(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	cases := []struct {
+		name string
+		body string
+		want bool
+	}{
+		// ── 真风控（必须命中）──
+		{"上游真实文案(带码)", `{"code":3012,"msg":"request has been blocked due to unusual activity."}`, true},
+		{"码是纯数字字符串", `{"code":"3012","msg":"x"}`, true},
+		{"仅正文语义(无数字)", `request has been blocked due to unusual activity.`, true},
+		{"3012 与 block 紧邻", `3012 blocked by waf`, true},
+
+		// ── 必须**不**命中（误判会让用户做错事）──
+		{"13012 不是 3012", `{"code":13012}`, false},
+		{"标识符 plan-3012-trust", `plan-3012-trust`, false},
+		{"标识符 trust_3012", `trust_3012`, false},
+		{"字母包裹 x3012y", `x3012y`, false},
+		{"限流的毫秒数", `too many requests, retry after 3012 ms`, false},
+		{"HTML 里的 3012", `<h1>Error 3012</h1>upstream connect timeout`, false},
+		{"限流+block 距 14", `rate limited: request blocked, retry after 3012 ms`, false},
+		{"block 距 12", `temporarily blocked; see error 3012`, false},
+		{"额度码 1005", `{"code":1005,"msg":"quota"}`, false},
+
+		// ── 隔离「词边界」规则：这些用例同时满足"block 紧邻"，
+		// 只有词边界能区分 ⇒ 裸子串实现会把前三个判成风控。
+		// （最初的矩阵没覆盖这一组，变异测试因此没咬住 —— 补上后才有效。）
+		{"标识符+block 紧邻", `plan-3012 blocked`, false},
+		{"字母包裹+block 紧邻", `x3012 blocked`, false},
+		{"下划线+block 紧邻", `trust_3012 blocked`, false},
+		{"独立词+block 紧邻", `3012 blocked`, true},
+		{"13012 里的片段+block 紧邻", `13012 blocked`, false},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			got := h.callZD("hasUnusualActivity", tc.body)
+			if got != tc.want {
+				t.Errorf("hasUnusualActivity(%q) = %v, want %v\n"+
+					"（误判的后果不是文案问题：领取路径会据此短路，且限流='稍后重试'、\n"+
+					" 风控='别重试'，两者用户动作完全相反）", tc.body, got, tc.want)
+			}
+		})
+	}
+}
+
+// ★ 时间差格式化必须逐档单独算：参考初版把分钟档写成 `floor(seconds % 60)`，
+// 于是 90 秒被渲染成「30分30秒」（分位取的是**秒的余数**）。
+// 该错误是在**真实探针输出**里发现的，纯函数单测当时没覆盖 ≥60 秒的区间。
+func TestZcodeFormatGapDoesNotMisrenderMinutes(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+	for _, tc := range []struct {
+		ms   int
+		want string
+	}{
+		{90000, "1分30秒"},   // 参考踩过的坑：错法会得到 "30分30秒"
+		{59000, "59.0s"},   // 不足一分钟
+		{60000, "1分"},      // 整分钟
+		{3600000, "1小时"},   // 整小时
+		{3900000, "1小时5分"}, // 小时+分
+		{500, "500ms"},
+	} {
+		got := h.callZDString("formatGap", tc.ms)
+		if got != tc.want {
+			t.Errorf("formatGap(%d) = %q, want %q", tc.ms, got, tc.want)
+		}
+	}
+}
+
+// ★ 诊断行**绝不能含凭据片段**（参考的设计红线之一）。
+//
+// 账号只以"进程内自增序号"出现。判据用「传入的账号 id 的每个子串都不得出现在
+// 文案里」来钉死这条 —— 不是"看起来没有"。
+func TestZcodeDiagnosticLeaksNoCredentials(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+	const secretID = "zcode-abcdef1234567890-SECRET"
+	h.callZDAction("accountOrdinal", secretID)
+	h.callZDAction2("noteRequestSent", secretID, 1000)
+	h.callZDAction2("noteRequestOk", secretID, 1100)
+
+	diag := h.callZDString("formatDiagnostic", map[string]interface{}{
+		"accountId": secretID,
+		"sentAt":    1200,
+		"now":       1300,
+		"status":    405,
+	})
+	if diag == "" {
+		t.Fatal("formatDiagnostic 返回空")
+	}
+	// 账号 id 的每个 >=4 字符子串都不得出现
+	for i := 0; i+4 <= len(secretID); i++ {
+		if strings.Contains(diag, secretID[i:i+4]) {
+			t.Fatalf("诊断行泄漏账号 id 片段 %q：%s", secretID[i:i+4], diag)
+		}
+	}
+	if !strings.Contains(diag, "账号#") {
+		t.Fatalf("诊断行应含「账号#序号」形态：%s", diag)
+	}
+	t.Logf("✓ 诊断行无凭据片段: %s", diag)
+}
+
+// ★ 3012 的文案必须**共用**（推理 + 领取两条路径），且必须含"请勿连续重试"。
+//
+// 3012 不是"重试就能过"（那是 3007），而是**有账号冷却惩罚**：
+// 30 分钟起步，反复触发升级到 24 小时乃至停用。
+func TestZcode3012MessageIsSharedAndWarnsAboutRetries(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	msg := h.callZDString("formatUnusualActivityMessage", map[string]interface{}{
+		"subject":     "领取 plan-x",
+		"rawResponse": "request has been blocked",
+	})
+	for _, want := range []string{"3012", "请勿连续重试", "冷却惩罚", "领取 plan-x"} {
+		if !strings.Contains(msg, want) {
+			t.Fatalf("风控文案缺 %q：%s", want, msg)
+		}
+	}
+
+	// 空 subject/diagnostic/rawResponse 时不得留下空壳（"本机诊断："后面啥都没有）
+	bare := h.callZDString("formatUnusualActivityMessage", map[string]interface{}{})
+	if strings.Contains(bare, "本机诊断：\n") || strings.Contains(bare, "原始响应：\n") {
+		t.Fatalf("空参数不应留下空壳段：%q", bare)
+	}
+	t.Logf("✓ 文案: %s", strings.SplitN(msg, "\n", 2)[0])
+}
+
+// ★ 请求体形态诊断必须读**真正要发出去的对象**，而不是常量。
+//
+// 常量只能证明"源码里写了多少字"，证明不了"线上发出去多少字"。
+// 两者一旦不一致（例如某条改动把 system 顶掉了），只有读实际值才看得出来
+// —— 它会**如实显示 0 字符**，而不是拿常量里的 2898 把问题盖住。
+func TestZcodeRequestShapeReadsActualObject(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	// 用真实的适配器产出 → 再诊断它（而不是手搓一个假 system）
+	out, err := h.transformRequest(`{"model":"m","messages":[{"role":"user","content":"hi"}]}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var req map[string]interface{}
+	if err := jsonUnmarshal(out, &req); err != nil {
+		t.Fatal(err)
+	}
+	shape := h.callZDMap("describeRequestShape", req["system"], req["messages"])
+	if shape == nil {
+		t.Fatal("describeRequestShape 返回空")
+	}
+	chars, _ := shape["identityChars"].(float64)
+	if chars < 2800 {
+		t.Fatalf("身份块实测字符数 %v < 2800（诊断必须读实际值）", chars)
+	}
+	if shape["hasDateBlock"] != true {
+		t.Fatalf("应检测到日期块，实得 %v", shape["hasDateBlock"])
+	}
+	if shape["firstRole"] != "user" {
+		t.Fatalf("firstRole 应为 user，实得 %v", shape["firstRole"])
+	}
+	t.Logf("✓ 形态诊断: 块数=%v 身份块=%v 日期块=%v role=%v",
+		shape["systemBlocks"], chars, shape["hasDateBlock"], shape["firstRole"])
+
+	// 反例：空 system ⇒ 必须**如实显示 0**（不能被常量盖住）
+	empty := h.callZDMap("describeRequestShape", []interface{}{}, req["messages"])
+	if c, _ := empty["identityChars"].(float64); c != 0 {
+		t.Fatalf("空 system 时 identityChars 必须为 0（如实反映实际值），实得 %v", c)
+	}
+}
+
+// ── harness 助手：经共用的探针打**那一份** ZD 实现 ──
+//
+// 走探针而不是让测试自己 load 一份副本：判据必须打真实被两条路径共用的实现，
+// 自己 load 副本会退化成"各自测各自的"，共用一旦漂移就测不出来。
+
+func (h *zcodeIdentityHarness) callZD(fn string, a interface{}) bool {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "__zcode_diag_probe",
+		map[string]interface{}{"fn": fn, "a": a})
+	if err != nil {
+		h.t.Fatalf("__zcode_diag_probe(%s): %v", fn, err)
+	}
+	m := res.(map[string]interface{})["json"].(map[string]interface{})
+	if e, ok := m["error"]; ok {
+		h.t.Fatalf("探针错误(%s): %v", fn, e)
+	}
+	v, ok := m["result"].(bool)
+	if !ok {
+		h.t.Fatalf("%s 返回非布尔: %#v", fn, m["result"])
+	}
+	return v
+}
+
+func (h *zcodeIdentityHarness) callZDString(fn string, a interface{}) string {
+	h.t.Helper()
+	var res interface{}
+	var err error
+	if opts, ok := a.(map[string]interface{}); ok {
+		res, err = h.ps.Call("channels", "__zcode_diag_probe",
+			map[string]interface{}{"fn": fn, "opts": opts})
+	} else if fn == "formatGap" {
+		res, err = h.ps.Call("channels", "__zcode_diag_probe",
+			map[string]interface{}{"fn": fn, "a": a})
+	} else {
+		res, err = h.ps.Call("channels", "__zcode_diag_probe",
+			map[string]interface{}{"fn": fn, "a": a})
+	}
+	if err != nil {
+		h.t.Fatalf("__zcode_diag_probe(%s): %v", fn, err)
+	}
+	m := res.(map[string]interface{})["json"].(map[string]interface{})
+	if e, ok := m["error"]; ok {
+		h.t.Fatalf("探针错误(%s): %v", fn, e)
+	}
+	s, _ := m["result"].(string)
+	return s
+}
+
+// callZDAction / callZDAction2：调"动作型"探针（不返回结果，只看没报错）。
+func (h *zcodeIdentityHarness) callZDAction(fn string, a interface{}) {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "__zcode_diag_probe",
+		map[string]interface{}{"fn": fn, "a": a})
+	if err != nil {
+		h.t.Fatalf("__zcode_diag_probe(%s): %v", fn, err)
+	}
+	if m := res.(map[string]interface{})["json"].(map[string]interface{}); m["error"] != nil {
+		h.t.Fatalf("探针错误(%s): %v", fn, m["error"])
+	}
+}
+
+func (h *zcodeIdentityHarness) callZDAction2(fn string, a interface{}, a2 int) {
+	h.t.Helper()
+	res, err := h.ps.Call("channels", "__zcode_diag_probe",
+		map[string]interface{}{"fn": fn, "a": a, "a2": a2})
+	if err != nil {
+		h.t.Fatalf("__zcode_diag_probe(%s): %v", fn, err)
+	}
+	if m := res.(map[string]interface{})["json"].(map[string]interface{}); m["error"] != nil {
+		h.t.Fatalf("探针错误(%s): %v", fn, m["error"])
+	}
+}
+
+func (h *zcodeIdentityHarness) callZDMap(fn string, args ...interface{}) map[string]interface{} {
+	h.t.Helper()
+	var res interface{}
+	var err error
+	if len(args) == 2 {
+		res, err = h.ps.Call("channels", "__zcode_diag_probe",
+			map[string]interface{}{"fn": fn, "system": args[0], "messages": args[1]})
+	} else {
+		res, err = h.ps.Call("channels", "__zcode_diag_probe",
+			map[string]interface{}{"fn": fn, "a": args[0]})
+	}
+	if err != nil {
+		h.t.Fatalf("__zcode_diag_probe(%s): %v", fn, err)
+	}
+	m := res.(map[string]interface{})["json"].(map[string]interface{})
+	if e, ok := m["error"]; ok {
+		h.t.Fatalf("探针错误(%s): %v", fn, e)
+	}
+	out, _ := m["result"].(map[string]interface{})
+	return out
+}
+
+// jsonUnmarshal 是本文件用的小助手（避免与其它测试文件的导入冲突）。
+func jsonUnmarshal(s string, v interface{}) error {
+	return json.Unmarshal([]byte(s), v)
+}

internal/core/channels_zcode_identity_test.go

@@ -294,3 +294,111 @@ func TestZcodeAdapterFailsLoudlyWithoutAnthropicBase(t *testing.T) {
 	}
 	t.Logf("✓ 基座缺失时响亮失败: %v", err)
 }
+
+// ★ 日期块必须**幂等**：已以 <system-reminder> 开头则不重复插。
+//
+// 不判的后果：同一请求重试/多次 transform 时日期块叠成多层，改变 content 的
+// 前缀结构（上游检查的正是结构）。参考 withContextPrefix 有 startsWithSystemReminder。
+func TestZcodeContextPrefixIsIdempotent(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+	// 已是插入后的形态（首条 user 的 content[0] 就是 system-reminder）
+	in := `{"model":"m","messages":[{"role":"user","content":[` +
+		`{"type":"text","text":"<system-reminder>\nOLD\n</system-reminder>"},` +
+		`{"type":"text","text":"hi"}]}]}`
+	out, err := h.transformRequest(in)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var req map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &req); err != nil {
+		t.Fatal(err)
+	}
+	msgs := req["messages"].([]interface{})
+	content := msgs[0].(map[string]interface{})["content"].([]interface{})
+	n := 0
+	for _, c := range content {
+		if b, ok := c.(map[string]interface{}); ok {
+			if s, _ := b["text"].(string); strings.Contains(s, "<system-reminder>") {
+				n++
+			}
+		}
+	}
+	if n != 1 {
+		t.Fatalf("日期块必须幂等（已存在则不重复插），实得 %d 个 system-reminder 块", n)
+	}
+}
+
+// ★ 日期块只处理**第一条**消息，且它必须 role == "user"。
+//
+// 反例（我第一版就是这样）：往后扫第一个 user 消息 —— 若首条是 assistant，
+// 官方行为是**不动**，而不是去找后面那条 user。判据钉住这个差别。
+func TestZcodeContextPrefixOnlyTouchesFirstMessage(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	t.Run("首条不是 user 时不动", func(t *testing.T) {
+		in := `{"model":"m","messages":[` +
+			`{"role":"assistant","content":"opening"},` +
+			`{"role":"user","content":"hi"}]}`
+		out, err := h.transformRequest(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var req map[string]interface{}
+		if err := json.Unmarshal([]byte(out), &req); err != nil {
+			t.Fatal(err)
+		}
+		msgs := req["messages"].([]interface{})
+		// ⚠ 注意：文本会被 anthropic 基座转成**块数组**（协议转换的正常行为），
+		// 所以这里不能断言 content 仍是字符串 —— 我第一版就这么断言，把正确的
+		// 实现判成了错。判据要验的是「**日期块**有没有被插进来」这个事实。
+		noReminder := func(content interface{}) bool {
+			switch c := content.(type) {
+			case string:
+				return !strings.Contains(c, "<system-reminder>")
+			case []interface{}:
+				for _, e := range c {
+					if b, ok := e.(map[string]interface{}); ok {
+						if t, _ := b["text"].(string); strings.Contains(t, "<system-reminder>") {
+							return false
+						}
+					}
+				}
+			}
+			return true
+		}
+		// 首条（assistant）不该被插日期块
+		if !noReminder(msgs[0].(map[string]interface{})["content"]) {
+			t.Fatal("首条是 assistant 时不该插日期块（官方只看第一条且要求 role=user）")
+		}
+		// 后面的 user 也**不该**被插（官方不往后找）
+		if !noReminder(msgs[1].(map[string]interface{})["content"]) {
+			t.Fatal("日期块被插到了后面的 user 消息上 —— 官方只看第一条")
+		}
+		// 且原文本内容必须保留（转换不能丢内容）
+		b, _ := json.Marshal(msgs[0])
+		if !strings.Contains(string(b), "opening") {
+			t.Fatal("首条 assistant 的内容丢了")
+		}
+	})
+
+	t.Run("首条是 user 时插入", func(t *testing.T) {
+		in := `{"model":"m","messages":[{"role":"user","content":"hi"}]}`
+		out, err := h.transformRequest(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var req map[string]interface{}
+		if err := json.Unmarshal([]byte(out), &req); err != nil {
+			t.Fatal(err)
+		}
+		msgs := req["messages"].([]interface{})
+		content, ok := msgs[0].(map[string]interface{})["content"].([]interface{})
+		if !ok {
+			t.Fatal("首条 user 的 content 应升级为块数组")
+		}
+		b0 := content[0].(map[string]interface{})
+		if s, _ := b0["text"].(string); !strings.Contains(s, "<system-reminder>") {
+			t.Fatalf("首条 user 的 content[0] 必须是日期块，实得 %q", s)
+		}
+	})
+}