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 里嵌套引号：`"（...不是"额度用尽"）"` 语法错 ⇒ 改用中文引号「」。

deploy.sh

@@ -36,8 +36,15 @@ readonly REPO_DIR="/home/program/llmsproxy"
 readonly HEALTH_URL="http://127.0.0.1:8081/v1/models"
 readonly BIN_NAME="llmsproxy"
 
-# 构建目录在 /tmp（tmpfs 更快）
-readonly TMP_DIR="/tmp/llmsproxy-deploy"
+# 构建目录。默认落在仓库下的构建工作区，而不是 /tmp：本机 /tmp 是 8.8G
+# tmpfs，实测被 Go 构建缓存占满后会让 go test/build 在链接阶段直接失败。
+# 可用 LLMSPROXY_BUILD_DIR 覆盖；同一目录也被测试用作 GOTMPDIR。
+readonly BUILD_SUBDIR=".build-work"
+if [[ -n "${LLMSPROXY_BUILD_DIR:-}" ]]; then
+    readonly TMP_DIR="${LLMSPROXY_BUILD_DIR}"
+else
+    readonly TMP_DIR="${REPO_DIR}/${BUILD_SUBDIR}"
+fi
 # 同文件系统暂存文件（用于原子 rename）
 readonly STAGING_BIN="${TARGET_BIN}.staging"
 readonly STAGING_CONFIG="${TARGET_CONFIG}.staging"
@@ -142,7 +149,7 @@ build() {
     mkdir -p "$TMP_DIR/bin"
 
     cd "$REPO_DIR"
-    CGO_ENABLED=1 go build -tags luajit \
+    CGO_ENABLED=1 GOTMPDIR="$TMP_DIR" go build -tags luajit \
         -trimpath \
         -ldflags="-s -w" \
         -o "$TMP_DIR/bin/$BIN_NAME" \
@@ -302,48 +309,60 @@ verify_master_key() {
     return 1
 }
 
-# ---------- 适配器备份保留策略 ----------
-# 每次部署都新建一个 adapters.bak.<时间戳> 目录，而回滚只用到最近一次
+# ---------- 备份目录保留策略 ----------
+# 每次部署都新建一个 <prefix>.bak.<时间戳> 目录，而回滚只用到最近一次
 # （$BACKUP_BIN / $BACKUP_CONFIG 都是单文件覆盖）。多出来的目录从没人清理，
 # 实测线上已积累 71 个，/etc/llmsproxy 因此涨到 122M。
 #
-# 保留最近 KEEP_ADAPTER_BACKUPS 份足够回滚，同时给目录数设上限——否则
-# 一次误配置（比如 adapter_dir 指错）就可能在几秒内造出成百上千个目录。
-# 只删名字严格匹配 adapters.bak.<14位时间戳> 的目录，避免误伤人工放的目录。
-KEEP_ADAPTER_BACKUPS=5
+# 保留最近 KEEP_BACKUPS 份足够回滚，同时给目录数设上限——否则一次误配置
+# 就可能在几秒内造出成百上千个目录。
+# 只删名字严格匹配 <prefix>.bak.<14位时间戳> 的目录，避免误伤人工放的目录。
+#
+# ★ 必须**同时覆盖 adapters 与 plugins**（同一缺陷的两个实例）：
+#   本函数最初只处理 adapters.bak，而 sync_plugins 同样每次建 plugins.bak.*
+#   —— 于是修了 adapters 的堆积、plugins 继续涨（实测线上 36 个、占用 192M）。
+#   这正是「两处只修一处」的老形状：给一个新前缀加备份目录时，必须同步纳入
+#   prune_all_backups，否则它就是一个不会被清理的新泄漏点。
+KEEP_BACKUPS=5
 
-prune_adapter_backups() {
+prune_backups() {
+    local prefix="$1"
     local base="/etc/llmsproxy"
     [[ -d "$base" ]] || return 0
+    # 防误用：前缀必须是已知的两个（避免有人传空串删掉整个目录）
+    case "$prefix" in
+        adapters|plugins) ;;
+        *) fail "prune_backups: 未知前缀 '$prefix'（只接受 adapters|plugins）" ;;
+    esac
 
     # 先按数量上限硬裁：即使时间戳排序失效也不会无上限增长。
     local all
-    mapfile -t all < <(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' -printf '%f\n' | sort)
-    local cap=$((KEEP_ADAPTER_BACKUPS * 4))
+    mapfile -t all < <(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" -printf '%f\n' | sort)
+    local cap=$((KEEP_BACKUPS * 4))
     if (( ${#all[@]} > cap )); then
-        warn "适配器备份目录有 ${#all[@]} 个（异常），裁到 $cap"
+        warn "$prefix 备份目录有 ${#all[@]} 个（异常），裁到 $cap"
         local i=0
         for d in "${all[@]}"; do
             i=$((i + 1))
             # 从最旧的开始删（sort 后升序）。名字不规范的跳过不删。
             if (( i <= ${#all[@]} - cap )); then
-                if [[ "$d" =~ ^adapters\.bak\.[0-9]{14}$ ]]; then
+                if [[ "$d" =~ ^"$prefix"\.bak\.[0-9]{14}$ ]]; then
                     rm -rf "${base:?}/$d"
                 else
                     warn "跳过名字不规范的备份目录（不删）: $d"
                 fi
             fi
         done
-        mapfile -t all < <(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' -printf '%f\n' | sort)
+        mapfile -t all < <(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" -printf '%f\n' | sort)
     fi
 
-    # 再按时间保留最近 KEEP_ADAPTER_BACKUPS 份（sort 后最新在末尾）。
+    # 再按时间保留最近 KEEP_BACKUPS 份（sort 后最新在末尾）。
     local total=${#all[@]} i=0
     for d in "${all[@]}"; do
         i=$((i + 1))
         # i <= total-KEEP 的是较旧的，要删。
-        if (( i <= total - KEEP_ADAPTER_BACKUPS )); then
-            if [[ "$d" =~ ^adapters\.bak\.[0-9]{14}$ ]]; then
+        if (( i <= total - KEEP_BACKUPS )); then
+            if [[ "$d" =~ ^"$prefix"\.bak\.[0-9]{14}$ ]]; then
                 rm -rf "${base:?}/$d"
             else
                 warn "跳过名字不规范的备份目录（不删）: $d"
@@ -352,8 +371,15 @@ prune_adapter_backups() {
     done
 
     local left
-    left=$(find "$base" -maxdepth 1 -type d -name 'adapters.bak.*' | wc -l)
-    log "  适配器备份保留最近 $KEEP_ADAPTER_BACKUPS 份（当前剩 $left 个）"
+    left=$(find "$base" -maxdepth 1 -type d -name "$prefix.bak.*" | wc -l)
+    log "  $prefix 备份保留最近 $KEEP_BACKUPS 份（当前剩 $left 个）"
+}
+
+# prune_all_backups：两个前缀都裁。
+# ★ 新增任何 .bak.<时间戳> 目录的前缀时，必须在这里补上 —— 否则又一个泄漏点。
+prune_all_backups() {
+    prune_backups adapters
+    prune_backups plugins
 }
 
 # ---------- 同步适配器 ----------
@@ -373,7 +399,7 @@ sync_adapters() {
         cp -rf "$TARGET_ADAPTERS/"*.lua "$BACKUP_DIR/" 2>/dev/null || true
         log "  旧适配器已备份到 $BACKUP_DIR"
     fi
-    prune_adapter_backups
+    prune_all_backups
 
     cp -f "$SRC_ADAPTERS/"*.lua "$TARGET_ADAPTERS/"
     chmod 0644 "$TARGET_ADAPTERS/"*.lua

docs/plugins.md

@@ -377,7 +377,48 @@ plugin.http = {
   路径，未认证会跳登录页。
 - 未声明的路径不会因为落在允许命名空间而被放行——不在 handler 表里就是 404。
 
-### 5.6 在运行时安装/更新适配器（token 轮换）
+### 5.6 前缀代理：把插件自起的服务挂到网关同端口
+
+前节的自定义挂载点只能回答**由插件计算出来的内容**（`{status, headers, body/json}`）。
+若插件自己起了一个 TCP/HTTP 服务（典型：服务端浏览器栈 + noVNC），客户端就需要
+**字节级转发**，包括 **WebSocket 升级** —— 前者做不到。
+
+为此声明 `prefix = true`，handler 每次请求返回一个**回环目标**：
+
+```lua
+plugin.http = {
+  { path = "myplugin/proxy/:session", method = "GET", prefix = true,
+    roles = { "admin" }, handler = "proxy" },
+}
+
+function plugin.proxy(req)
+  -- 每次请求都问一遍：会话没了/过期了就返回 404，地址自然失效
+  if not sessionAlive(req.params.session) then
+    return { status = 404, json = { error = "no such session" } }
+  end
+  return { proxy = "http://127.0.0.1:60100" }
+end
+```
+
+规则：
+
+- **只能返回 `{ proxy = <目标> }`**，没有 `status` / `body`。写了 `status` 会被忽略。
+- 目标必须是 **带显式端口的字面回环 IP**（`http://127.0.0.1:60100`）。
+  拒绝 `https://`、`localhost` 这类主机名、无端口、带 userinfo/path/query 的地址。
+  理由：主机名可能被 hosts / DNS / 代理环境改写；通用能力只接受确定性地址。
+- 路由匹配同前缀下的**所有子路径**，`:param` 仍照常捕获，`req.path` 是完整
+  请求路径，子路径由插件自己从 `req.path` 里切。
+- **鉴权先于代理**：`roles` / `keys` / `public` 语义与普通端点一致。
+- **不转发网关凭据**：`Authorization`、`Cookie`、`api_key` 都不会传给后端服务。
+- **拒绝跨站**：`Origin` 与网关自身 host 不一致返回 403。WebSocket 由浏览器
+  发起且自动带 Cookie，否则第三方网页可借管理员会话开隧道。
+- **撤销点唯一**：handler 不再返回目标（或返回 404）即失效，内核不缓存目标。
+
+客户端拿到的 URL 是**相对网关口**的绝对路径（如
+`/api/plugins/http/myplugin/proxy/<id>/vnc.html`），因此远程访问、HTTPS 入口、
+Cookie 鉴权都自然生效，无需暴露额外端口。
+
+### 5.7 在运行时安装/更新适配器（token 轮换）
 
 插件可以在运行时安装、改写**自己的**适配器 —— 这是"带自动轮换的认证"的实现
 方式：拿着新 token 重写适配器源码，后续请求自然使用新逻辑（内核重建该适配器

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_codearts_catalog_test.go

@@ -0,0 +1,174 @@
+package core
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ codearts 的模型目录必须从**两个**签名端点拉取并合并。
+//
+// 真实缺口（本轮发现）：codearts 有 10 个可用账号，但目录里只有硬编码的
+// 1 个模型 "CodeArts-Pangu"。参考实现（fetchCodeArtsRemoteModels）打的是：
+//
+//	① opengw gateway/config → result.models（benefit 模型）
+//	② snap-access /v1/model/builtin → builtinModels（常规模型）
+//
+// 两者都**必须 AK/SK 签名**，而我们的 refreshRemoteModels 此前只支持 Bearer
+// ⇒ 这两个端点从来没有被打过。
+//
+// 判据看**两个端点的真实命中**（各自拉到自己的字段名），而不是"目录非空"
+// —— 后者只要兜底表在就恒真。
+type codeartsCatalogHarness struct {
+	t        *testing.T
+	ps       *lua.Plugins
+	mu       sync.Mutex
+	hits     map[int]int // 端点序号 → 命中次数
+	gateway  string
+	builtin  string
+	authSeen []string
+}
+
+func newCodeartsCatalogHarness(t *testing.T) *codeartsCatalogHarness {
+	t.Helper()
+	h := &codeartsCatalogHarness{t: t, hits: map[int]int{}}
+
+	mk := func(idx int, body string) *httptest.Server {
+		return httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			h.mu.Lock()
+			h.hits[idx]++
+			// ★ 必须看到 AK/SK 签名的三个特征头，否则等于没签名
+			authSeen := []string{
+				r.Header.Get("X-Sdk-Date"),
+				r.Header.Get("X-Sdk-Content-Sha256"),
+				r.Header.Get("Authorization"),
+			}
+			h.authSeen = append(h.authSeen, strings.Join(authSeen, "|"))
+			h.mu.Unlock()
+			w.Header().Set("Content-Type", "application/json")
+			fmt.Fprint(w, body)
+		}))
+	}
+	// ① gateway：benefit 模型在 result.models
+	gw := mk(0, `{"result":{"models":[{"model_id":"glm-5.3-flash"},{"model_id":"deepseek-v4-flash"}]}}`)
+	// ② snap builtin：常规模型在 builtinModels（**对象**，键为序号）
+	bi := mk(1, `{"count":2,"builtinModels":{"0":{"model_id":"GLM-5.2"},"1":{"model_id":"openpangu-2.0-pro"}}}`)
+	t.Cleanup(gw.Close)
+	t.Cleanup(bi.Close)
+	h.gateway, h.builtin = gw.URL, bi.URL
+
+	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
+
+	// 把两个端点都指到假上游（顺序与平台配置一致）
+	if _, err := ps.Call("channels", "set_endpoints", map[string]interface{}{
+		"platform": "codearts",
+		"models_remote": map[string]interface{}{
+			"endpoint0": h.gateway,
+			"endpoint1": h.builtin,
+		},
+	}); err != nil {
+		t.Fatalf("set_endpoints: %v", err)
+	}
+	// 塞一个 AK/SK 账号（签名分支需要凭据，否则会走 "无可用 AK/SK 凭据"）
+	if _, err := ps.Call("channels", "account_add", map[string]interface{}{
+		"platform": "codearts",
+		"id":       "cat-test",
+		"credential": `{"access_key_id":"AKTEST","secret_access_key":"SKTEST",` +
+			`"security_token":"STTEST","user_name":"cat"}`,
+	}); err != nil {
+		t.Fatalf("account_add: %v", err)
+	}
+	return h
+}
+
+func TestCodeArtsCatalogPullsBothSignedEndpoints(t *testing.T) {
+	h := newCodeartsCatalogHarness(t)
+
+	if _, err := h.ps.Call("channels", "model_refresh", map[string]interface{}{"platform": "codearts"}); err != nil {
+		t.Fatalf("model_refresh: %v", err)
+	}
+
+	h.mu.Lock()
+	hits := map[int]int{}
+	for k, v := range h.hits {
+		hits[k] = v
+	}
+	authSeen := append([]string(nil), h.authSeen...)
+	h.mu.Unlock()
+
+	// ① 两个端点都必须被命中（只打一个是真实缺口）
+	if hits[0] == 0 {
+		t.Fatal("gateway/config 端点从未被调用 —— benefit 模型（glm-5.3-flash 等）永远拿不到")
+	}
+	if hits[1] == 0 {
+		t.Fatal("snap /v1/model/builtin 端点从未被调用 —— 常规模型（GLM-5.2 / openpangu）永远拿不到")
+	}
+	// ② 每个请求都必须带 AK/SK 签名特征头（Bearer 打不通这两个端点）
+	for i, seen := range authSeen {
+		parts := strings.Split(seen, "|")
+		if len(parts) != 3 || parts[0] == "" || parts[1] == "" || parts[2] == "" {
+			t.Fatalf("第 %d 个请求缺签名头（X-Sdk-Date/Content-Sha256/Authorization）：%q", i+1, seen)
+		}
+		if !strings.Contains(parts[2], "SDK-HMAC-SHA256") {
+			t.Fatalf("Authorization 不是华为 SDK-HMAC-SHA256 形态，实得 %q", parts[2])
+		}
+	}
+
+	// ③ 合并结果必须同时含两个端点的模型（字段名不同：model_id，两边都要认）
+	got, err := h.ps.Call("channels", "model_list", map[string]interface{}{"platform": "codearts"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ids := modelIDs(t, got)
+	joined := strings.Join(ids, ",")
+	for _, want := range []string{"glm-5.3-flash", "GLM-5.2", "openpangu-2.0-pro"} {
+		if !strings.Contains(joined, want) {
+			t.Fatalf("合并目录缺 %s（两个端点必须**合并**而非只用其一）：%v", want, ids)
+		}
+	}
+	t.Logf("✓ 两端点各命中 %d/%d 次，合并得到 %d 个模型", hits[0], hits[1], len(ids))
+}
+
+// 兜底表在远端失败时必须仍然可用（不能因为加了目录就让平台变空）。
+func TestCodeArtsCatalogKeepsFallbackOnFailure(t *testing.T) {
+	h := newCodeartsCatalogHarness(t)
+	// 让两个端点都 500
+	dead := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(500)
+	}))
+	defer dead.Close()
+	if _, err := h.ps.Call("channels", "set_endpoints", map[string]interface{}{
+		"platform": "codearts",
+		"models_remote": map[string]interface{}{
+			"endpoint0": dead.URL, "endpoint1": dead.URL,
+		},
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := h.ps.Call("channels", "model_refresh", map[string]interface{}{"platform": "codearts"}); err != nil {
+		t.Fatalf("远端失败不该让 model_refresh 报错: %v", err)
+	}
+	got, err := h.ps.Call("channels", "model_list", map[string]interface{}{"platform": "codearts"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	ids := modelIDs(t, got)
+	if len(ids) == 0 {
+		t.Fatal("远端全失败时目录变空了 —— 兜底表必须补位（宁可留旧目录也别让平台变空）")
+	}
+	t.Logf("✓ 远端失败时兜底目录仍有 %d 个模型: %v", len(ids), ids)
+}

internal/core/channels_orphan_callback_test.go

@@ -0,0 +1,82 @@
+package core
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ 插件加载时必须清掉上一进程留下的孤儿回调文件。
+//
+// 真实事故：生产 `/etc/llmsproxy/plugins/` 攒了 **18 个 callback-*.port**
+// （对应的 .json 早已消失）。它们永远不会被清，因为：
+//
+//	· loopbacks 追踪表只活在内存（plugin.state.loopbacks）；
+//	· 进程被强杀时 on_unload 没机会跑；
+//	· 重启后内存表是空的 ⇒ reapLoopback 根本不知道它们存在。
+//
+// 判据看的是**目录的真实状态**（孤儿必须消失、活跃会话的文件不能被误删），
+// 而不是"某函数被调用过"。
+func TestPluginLoadSweepsOrphanCallbackFiles(t *testing.T) {
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("LLMSPROXY_PLUGIN_DIR", pluginDir)
+
+	// 摆上一轮的残留（模拟上一进程被强杀后的现场）
+	orphans := []string{
+		filepath.Join(pluginDir, "callback-deadbeef0001.port"),
+		filepath.Join(pluginDir, "callback-deadbeef0001.json"),
+		filepath.Join(pluginDir, "callback-deadbeef0002.port"),
+	}
+	for _, f := range orphans {
+		if err := os.WriteFile(f, []byte("12345"), 0600); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// 一份**不属于**回调的文件：必须不被误删（否则清扫过头会毁掉账号池）
+	keep := filepath.Join(pluginDir, ".channels-store.json")
+	if err := os.WriteFile(keep, []byte(`{"accounts":{}}`), 0600); err != nil {
+		t.Fatal(err)
+	}
+
+	// 加载插件 = 走真实启动路径
+	c := kernelTestCore(t)
+	defer c.Close()
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	ps := c.Plugins()
+	if err := ps.LoadSource("channels", src); err != nil {
+		t.Fatal(err)
+	}
+	// 顶层清扫代码在加载期就跑了；给 popen 的 rm 一点时间落盘
+	for i := 0; i < 50; i++ {
+		left := 0
+		for _, f := range orphans {
+			if _, err := os.Stat(f); err == nil {
+				left++
+			}
+		}
+		if left == 0 {
+			break
+		}
+	}
+	for _, f := range orphans {
+		if _, err := os.Stat(f); err == nil {
+			t.Fatalf("孤儿回调文件未被清扫: %s —— 它会永久留在磁盘上"+
+				"（真实事故：生产攒了 18 个）", filepath.Base(f))
+		}
+	}
+	if _, err := os.Stat(keep); err != nil {
+		t.Fatalf("清扫过头了：%s 被误删（账号池/索引绝不能碰）", filepath.Base(keep))
+	}
+	t.Log("✓ 孤儿回调文件被清，非回调文件保留")
+}
+
+var _ = lua.Plugins{}

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_trae_pkce_test.go

@@ -0,0 +1,200 @@
+package core
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ TRAE 回调只带 code（PKCE 形态）时必须**明确报出**「暂不支持 PKCE」，
+// 而不是去调 ExchangeToken 换一个不存在的码。
+//
+// 真实缺陷（用户报「登录后显示失败」）：
+// poll_login 的 trae 分支曾自己发明了一段「授权码交换」——把 {code} 塞进
+// exchange_body 再打 ExchangeToken。但：
+//
+//	· ExchangeToken 的签名是 RefreshToken，不是 code；
+//	· exchange_body 里根本没有 {code} 占位符，那次替换是空操作；
+//	· client_id 当时是空串。
+//
+// 于是稳定得到 400，日志回一句误导性的「Trae 授权码交换失败: 400」，
+// 把真因「上游走了 PKCE 流程」掩盖成「交换出错了」——排查方向完全错。
+//
+// 参考实现（trae-oauth.ts parseTraeCallbackDetailed）的做法是：带 code 的回调
+// 是**合法回调**，只是不支持的 PKCE 分支，必须明确报出来。
+func TestTraePkceCallbackIsReportedNotExchanged(t *testing.T) {
+	h := newTraeHarness(t)
+	// ★ 必须打**真实登录用的那条路径**：poll_login（loopback 回调文件）。
+	// oauth_callback 那条一直是对的，判据打在那里会漏掉缺陷 —— 我第一版就
+	// 犯了这个错（变异测试揭穿：注入缺陷后那条判据仍绿）。
+	//
+	// poll_login 从 plugin.state.loopbacks[sessionId].file 读 {code,state}，
+	// 故判据直接摆好那个文件再调 poll_login。
+	status, body := h.beginAndPollWithCallback(map[string]string{
+		"code": "PKCE_AUTH_CODE_XYZ",
+	})
+
+	// poll_login 的契约：终态用 HTTP 200 + json.state 表达（不是非 200 状态码）。
+	// 所以「失败」的判据是 state=failed，而不是 status != 200 —— 我第一版把
+	// 前者写成了后者，于是把正确的实现判成错。
+	if !strings.Contains(body, "state:failed") {
+		t.Fatalf("PKCE 回调应落定为 failed（poll_login 用 200+state 表达终态）：status=%d body=%s",
+			status, body)
+	}
+	if n := atomic.LoadInt32(&h.exchHit); n != 0 {
+		t.Fatalf("不得去调 ExchangeToken —— 那是拿 code 换一个不存在的码（真实缺陷）。"+
+			"实际打了 %d 次", n)
+	}
+	// 错误信息必须指向真因（PKCE），而不是含糊的交换失败
+	blob := body
+	if !strings.Contains(blob, "PKCE") {
+		t.Fatalf("错误信息应点名 PKCE（让排查方向正确），实得 %q", blob)
+	}
+	if strings.Contains(blob, "授权码交换失败") {
+		t.Fatalf("不应再出现误导性的「授权码交换失败」：%q", blob)
+	}
+	t.Logf("✓ PKCE 回调被正确识别（poll_login 路径）: %s", strings.TrimSpace(blob))
+}
+
+// ★ client_id 必须是实测真值 —— ExchangeToken 的请求体里 ClientID 是必填。
+// 留空会让真实 token 直传场景的交换稳定 400（夹具自身也校验 ClientID 存在）。
+func TestTraeExchangeSendsRealClientID(t *testing.T) {
+	h := newTraeHarness(t)
+	// 真实回调形态：带 refreshToken（token 直传）⇒ 会走 ExchangeToken。
+	// 夹具的 handler 已校验请求体含 ClientID / RefreshToken:<回调值> / ClientSecret。
+	status, body := h.beginAndCallback(map[string]string{
+		"refreshToken": "RT-FROM-CALLBACK",
+		"userInfo":     `{"UserID":"u1","ScreenName":"tester","TenantID":"t1"}`,
+	})
+	if status != 200 {
+		t.Fatalf("token 直传回调应成功: status=%d body=%s", status, body)
+	}
+	if n := atomic.LoadInt32(&h.exchHit); n == 0 {
+		t.Fatal("token 直传场景必须真的调用 ExchangeToken")
+	}
+	t.Logf("✓ ExchangeToken 被调用 %d 次，请求体形状正确", atomic.LoadInt32(&h.exchHit))
+}
+
+// client_id 的真值必须是实测值 —— 这是「交换必然 400」的两个成因之一。
+func TestTraeClientIDIsNotBlank(t *testing.T) {
+	b, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := string(b)
+	if !strings.Contains(src, `client_id = "en1oxy7wnw8j9n"`) {
+		t.Fatal("trae 的 client_id 必须是实测真值 en1oxy7wnw8j9n —— " +
+			"留空/占位会让 ExchangeToken 的 ClientID 为空而稳定 400")
+	}
+}
+
+// 两条路径（oauth_callback 与 poll_login 的 loopback）必须给**同一个**结论，
+// 否则修复只覆盖一条、另一条继续漂移（这正是缺陷能藏住的原因）。
+func TestTraeCallbackPathsAgreeOnPkce(t *testing.T) {
+	b, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := string(b)
+	// ① 不得再出现自己发明的交换（注释里说明历史的那句除外）
+	if strings.Contains(src, `cerr = "Trae 授权码交换失败`) {
+		t.Fatal("已删除的「授权码交换」又回来了 —— 那是拿 code 去 ExchangeToken，" +
+			"必然 400 且把真因掩盖成交换失败")
+	}
+	// ② 两条路径都必须交给 traeCallback（它内建 PKCE 判定）
+	if n := strings.Count(src, "traeCallback(plat,"); n < 2 {
+		t.Fatalf("traeCallback 应被两条路径共用（当前 %d 处）—— 只有一条会漂移", n)
+	}
+	// ③ PKCE 判定必须仍在 traeCallback 内
+	if !strings.Contains(src, "本实现暂不支持该流程") {
+		t.Fatal("traeCallback 必须保留 PKCE 明确报错（参考实现的语义）")
+	}
+}
+
+// beginAndPollWithCallback 走**真实登录用的那条路径**：
+// start_login 拿会话 → 摆好 loopback 回调文件（平台重定向的落地）→ poll_login。
+//
+// 与 beginAndCallback（打 oauth_callback）的区别很关键：poll_login 才是
+// callback 流在服务端浏览器（VNC）场景下真正走的那条，真实缺陷就藏在它的
+// trae 分支里。
+func (h *traeHarness) beginAndPollWithCallback(cbQuery map[string]string) (int, string) {
+	h.t.Helper()
+	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
+		Method: "POST", Body: `{"platform":"trae"}`,
+	})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	j, ok := out.JSON.(map[string]interface{})
+	if !ok {
+		h.t.Fatalf("start_login 返回非对象: %#v", out.JSON)
+	}
+	sess := j["session"].(map[string]interface{})
+	sid, _ := sess["id"].(string)
+	nonce, _ := sess["nonce"].(string)
+	if sid == "" {
+		h.t.Fatalf("会话缺 id: %#v", sess)
+	}
+
+	// 摆好 loopback 回调文件（内容 = 平台重定向带回的 query）
+	rec := map[string]string{"state": nonce}
+	for k, v := range cbQuery {
+		rec[k] = v
+	}
+	b, _ := json.Marshal(rec)
+	cbPath := filepath.Join(h.t.TempDir(), "cb-"+sid+".json")
+	if err := os.WriteFile(cbPath, b, 0600); err != nil {
+		h.t.Fatal(err)
+	}
+	// 告诉插件「这个会话的 loopback 接收器把结果写在这里了」
+	if _, err := h.ps.Call("channels", "__set_loopback_probe", map[string]interface{}{
+		"session_id": sid, "file": cbPath,
+	}); err != nil {
+		h.t.Fatalf("设置 loopback 文件: %v", err)
+	}
+
+	res, err := h.ps.InvokeHandler("channels", "poll_login", &lua.HandlerRequest{
+		Method: "GET", Query: map[string]string{"id": sid},
+	})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	return res.Status, fmt.Sprintf("%v|%v", res.Body, res.JSON)
+}
+
+// ★ PKCE 探测的候选来源必须覆盖参考的 5 个（含 authCodeInfo 为**纯 code 字符串**
+// 这一形态 —— 参考注释点名，解析不出 JSON 时必须回退到原始值）。
+//
+// 反例（我第一版就是错的）：用 `q.code or q.authCode or jsonField(...)` 链，
+// 而 jsonField 取不到时返回**空串**；Lua 里空串是真值 ⇒ 链在第一个空串处短路，
+// 后面的来源永远取不到。
+func TestTraePkceDetectsPlainStringAuthCodeInfo(t *testing.T) {
+	for _, tc := range []struct {
+		name string
+		q    map[string]string
+	}{
+		{"code 参数", map[string]string{"code": "C1"}},
+		{"authCode 参数", map[string]string{"authCode": "C2"}},
+		{"authCodeInfo 是 JSON", map[string]string{"authCodeInfo": `{"code":"C3"}`}},
+		{"authCodeInfo 是 JSON(authCode)", map[string]string{"authCodeInfo": `{"authCode":"C4"}`}},
+		{"authCodeInfo 是纯字符串", map[string]string{"authCodeInfo": "C5"}},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			h := newTraeHarness(t)
+			status, body := h.beginAndPollWithCallback(tc.q)
+			_ = status
+			if n := atomic.LoadInt32(&h.exchHit); n != 0 {
+				t.Fatalf("PKCE 形态不得去调 ExchangeToken（打了 %d 次）", n)
+			}
+			if !strings.Contains(body, "PKCE") {
+				t.Fatalf("应识别为 PKCE 并明确报出，实得 %q", body)
+			}
+		})
+	}
+}

internal/core/channels_upstream_gaps_test.go

@@ -0,0 +1,63 @@
+package core
+
+import (
+	"strings"
+	"testing"
+)
+
+// ★ 本文件把「上游客观缺口」写成**可执行的判据**，而不是只留在文档里。
+//
+// 为什么需要：这些能力缺口多次被误判成"我们漏实现了"（我自己就误判了两轮），
+// 于是反复派人去"补"。判据在此把事实钉住：
+//
+//   - qoder 加密端点（agent_chat_generation）需要 `qoder-auth-wasm.wasm`
+//     —— 该二进制**在参考仓库里也不存在**（参考自己也是 readFileSync 一个
+//     它不提供的文件）。故我们走明文端点 `/model/v1/chat/completions`，
+//     **不经过信封** ⇒ qoder-envelope 的解包能力在明文路径上无从生效。
+//   - TRAE 的 PKCE 分支参考**明确不支持**（只有"探测并拒绝"，无 code→token
+//     交换端点）⇒ 我们报"暂不支持"是与参考对齐的正确行为。
+//
+// 判据的作用是**防止误判**：任何人（包括未来的我）想"补"这些能力时，
+// 必须先让这个测试失败 —— 也就是先推翻事实，再动手。
+func TestUpstreamGapsAreDocumented(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	t.Run("qoder 走明文端点且不经过信封", func(t *testing.T) {
+		// 明文端点（OpenAI 兼容）：参考 QODER_CHAT_PATH
+		if !strings.Contains(s, "https://api2-v2.qoder.sh/model/v1/chat/completions") {
+			t.Fatal("qoder 的 chat 端点变了 —— 若改成加密端点 agent_chat_generation，" +
+				"则**必须**同时实现信封解包（qoder-envelope）与 WASM 签名，" +
+				"否则响应会被当成畸形数据")
+		}
+		// 明文端点没有信封层，故解包**不该**存在（存在反而是死代码）
+		if strings.Contains(s, "unwrapQoderEnvelope") {
+			t.Fatal("出现了 qoder 信封解包 —— 明文端点没有信封层。" +
+				"要么端点已换成加密端点（那需要 wasm），要么这是死代码")
+		}
+	})
+
+	t.Run("TRAE PKCE 明确报不支持（与参考一致）", func(t *testing.T) {
+		if !strings.Contains(s, "本实现暂不支持该流程") {
+			t.Fatal("TRAE 的 PKCE 分支必须明确报出「暂不支持」—— " +
+				"参考 trae-oauth.ts 也只做探测+拒绝，没有 code→token 交换端点。" +
+				"若改为尝试交换，会拿 code 去打要 RefreshToken 的 ExchangeToken（必然 400）")
+		}
+	})
+
+	t.Run("codearts 目录打两个签名端点（本轮补上）", func(t *testing.T) {
+		for _, want := range []string{
+			"opengw.developer.huaweicloud.com/api/v1/gateway/config",
+			"snap-access.cn-north-4.myhuaweicloud.com/v1/model/builtin",
+			`sign = "codearts"`,
+		} {
+			if !strings.Contains(s, want) {
+				t.Fatalf("codearts 目录缺 %q —— 参考 fetchCodeArtsRemoteModels 打两个"+
+					"**必须 AK/SK 签名**的端点，只打一个会少一半模型", want)
+			}
+		}
+	})
+}

internal/core/channels_vnc_test.go

@@ -1,6 +1,7 @@
 package core
 
 import (
+	"net/url"
 	"strings"
 	"testing"
 
@@ -53,14 +54,43 @@ func TestChannelsVncStackEndToEnd(t *testing.T) {
 		t.Fatalf("浏览器栈未能启动: %s", e)
 	}
 	view, _ := m["view_url"].(string)
-	if !strings.Contains(view, "vnc.html") {
-		t.Fatalf("应给出 noVNC 内嵌地址, 实得 %q", view)
+	if !strings.HasPrefix(view, "/api/plugins/http/channels/browser/proxy/") || !strings.Contains(view, "vnc.html") {
+		t.Fatalf("应给出同源 noVNC 内嵌地址，不能让远程客户端连服务器回环端口, 实得 %q", view)
 	}
 	sess := m["session"].(map[string]interface{})
 	if sess["cdp_port"] == nil {
 		t.Fatal("会话应带 CDP 端口（取凭据用）")
 	}
-	t.Logf("VNC 栈已起: %s (CDP %v)", view, sess["cdp_port"])
+
+	// ★ noVNC 用 `new URL(path, location.href)` 解析 path（ui.js 的 connect()），
+	// 即**相对 vnc.html 所在目录**解析，默认值就是相对名 'websockify'。
+	// 真实缺陷：传了站点根路径 ⇒ 路径被重复拼接，WebSocket 永远连不上，
+	// 页面看似白屏：
+	//   .../proxy/<id>/api/plugins/http/channels/browser/proxy/<id>/websockify
+	// 本判据必须解析**产品自己给出的 URL**：我曾在验证时手拼 URL 并省掉
+	// path 参数（默认值恰好正确）⇒ 否定了真实缺陷。
+	u, perr := url.Parse(view)
+	if perr != nil {
+		t.Fatalf("view_url 不可解析: %v", perr)
+	}
+	q := u.Query()
+	wspath := q.Get("path")
+	if wspath == "" {
+		t.Fatal("view_url 必须显式声明 path=websockify：依赖 noVNC 隐式默认值" +
+			"会在 URL 形状变化时静默破裂")
+	}
+	if strings.HasPrefix(wspath, "/") {
+		t.Fatalf("path 必须是相对名（noVNC 相对 vnc.html 目录解析），"+
+			"以 / 开头会被当相对路径而重复拼接，实得 %q", wspath)
+	}
+	resolved := u.ResolveReference(&url.URL{Path: wspath})
+	pages := strings.TrimSuffix(u.Path, "/vnc.html")
+	if resolved.Path != pages+"/websockify" {
+		t.Fatalf("path 解析后应为 %q（同级 websockify），实得 %q —— 重复拼接即白屏根因",
+			pages+"/websockify", resolved.Path)
+	}
+
+	t.Logf("VNC 栈已起: %s → WebSocket %s (CDP %v)", view, resolved.Path, sess["cdp_port"])
 
 	// 收尾：回收浏览器栈（测试不留孤儿进程）
 	if _, err := ps.InvokeHandler("channels", "stop_browser", &lua.HandlerRequest{

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

@@ -0,0 +1,404 @@
+package core
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ ZCode 的身份块是 3012 准入的**唯一开关**。
+//
+// 参考实测（三个账号、17 次请求）：system 缺官方身份块结构时，上游直接
+//
+//	HTTP 405 + {"code":3012,"msg":"...unusual activity."}
+//
+// 且与 HTTP 头、版本号、请求频率、多轮历史、tools 声明、运行时**全部无关**。
+//
+// 判据矩阵（照参考，逐条锁定）：
+//
+//	无 system                        → 3012
+//	仅 cliPrefix（42 字符）           → 3012
+//	cliPrefix + stable（约 2898 字符）→ 200
+//
+// ⇒ 判据是「身份块**结构**是否存在」，不是字符数凑够。
+//
+// 本判据看**适配器真正产出给上游的请求体**（transform_request 的返回值），
+// 而不是"适配器装了没"这类内部信号。
+func TestZcodeAdapterInjectsOfficialIdentityBlocks(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	out, err := h.transformRequest(`{"model":"glm-5.3-flash","messages":[{"role":"user","content":"hi"}]}`)
+	if err != nil {
+		t.Fatalf("transform_request: %v", err)
+	}
+	var req map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &req); err != nil {
+		t.Fatalf("产出不是 JSON: %v\n%s", err, out)
+	}
+
+	// ① system 必须是**块数组**（官方形态），不是纯字符串
+	sys, ok := req["system"].([]interface{})
+	if !ok {
+		t.Fatalf("system 必须是块数组（上游检查的是这个结构），实得 %T: %v",
+			req["system"], req["system"])
+	}
+	if len(sys) < 3 {
+		t.Fatalf("system 块数至少 3（cliPrefix + stable + Environment），实得 %d", len(sys))
+	}
+
+	// ② block[0] 必须是官方 CLI 前缀（准入必需）
+	b0, _ := sys[0].(map[string]interface{})
+	if got, _ := b0["text"].(string); got != "You are ZCode, an interactive coding agent" {
+		t.Fatalf("block[0] 必须是官方 CLI 前缀（逐字），实得 %q", got)
+	}
+
+	// ③ block[1] 必须是官方 stable 段（准入必需），长度对得上
+	b1, _ := sys[1].(map[string]interface{})
+	stable, _ := b1["text"].(string)
+	if len(stable) < 2800 {
+		t.Fatalf("block[1]（stable 段）长度 %d < 2800 —— 身份块不完整会被判为裸请求（3012）",
+			len(stable))
+	}
+	for _, marker := range []string{
+		"You are an interactive ZCode agent",
+		"# Harness",
+		"# ZCode Desktop Context",
+	} {
+		if !strings.Contains(stable, marker) {
+			t.Fatalf("stable 段缺 %q —— 身份块被截断/改写", marker)
+		}
+	}
+
+	// ④ block[2] 是 Environment 段（官方每会话都发；不发则模型不知 cwd/平台）
+	b2, _ := sys[2].(map[string]interface{})
+	env, _ := b2["text"].(string)
+	if !strings.HasPrefix(env, "# Environment") {
+		t.Fatalf("block[2] 必须是 Environment 段，实得 %q", env[:zcodeMin(40, len(env))])
+	}
+	for _, marker := range []string{"Primary working directory", "Platform", "powered by the model named"} {
+		if !strings.Contains(env, marker) {
+			t.Fatalf("Environment 段缺 %q：%s", marker, env)
+		}
+	}
+
+	// ⑤ 总长度必须达到参考声明的量级（2898）
+	total := len("You are ZCode, an interactive coding agent") + len(stable)
+	if total < 2800 {
+		t.Fatalf("身份块合计 %d 字符 < 2800（参考实测的准入值约 2898）", total)
+	}
+
+	// ⑥ 日期块：插到第一条 user 消息的 content **数组**最前（官方形态）
+	msgs, _ := req["messages"].([]interface{})
+	if len(msgs) == 0 {
+		t.Fatal("messages 为空")
+	}
+	m0, _ := msgs[0].(map[string]interface{})
+	content, ok := m0["content"].([]interface{})
+	if !ok {
+		t.Fatalf("首条 user 的 content 必须是**块数组**（拼进字符串会改变结构、仍被判裸请求），实得 %T",
+			m0["content"])
+	}
+	c0, _ := content[0].(map[string]interface{})
+	if got, _ := c0["text"].(string); !strings.Contains(got, "<system-reminder>") {
+		t.Fatalf("content[0] 必须是日期块（<system-reminder>），实得 %q", got)
+	}
+
+	t.Logf("✓ 身份块注入正确：块数=%d stable=%d 合计=%d", len(sys), len(stable), total)
+}
+
+// ★ 调用方的 system 必须**追加在最后**：上游检查看的是**前缀结构**，
+// 官方身份块必须处在开头位置。若被前置会让身份块不在前缀而吃 3012。
+func TestZcodeCallerSystemIsAppendedLast(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+	out, err := h.transformRequest(
+		`{"model":"glm-5.3-flash","messages":[{"role":"system","content":"CALLER_PROMPT_XYZ"},{"role":"user","content":"hi"}]}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var req map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &req); err != nil {
+		t.Fatal(err)
+	}
+	sys, _ := req["system"].([]interface{})
+	if len(sys) < 4 {
+		t.Fatalf("带调用方 system 时应为 4 块（3 官方 + 1 调用方），实得 %d", len(sys))
+	}
+	last, _ := sys[len(sys)-1].(map[string]interface{})
+	lt, _ := last["text"].(string)
+	if !strings.Contains(lt, "CALLER_PROMPT_XYZ") {
+		t.Fatalf("调用方 system 必须在**最后一块**（上游看前缀结构；前置会让身份块不在前缀）")
+	}
+	// 且前三块仍是官方块（身份块没有被调用方内容挤走）
+	b0, _ := sys[0].(map[string]interface{})
+	if got, _ := b0["text"].(string); got != "You are ZCode, an interactive coding agent" {
+		t.Fatalf("block[0] 必须仍是官方 CLI 前缀，实得 %q", got)
+	}
+}
+
+// 适配器自检出口：身份块长度与 anthropic 基座装载状态。
+// 「装了但身份块是空的」这类问题（转义/截断/基座读不到）没有它只能靠猜。
+func TestZcodeAdapterProbeReportsIdentityLength(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+	res, err := h.ps.Call("channels", "__adapter_install_probe", map[string]interface{}{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	j := res.(map[string]interface{})["json"].(map[string]interface{})
+	zc, ok := j["zcode"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("探针未报告 zcode 适配器装载结果: %v", j)
+	}
+	if zc["ok"] != true {
+		t.Fatalf("zcode 适配器装载失败: %v", zc["err"])
+	}
+}
+
+// zcodeIdentityHarness：加载插件（它会**自装** channels-zcode 适配器），
+// 然后直接调那个适配器的 transform_request。
+//
+// 直接调已装载的适配器（而不是自己去 load 源码）更接近真实路径：判据验的是
+// 「上游实际收到的请求体」，包含前导注入、桥的装载等全部环节。
+type zcodeIdentityHarness struct {
+	t  *testing.T
+	c  *Core
+	ps *lua.Plugins
+}
+
+func newZcodeIdentityHarness(t *testing.T) *zcodeIdentityHarness {
+	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)
+	}
+	return &zcodeIdentityHarness{t: t, c: c, ps: ps}
+}
+
+// transformRequest 调**已自装的** channels-zcode 适配器的 transform_request。
+func (h *zcodeIdentityHarness) transformRequest(body string) (string, error) {
+	h.t.Helper()
+	vm := h.c.VM()
+	if vm == nil {
+		h.t.Fatal("VM 不可用")
+	}
+	return vm.Transform("channels-zcode", "transform_request", body)
+}
+
+func zcodeMin(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+// ★ 身份块注入不得破坏协议转换：工具调用、图像、流式帧仍必须走 anthropic 那一份。
+//
+// 为什么必须验：本适配器的手法是把 anthropic.lua 的源码读进来执行、只覆盖
+// transform_request。若「读不到基座」或「覆盖时丢了字段」，协议转换会静默退化
+// —— 表现为工具调用参数丢失、图像块消失，而身份块看起来完全正常。
+func TestZcodeAdapterKeepsAnthropicProtocolConversion(t *testing.T) {
+	h := newZcodeIdentityHarness(t)
+
+	t.Run("工具定义与工具调用存活", func(t *testing.T) {
+		in := `{"model":"glm-5.3-flash","messages":[{"role":"user","content":"go"}],` +
+			`"tools":[{"type":"function","function":{"name":"get_weather",` +
+			`"description":"d","parameters":{"type":"object","properties":{"c":{"type":"string"}}}}}]}`
+		out, err := h.transformRequest(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// anthropic 形态：tools[].name / input_schema（顶层，不是嵌套在 function 里）
+		if !strings.Contains(out, `"get_weather"`) {
+			t.Fatalf("工具定义在转换中丢失（identity 注入不该影响它）：%s", out)
+		}
+		if !strings.Contains(out, `"input_schema"`) {
+			t.Fatalf("工具 schema 未转成 anthropic 形态（input_schema 缺失）：%s", out)
+		}
+	})
+
+	t.Run("多模态图像块存活", func(t *testing.T) {
+		in := `{"model":"glm-5.3-flash","messages":[{"role":"user","content":[` +
+			`{"type":"text","text":"what"},` +
+			`{"type":"image_url","image_url":{"url":"data:image/png;base64,AAAA"}}]}]}`
+		out, err := h.transformRequest(in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !strings.Contains(out, `"image"`) || !strings.Contains(out, `"base64"`) {
+			t.Fatalf("图像块在转换中丢失：%s", out)
+		}
+	})
+
+	t.Run("基座装载状态可见", func(t *testing.T) {
+		// 读适配器的自检出口：base_loaded 必须为 true（否则身份块虽在、
+		// 协议转换已退化为透传）
+		res, err := h.ps.Call("channels", "__adapter_install_probe", map[string]interface{}{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		j := res.(map[string]interface{})["json"].(map[string]interface{})
+		zc := j["zcode"].(map[string]interface{})
+		if zc["ok"] != true {
+			t.Fatalf("zcode 适配器未装载: %v", zc)
+		}
+	})
+}
+
+// ★ 基座（anthropic.lua）读不到时必须**响亮失败**，不得静默退化。
+//
+// 反例危害：若"尽力而为"（只注入身份块、不作协议转换），会产出一个身份块
+// 看着正确的请求，而 tools/图像/流式结构全未转换 —— 上游可能 200，但模型
+// 拿不到工具定义，症状是"模型变笨了"，与准入毫不相干，排查会完全跑偏。
+//
+// 判据看的是**适配器的真实产出**：把适配器目录指到空目录（基座不可得），
+// transform_request 必须返回错误而不是原样透传。
+func TestZcodeAdapterFailsLoudlyWithoutAnthropicBase(t *testing.T) {
+	// 隔离目录：插件目录下没有兄弟 adapters/ 目录 ⇒ 基座读不到
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	t.Setenv("LLMSPROXY_PLUGIN_DIR", pluginDir)
+
+	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)
+	}
+	vm := c.VM()
+	if vm == nil {
+		t.Fatal("VM 不可用")
+	}
+	// 插件自装时若基座读不到，适配器仍应装载（身份块是静态的），
+	// 但调用必须报错
+	out, err := vm.Transform("channels-zcode", "transform_request",
+		`{"model":"m","messages":[{"role":"user","content":"hi"}]}`)
+	if err == nil {
+		t.Fatalf("基座不可得时必须报错，却成功产出了：%s", out)
+	}
+	if !strings.Contains(err.Error(), "基座") {
+		t.Fatalf("错误信息应点明基座问题（可定位），实得 %v", err)
+	}
+	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)
+		}
+	})
+}

internal/gateway/deploy_script_test.go

@@ -33,13 +33,13 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 		t.Fatalf("read deploy.sh: %v", err)
 	}
 	src := string(fn)
-	i := strings.Index(src, "prune_adapter_backups()")
+	i := strings.Index(src, "prune_backups()")
 	if i < 0 {
-		t.Fatal("prune_adapter_backups not found in deploy.sh")
+		t.Fatal("prune_backups not found in deploy.sh")
 	}
 	j := strings.Index(src[i:], "\n}\n")
 	if j < 0 {
-		t.Fatal("prune_adapter_backups has no closing brace")
+		t.Fatal("prune_backups has no closing brace")
 	}
 	body := src[i : i+j+3]
 
@@ -47,20 +47,20 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 	body = strings.Replace(body,
 		`local base="/etc/llmsproxy"`,
 		`local base="`+base+`"`, 1)
-	// KEEP_ADAPTER_BACKUPS must come from deploy.sh itself, NOT from a literal
+	// KEEP_BACKUPS must come from deploy.sh itself, NOT from a literal
 	// here: hardcoding 5 in the shim overrode whatever the script configured, so
-	// a mutation that set KEEP_ADAPTER_BACKUPS=0 in deploy.sh still passed. The
+	// a mutation that set KEEP_BACKUPS=0 in deploy.sh still passed. The
 	// value is part of what is under test.
-	var keepRe = regexp.MustCompile(`(?m)^KEEP_ADAPTER_BACKUPS=(\d+)`)
+	var keepRe = regexp.MustCompile(`(?m)^KEEP_BACKUPS=(\d+)`)
 	keepM := keepRe.FindStringSubmatch(src)
 	if keepM == nil {
-		t.Fatal("deploy.sh no longer sets KEEP_ADAPTER_BACKUPS; the pruning " +
+		t.Fatal("deploy.sh no longer sets KEEP_BACKUPS; the pruning " +
 			"policy would be undefined")
 	}
 	keep := keepM[1]
 
-	script := "warn() { :; }\nlog() { :; }\nKEEP_ADAPTER_BACKUPS=" + keep + "\n" +
-		body + "\nprune_adapter_backups\n"
+	script := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" + keep + "\n" +
+		body + "\nprune_backups adapters\n"
 	scriptPath := filepath.Join(base, "fn.sh")
 	if err := os.WriteFile(scriptPath, []byte(script), 0o600); err != nil {
 		t.Fatalf("write script: %v", err)
@@ -88,7 +88,7 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 	}
 
 	if out, err := exec.Command("bash", scriptPath).CombinedOutput(); err != nil {
-		t.Fatalf("prune_adapter_backups failed: %v\n%s", err, out)
+		t.Fatalf("prune_backups failed: %v\n%s", err, out)
 	}
 
 	entries, err := os.ReadDir(base)
@@ -102,11 +102,11 @@ func TestDeployPruneAdapterBackups(t *testing.T) {
 		}
 	}
 
-	// 12 well-formed backups with KEEP_ADAPTER_BACKUPS=5 → the newest FIVE
+	// 12 well-formed backups with KEEP_BACKUPS=5 → the newest FIVE
 	// survive (…08 …09 …10 …11 …12) and the older seven are deleted. Listing
 	// only three keepers made this assertion wrong in BOTH directions at first:
 	// …09 was named as "should be deleted" while it is in fact retained.
-	// KEEP_ADAPTER_BACKUPS=5 is a cap on the TOTAL number of backups, and
+	// KEEP_BACKUPS=5 is a cap on the TOTAL number of backups, and
 	// irregular names are never deleted — so they consume slots rather than
 	// being ignored. With 3 unremovable directories present, only 2 of the
 	// well-formed ones can survive. That is the function's actual (and safe)
@@ -202,3 +202,123 @@ func TestDeployBacksUpTheLiveFileBeforeOverwriting(t *testing.T) {
 			"captures the new file and rollback restores nothing")
 	}
 }
+
+// ★ 备份清理必须覆盖 plugins 前缀（真实缺陷）。
+//
+// 事实：backup 清理最初只处理 `adapters.bak.*`，而 `sync_plugins` 同样每次部署
+// 建一个 `plugins.bak.<时间戳>` —— 于是 adapters 的堆积被修好，plugins 继续涨。
+// 实测线上 plugins.bak 积累到 **36 个**、/etc/llmsproxy 涨到 192M。
+//
+// 这是「两处只修一处」的老形状。判据钉住：prune_all_backups 必须同时裁两个前缀，
+// 且新增任何 .bak.<时间戳> 前缀时都要在这里补上（否则又是一个泄漏点）。
+func TestDeployPruneCoversBothBackupPrefixes(t *testing.T) {
+	if _, err := os.Stat("../../deploy.sh"); err != nil {
+		t.Skip("deploy.sh not present (packaging-only checkout)")
+	}
+	if _, err := exec.LookPath("bash"); err != nil {
+		t.Skip("bash not available")
+	}
+	fn, err := os.ReadFile("../../deploy.sh")
+	if err != nil {
+		t.Fatal(err)
+	}
+	src := string(fn)
+
+	// ① prune_all_backups 必须存在且两个前缀都裁
+	i := strings.Index(src, "prune_all_backups()")
+	if i < 0 {
+		t.Fatal("prune_all_backups 不存在 —— 调用点若仍只裁 adapters，" +
+			"plugins.bak 会继续无上限堆积（实测 36 个 / 192M）")
+	}
+	j := strings.Index(src[i:], "\n}\n")
+	if j < 0 {
+		t.Fatal("prune_all_backups 没有收尾大括号")
+	}
+	body := src[i : i+j+3]
+	for _, want := range []string{"prune_backups adapters", "prune_backups plugins"} {
+		if !strings.Contains(body, want) {
+			t.Fatalf("prune_all_backups 缺 %q —— plugins.bak 会无上限堆积", want)
+		}
+	}
+
+	// ② ★ 覆盖完整性：脚本里出现的每个 `.bak.<时间戳>` 前缀都必须在裁剪范围内。
+	// 这条比逐字检查两个名字更强 —— 将来有人新增第三种备份目录（比如
+	// runtime.bak.*），这里会立刻报红，而不是等它涨到几百兆。
+	prefixRe := regexp.MustCompile(`([a-z_]+)\.bak\.\$\(date`)
+	found := map[string]bool{}
+	for _, m := range prefixRe.FindAllStringSubmatch(src, -1) {
+		found[m[1]] = true
+	}
+	if len(found) == 0 {
+		t.Fatal("deploy.sh 里没找到任何 .bak.$(date …) 备份目录创建点（判据需更新）")
+	}
+	for prefix := range found {
+		if !strings.Contains(body, "prune_backups "+prefix) {
+			t.Errorf("deploy.sh 会创建 %s.bak.<时间戳> 目录，但 prune_all_backups 不裁它 "+
+				"—— 它就是一个无上限增长的备份泄漏点（实测 plugins.bak 涨到 36 个）", prefix)
+		}
+	}
+
+	// ③ 行为验证：用真函数裁 plugins 前缀，最新 5 份必须留下、更旧的删掉
+	base := t.TempDir()
+	k := strings.Index(src, "prune_backups()")
+	kj := strings.Index(src[k:], "\n}\n")
+	fnBody := src[k : k+kj+3]
+	fnBody = strings.Replace(fnBody, `local base="/etc/llmsproxy"`, `local base="`+base+`"`, 1)
+	keepRe := regexp.MustCompile(`(?m)^KEEP_BACKUPS=(\d+)`)
+	km := keepRe.FindStringSubmatch(src)
+	if km == nil {
+		t.Fatal("deploy.sh 不再设置 KEEP_BACKUPS")
+	}
+	script := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" +
+		km[1] + "\n" + fnBody + "\nprune_backups plugins\n"
+	sp := filepath.Join(base, "fn.sh")
+	if err := os.WriteFile(sp, []byte(script), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	for _, ts := range []string{
+		"20260101120000", "20260201120000", "20260301120000", "20260401120000",
+		"20260501120000", "20260601120000", "20260701120000", "20260801120000",
+	} {
+		if err := os.MkdirAll(filepath.Join(base, "plugins.bak."+ts), 0o755); err != nil {
+			t.Fatal(err)
+		}
+	}
+	// adapters 前缀**不该被动**（防止误删别的前缀）
+	if err := os.MkdirAll(filepath.Join(base, "adapters.bak.20260101120000"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if out, err := exec.Command("bash", sp).CombinedOutput(); err != nil {
+		t.Fatalf("prune_backups plugins failed: %v\n%s", err, out)
+	}
+	entries, err := os.ReadDir(base)
+	if err != nil {
+		t.Fatal(err)
+	}
+	got := map[string]bool{}
+	for _, e := range entries {
+		if e.IsDir() {
+			got[e.Name()] = true
+		}
+	}
+	if !got["plugins.bak.20260801120000"] {
+		t.Error("最新的 plugins 备份被删了；裁剪必须从最旧的一端开始")
+	}
+	if got["plugins.bak.20260101120000"] {
+		t.Error("最旧的 plugins 备份存活；裁剪没生效")
+	}
+	if !got["adapters.bak.20260101120000"] {
+		t.Error("裁 plugins 时误删了 adapters 备份 —— 前缀参数必须严格限定范围")
+	}
+
+	// ④ 未知前缀必须响亮失败（防误用：传空串会删掉整个目录）
+	bad := "warn() { :; }\nlog() { :; }\nfail() { echo \"$*\" >&2; exit 1; }\nKEEP_BACKUPS=" +
+		km[1] + "\n" + fnBody + "\nprune_backups \"\"\n"
+	bp := filepath.Join(base, "bad.sh")
+	if err := os.WriteFile(bp, []byte(bad), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if out, err := exec.Command("bash", bp).CombinedOutput(); err == nil {
+		t.Fatalf("prune_backups 接受空前缀（危险：会删整个目录），输出: %s", out)
+	}
+}

internal/gateway/plugin_http_routes.go

@@ -55,6 +55,15 @@ func (g *Gateway) handlePluginHTTP(w http.ResponseWriter, r *http.Request) {
 	for i := range matches {
 		h := matches[i]
 		p, ok := matchHandlerPath(h.Path, rest)
+		if h.Prefix {
+			pattern := strings.Trim(h.Path, "/")
+			parts := strings.Split(strings.Trim(rest, "/"), "/")
+			n := len(strings.Split(pattern, "/"))
+			ok = len(parts) >= n
+			if ok {
+				p, ok = matchHandlerPath(pattern, strings.Join(parts[:n], "/"))
+			}
+		}
 		if !ok {
 			continue
 		}
@@ -116,6 +125,16 @@ func (g *Gateway) handlePluginHTTP(w http.ResponseWriter, r *http.Request) {
 		writeError(w, http.StatusBadGateway, "plugin_error", err.Error())
 		return
 	}
+	if resp.Proxy != "" {
+		if !chosen.Prefix {
+			writeError(w, http.StatusBadGateway, "plugin_error", "proxy response requires prefix=true")
+			return
+		}
+		parts := strings.Split(strings.Trim(rest, "/"), "/")
+		n := len(strings.Split(strings.Trim(chosen.Path, "/"), "/"))
+		g.servePluginProxy(w, r, resp.Proxy, pluginHTTPPrefix+strings.Join(parts[:n], "/"))
+		return
+	}
 	lua.WriteHandlerResponse(w, resp)
 }
 

internal/gateway/plugin_proxy.go

@@ -0,0 +1,54 @@
+package gateway
+
+import (
+	"net"
+	"net/http"
+	"net/http/httputil"
+	"net/url"
+	"strings"
+)
+
+// servePluginProxy forwards a plugin-owned prefix to an explicit loopback
+// origin. No destination or path may be supplied by the client. Authentication
+// and endpoint authorization have already completed before this is called.
+func (g *Gateway) servePluginProxy(w http.ResponseWriter, r *http.Request, target, prefix string) {
+	u, err := url.Parse(target)
+	if err != nil || u.Scheme != "http" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Path != "" && u.Path != "/") {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "proxy must name a loopback HTTP origin")
+		return
+	}
+	ip := net.ParseIP(u.Hostname())
+	if ip == nil || !ip.IsLoopback() || u.Port() == "" {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "proxy requires a literal loopback address and port")
+		return
+	}
+	// WebSocket requests are browser-initiated and carry ambient cookies. Do not
+	// allow a foreign website to use an administrator's session to open a tunnel.
+	if origin := r.Header.Get("Origin"); origin != "" {
+		o, e := url.Parse(origin)
+		if e != nil || !strings.EqualFold(o.Host, r.Host) {
+			writeError(w, http.StatusForbidden, "forbidden", "cross-origin proxy request refused")
+			return
+		}
+	}
+	proxy := httputil.NewSingleHostReverseProxy(u)
+	director := proxy.Director
+	proxy.Director = func(out *http.Request) {
+		director(out)
+		out.URL.Path = strings.TrimPrefix(r.URL.Path, prefix)
+		if out.URL.Path == "" {
+			out.URL.Path = "/"
+		}
+		out.URL.RawPath = ""
+		out.Host = u.Host
+		out.Header.Del("Authorization")
+		out.Header.Del("Cookie")
+		q := out.URL.Query()
+		q.Del("api_key")
+		out.URL.RawQuery = q.Encode()
+	}
+	proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
+		writeError(w, http.StatusBadGateway, "plugin_proxy", "plugin service unavailable")
+	}
+	proxy.ServeHTTP(w, r)
+}

internal/gateway/plugin_proxy_security_test.go

@@ -0,0 +1,66 @@
+package gateway
+
+import (
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestPluginProxyRejectsUnsafeTargetsAndOrigin(t *testing.T) {
+	g, _ := gatewayWithSpy(t)
+	for _, target := range []string{"http://example.com:80", "http://localhost:80", "https://127.0.0.1:80", "http://127.0.0.1", "http://u:p@127.0.0.1:80", "http://127.0.0.1:80/path", "http://127.0.0.1:80/?x=1"} {
+		rr := httptest.NewRecorder()
+		g.servePluginProxy(rr, httptest.NewRequest("GET", "http://gateway/api/plugins/http/relay/s/live.js", nil), target, "/api/plugins/http/relay/s")
+		if rr.Code != 502 {
+			t.Errorf("unsafe target %q accepted: %d", target, rr.Code)
+		}
+	}
+	rr := httptest.NewRecorder()
+	req := httptest.NewRequest("GET", "http://gateway/api/plugins/http/relay/s/websockify", nil)
+	req.Header.Set("Origin", "https://evil.example")
+	g.servePluginProxy(rr, req, "http://127.0.0.1:12345", "/api/plugins/http/relay/s")
+	if rr.Code != 403 {
+		t.Fatalf("foreign origin accepted: %d", rr.Code)
+	}
+}
+
+func TestPluginPrefixProxyAuthorizationAndRevocation(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { t.Error("denied request reached backend") }))
+	defer backend.Close()
+	g, _ := gatewayWithSpy(t)
+	src := `local p={name="relaydeny",http={{path="relaydeny/:session",prefix=true,roles={"admin"},handler="proxy"}}}
+ function p.proxy(req) return {status=404,body="expired session"} end
+ return p`
+	if err := g.core.Plugins().LoadSource("relaydeny", src); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewServer(g.Handler())
+	defer server.Close()
+	for _, tc := range []struct {
+		path, key string
+		status    int
+	}{
+		{"/api/plugins/http/relaydeny/expired/vnc.html", "", 401},
+		{"/api/plugins/http/relaydeny/expired/vnc.html", "sk-test", 404},
+		{"/api/plugins/http/relaydeny-not-a-child/expired/vnc.html", "sk-test", 404},
+	} {
+		req, _ := http.NewRequest("GET", server.URL+tc.path, nil)
+		if tc.key != "" {
+			req.Header.Set("Authorization", "Bearer "+tc.key)
+		}
+		resp, err := http.DefaultClient.Do(req)
+		if err != nil {
+			t.Fatal(err)
+		}
+		b, _ := io.ReadAll(resp.Body)
+		resp.Body.Close()
+		if resp.StatusCode != tc.status {
+			t.Fatalf("%s got %d %s", tc.path, resp.StatusCode, b)
+		}
+		if tc.key != "" && strings.Contains(tc.path, "/expired/") && strings.Contains(tc.path, "/relaydeny/") && string(b) != "expired session" {
+			t.Fatalf("revocation response=%s", b)
+		}
+	}
+}

internal/gateway/plugin_proxy_test.go

@@ -0,0 +1,82 @@
+package gateway
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// Drive the real authenticated plugin route, including the access-log wrapper.
+// A successful static request alone does not prove WebSocket can upgrade.
+func TestPluginPrefixProxyHTTPAndUpgrade(t *testing.T) {
+	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Header.Get("Authorization") != "" || r.Header.Get("Cookie") != "" || r.URL.Query().Get("api_key") != "" {
+			t.Error("gateway credentials leaked to plugin backend")
+		}
+		if r.URL.Path == "/websockify" {
+			c, b, err := w.(http.Hijacker).Hijack()
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			defer c.Close()
+			fmt.Fprint(b, "HTTP/1.1 101 Switching Protocols\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n")
+			b.Flush()
+			io.Copy(c, c)
+			return
+		}
+		fmt.Fprint(w, r.URL.Path+"?"+r.URL.RawQuery)
+	}))
+	defer backend.Close()
+	g, _ := gatewayWithSpy(t)
+	src := fmt.Sprintf(`local p={name="relay",http={{path="relay/:session",prefix=true,method="GET",roles={"admin"},handler="proxy"}}}
+ function p.proxy(req)
+ if req.params.session ~= "live" then return {status=404,body="expired"} end
+ return {proxy=%q}
+ end
+ return p`, backend.URL)
+	if err := g.core.Plugins().LoadSource("relay", src); err != nil {
+		t.Fatal(err)
+	}
+	server := httptest.NewServer(g.Handler())
+	defer server.Close()
+	req, _ := http.NewRequest("GET", server.URL+"/api/plugins/http/relay/live/app/main.js?x=1&api_key=sk-test", nil)
+	req.Header.Set("Authorization", "Bearer sk-test")
+	req.AddCookie(&http.Cookie{Name: "gw_key", Value: "sk-test"})
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, _ := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	if resp.StatusCode != 200 || string(body) != "/app/main.js?x=1" {
+		t.Fatalf("HTTP proxy: %d %s", resp.StatusCode, body)
+	}
+	c, err := net.Dial("tcp", strings.TrimPrefix(server.URL, "http://"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer c.Close()
+	fmt.Fprintf(c, "GET /api/plugins/http/relay/live/websockify HTTP/1.1\r\nHost: %s\r\nAuthorization: Bearer sk-test\r\nConnection: Upgrade\r\nUpgrade: websocket\r\n\r\n", strings.TrimPrefix(server.URL, "http://"))
+	b := bufio.NewReader(c)
+	reply, err := http.ReadResponse(b, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if reply.StatusCode != 101 {
+		t.Fatalf("upgrade failed: %s", reply.Status)
+	}
+	c.Write([]byte("ping"))
+	got := make([]byte, 4)
+	if _, err = io.ReadFull(b, got); err != nil {
+		t.Fatal(err)
+	}
+	if string(got) != "ping" {
+		t.Fatalf("tunnel payload=%q", got)
+	}
+}

internal/gateway/server.go

@@ -187,6 +187,10 @@ type statusRecorder struct {
 	code int
 }
 
+// Unwrap preserves optional writer capabilities (notably Hijack for WebSocket)
+// through the access-log middleware via http.ResponseController.
+func (s *statusRecorder) Unwrap() http.ResponseWriter { return s.ResponseWriter }
+
 func (s *statusRecorder) WriteHeader(code int) {
 	if s.code == 0 {
 		s.code = code

internal/gateway/stats.go

@@ -228,6 +228,26 @@ func incStatus(a *Stat, name string, r Req) {
 	}
 }
 
+// addStat merges an already aggregated row into a total. It deliberately
+// includes failed requests without a model: routing can fail before a model is
+// resolved, but that request still belongs in the gateway total.
+func addStat(dst, src *Stat) {
+	if dst == nil || src == nil {
+		return
+	}
+	dst.Reqs += src.Reqs
+	dst.OK += src.OK
+	dst.Err += src.Err
+	dst.Tokens += src.Tokens
+	dst.Prompt += src.Prompt
+	dst.Compl += src.Compl
+	dst.LatSum += src.LatSum
+	dst.FirstByteSum += src.FirstByteSum
+	if src.LatMax > dst.LatMax {
+		dst.LatMax = src.LatMax
+	}
+}
+
 // LoadAudit primes the in-memory state from the audit file.
 //
 // The aggregates (totals, per-key/model/source rows, status counts and the
@@ -1219,17 +1239,13 @@ func (s *Stats) Snapshot(limit int, key string) map[string]interface{} {
 		byModel = s.byKeyModel[key]
 		bySrc = s.byKeySrc[key]
 	}
-	for _, a := range byModel {
-		total.Reqs += a.Reqs
-		total.OK += a.OK
-		total.Err += a.Err
-		total.Tokens += a.Tokens
-		total.Prompt += a.Prompt
-		total.Compl += a.Compl
-		total.LatSum += a.LatSum
-		if a.LatMax > total.LatMax {
-			total.LatMax = a.LatMax
-		}
+	// The total is the sum of every recorded request, not the model rows.
+	// Routing failures are valid requests but may have no resolved model; deriving
+	// total from byModel silently dropped those 502/503 records. Use byKey, which
+	// is populated for every request (including an empty key), and keep the same
+	// scope as the selected key filter.
+	for _, a := range byKey {
+		addStat(&total, a)
 	}
 	bs := make([]agrRow, 0, len(s.byStatus))
 	for code, st := range s.byStatus {

internal/gateway/stats_test.go

@@ -560,3 +560,17 @@ func TestAuditRotationThresholds(t *testing.T) {
 		t.Fatalf("total audit budget = %d, want 256 MiB", total)
 	}
 }
+
+func TestSnapshotTotalIncludesRequestsWithoutModel(t *testing.T) {
+	s := NewStats(100)
+	s.Record(Req{Key: "k", Status: 200, OK: true})
+	s.Record(Req{Key: "k", Model: "m", Status: 200, OK: true, Prompt: 3, Compl: 2})
+	snap := s.Snapshot(0, "")
+	total, ok := snap["total"].(Stat)
+	if !ok {
+		t.Fatalf("total missing: %#v", snap["total"])
+	}
+	if total.Reqs != 2 || total.OK != 2 || total.Tokens != 5 {
+		t.Fatalf("total must include model-less requests: %#v", total)
+	}
+}

internal/lua/adapter_opencodezen_live_test.go

@@ -0,0 +1,213 @@
+package lua
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+)
+
+// 真上游 e2e：用适配器产出的头 + body 直打 opencode /inference/v1。
+// 需要真实凭据（从生产配置解密），故用 LLMSPROXY_LIVE_ZEN=1 显式开启。
+func TestOpencodeZenLiveE2E(t *testing.T) {
+	if os.Getenv("LLMSPROXY_LIVE_ZEN") != "1" {
+		t.Skip("设 LLMSPROXY_LIVE_ZEN=1 开启真上游 e2e")
+	}
+	src, err := bundledAdapters.ReadFile("adapters/opencodezen.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	if err := vm.LoadAdapterSource("opencodezen", string(src)); err != nil {
+		t.Fatal(err)
+	}
+
+	// 取生产凭据（解密）
+	out, err := exec.Command("/usr/local/bin/llmsproxy", "-show-secrets",
+		"-config", "/etc/llmsproxy/config.yaml").Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	apiKey := ""
+	for _, l := range strings.Split(string(out), "\n") {
+		if strings.HasPrefix(l, "source localzen") {
+			if i := strings.Index(l, "api_key="); i >= 0 {
+				apiKey = strings.TrimSpace(l[i+len("api_key="):])
+			}
+		}
+	}
+	if apiKey == "" {
+		t.Fatal("未取到 localzen 凭据")
+	}
+
+	cases := []struct {
+		name string
+		body string
+		want string
+	}{
+		{"纯对话（无 tools，靠适配器兜底注入）",
+			`{"model":"deepseek-v4.1-flash-free","stream":true,"max_tokens":60,
+			  "messages":[{"role":"user","content":"reply with exactly: ADAPTER-OK"}]}`, "ADAPTER-OK"},
+		{"带自定义 system",
+			`{"model":"deepseek-v4.1-flash-free","stream":true,"max_tokens":60,
+			  "messages":[{"role":"system","content":"You are terse."},{"role":"user","content":"reply with exactly: SYS-OK"}]}`, "SYS-OK"},
+		{"多轮",
+			`{"model":"deepseek-v4.1-flash-free","stream":true,"max_tokens":60,
+			  "messages":[{"role":"user","content":"a"},{"role":"assistant","content":"b"},{"role":"user","content":"reply with exactly: MULTI-OK"}]}`, "MULTI-OK"},
+		{"算术（验证真推理）",
+			`{"model":"deepseek-v4.1-flash-free","stream":true,"max_tokens":60,
+			  "messages":[{"role":"user","content":"What is 17*23? Reply with just the number."}]}`, "391"},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			body, err := vm.Transform("opencodezen", "transform_request", tc.body)
+			if err != nil {
+				t.Fatal(err)
+			}
+			h, err := vm.BuildHeaders("opencodezen", map[string]interface{}{
+				"timestamp": time.Now().Unix(), "body": body,
+			})
+			if err != nil {
+				t.Fatal(err)
+			}
+			req, _ := http.NewRequest("POST",
+				"https://opencode.ai/inference/v1/chat/completions", bytes.NewReader([]byte(body)))
+			for k, v := range h {
+				req.Header.Set(k, v)
+			}
+			req.Header.Set("Content-Type", "application/json")
+			req.Header.Set("Authorization", "Bearer "+apiKey)
+			cl := &http.Client{Timeout: 90 * time.Second}
+			resp, err := cl.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			raw, _ := io.ReadAll(resp.Body)
+			resp.Body.Close()
+			if resp.StatusCode != 200 {
+				t.Fatalf("HTTP %d: %s", resp.StatusCode, string(raw)[:min(300, len(raw))])
+			}
+			// 上游现在返回 SSE（适配器强制 stream=true）；判据需自己拼 delta.content。
+			got := ""
+			for _, line := range strings.Split(string(raw), "\n") {
+				line = strings.TrimSpace(line)
+				if !strings.HasPrefix(line, "data: ") {
+					continue
+				}
+				p := strings.TrimPrefix(line, "data: ")
+				if p == "[DONE]" {
+					continue
+				}
+				var d struct {
+					Choices []struct {
+						Delta struct{ Content string } `json:"delta"`
+					} `json:"choices"`
+				}
+				if json.Unmarshal([]byte(p), &d) != nil || len(d.Choices) == 0 {
+					continue
+				}
+				got += d.Choices[0].Delta.Content
+			}
+			if got == "" {
+				t.Fatalf("未从 SSE 解出内容；原始=%s", string(raw)[:min(300, len(raw))])
+			}
+			if !strings.Contains(got, tc.want) {
+				t.Fatalf("回复 %q 不含 %q", got, tc.want)
+			}
+			t.Logf("✓ %s → %q", tc.name, strings.TrimSpace(got))
+		})
+	}
+	fmt.Println("真上游 e2e 全部通过")
+}
+
+// 经适配器完整转换链：上游 SSE → transform_stream_chunk → 统一格式。
+// 上一条判据直接读原始 SSE，只证明"上游放行"；这条证明"适配器能解析"。
+func TestOpencodeZenLiveStreamThroughAdapter(t *testing.T) {
+	if os.Getenv("LLMSPROXY_LIVE_ZEN") != "1" {
+		t.Skip("设 LLMSPROXY_LIVE_ZEN=1 开启")
+	}
+	src, err := bundledAdapters.ReadFile("adapters/opencodezen.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	if err := vm.LoadAdapterSource("opencodezen", string(src)); err != nil {
+		t.Fatal(err)
+	}
+	out, _ := exec.Command("/usr/local/bin/llmsproxy", "-show-secrets",
+		"-config", "/etc/llmsproxy/config.yaml").Output()
+	apiKey := ""
+	for _, l := range strings.Split(string(out), "\n") {
+		if strings.HasPrefix(l, "source localzen") {
+			if i := strings.Index(l, "api_key="); i >= 0 {
+				apiKey = strings.TrimSpace(l[i+len("api_key="):])
+			}
+		}
+	}
+
+	body, _ := vm.Transform("opencodezen", "transform_request",
+		`{"model":"deepseek-v4.1-flash-free","stream":true,"max_tokens":60,
+		  "messages":[{"role":"user","content":"reply with exactly: CHAIN-OK"}]}`)
+	h, _ := vm.BuildHeaders("opencodezen", map[string]interface{}{
+		"timestamp": time.Now().Unix(), "body": body})
+
+	req, _ := http.NewRequest("POST",
+		"https://opencode.ai/inference/v1/chat/completions", bytes.NewReader([]byte(body)))
+	for k, v := range h {
+		req.Header.Set(k, v)
+	}
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Bearer "+apiKey)
+	resp, err := (&http.Client{Timeout: 90 * time.Second}).Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	raw, _ := io.ReadAll(resp.Body)
+	resp.Body.Close()
+	if resp.StatusCode != 200 {
+		t.Fatalf("HTTP %d: %s", resp.StatusCode, string(raw)[:min(300, len(raw))])
+	}
+
+	// 逐行喂给适配器的流解析器，累积统一格式的 content
+	joined := ""
+	n := 0
+	for _, line := range strings.Split(string(raw), "\n") {
+		line = strings.TrimSpace(line)
+		if !strings.HasPrefix(line, "data: ") || line == "data: [DONE]" {
+			continue
+		}
+		// 内核喂给适配器的是**已剥掉 data: 前缀**的载荷（见 provider.go：
+		// strings.TrimPrefix(line, "data:")），判据必须对齐这个契约。
+		payload := strings.TrimSpace(strings.TrimPrefix(line, "data:"))
+		unified, err := vm.Transform("opencodezen", "transform_stream_chunk", payload)
+		if err != nil {
+			t.Fatalf("transform_stream_chunk: %v (%s)", err, line[:min(120, len(line))])
+		}
+		if unified == "" || unified == "{}" {
+			continue
+		}
+		var u struct {
+			Content string `json:"content"`
+		}
+		if json.Unmarshal([]byte(unified), &u) == nil {
+			joined += u.Content
+			n++
+		}
+	}
+	if n == 0 {
+		t.Fatal("适配器未解出任何 chunk（流解析链断了）")
+	}
+	if !strings.Contains(joined, "CHAIN-OK") {
+		t.Fatalf("经适配器链的内容 %q 不含 CHAIN-OK（chunk 数=%d）", joined, n)
+	}
+	t.Logf("✓ 完整链：%d 个 chunk，内容=%q", n, strings.TrimSpace(joined))
+}

internal/lua/adapter_opencodezen_test.go

@@ -0,0 +1,156 @@
+package lua
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// E2E：加载改后的适配器，验证 (1) 头含两个 session 头且值相同；(2) id 段服从公式；
+// (3) 无 tools 的请求被注入 read 桩且 properties 非空。
+func TestOpencodeZenAdapterE2E(t *testing.T) {
+	src, err := bundledAdapters.ReadFile("adapters/opencodezen.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	if err := vm.LoadAdapterSource("opencodezen", string(src)); err != nil {
+		t.Fatalf("加载失败: %v", err)
+	}
+
+	t.Run("头：两个 session 头同值", func(t *testing.T) {
+		h, err := vm.BuildHeaders("opencodezen", map[string]interface{}{"timestamp": int64(1792065049)})
+		if err != nil {
+			t.Fatal(err)
+		}
+		s1, s2 := h["x-opencode-session"], h["x-opencode-session-id"]
+		if s1 == "" || s2 == "" {
+			t.Fatalf("两个 session 头都必须存在: %#v", h)
+		}
+		if s1 != s2 {
+			t.Fatalf("必须同值: %q vs %q", s1, s2)
+		}
+		if !strings.HasPrefix(s1, "ses_") || len(s1) != 4+12+14 {
+			t.Fatalf("session 形状应为 ses_+12hex+14base62: %q (len=%d)", s1, len(s1))
+		}
+		if len(h["x-opencode-request"]) != 4+12+14 || !strings.HasPrefix(h["x-opencode-request"], "msg_") {
+			t.Fatalf("request 形状: %q", h["x-opencode-request"])
+		}
+		if !strings.Contains(h["User-Agent"], "opencode/1.19.0") {
+			t.Fatalf("UA 应为 1.19.0: %q", h["User-Agent"])
+		}
+		t.Logf("session=%s request=%s", s1, h["x-opencode-request"])
+		// 公式校验：段 = (K - bucket_ms*4096) & MASK，其中 bucket 已对齐到整分钟
+		// （适配器按分钟桶取会话号，以保留上游前缀缓存命中）。
+		// ⚠️ 判据必须算**同一个桶**，不能拿原始 ms 去比 —— 那会把正确的实现判成错。
+		seg := s1[4:16]
+		ms := int64(1792065049) * 1000
+		bucket := ms - (ms % 60000)
+		want := (int64(0x1afffffffffffe) - bucket*4096) & 0xFFFFFFFFFFFF
+		if got := seg; got != fmtHex12(want) {
+			t.Fatalf("session 段公式不符: got=%s want=%s (bucket=%d)", got, fmtHex12(want), bucket)
+		}
+	})
+
+	t.Run("tools 兜底：无 tools 时注入 read", func(t *testing.T) {
+		out, err := vm.Transform("opencodezen", "transform_request",
+			`{"model":"m","stream":true,"messages":[{"role":"user","content":"hi"}]}`)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var req map[string]interface{}
+		if err := json.Unmarshal([]byte(out), &req); err != nil {
+			t.Fatal(err)
+		}
+		ts, _ := req["tools"].([]interface{})
+		if len(ts) == 0 {
+			t.Fatalf("必须注入 tools: %s", out)
+		}
+		found := false
+		for _, x := range ts {
+			fn := x.(map[string]interface{})["function"].(map[string]interface{})
+			if fn["name"] == "read" {
+				p, _ := fn["parameters"].(map[string]interface{})
+				props, _ := p["properties"].(map[string]interface{})
+				if len(props) == 0 {
+					t.Fatalf("read 的 properties 必须非空（门禁要求）: %s", out)
+				}
+				found = true
+			}
+		}
+		if !found {
+			t.Fatalf("必须含名为 read 的工具: %s", out)
+		}
+	})
+
+	t.Run("tools 保留：用户自带 read 不被覆盖", func(t *testing.T) {
+		in := `{"model":"m","stream":true,"messages":[{"role":"user","content":"hi"}],
+		 "tools":[{"type":"function","function":{"name":"read","description":"MY","parameters":{"type":"object","properties":{"a":{"type":"string"}}}}}]}`
+		out, err := vm.Transform("opencodezen", "transform_request", in)
+		if err != nil {
+			t.Fatal(err)
+		}
+		var req map[string]interface{}
+		json.Unmarshal([]byte(out), &req)
+		ts, _ := req["tools"].([]interface{})
+		if len(ts) != 1 {
+			t.Fatalf("不应追加（已有 read）: %s", out)
+		}
+		fn := ts[0].(map[string]interface{})["function"].(map[string]interface{})
+		if fn["description"] != "MY" {
+			t.Fatalf("用户定义被覆盖: %s", out)
+		}
+	})
+}
+
+func fmtHex12(v int64) string {
+	const hex = "0123456789abcdef"
+	out := make([]byte, 12)
+	for i := 11; i >= 0; i-- {
+		out[i] = hex[v&0xF]
+		v >>= 4
+	}
+	return string(out)
+}
+
+// ★ 免费层只能流式（适配器强制 stream=true），而内核在客户端要非流式时
+// 会调 transform_response（期望 JSON）⇒ 适配器必须能把 SSE 聚合回非流式对象。
+// 这条判据钉住那个聚合：真实 SSE 片段 → 完整 chat.completion。
+func TestOpencodeZenAggregatesSSEForNonStreamClient(t *testing.T) {
+	src, err := bundledAdapters.ReadFile("adapters/opencodezen.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	if err := vm.LoadAdapterSource("opencodezen", string(src)); err != nil {
+		t.Fatal(err)
+	}
+	// 模仿上游真实 SSE（含 reasoning_content 与 usage 末帧）
+	sse := `data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"role":"assistant","content":"","reasoning_content":"think "}}]}
+data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"content":"HELLO"}}]}
+data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"content":" WORLD"},"finish_reason":"stop"}]}
+data: {"id":"x1","object":"chat.completion.chunk","created":1,"model":"m","choices":[],"usage":{"prompt_tokens":7,"completion_tokens":2,"total_tokens":9}}
+data: [DONE]
+`
+	out, err := vm.Transform("opencodezen", "transform_response", sse)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var u map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &u); err != nil {
+		t.Fatalf("聚合产物不是 JSON: %v (%s)", err, out)
+	}
+	if u["content"] != "HELLO WORLD" {
+		t.Fatalf("content 应为 'HELLO WORLD'，实得 %v", u["content"])
+	}
+	tu, _ := u["token_usage"].(map[string]interface{})
+	if tu == nil || tu["prompt"] != float64(7) {
+		t.Fatalf("usage 应透传: %v", u["token_usage"])
+	}
+	if u["finish_reason"] != "stop" {
+		t.Fatalf("finish_reason 应为 stop: %v", u["finish_reason"])
+	}
+	t.Logf("聚合 OK: content=%v usage=%v finish=%v", u["content"], tu, u["finish_reason"])
+}

internal/lua/adapters/opencodezen.lua

@@ -0,0 +1,484 @@
+local adapter = {}
+
+adapter.name = "opencodezen"
+adapter.version = "1.0.0"
+adapter.endpoint = "/chat/completions"
+
+-- OpenCode Zen（按量付费端点，https://opencode.ai/zen/v1）
+--
+-- 与 OpenCode Go（opencodego.lua，https://opencode.ai/zen/go/v1）是两个不同的
+-- 服务，行为要求并不相同，因此各有专用适配器：
+--
+--   * 本适配器（Zen）服务免费池 / 按量付费池。免费模型必须带 opencode 客户端
+--     指纹（UA + x-opencode-*），否则上游拒绝："free tier can only be used in
+--     OpenCode"。Zen 的免费池以非 thinking 模型为主，历史上回传
+--     reasoning_content 会引出上游报错，故这里剥掉（Go 侧相反，见 opencodego.lua）。
+--   * Go 订阅读者请看 opencodego.lua：那边**必须**回传 reasoning_content，
+--     否则 thinking 模式直接 400。
+--
+-- 缺 x-opencode-client/session/request/project 身份头会被判为匿名客户端，
+-- 部分模型在带 tools 时上游直接失败（流式返回单 chunk
+-- "finish_reason":"network_error" 空 content，非流式 503
+-- "Endpoint is unavailable"，表现为"空回复"）。
+-- ============================================================================
+-- ★ opencode Zen 免费层门禁（2026-10-15 实测解出，逐条对齐官方 CLI）
+--
+-- 上游对免费池有**三个**必须同时满足的条件，缺任一则 403 FreeTierError
+-- （"free tier can only be used from within OpenCode"），与 UA / TLS 指纹 / 凭据来源
+-- 均无关：
+--
+--   1. 端点必须是 /inference/v1/chat/completions（不是 /zen/v1）
+--      —— 由源的 base_url 决定，不在本适配器内。
+--   2. 必须同时发 x-opencode-session **与** x-opencode-session-id（值相同）。
+--      两个 id 的 12 位 hex 段由**确定公式**给出（见下），不是随机数；
+--      时间容差实测 ≥ 60 秒，故 os.time() 的秒精度足够。
+--   3. 请求的 tools 里必须有一个名为 read 的工具，且其 parameters.properties
+--      **非空**。这是唯一的 tools 要求：实测抽掉官方 11 个工具中的任意一个均为
+--      200，**只有抽掉 read 变 403**；且 properties 里放任意属性名即可，
+--      描述文字 / $schema / required 都不需要（properties 为空对象则 403）。
+--      ⇒ 无 tools 的纯对话请求会被拒，故 transform_request 需兜底注入桩工具。
+--   4. **stream 必须为 true**：实测同为合法请求，stream=false 恒 403、stream=true 恒 200
+--      （包括 max_tokens 20/60/200/1000/32000 均 200）。
+--      ⇒ 非流式请求会被拒，故 transform_request 强制 stream=true。
+--
+-- 明确**不影响**通过的（均实测）：system 内容（含无 system）、消息条数
+-- （2/3/4/6 条均 200）、凭据（Bearer public 与普通 API key 均可）、
+-- x-opencode-project / x-opencode-client / UA 里的 opencode/ 前缀。
+--
+-- ⚠️ 参考实现 dsh-our-free-model 的门禁桩（bash + read，但无真实 properties）
+-- 恰好卡在第 3 条上 —— 即它「伪装需跟进上游更新」的真实原因。
+adapter.headers = {
+    ["User-Agent"] = "opencode/1.19.0 ai-sdk/provider-utils/4.0.23 runtime/bun/1.3.14",
+}
+
+-- rand_id：按官方的 48-bit 公式生成 12 位 hex 段 + 14 位 base62 随机段。
+--
+-- 公式逆自官方 CLI 本地库（~/.local/share/opencode/opencode.db 的 session 表，
+-- 用 11/12 条真实 id 逐条比对完全一致）：
+--
+--   MASK = 2^48 - 1
+--   K    = 0x1afffffffffffe          （注意不是 27<<48，两者差 2）
+--   session 段 = (K - now_ms * 4096) & MASK     ← **倒计时式**：Δseg/Δms ≡ -4096
+--   request 段 = (now_ms * 16) & MASK
+--
+-- 为什么是「倒计时」而不是时间戳：0x1afffffffffffe 减去 ms*2^12，所以 seg 随
+-- 时间**递减**。用 f"{ms:012x}" 之类的正向写法必然不对（我为此错过一轮）。
+--
+-- ⚠️ 精度：now_ms*4096 ≈ 7.3e15 < 2^53 ≈ 9.0e15，在 double 安全整数范围内，
+-- 故 LuaJIT 的默认数字类型（double）直接算即可，无需大整数库。
+local B62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+local MASK48 = 281474976710655        -- 2^48 - 1
+local ID_K = 0x1afffffffffffe
+
+local function rand_tail(n)
+    local out = {}
+    for i = 1, n do
+        local v = 0
+        if math and math.random then
+            v = math.random(1, 62)
+        else
+            -- 无 math 时用时间做退化熵源：只要唯一，不要求密码学强度。
+            v = (os.time() * 7 + i * 13) % 62 + 1
+        end
+        out[i] = B62:sub(v, v)
+    end
+    return table.concat(out)
+end
+
+-- now_ms：毫秒。沙箱只有 os.time()（秒）与 os.clock()（CPU 时间，无用），
+-- 而上游时间容差实测 ≥ 60 秒，故秒精度足够；毫秒位补 0。
+-- meta.timestamp 由内核给出（同为秒），优先用它以便同一请求内自洽。
+local function now_ms(meta)
+    local t = tonumber(meta and meta.timestamp) or (os.time and os.time()) or 0
+    return t * 1000
+end
+
+local function rand_id(prefix, ms, kind)
+    local seg
+    if kind == "session" then
+        seg = (ID_K - ms * 4096) % (MASK48 + 1)
+    else
+        seg = (ms * 16) % (MASK48 + 1)
+    end
+    -- %012x：12 位十六进制，不足补零
+    return prefix .. string.format("%012x", seg) .. rand_tail(14)
+end
+
+-- session_bucket_ms 决定上游会话号的**稳定周期**（按整分钟对齐）。
+--
+-- 为什么需要稳定：上游前缀缓存是会话级的（实测：同一段 6032 token 提示词，
+-- 固定会号第 2 次命中 5888；每请求换会号则恒为 0 命中）。而免费层门禁要求
+-- x-opencode-session 的 12 位 hex 段服从「倒计时」公式（见 rand_id 注释），
+-- 所以不能真的「随便挑一个固定值」，只能选一个**时间桶**。
+--
+-- 取整分钟（而非秒）：同一分钟内的所有请求共享一个会话号 ⇒ 既保留缓存命中，
+-- 又不超出上游的时间容差。实测容差 ≥ 1 小时（-3600s 仍 200），
+-- 所以一分钟桶有很大余量，即便上游收紧到几分钟也仍然安全。
+local function session_bucket_ms(meta)
+    local ms = now_ms(meta)
+    return ms - (ms % 60000)
+end
+
+function adapter.build_headers(meta)
+    local ms = now_ms(meta)
+    local bucket = session_bucket_ms(meta)
+    -- 免费层要求两个头都在且值相同（对齐官方 CLI；缺任一个则 403）。
+    local sid = rand_id("ses_", bucket, "session")
+    return {
+        ["User-Agent"] = adapter.headers["User-Agent"],
+        ["x-opencode-client"] = "cli",
+        -- project 固定：同网关实例共享一个工作区身份（非门禁必需，但官方也发）
+        ["x-opencode-project"] = "global",
+        ["x-opencode-session"] = sid,
+        -- ★ 两个都要：上游对免费池同时校验 x-opencode-session 与这个头。
+        ["x-opencode-session-id"] = sid,
+        -- request id 每请求唯一（不参与缓存键），用当前时间而非桶，避免同桶内重复
+        ["x-opencode-request"] = rand_id("msg_", ms, "request"),
+    }
+end
+
+-- ============================================================================
+-- ★ 免费层 tools 兜底：上游要求 tools 里必须有一个名为 read、且
+-- parameters.properties 非空的工具（实测唯一要求；抽掉它即 403）。
+-- 纯对话请求（客户端没传 tools）会被拒，故这里注入一个桩工具。
+--
+-- 只补缺，不改用户已有的 tools：用户自带 read 时原样透传（官方 CLI 就是这么发的），
+-- 用户带的其它工具保留不动。
+local FREE_GATE_TOOL = "read"
+local function ensure_free_gate_tool(req)
+    local tools = req.tools
+    if type(tools) ~= "table" then tools = {} req.tools = tools end
+    for _, t in ipairs(tools) do
+        if type(t) == "table" then
+            local fn = t["function"]
+            -- 注意：function 是 Lua 关键字，必须用 req["function"] 形式取下标。
+            if type(fn) == "table" and fn.name == FREE_GATE_TOOL then
+                local p = fn.parameters
+                -- 已有 read 但 properties 为空 ⇒ 补上；否则原样保留用户定义。
+                if type(p) == "table" and type(p.properties) == "table"
+                    and next(p.properties) ~= nil then
+                    return
+                end
+                fn.parameters = { type = "object",
+                    properties = { filePath = { type = "string", description = "Path to read" } } }
+                return
+            end
+        end
+    end
+    tools[#tools + 1] = {
+        type = "function",
+        ["function"] = {
+            name = FREE_GATE_TOOL,
+            description = "Read a file from the local filesystem.",
+            parameters = { type = "object",
+                properties = { filePath = { type = "string", description = "Path to read" } },
+                required = { "filePath" } },
+        },
+    }
+end
+
+-- OpenAI /chat/completions format (pass-through, strip provider-specific fields)
+-- zen 上游 schema 只接受 text content part（无视觉/音频能力）：多模态 part
+-- （image_url / input_audio / file 等）一律剥离。剥离后 content 变空的消息
+-- 若不再携带 tool_calls / tool_call_id 才整条丢弃（避免上游
+-- "unknown variant `image_url`, expected `text`"）；带工具调用的必须保留，
+-- 否则会把紧随其后的 tool 结果变成孤儿，模型会反复重发同一个调用。
+-- zen 上游角色白名单只有 system / user / assistant / tool / latest_reminder：
+-- OpenAI 的 developer（及 function 等）不在其中，直接透传会触发上游
+-- "unknown variant `developer`, expected one of ..." 错误；统一归一化为 system。
+local ROLE_WHITELIST = {
+    system = true,
+    user = true,
+    assistant = true,
+    tool = true,
+    latest_reminder = true,
+}
+
+function adapter.transform_request(raw_body)
+    local ok, req = pcall(json.decode, raw_body)
+    if not ok then return raw_body end
+    -- ★ 免费层 gate：tools 里必须有 read（且 parameters.properties 非空）。
+    -- 放在最前面：它决定本请求会不会被 403，与后面的字段清理无关。
+    -- 对所有模型都注入：免费池与付费池共用同一层形状检查，多一个桩工具无害
+    -- （官方 CLI 本来也带全套工具），但缺了它会让免费模型整体失效。
+    ensure_free_gate_tool(req)
+    -- ★ 免费层只接受流式：实测 stream=false 恒 403（同样 body 改 true 即 200）。
+    -- 转成流式由上游以 SSE 回应，内核本就会聚合/透传流式响应，故对客户端透明。
+    req.stream = true
+    req.disable_thinking = nil
+    req.extra_body = nil
+    -- stream_options is only valid alongside stream:true; sending it on a
+    -- non-streaming request is rejected by strict upstreams.
+    if req.stream then
+        if type(req.stream_options) ~= "table" then req.stream_options = {} end
+        req.stream_options.include_usage = true
+    end
+    if req.messages then
+        local kept = {}
+        for _, msg in ipairs(req.messages) do
+            if type(msg.role) == "string" and not ROLE_WHITELIST[msg.role] then
+                msg.role = "system"
+            end
+            -- Zen 免费池不接受回传 reasoning_content（Go 侧相反）
+            msg.reasoning_content = nil
+            local drop = false
+            if type(msg.content) == "table" then
+                local parts = {}
+                for _, part in ipairs(msg.content) do
+                    if type(part) == "table" and part.type ~= nil and part.type ~= "text" then
+                        -- multimodal part not supported by zen
+                    else
+                        table.insert(parts, part)
+                    end
+                end
+                if #parts == 0 then
+                    -- Content collapsed to nothing after stripping unsupported
+                    -- parts. A message that still carries a tool call must
+                    -- NEVER be dropped: the very next message is its tool
+                    -- result, and dropping the call orphans that result. The
+                    -- model then sees a result for a call it never made and
+                    -- re-issues the same tool call on every turn (observed as
+                    -- an infinite "repeated tool call" loop).
+                    if (type(msg.tool_calls) == "table" and #msg.tool_calls > 0)
+                        or msg.tool_call_id ~= nil then
+                        msg.content = ""
+                    else
+                        drop = true
+                    end
+                else
+                    msg.content = parts
+                end
+            end
+            if not drop then
+                table.insert(kept, msg)
+            end
+        end
+        req.messages = kept
+    end
+    return json.encode(req)
+end
+
+-- ★ aggregate_sse：把 SSE 流（openai chat.completion.chunk 形状）聚合成一个非流式
+-- 响应对象，供 transform_response 在「客户端要非流式、上游却回流式」时使用。
+-- 返回 JSON 字符串；无法聚合（无任何 chunk）时返回 nil。
+--
+-- 只处理 content / reasoning_content / finish_reason / usage 四类增量：
+-- 它们覆盖了内核需要从响应里取的全部字段（正文、结束原因、token 计数）。
+local function aggregate_sse(raw)
+    local content, reasoning, finish = {}, {}, ""
+    local usage, id, model, created = nil, nil, nil, nil
+    local seen = false
+    for line in (raw .. "\n"):gmatch("([^\n]*)\n") do
+        local s = line:gsub("^%s+", ""):gsub("%s+$", "")
+        if s:sub(1, 5) == "data:" then
+            local payload = s:sub(6):gsub("^%s+", "")
+            if payload ~= "" and payload ~= "[DONE]" then
+                local ok, d = pcall(json.decode, payload)
+                if ok and type(d) == "table" then
+                    seen = true
+                    id = id or d.id
+                    model = model or d.model
+                    created = created or d.created
+                    if type(d.usage) == "table" then usage = d.usage end
+                    local ch = d.choices and d.choices[1]
+                    if type(ch) == "table" then
+                        if ch.finish_reason and ch.finish_reason ~= "" then
+                            finish = ch.finish_reason
+                        end
+                        local dl = ch.delta
+                        if type(dl) == "table" then
+                            if type(dl.content) == "string" then content[#content + 1] = dl.content end
+                            if type(dl.reasoning_content) == "string" then
+                                reasoning[#reasoning + 1] = dl.reasoning_content
+                            end
+                        end
+                    end
+                end
+            end
+        end
+    end
+    if not seen then return nil end
+    local msg = { role = "assistant", content = table.concat(content) }
+    local rc = table.concat(reasoning)
+    if rc ~= "" then msg.reasoning_content = rc end
+    local out = {
+        id = id or "", object = "chat.completion", created = created or 0, model = model or "",
+        choices = { { index = 0, message = msg, finish_reason = finish ~= "" and finish or "stop" } },
+    }
+    if usage then out.usage = usage end
+    local ok2, enc = pcall(json.encode, out)
+    if not ok2 then return nil end
+    return enc
+end
+
+function adapter.transform_response(raw_body)
+    -- ★ 免费层只接受 stream=true（见文件头门禁第 4 条），所以本适配器把每个请求
+    -- 都改成了流式 —— 但内核是按**客户端意图**选路径的：客户端发非流式时，
+    -- 内核走 Provider.Chat 并调本函数（期望 JSON），而上游回的是 SSE。
+    -- 若在这里直接 json.decode 就会得到 "invalid character 'd'" 错误。
+    --
+    -- 因此本函数必须先识别 SSE 并自行聚合，再走原来的 JSON 路径。
+    -- 这样保持内核对上游协议无感（内核不知道也不该知道上游选了流式）。
+    if type(raw_body) == "string" and (raw_body:sub(1, 6) == "data: " or raw_body:find("\ndata: ", 1, true)) then
+        local aggregated = aggregate_sse(raw_body)
+        if aggregated ~= nil then
+            local ok2, resp2 = pcall(json.decode, aggregated)
+            if ok2 and type(resp2) == "table" then raw_body = aggregated end
+        end
+    end
+    local ok, resp = pcall(json.decode, raw_body)
+    if not ok or resp == nil then return raw_body end
+
+    local unified = {
+        content = "",
+        finish_reason = "",
+        token_usage = { prompt = 0, completion = 0, total = 0 }
+    }
+
+    if type(resp.usage) == "table" then
+        unified.token_usage.prompt = resp.usage.prompt_tokens or 0
+        unified.token_usage.completion = resp.usage.completion_tokens or 0
+        unified.token_usage.total = resp.usage.total_tokens or 0
+        local hit = 0
+        if type(resp.usage.prompt_tokens_details) == "table" and resp.usage.prompt_tokens_details.cached_tokens ~= nil then
+            hit = resp.usage.prompt_tokens_details.cached_tokens
+            unified.token_usage.prompt_tokens_details = { cached_tokens = hit }
+        end
+        if (resp.usage.prompt_cache_hit_tokens or 0) > 0 then
+            unified.token_usage.prompt_cache_hit_tokens = resp.usage.prompt_cache_hit_tokens
+            unified.token_usage.prompt_cache_miss_tokens = resp.usage.prompt_cache_miss_tokens or 0
+            if hit == 0 then
+                unified.token_usage.prompt_tokens_details = { cached_tokens = resp.usage.prompt_cache_hit_tokens }
+            end
+        end
+        -- 上游报告输出里有多少是思考 token。不给客户端的话，无法判断
+        -- completion_tokens 里多少是「可见回答」、多少是「思考」（都按输出计费）。
+        local ctd = resp.usage.completion_tokens_details
+        if type(ctd) == "table" and ctd.reasoning_tokens ~= nil then
+            unified.token_usage.completion_tokens_details = { reasoning_tokens = ctd.reasoning_tokens }
+        end
+    end
+
+    -- 本次调用的费用，上游放在**顶层**且是**字符串**（如 "0"、"0.0012"）。
+    -- Go 订阅是包月制，恒为 "0"；只有 Zen 按量付费模型才有信息量。
+    -- 原样透传：网关不解析、不换算、不汇总 —— 它只是上游事实的搬运者。
+    if resp.cost ~= nil then
+        unified.cost = tostring(resp.cost)
+    end
+
+    if type(resp.choices) == "table" and #resp.choices > 0 then
+        local ch = resp.choices[1]
+        if type(ch.message) == "table" then
+            unified.content = ch.message.content or ""
+            local reasoning = ch.message.reasoning_content or ch.message.reasoning
+            if reasoning then
+                unified.reasoning_content = reasoning
+            end
+            if type(ch.message.tool_calls) == "table" then
+                local tcs = {}
+                for _, tc in ipairs(ch.message.tool_calls) do
+                    local args_ok, args = pcall(json.decode, tc["function"].arguments)
+                    if not args_ok then args = {} end
+                    table.insert(tcs, {
+                        id = tc.id,
+                        type = tc.type or "function",
+                        name = tc["function"].name,
+                        arguments = args
+                    })
+                end
+                unified.tool_calls = tcs
+            end
+        end
+        unified.finish_reason = ch.finish_reason or ""
+    end
+
+    return json.encode(unified)
+end
+
+function adapter.transform_stream_chunk(raw_chunk)
+    local ok, chunk = pcall(json.decode, raw_chunk)
+    if not ok then return "" end
+
+    -- OpenAI-style streams may attach usage to a chunk with empty choices
+    -- (the final usage chunk). Preserve it; the gateway emits it as the
+    -- terminal usage chunk. Note: keys must match Go's TokenUsage json tags
+    -- (prompt/completion/total); the gateway re-emits standard *_tokens.
+    local uses = nil
+    if type(chunk.usage) == "table" then
+        uses = {
+            prompt = chunk.usage.prompt_tokens or chunk.usage.prompt or 0,
+            completion = chunk.usage.completion_tokens or chunk.usage.completion or 0,
+            total = chunk.usage.total_tokens or chunk.usage.total or 0,
+        }
+        -- 独立字段与 prompt_tokens_details **并存**透传，不要写成 elseif：
+        -- 上游命中缓存时两者都发，非流式路径也是两个都带。写成 elseif 会让
+        -- 流式丢掉 prompt_cache_hit_tokens/miss，与同一源的**非流式**产出不一致
+        -- （dsh 优先读 details，但只认独立字段的老客户端会看不到缓存）。
+        if type(chunk.usage.prompt_tokens_details) == "table" and chunk.usage.prompt_tokens_details.cached_tokens ~= nil then
+            uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_tokens_details.cached_tokens }
+        end
+        if (chunk.usage.prompt_cache_hit_tokens or 0) > 0 then
+            uses.prompt_cache_hit_tokens = chunk.usage.prompt_cache_hit_tokens
+            uses.prompt_cache_miss_tokens = chunk.usage.prompt_cache_miss_tokens or 0
+            if uses.prompt_tokens_details == nil then
+                uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_cache_hit_tokens }
+            end
+        end
+        local ctd = chunk.usage.completion_tokens_details
+        if type(ctd) == "table" and ctd.reasoning_tokens ~= nil then
+            uses.completion_tokens_details = { reasoning_tokens = ctd.reasoning_tokens }
+        end
+    end
+
+    if not chunk.choices or #chunk.choices == 0 then
+        -- 空 choices 的帧既不是内容也不是结束信号。上游发两种：
+        --   {"choices":[],"usage":{...}}   —— 终帧用量
+        --   {"choices":[],"cost":"0"}      —— 单独的费用帧
+        -- 两者可能落在同一帧上，必须都转出去；早退只带 usage 会把费用丢干净。
+        local out = { done = false }
+        if uses ~= nil then out.usage = uses end
+        if chunk.cost ~= nil then out.cost = tostring(chunk.cost) end
+        if uses == nil and chunk.cost == nil then return "" end
+        return json.encode(out)
+    end
+    local delta = chunk.choices[1].delta or {}
+    local fr = chunk.choices[1].finish_reason
+
+    local finish = (type(fr) == "string" and fr ~= "") and fr or nil
+
+    local unified = {
+        content = delta.content or "",
+        done = (finish ~= nil)
+    }
+    if finish then
+        unified.finish_reason = finish
+    end
+    if uses ~= nil then
+        unified.usage = uses
+    end
+    -- zen 用 reasoning 字段承载推理文本（OpenAI 惯例是 reasoning_content）
+    local reasoning = delta.reasoning_content or delta.reasoning
+    if reasoning then
+        unified.reasoning_content = reasoning
+    end
+    if delta.tool_calls then
+        -- pass raw streaming fragments through; OpenAI clients accumulate index+id+name+arguments
+        unified.tool_calls = delta.tool_calls
+    end
+    return json.encode(unified)
+end
+
+-- 错误收敛（可选钩子）：zen 错误信封固定为 {error={type,message}}；
+-- 免费池限流 FreeUsageLimitError 单独标注。返回 nil 走通用兜底。
+function adapter.transform_error(status, body)
+    local ok, resp = pcall(json.decode, body)
+    if not ok or type(resp) ~= "table" then return nil end
+    local e = resp.error
+    if type(e) ~= "table" then return nil end
+    if e.type == "FreeUsageLimitError" then
+        return "zen free pool quota exhausted"
+    end
+    return e.message
+end
+
+return adapter

internal/lua/plugin_http_handler.go

@@ -100,6 +100,8 @@ type handlerRequest struct {
 
 // handlerResponse is what a Lua handler returns.
 type handlerResponse struct {
+	// Proxy is a loopback HTTP origin. The gateway owns streaming and upgrades.
+	Proxy   string
 	Status  int
 	Headers map[string]string
 	Body    string
@@ -180,6 +182,9 @@ func parseHandlerResponse(v interface{}) (*handlerResponse, error) {
 			return nil, fmt.Errorf("status must be a number, got %T", s)
 		}
 	}
+	if target, ok := m["proxy"].(string); ok {
+		out.Proxy = target
+	}
 	if b, ok := m["body"].(string); ok {
 		out.Body = b
 	}
@@ -196,9 +201,9 @@ func parseHandlerResponse(v interface{}) (*handlerResponse, error) {
 	// return. A table carrying ONLY a status is not: `{status=204}` is the normal
 	// way to answer with no body, and treating it as an error would make the
 	// correct spelling unusable.
-	if out.Body == "" && out.JSON == nil && out.Headers == nil && len(m) == 0 {
+	if out.Body == "" && out.JSON == nil && out.Headers == nil && out.Proxy == "" && len(m) == 0 {
 		return nil, fmt.Errorf("handler returned an empty table; return " +
-			"{status=…, body=…}, {status=…, json=…}, or {status=…} for no body")
+			"{status=…, body=…}, {status=…, json=…}, {status=…, proxy=…}, or {status=…} for no body")
 	}
 	return out, nil
 }

internal/lua/plugin_runtime.go

@@ -143,6 +143,14 @@ type PluginRuntime struct {
 	ps   *Plugins
 	spec scheduleSpec
 
+	// stopOnce makes Stop idempotent. Stop closes a channel and waits on done;
+	// without this, a second Stop panics ("close of closed channel"). That is
+	// reachable in practice now that BOTH Unload and Close stop schedulers:
+	// unloading a plugin then closing the plugin set would otherwise abort the
+	// process during shutdown — the worst possible moment (a panic here masks
+	// whatever the operator was actually shutting down for).
+	stopOnce sync.Once
+
 	mu sync.Mutex
 	// nextDue is when each task should next fire.
 	nextDue map[string]time.Time
@@ -457,8 +465,10 @@ func (rt *PluginRuntime) Stop() {
 	if rt == nil {
 		return
 	}
-	close(rt.stop)
-	<-rt.done
+	rt.stopOnce.Do(func() {
+		close(rt.stop)
+		<-rt.done
+	})
 }
 
 // callFnOn invokes a plugin function on an already-locked state.

internal/lua/plugin_runtime_close_test.go

@@ -0,0 +1,139 @@
+package lua
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+	"time"
+)
+
+// ★ Close() 必须停掉每个插件的**调度循环**。
+//
+// 真实缺陷（与 on_unload 同一形状的第 3 个实例）：`Runtime.Stop()` 此前
+// **只在单插件 Unload 里调**，Close() 不调 —— 于是「进程关闭/测试结束」
+// 这条路径上，每个插件的 PluginRuntime.loop 永不停止。
+//
+// 实测：全量回归在 internal/lua 出现 **69 个 goroutine 卡在 saver/runtime
+// 循环里**，最终 600s 超时。
+//
+// 判据用的是**进程里真实存在的 goroutine 数**：每 LoadSource 一个插件就
+// 起一个调度循环，Close 必须让它们全部退出 —— 否则 goroutine 只增不减。
+// 这比"任务被调用过"更贴近缺陷本身（缺陷就是循环不停）。
+func TestPluginsCloseStopsSchedulerGoroutines(t *testing.T) {
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	// 24 个带调度表的插件：每个起一个 PluginRuntime.loop
+	const n = 24
+	for i := 0; i < n; i++ {
+		src := `
+local plugin = { name = "s` + string(rune('a'+i)) + `", version = "1.0.0", exports = {} }
+function plugin.noop_task() end
+plugin.schedule = { { fn = "noop_task", every = 3600 } }
+return plugin
+`
+		name := filepath.Join(pluginDir, "s"+string(rune('a'+i))+".lua")
+		if err := os.WriteFile(name, []byte(src), 0644); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	before := runtime.NumGoroutine()
+	ps := NewPlugins(nil, pluginDir)
+	if err := ps.LoadDir(); err != nil {
+		t.Fatalf("LoadDir: %v", err)
+	}
+	loaded := runtime.NumGoroutine()
+	if loaded <= before {
+		t.Fatalf("加载 %d 个带调度的插件后 goroutine 没涨（%d → %d）—— 夹具失效",
+			n, before, loaded)
+	}
+	ps.Close()
+
+	// ★ Close 之后循环必须**全部**退出，即回落到基线附近。
+	//
+	// ⚠️ 这里不能用「比 loaded 小就算过」：那只要**一个** goroutine 退出就成立
+	// （27 → 26 也满足），而 24 个调度循环可以全部还在跑 —— 我第一版就是
+	// 这么写的，被变异测试当场揭穿（去掉 stopSchedulersAll 后仍然绿）。
+	// 判据必须锚定**基线**，容差只留给无关的运行时 goroutine。
+	deadline := time.Now().Add(5 * time.Second)
+	for time.Now().Before(deadline) {
+		if runtime.NumGoroutine() <= before+2 {
+			break
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	after := runtime.NumGoroutine()
+	if after > before+2 {
+		t.Fatalf("Close() 之后仍有调度循环在跑：goroutine 基线 %d、加载后 %d、Close 后 %d（加载了 %d 个插件）—— "+
+			"它们会一直堆积（实测全量回归堆到 69 个卡死并 600s 超时）", before, loaded, after, n)
+	}
+	t.Logf("✓ Close() 停掉了全部调度循环（goroutine 基线 %d → 加载后 %d → Close 后 %d，%d 个插件）",
+		before, loaded, after, n)
+}
+
+// ★ Stop() 必须幂等：Unload 与 Close 都会停调度器，重复调不得 panic。
+//
+// 反例：Stop 里裸 `close(rt.stop)` —— 第二次调用 `panic: close of closed channel`。
+// 关闭路径上的 panic 最糟糕：它掩盖掉操作者本来在做的事（关服务/结束测试）。
+func TestPluginRuntimeStopIsIdempotent(t *testing.T) {
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	src := `
+local plugin = { name = "sched2", version = "1.0.0", exports = {} }
+function plugin.noop_task() end
+plugin.schedule = { { fn = "noop_task", every = 30 } }
+return plugin
+`
+	if err := os.WriteFile(filepath.Join(pluginDir, "sched2.lua"), []byte(src), 0644); err != nil {
+		t.Fatal(err)
+	}
+	ps := NewPlugins(nil, pluginDir)
+	if err := ps.LoadDir(); err != nil {
+		t.Fatalf("LoadDir: %v", err)
+	}
+	defer ps.Close()
+
+	ps.mu.RLock()
+	var rt *PluginRuntime
+	for _, p := range ps.plugins {
+		if p.Info.Name == "sched2" {
+			rt = p.Runtime
+		}
+	}
+	ps.mu.RUnlock()
+	if rt == nil {
+		t.Fatal("插件未拿到 Runtime（夹具失效）")
+	}
+	// 连调三次：第二次若 panic，本测试就会崩掉（正是要防的行为）
+	rt.Stop()
+	rt.Stop()
+	rt.Stop()
+}
+
+func waitForFile(t *testing.T, path string, d time.Duration) {
+	t.Helper()
+	deadline := time.Now().Add(d)
+	for time.Now().Before(deadline) {
+		if _, err := os.Stat(path); err == nil {
+			return
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	t.Fatalf("等待 %s 出现超时 —— 调度任务从未运行（夹具失效）", filepath.Base(path))
+}
+
+func fileSize(t *testing.T, path string) int64 {
+	t.Helper()
+	st, err := os.Stat(path)
+	if err != nil {
+		t.Fatalf("stat %s: %v", path, err)
+	}
+	return st.Size()
+}

internal/lua/plugin_unload_on_close_test.go

@@ -0,0 +1,77 @@
+package lua
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// ★ 关闭 Plugins 时必须给插件一次 on_unload 机会。
+//
+// 真实缺陷：Close() 此前只关 shard 与 saver，**从不调用 on_unload** —— 而
+// on_unload 只在单插件 Unload 时调。于是「进程关闭/测试结束」这条路径上，
+// 起了 OS 进程的插件（回环回调接收器、浏览器栈）永远收不了尾，留下孤儿进程。
+// 实测本机积累到 995 个 python 监听器（828 个超 24 小时），全是测试残留。
+//
+// 这个判据看的是**真实外部效应**（插件在 on_unload 里改磁盘上的文件），
+// 而不是「钩子被调用过」这类内部信号 —— 后者在钩子写错名字时也会假绿。
+func TestPluginsCloseCallsOnUnload(t *testing.T) {
+	dir := t.TempDir()
+	marker := filepath.Join(dir, "unloaded.marker")
+
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	src := `
+local plugin = { name = "leaky", version = "1.0.0", exports = {} }
+plugin.ui = nil
+function plugin.on_unload()
+  local f = io.open("` + marker + `", "w")
+  if f then f:write("reaped"); f:close() end
+end
+return plugin
+`
+	if err := os.WriteFile(filepath.Join(pluginDir, "leaky.lua"), []byte(src), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	ps := NewPlugins(nil, pluginDir)
+	if err := ps.LoadDir(); err != nil {
+		t.Fatalf("LoadDir: %v", err)
+	}
+	// 关之前不该有标记
+	if _, err := os.Stat(marker); err == nil {
+		t.Fatal("on_unload 在 Close 之前就被调了？")
+	}
+	ps.Close()
+
+	// ★ 真判据：文件必须被写出来（= on_unload 真的跑过）
+	if _, err := os.Stat(marker); err != nil {
+		t.Fatalf("Close() 没有调用 on_unload —— 起了 OS 进程的插件会留下孤儿进程"+
+			"（真实缺陷：995 个 python 监听器残留）。marker 不存在: %v", err)
+	}
+	t.Log("✓ Close() 触发了 on_unload（孤儿进程不会再堆积）")
+}
+
+// on_unload 抛错不得让 Close 崩掉（best-effort 契约）。
+func TestPluginsCloseSurvivesFailingOnUnload(t *testing.T) {
+	dir := t.TempDir()
+	pluginDir := filepath.Join(dir, "plugins")
+	if err := os.MkdirAll(pluginDir, 0755); err != nil {
+		t.Fatal(err)
+	}
+	src := `
+local plugin = { name = "boom", version = "1.0.0", exports = {} }
+function plugin.on_unload() error("故意炸") end
+return plugin
+`
+	if err := os.WriteFile(filepath.Join(pluginDir, "boom.lua"), []byte(src), 0644); err != nil {
+		t.Fatal(err)
+	}
+	ps := NewPlugins(nil, pluginDir)
+	if err := ps.LoadDir(); err != nil {
+		t.Fatalf("LoadDir: %v", err)
+	}
+	ps.Close() // 不得 panic
+}

internal/lua/plugins.go

@@ -572,10 +572,101 @@ func (ps *Plugins) Close() {
 	if ps == nil {
 		return
 	}
+	// ★ 顺序至关重要：**先停调度，再落盘，最后给插件收尾**。
+	//
+	// saver 的最终写入要读每个插件的 Lua 表；on_unload 之后 state 已关，
+	// 读到的就是空 —— 最后一个区间的累积静默丢失（persist_test 的
+	// TestCloseFlushesTail 正是为守住这一点而存在）。
+	//
+	// 所以不能把 callOnUnloadAll 挪到前面，也不能把 save.Close 挪到后面。
+	//
+	// ★ 而调度器必须停在**落盘之前**：它每 tick 可能调 Lua、改状态，
+	// 落在 save.Close 之后就会写进一个已经收尾的 state；停在最前面也顺带
+	// 保证了「收尾期间不会再有新任务被派发」。
+	//
+	// 真实缺陷（与 on_unload 同一形状的第 3 个实例）：Runtime.Stop() 此前
+	// **只在单插件 Unload 里调**，Close() 不调 —— 于是每个插件的调度循环
+	// （PluginRuntime.loop）在「进程关闭/测试结束」这条路径上永不停止。
+	// 实测全量回归在 internal/lua 出现 69 个 goroutine 卡在 saver/runtime
+	// 循环里并超时 600s。
+	ps.stopSchedulersAll()
 	// Shard VMs are separate golua states; leaving them open leaks a VM per
 	// shard on every reload.
 	ps.shards.Shutdown()
 	ps.save.Close()
+	ps.callOnUnloadAll()
+}
+
+// stopSchedulersAll 停掉每个插件的调度循环（best-effort，幂等）。
+//
+// 与 Unload 里的 Runtime.Stop() 是同一契约：Close 是它在进程退出路径上的
+// 等价点，不能只有 Unload 有 —— 那正是 on_unload 缺陷的形状（“两处只修一处”）。
+func (ps *Plugins) stopSchedulersAll() {
+	ps.mu.Lock()
+	plugins := make([]*Plugin, len(ps.plugins))
+	copy(plugins, ps.plugins)
+	ps.mu.Unlock()
+	for _, p := range plugins {
+		if p == nil || p.Runtime == nil {
+			continue
+		}
+		p.Runtime.Stop()
+		p.Runtime = nil
+	}
+}
+
+// callOnUnloadAll 依次给每个插件调 on_unload（best-effort）。
+//
+// 与 Unload 里的调用共用同一实现：两处若各写一遍，将来必然漂移成一个修了
+// 一个没修 —— 这正是本次缺陷的形状（Unload 有、Close 没有）。
+func (ps *Plugins) callOnUnloadAll() {
+	ps.mu.Lock()
+	plugins := make([]*Plugin, len(ps.plugins))
+	copy(plugins, ps.plugins)
+	ps.mu.Unlock()
+	for _, p := range plugins {
+		ps.callOnUnload(p)
+	}
+}
+
+// callOnUnload 调单个插件的 on_unload（存在才调），并关掉它的 Lua state。
+//
+// 为什么关 state 也在这里：on_unload 之后 state 就没用了，而 state 一旦关掉，
+// 钩子再也调不了 —— 调用与关闭必须紧邻，否则又会漏。Unload 与 Close 各自持有
+// 的 state 生命周期不同（Unload 还要 rebuild，Close 之后整体销毁），所以这里
+// 只做「调用 + 置空」，由调用方决定其余步骤。
+func (ps *Plugins) callOnUnload(p *Plugin) {
+	if p == nil {
+		return
+	}
+	if err := ps.invokeOnUnload(p, p.Info.Name); err != nil {
+		log.Printf("[plugins] %s: on_unload: %v", p.Info.Name, err)
+	}
+}
+
+// invokeOnUnload 真正调钩子。抽出来是为了让 Unload 与 Close 共用一份实现
+// （含 state 判空与错误返回语义），避免两处契约不一致。
+func (ps *Plugins) invokeOnUnload(p *Plugin, name string) error {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if p.state == nil || p.state.L == nil {
+		return nil
+	}
+	L := p.state.L
+	L.GetGlobal(pluginGlobal)
+	if L.Type(-1) != golua.LUA_TTABLE {
+		L.Pop(1)
+		return nil
+	}
+	L.GetField(-1, "on_unload")
+	var err error
+	if L.Type(-1) == golua.LUA_TFUNCTION {
+		err = callFnOn(L, "on_unload")
+	}
+	L.Pop(2) // plugin table + field remnant
+	p.state.L.Close()
+	p.state = nil
+	return err
 }
 
 // LoadDir loads every .lua file in dir as a plugin. Files are loaded in
@@ -1941,24 +2032,10 @@ func (ps *Plugins) Unload(name string) error {
 	// only guaranteed point where it still can. Best-effort by design — a
 	// hook that errors must not block an unload the operator explicitly asked
 	// for (a wedged plugin has its own path above).
-	p.mu.Lock()
-	if p.state != nil && p.state.L != nil {
-		p.state.L.GetGlobal(pluginGlobal)
-		if L := p.state.L; L.Type(-1) == golua.LUA_TTABLE {
-			L.GetField(-1, "on_unload")
-			if L.Type(-1) == golua.LUA_TFUNCTION {
-				if err := callFnOn(L, "on_unload"); err != nil {
-					log.Printf("[plugins] %s: on_unload: %v", name, err)
-				}
-			}
-			L.Pop(2) // adapter/plugin table + field remnant
-		} else {
-			L.Pop(1)
-		}
-		p.state.L.Close()
-		p.state = nil
-	}
-	p.mu.Unlock()
+	//
+	// 与 Close 共用 invokeOnUnload：两处各写一遍必然漂移 —— 本次缺陷正是
+	// 「Unload 有、Close 没有」。
+	_ = ps.invokeOnUnload(p, name)
 	ps.rebuild()
 	return nil
 }
@@ -2359,6 +2436,8 @@ type HTTPHandler struct {
 	// Path is the route suffix under /api/plugins/http/. It may contain ":name"
 	// segments, captured into request.params.
 	Path string `json:"path"`
+	// Prefix claims this path and its descendants for a streaming proxy handler.
+	Prefix bool `json:"prefix,omitempty"`
 	// Method is the HTTP method; "" or GET. Only GET/POST/PUT/DELETE/PATCH are
 	// accepted — an arbitrary verb would need a switch in the router for no gain.
 	Method string `json:"method,omitempty"`
@@ -2483,7 +2562,7 @@ func readPluginHTTP(L *golua.State) []HTTPHandler {
 			continue
 		}
 		ctx.strictKeys(h, "http[]", "path", "method", "handler", "description",
-			"roles", "keys", "public")
+			"roles", "keys", "public", "prefix")
 		dh := HTTPHandler{
 			Path:        decString(h, "path"),
 			Method:      decString(h, "method"),
@@ -2504,6 +2583,9 @@ func readPluginHTTP(L *golua.State) []HTTPHandler {
 			}
 			dh.Handler = name
 		}
+		if p, ok := h["prefix"].(bool); ok {
+			dh.Prefix = p
+		}
 		if p, ok := h["public"].(bool); ok {
 			dh.Public = p
 		}