fix(channels,provider): 渠道模型不可用 + 额度异常的三个根因

## 背景
用户报三问题：① channel 注册的模型无法使用；② 额度显示依旧异常；
③ 其他渠道应也存在类似问题。三条全部核实并给出结论（③ 见文档）。

## ① 网关解不开 `源名:模型名` 限定名（internal/provider/registry.go）

`ResolvePinned` 用 `strings.IndexAny(model, "-:/")` 找**第一个**分隔符。
而渠道源名形如 `channels-trae-b8dd6b3df30e`（**含 `-`**），于是
`channels-trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro` 被切成

    src="channels"、model="trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro"

⇒ 源名永不匹配 ⇒ `Resolve()` 返回 nil
⇒ 客户端看到 `model "..." is not configured`。

**为什么这个写法必须支持**：本实例有 **44 个模型被多源同时提供**
（`glm-5.2` 由 6 个源提供），WebUI 的模型下拉框用 `源名:模型名` 作为
option value 是**有意设计** —— 用户必须能指定"从哪个源调用"。

修法：抽 `splitPinned()`，**按已知源名做最长前缀匹配**（源名是已知集合，
这是唯一可靠办法），保留旧 `-:/` 兜底以兼容非源名形态。
`EffectiveModel` 同步修（同一拆分规则，避免两处漂移）。

## ② trae 适配器三连错（internal/lua/plugins/channels.lua）

三个错误逐层叠加，每个都被上一层掩盖：

**(a) 没有 `build_headers`** ⇒ 内核兜底发 `Authorization: Bearer`，
而 trae 推理端点要 `Cloud-IDE-JWT` + 设备身份头 ⇒
401「We're sorry, but we are not able to authenticate you」。
→ 与上一轮「额度不可用」是**同一根因的两个出口**（额度端点修了、推理端点漏了）。
教训：修"某一族请求的鉴权"时，必须把该族的**所有出口**列出来逐个对齐。

**(b) header 常量的值是错的**（照参考 trae-product.ts 的 TRAE 配置逐项核对）：
  · `X-App-Id` 抄成 `6eefa6c9`，真实是 `6eefa01c-1036-4c7e-9ca5-d891f63bfcd8`
  · `app_version_code` 用了 `0.1.52`，真实是**日期式** `20260811`
⇒ 上游 `4001 bad request: binding: expr_path=app_version_code,
   cause=parameter type does not match binding data`

**(c) 流式转换完全不对**：TRAE 是 **SOLO 自定义 SSE**：
    event:output → data:{"response":"###","reasoning_content":null,...}
正文在 `response`，推理在 `reasoning_content`。
  · 套 `__prelude.openai_stream_chunk` ⇒ 无 `choices` ⇒ `empty stream`
  · 改成 OpenAI 外壳 `{choices:[{delta}]}` **仍然空** —— 内核
    `json.Unmarshal(unified, &UnifiedChunk)` 解的是**扁平结构**，外壳字段全被丢弃
⇒ 必须输出扁平 `{content, reasoning_content, usage, done, finish_reason}`。

⚠️ 内核只把 `data:` 行交给适配器（`event:` 行在 provider.go 被丢弃），
   因此判别帧类型只能靠**内容特征**（`response` / `reasoning_content` /
   `finish_reason` / `prompt_tokens`），拿不到 event 名。

## ③ 余额恒为 0（同文件 balance.total_fn）

读的是 `p.credits_limit`（pack **顶层**）—— 该字段**根本不存在**。
真实路径是 `pack.entitlement_base_info.quota.credits_limit`
（参考 trae-credits.ts:341）+ `pack.usage.credits_amount`。
实测上游：`免费`(无该字段) / `每月登录赠送`(500) / `签到奖励`(100) ⇒ 实际 600。
修法：读嵌套路径 + 保留顶层兼容 + `usage_summary.{total,consumed}_amount` 兜底。
修后余额 600 → 实测 598.516（真实扣减）。

## ④ 夹具与生产形状不一致（internal/core/channels_trae_test.go）

夹具原先返回**扁平** `{"Token":...}`，与生产 `{"Result":{"Token":...}}` 不符
⇒ 「代码只读顶层」这个缺陷在夹具里**恰好是对的**，所有 trae 判据都绿。
**夹具形状错 = 判据必然虚假通过**。这是 ExchangeToken 缺陷藏了两轮的原因。

## 判据（新增，变异 4/4 咬住）
- `internal/provider/registry_pinned_name_test.go`（4 用例）
- `internal/core/channels_trae_chat_headers_test.go`（3 条）
- `internal/core/channels_trae_solo_sse_test.go`（2 条）
- `internal/core/channels_trae_credits_hdr_test.go`（1 条）
- `internal/core/channels_trae_exchange_shape_test.go`（2 条）

## 文档
`docs/channel-repair-plan.md`：现状快照（生产实测）+ 各渠道缺陷矩阵 +
后续计划（P0-P4）。**如实记录**：其余 4 个渠道（zcode/cline/gemini/qoder）
有同类缺陷风险，但**账号数均为 0、无法做生产验证**。

## 生产已实测
- `channels-trae-...:Doubao-Seed-2.1-Pro` → 80 帧，正文 27 + 推理 299
- `channels-trae-...:glm-5.2` / `channels-buddy-...:hy4-preview` → OK
- `credits/status` → active:true, dailyCredit:100, todayCheckedIn:true
- `credits/balances` → total:598.516 credits

docs/channel-repair-plan.md

@@ -0,0 +1,183 @@
+# 渠道链路修复计划与现状
+
+> 本文是 `plan.md` 中「渠道链路修复计划（2026-10-17 起）」章节的**可提交版本**。
+> `plan.md` 本身被 `.gitignore` 忽略（本地工作台账），故关键计划与现状单独落在这里，
+> 以便随代码一起进 git、供他人查阅。
+>
+> **写作原则：只写实测到的，标注"推断"的必须写明。** 每条缺陷都附可复现的观测。
+
+> 记录 **2026-10-17 用户报障三连修**（模型不可用 / 额度异常 / 其他渠道同类）
+> 的现状与后续计划。上接 `plan.md` §9（v2 契约收尾）。
+
+## 1. 现状快照（2026-10-17 14:00 实测，非推断）
+
+### 1.1 生产实例
+
+| 项 | 值 |
+|---|---|
+| 服务 | `active`，NRestarts=0 |
+| 二进制 sha256 | `56396f79bfc2433a`（与仓库逐字节一致） |
+| 插件 sha256 | `c15cb4bf5d5c0f21`（与仓库逐字节一致） |
+| 插件 | 4 个（billing/channels/quota/usage）**全部 loaded** |
+| 源 / 适配器 | 21 源 / 23 适配器 |
+| 账号池 | **仅 trae、buddy 各有 1 个有凭据账号**；其余 10 个平台**账号数 0** |
+
+### 1.2 各渠道缺陷矩阵（本文件写入时的实测）
+
+自装适配器（插件在加载时经 `__llmsproxy_adapters` 装入）：
+
+| 适配器 | `build_headers` | 静态 `adapter.headers` | 流式转换 | 鉴权是否可能错 |
+|---|---|---|---|---|
+| `codearts` | 有 | 无 | 复合 openai | 有（SDK-HMAC 自签，已实现） |
+| `channels-trae` | **有（本次新加）** | 无 | **SOLO 自定义（本次新写）** | 已修 |
+| `channels-gemini` | **★ 缺** | 有 | 自定义 | 静态头 + Bearer，**待确认** |
+| `channels-zcode` | **★ 缺** | 无 | 无（继承 anthropic 基座） | **★ 高度可疑** |
+| `channels-cline` | **★ 缺** | 无 | 套 openai | **★ 可疑**（要 `Bearer workos:<jwt>`） |
+| `channels-qoder` | **★ 缺** | 无 | 套 openai | **★ 可疑**（头由 WASM 生成） |
+
+内置适配器里 `build_headers` 只有 3 个有（buddy / kimicode / opencodezen），
+其余 11 个（含 **anthropic 基座**）靠静态头 + 内核兜底 `Bearer`。
+
+> **★ anthropic 基座本身没有 `build_headers`**，而 anthropic 协议实际要
+> `x-api-key` 而非 `Authorization: Bearer`。`channels-zcode` 继承它 ⇒
+> 一旦有账号就会立刻暴露，与 trae 修复前完全同型。
+
+### 1.3 已验证可用的通道（生产实测，不是单测）
+
+| 模型（源限定名） | 结果 |
+|---|---|
+| `channels-trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro` | ✅ 80 帧，正文 27 + 推理 299 |
+| `channels-trae-b8dd6b3df30e:glm-5.2` | ✅ OK |
+| `channels-buddy-buddy-main:hy4-preview` | ✅ OK |
+
+| 端点 | 结果 |
+|---|---|
+| `channels/credits/status` (trae) | ✅ `active:true, dailyCredit:100, todayCheckedIn:true` |
+| `channels/credits/balances` (trae) | ✅ `total:598.516 credits` |
+
+### 1.4 本轮已修（代码已部署生产，**尚未提交 git**）
+
+**① 网关解不开 `源名:模型名` 限定名**（`internal/provider/registry.go`）
+
+- 根因：`ResolvePinned` 用 `strings.IndexAny(model, "-:/")` 找**第一个**分隔符。
+  渠道源名形如 `channels-trae-b8dd6b3df30e`（**含 `-`**）⇒ 切成 `src="channels"`
+  ⇒ 永不匹配 ⇒ `Resolve()` 返回 nil ⇒ `model "..." is not configured`。
+- 为什么必须支持：本实例 **44 个模型被多源同时提供**（`glm-5.2` 由 6 个源提供），
+  WebUI 下拉框用 `源名:模型名` 作 option value 是**有意设计**。
+- 修法：抽 `splitPinned()`，**按已知源名做最长前缀匹配**（源名是已知集合，
+  唯一可靠办法），保留旧 `-:/` 兜底。`EffectiveModel` 同步修。
+- 判据：`internal/provider/registry_pinned_name_test.go`（4 用例，变异 1/1 咬住）。
+
+**② trae 适配器三连错**（`internal/lua/plugins/channels.lua`，逐层剥开）
+
+1. **没有 `build_headers`** ⇒ 内核兜底发 `Bearer`，而 trae 推理端点要
+   `Cloud-IDE-JWT` + 设备身份头 ⇒ 401「not able to authenticate you」。
+   → 与「额度不可用」是**同一根因的两个出口**（额度端点当轮修了、推理端点漏了）。
+2. **header 常量值是错的**：`X-App-Id` 抄成 `6eefa6c9`（真实
+   `6eefa01c-1036-4c7e-9ca5-d891f63bfcd8`）、`app_version_code` 用 `0.1.52`
+   （真实是**日期式** `20260811`）⇒ 上游 `4001 binding: expr_path=app_version_code,
+   cause=parameter type does not match binding data`。
+3. **流式转换完全不对**：TRAE 是 **SOLO 自定义 SSE**
+   （`event:output` → `data:{"response":"###","reasoning_content":...}`）。
+   套 `openai_stream_chunk` ⇒ 无 `choices` ⇒ `empty stream`；
+   改成 OpenAI 外壳 `{choices:[{delta}]}` **仍不对** —— 内核
+   `json.Unmarshal(unified, &UnifiedChunk)` 解的是**扁平结构**，外壳字段全丢。
+   ⇒ 必须输出扁平 `{content, reasoning_content, usage, done, finish_reason}`。
+- 判据：`channels_trae_chat_headers_test.go`(3)、`channels_trae_solo_sse_test.go`(2)，
+  变异 2/2 咬住。
+
+**③ 余额恒为 0**（同文件 `balance.total_fn`）
+
+- 根因：读 `p.credits_limit`（pack **顶层**）—— 该字段**根本不存在**。
+  真实路径是 `pack.entitlement_base_info.quota.credits_limit`
+  （参考 `trae-credits.ts:341`）+ `pack.usage.credits_amount`。
+- 实测上游：`免费`(无 credits_limit) / `每月登录赠送`(500) / `签到奖励`(100) = **600**。
+- 修法：读嵌套路径 + 保留顶层兼容 + `usage_summary.{total,consumed}_amount` 兜底。
+- 判据：`channels_trae_credits_hdr_test.go`(1)。
+- 修后余额 **600 → 实测 598.516**（真实扣减）。
+
+**④ 附带**：`channels_trae_test.go` 夹具从**扁平** `{"Token":...}` 改为真实
+`{"Result":{"Token":...}}` —— 原来夹具形状与生产不一致，**判据必然虚假通过**
+（这是 ExchangeToken 缺陷藏了很久的原因）。
+
+## 2. 后续计划
+
+### P0 — 提交本轮修复（必须先做）
+
+代码已部署生产但**未进 git**。必须：
+1. 在 `release/v2.0.x` 上提交（含 3 个源文件 + 6 个判据文件）
+2. 打 tag `v2.0.40`（**这是内核 Go 改动**：`registry.go` ⇒ 真核心版本）
+3. 回流 main（cherry-pick，不 merge）
+4. 复核 tag 落点 + release vs main 零差异 + 生产 sha256 一致
+
+> 判据：`git tag --points-at <release HEAD>` 非空；`git diff release/v2.0.x main` 为空。
+
+### P1 — 其余渠道的同类缺陷（**账号 0，验证不了**）
+
+按"风险 × 可验证性"排序。**核心限制：这 4 个平台账号数均为 0，
+无法做生产实测** —— 只能靠静态对齐参考 + 装好适配器后看 `__adapter_install_probe`。
+
+| 优先 | 项 | 缺陷 | 修法 | 可验证性 |
+|---|---|---|---|---|
+| P1-1 | `channels-zcode` | 走 anthropic 基座，而**基座无 `build_headers`**，anthropic 要 `x-api-key` 不是 Bearer | 给基座补 `build_headers`（`x-api-key` + `anthropic-version`），zcode 继承即得 | 静态可验；运行需账号 |
+| P1-2 | `channels-cline` | 参考要 `Bearer workos:<jwt>`，我们的 token 无 `workos:` 前缀 | 登录/续期处拼前缀，或适配器 `build_headers` 补 | 静态可验；运行需账号 |
+| P1-3 | `channels-gemini` | 有静态头 + Bearer（参考注释也说 Cloud Code 用 OAuth Bearer）⇒ **可能本来就对** | 只需确认，不改 | 静态可验 |
+| P1-4 | `channels-qoder` | 头由 **WASM 生成必须原样透传**，我们拿不到 `.wasm` | **阻塞**：二进制不在仓库任何位置 | 不可验证 |
+
+### P2 — 内核对"限定名"的契约收口
+
+`ResolvePinned` / `EffectiveModel` 现在各自调 `splitPinned`。建议：
+- 把"源名可含哪些字符"写进 `docs/`，并加判据：新增源名若含 `:` 或 `/` 必须报警
+  （否则限定名会歧义）。
+- 现状：源名由插件生成 `channels-<platform>-<accountId>`，只含 `-`/字母数字，安全。
+
+### P3 — 判据防回归（防"夹具与生产不一致"再犯）
+
+本轮最大的教训不是某个 bug，而是**夹具形状错 ⇒ 判据虚假通过**（trae 活了两轮）。
+
+建议加一条**通用**判据：`TestAdaptersFixturesMatchRealUpstreamShape` ——
+对每个有夹具的渠道，把夹具响应体与
+`/tmp/pi-github-repos/.../vendor/channel-pack/src/*.ts` 里注释记录的真实响应形状
+做**结构对照**（键集合），不一致即报红。做不到全自动，至少把已知的
+"Result 信封 / SOLO SSE / 嵌套 quota" 三类钉住。
+
+### P4 — 待用户决策
+
+| 项 | 需要什么 |
+|---|---|
+| zcode 真实登录 | 用户点授权（身份块 + init-poll 流已就绪） |
+| cline / qoder / gemini / codearts / minimax / lobsterai / opencode | 需各平台账号；`device-poll` 系列要用户去官方页输码 |
+| raccoon / loomy | 需扫码 |
+| qoder WASM | 用户提供 `.wasm` |
+
+## 3. 风险与纪律（本轮新增）
+
+1. **`luac -p` 对长字符串内的适配器代码无效**（只看外层）⇒ 会得到假绿。
+   **必须**用 `__adapter_install_probe` 看真实装载结果。本轮我因此把 TRAE 的
+   SSE 代码误塞进 CODEARTS 适配器，导致 codearts 装载失败而 `luac` 一直通过。
+2. **Python 字符串替换会静默不生效**：锚文本缩进不符 ⇒ 匹配 0 次。
+   规矩：① 先 `cp` 备份 ② **行号定位** ③ 写后 `luac -p` + `grep -c` 双确认
+   ④ 长字符串内的改动必须验装载。
+3. **`function` 是 Lua 关键字**：`cc.function` 是语法错误，必须 `cc["function"]`；
+   但批量替换时别把 `cc.function_call` 一起改坏（本轮踩过，导致
+   `')' expected near '_call'`）。
+4. **判据要咬被测对象**：本轮 `channels_trae_credits_hdr_test.go` 第一版造 HTTP 假上游，
+   因 URL 覆盖/凭据 ref/路径匹配任一环错，"没发请求"伪装成"头不对"（耗了三轮）。
+   改成直接咬 `spec.headers_fn` 的真实产出，一轮就准。
+5. **只改插件不必换二进制**；改内核 Go 必须换。混着发会把"插件改动"记成"核心版本"
+   （v2.0.21–v2.0.39 有 18 个 tag 是这么来的，见 §4）。
+6. **`/tmp` 是 8.8G tmpfs**，Go 链接失败常见于它满（`no space left on device`）。
+   元凶通常是 `/tmp/gocache`（可安全清）。
+
+## 4. 账务实况（必须记住）
+
+| 事实 | 值 |
+|---|---|
+| 内核 Go 代码自 v2.0.20 起的**全部**改动 | 仅 `internal/lua/adapter_prelude.go`、`internal/provider/provider.go`、`internal/provider/registry.go` |
+| 只改插件却发了核心 tag 的版本 | v2.0.21–v2.0.39 中的 **18 个** |
+| 当前最新 tag | `v2.0.39`（`091f790`），落点正确 |
+| main | `56ea269`（与 release 内容零差异） |
+| **未提交的改动** | 本轮三个修复（见 §1.4），已部署生产 |
+
+> ⇒ **版本号语义教训**：以后"改插件不打核心 tag"，插件自身维护版本；
+> 内核版本只在 Go 代码变更时递增。

internal/core/channels_buddy_catalog_filter_test.go

@@ -0,0 +1,85 @@
+package core
+
+import (
+	"strings"
+	"testing"
+)
+
+// ★ 远端模型目录混着「不可调用」的条目，必须过滤掉。
+//
+// 真实缺陷（生产实测）：buddy 源声明了 24 个模型，其中
+//
+//	nes-gf / codewise-completions / codewise-rewrite / codewise-jump /
+//	codewise-default-model-v2 / hunyuan-image-alpha / auto
+//
+// 全部调不通（`glm-5.1` 也是 404）。用户选中就报错，而错误文案指向**模型**，
+// 极易被误判成"这个模型坏了"。
+//
+// 参考实现（buddy.ts 的 isChatModel / isAutoSelectAlias）记录了**四类**判据，
+// 且都是实测依据：
+//
+//	① 自动选择别名 auto/default（**只按字面量**，前缀匹配会误伤 default-model）
+//	② 补全/NES 专用前缀 nes- / completion- / codewise-，或 supportsExtra=true
+//	   （参考实测 codewise-default-model-v2 → `code 11102 service info not found`）
+//	③ maxOutputTokens >0 且 ≤256（补全用途；对话模型普遍 ≥24000）
+//	④ 带 text-to-image 标签（如 hunyuan-image-alpha）
+func TestBuddyCatalogFilterDropsNonChatModels(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// 判据一：四类规则必须都在源码里（防止有人"精简"掉其中一条）
+	for _, rule := range []string{
+		`id == "auto" or id == "default"`, // ①
+		`id:sub(1, 4) == "nes-"`,          // ②
+		`id:sub(1, 11) == "completion-"`,  // ②
+		`id:sub(1, 9) == "codewise-"`,     // ②
+		`m.supportsExtra == true`,         // ②
+		`mo > 0 and mo <= 256`,            // ③
+		`t == "text-to-image"`,            // ④
+	} {
+		if !strings.Contains(s, rule) {
+			t.Errorf("buddy 目录过滤缺少规则：%s\n"+
+				"（这四类都是参考用真实请求验证过的「列出来就会让用户报错」的条目，"+
+				"删任何一条都会把不可调用模型放回选择器）", rule)
+		}
+	}
+
+	// 判据二：`default-model` / `fast-model` 必须**不在**被过滤的形态里。
+	// 参考注释明确警告：只过滤 auto/default 两个字面量，不做前缀匹配 ——
+	// 前缀会误伤这两个国际版别名（它们被 craft agent 引用，是官方推荐入口）。
+	if strings.Contains(s, `id:sub(1, 7) == "default"`) {
+		t.Error("buddy 过滤把 default 做成了**前缀**匹配 ⇒ 会误伤 default-model（参考点名警告）")
+	}
+	t.Log("✓ buddy 目录过滤四类规则齐备，且未误伤 default-model 类别名")
+}
+
+// ★ 已实测**不可调用**的模型必须也从目录里排除 —— 包括 agentRef 例外路径。
+//
+// 真实缺陷：`hy4-preview-x` 被服务端 agents 引用，于是 agentRef 例外把它放回
+// 目录；而它对上游**恒回 11102**（`model service info not found`，加/不加
+// reasoning_effort 都一样 ⇒ 与 effort 无关，是后端未开放）。
+// 用户选中就 400，错误文案指向模型 ⇒ 极易误判"模型坏了"。
+//
+// 参考用**白名单重建**（product.ts 的兜底表里没有它）达到同样效果。
+func TestBuddyCatalogDropsKnownUncallable(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	if !strings.Contains(s, "local NOT_CALLABLE = {") {
+		t.Fatal("必须有已实测不可调用的排除表（等价于参考的白名单）")
+	}
+	if !strings.Contains(s, `["hy4-preview-x"] = true`) {
+		t.Error("hy4-preview-x 实测恒 11102，必须排除")
+	}
+	// 闸门必须生效在**所有**入口 —— 尤其是 agentRef 例外之后
+	if !strings.Contains(s, "if NOT_CALLABLE[id] then return false end") {
+		t.Error("NOT_CALLABLE 闸门必须在 buddyIsChatModel 内（覆盖 models 与 agentRef 两条路径）")
+	}
+	t.Log("✓ 不可调用模型已排除，且 agentRef 例外也过闸")
+}

internal/core/channels_endpoint_url_test.go

@@ -0,0 +1,76 @@
+package core
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// ★ 源的 chat URL = `base_url + endpoint`（内核 provider.go ChatURL）。
+//
+// 真实缺陷（生产实测）：多个渠道平台的 `base_url` 里塞了**完整路径**，
+// 而适配器默认 endpoint 又是 "/chat/completions" ⇒ 实际请求变成
+//
+//	https://copilot.tencent.com/v2/chat/completions/chat/completions
+//
+// ⇒ 上游回 `{"error_msg":"404 Route Not Found"}`（APISIX 的措辞，不是模型错误）。
+//
+// 受影响平台 8 个：buddy / cline / lobsterai / opencode / qoder / loomy /
+// raccoon（zcode 当时已用 endpoint 覆盖，形态正确）。
+//
+// ★ 为什么这个缺陷能活很久：**模型名被多个源服务**。
+//
+//	`deepseek-v4.1-flash` 同时由 4 个源提供（alittokenplan/vela/oin/channels-buddy…）
+//	⇒ 网关在 buddy 源失败后会**继续尝试下一个源**并成功 ⇒ 用户看到"能回话"，
+//	于是"buddy 通道是好的"这个结论**完全没有证据**。
+//	而 `hy3` 只由 buddy 一个源提供 ⇒ 一调就暴露真因。
+//	⇒ 判据必须断言**源的 URL 形态**（结构不变量），不能靠"某个模型能调通"。
+//
+// 判据：base_url 不得自带任何 chat 路径段（它只应是 host[+协议公共前缀]），
+// 路径必须在 `endpoint` 里。
+func TestChannelSourceBaseURLHasNoChatPath(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// 只在平台定义区里找 base_url（避免误判注释/文档里的示例）
+	declRe := regexp.MustCompile(`(?m)^\s*base_url = "([^"]+)"\s*,?$`)
+	// 已知适配器会把这些路径各追加一次；出现即说明 base_url 侵占了 endpoint 的地盘
+	banned := []string{"/chat/completions", "/v1/messages", "/generateContent", "/api/chat"}
+
+	found := 0
+	for _, m := range declRe.FindAllStringSubmatch(s, -1) {
+		url := m[1]
+		found++
+		for _, b := range banned {
+			if strings.Contains(url, b) {
+				t.Errorf("base_url 侵占了 endpoint 的路径：%s\n"+
+					"  内核的 URL 是 `base_url + endpoint`（provider.go ChatURL），"+
+					"适配器默认 endpoint=\"/chat/completions\" ⇒ 实际会请求 %s%s\n"+
+					"  修法：base_url 只留 host，把 `%s` 移到该平台的 `endpoint = \"...\"`",
+					url, url, b, b)
+			}
+		}
+	}
+	if found == 0 {
+		t.Fatal("没扫到任何 base_url 声明（判据失效）")
+	}
+	t.Logf("✓ %d 个 base_url 均不含 chat 路径段", found)
+}
+
+// ★ 反过来也要咬：说明该缺陷**确实已被修好**、而不是判据太松。
+// 用一段**故意的坏数据**验证判据的判别力（变异测试的静态等价物）。
+func TestChannelBaseURLJudgeBitesOnBadInput(t *testing.T) {
+	bad := `    base_url = "https://copilot.tencent.com/v2/chat/completions",`
+	declRe := regexp.MustCompile(`(?m)^\s*base_url = "([^"]+)"\s*,?$`)
+	m := declRe.FindStringSubmatch(bad)
+	if m == nil {
+		t.Fatal("判据的正则匹配不到坏数据 ⇒ 判据无判别力（形同虚设）")
+	}
+	if !strings.Contains(m[1], "/chat/completions") {
+		t.Fatal("坏数据未被识别 ⇒ 判据无判别力")
+	}
+	t.Log("✓ 判据对坏数据有判别力")
+}

internal/core/channels_log_panel_test.go

@@ -0,0 +1,190 @@
+package core
+
+import (
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// ★ 插件日志面板：级别 + 归属 + 同文折叠（否则用户动作被 96% 的周期噪音淹没）。
+//
+// 真实问题（生产实测）：50 条日志里 **48 条（96%）** 是三个定时任务
+// （refresh_models 2h / auto_claim 2h / refresh_creds 0.5h，全为 first_due_now）
+// 的重复回音，唯一模式只有 8 种 ⇒ 约 2 小时就把 50 条环形缓冲冲满一轮，
+// **真正的用户动作**（如「账号删除」）被挤到看不见。
+//
+// 三个结构性修法，每个都在源码里可断言：
+//
+//	① logEvent 支持 level（task/warn/error），前端默认折叠 task
+//	② logEvent 支持 platform，前端按选中渠道过滤（修"点 buddy 看到 trae"的归属错误）
+//	③ 同文折叠：紧邻同文不新增条目，只 n=n+1
+func TestChannelsLogEventCarriesLevelAndPlatform(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// ① 签名必须收 level 与 platform（三参）
+	if !regexp.MustCompile(`local function logEvent\(msg, level, platform\)`).MatchString(s) {
+		t.Error("logEvent 必须接收 (msg, level, platform) —— 否则级别与渠道归属都无从表达")
+	}
+	// ② 写入的条目必须带上这两个字段
+	for _, field := range []string{"level = level or", "platform = platform"} {
+		if !strings.Contains(s, field) {
+			t.Errorf("日志条目必须写入 %s", field)
+		}
+	}
+	// ③ 同文折叠：紧邻同文时只加计数
+	if !strings.Contains(s, "top.n = (top.n or 1) + 1") {
+		t.Error("必须实现紧邻同文折叠（否则周期任务的重复回音会把 50 条缓冲冲满）")
+	}
+	// ④ 折叠必须只针对**紧邻**条目 —— 否则一条每小时出现的消息会不断跳到最前，
+	//    时间线失去意义。断言比较对象是 log[1]（栈顶）而不是任意条目。
+	if !strings.Contains(s, "local top = log[1]") {
+		t.Error("折叠必须只比较**紧邻**的上一条（log[1]）；对任意条目折叠会让时间线错乱")
+	}
+	t.Log("✓ logEvent 具备 level / platform / 紧邻同文折叠")
+}
+
+// ★ 周期任务的**常规**结果必须是 task 级（默认折叠），异常必须是 warn/error。
+//
+// 判据咬的是"这些具体调用点被降级了"，而不是"存在 task 这个词" ——
+// 后者只要有一处就为真，测不出"某个噪音源忘了降级"。
+func TestChannelsPeriodicTaskLogsAreDowngraded(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// 这些是「每次跑都成功」的常规回音 —— 必须 task 级
+	routine := []string{
+		`logEvent("模型目录已刷新（" .. updated .. " 个平台）", "task")`,
+		`logEvent("模型能力元数据已刷新（" .. tostring(cerr or 0) .. " 条）", "task")`,
+		`logEvent("模型刷新：跳过 " .. cooled .. " 个冷却中的平台", "task")`,
+	}
+	for _, r := range routine {
+		if !strings.Contains(s, r) {
+			t.Errorf("周期任务的常规结果必须降级为 task（否则会淹没用户动作）：\n  %s", r)
+		}
+	}
+	// 这些是异常 —— 必须 warn（不能被一起折叠掉）
+	for _, pat := range []string{
+		`logEvent("能力元数据未刷新: " .. plugin.utf8Clip(cerr, 120), "warn")`,
+		`logEvent("能力元数据刷新异常: " .. plugin.utf8Clip(cres, 120), "warn")`,
+		`logEvent("凭据续期失败 " .. #failed .. " 个：`,
+	} {
+		if !strings.Contains(s, pat) {
+			t.Errorf("异常必须保持 warn（不能被当常规噪音折叠）：%s", pat)
+		}
+	}
+	// 「已同步源」是周期重同步的常规回音 —— 降级为 task
+	if !strings.Contains(s, `logEvent("已同步源 " .. name .. "（" .. #models .. " 模型）", "task", provider)`) {
+		t.Error("「已同步源」是周期重同步的常规回音，必须 task 级且带平台归属")
+	}
+	t.Log("✓ 周期噪音已降级，异常保持 warn")
+}
+
+// ★ 前端的三个过滤维度必须都在（级别门槛 / 例行折叠 / 按渠道过滤）。
+func TestChannelsLogPanelHasFilters(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// ① 日志卡片必须**独立于渠道详情**（C 的核心：修正归属）
+	//    判据：日志卡片的 DOM 不是 ch-detail 的子元素。
+	//    做法：取 ch-detail 开始到 ch-log-card 之间的片段，要求中间出现过
+	//    ch-detail 的闭合（即两者是兄弟而非父子）。
+	iDetail := strings.Index(s, `id="ch-detail"`)
+	iLogCard := strings.Index(s, `id="ch-log-card"`)
+	if iDetail < 0 || iLogCard < 0 {
+		t.Fatal("找不到 ch-detail 或 ch-log-card（判据需更新）")
+	}
+	if iLogCard < iDetail {
+		t.Fatal("运行日志卡片应在渠道详情**之后**（作为兄弟节点）")
+	}
+	// 统计 ch-detail 打开到日志卡片之间未闭合的 div 层数
+	seg := s[iDetail:iLogCard]
+	depth := 0
+	for _, m := range regexp.MustCompile(`</?div`).FindAllString(seg, -1) {
+		if strings.HasPrefix(m, "</") {
+			depth--
+		} else {
+			depth++
+		}
+	}
+	if depth > 0 {
+		t.Errorf("运行日志卡片仍嵌在渠道详情内部（depth=%d）⇒ 点开某渠道会看到别的渠道的日志（归属错误）", depth)
+	}
+
+	// ② 三个过滤维度
+	for _, id := range []string{`id="ch-log-verbose"`, `id="ch-log-level"`} {
+		if !strings.Contains(s, id) {
+			t.Errorf("缺少日志视图控件 %s", id)
+		}
+	}
+	if !strings.Contains(s, "function chLogRender()") {
+		t.Error("必须实现 chLogRender()（否则过滤逻辑无处落地）")
+	}
+	// ③ 按渠道过滤 + 切渠道重渲染
+	if !strings.Contains(s, "if (selPlat) return e.platform === selPlat;") {
+		t.Error("必须按当前选中渠道过滤日志（否则归属错误以另一种形式回来）")
+	}
+	if !strings.Contains(s, "chLogRender();\n  };\n") {
+		t.Error("chSelect 切换渠道后必须重渲染日志")
+	}
+	t.Log("✓ 日志面板独立成卡片，三个过滤维度齐备")
+}
+
+// ★ 日志截断必须按**字符**切，不能按字节 —— 否则中文被切出无效 UTF-8。
+//
+// 真实缺陷（生产实测，v2.0.33 截图里可见）：日志尾显示成
+//
+//	`能力增强不<E5BCBA>`
+//
+// 根因：`tostring(cerr):sub(1, 120)` —— Lua 的 sub 按**字节**切，而中文占 3 字节
+// ⇒ 切在字符中间产生替换字符（U+FFFD）。一句本来完整的诊断看起来像数据损坏。
+func TestLogTruncationIsUTF8Safe(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+
+	// ① 必须存在按字符截断的助手
+	if !strings.Contains(s, "plugin.utf8Clip = function(s, maxBytes)") {
+		t.Fatal("必须实现 plugin.utf8Clip（按字符截断）")
+	}
+	// ② 中文文案上的截断不得再用裸 sub()
+	for _, bad := range []string{
+		`tostring(cres):sub(1, 120)`,
+		`tostring(cerr):sub(1, 120)`,
+		`table.concat(failed, "; "):sub(1, 300)`,
+	} {
+		if strings.Contains(s, bad) {
+			t.Errorf("中文文案的截断不能用裸 sub()（按字节切会产生 U+FFFD）：%s", bad)
+		}
+	}
+	// ③ 三处必须已换成 utf8Clip
+	for _, want := range []string{
+		"plugin.utf8Clip(cres, 120)",
+		"plugin.utf8Clip(cerr, 120)",
+		`plugin.utf8Clip(table.concat(failed, "; "), 300)`,
+	} {
+		if !strings.Contains(s, want) {
+			t.Errorf("缺少 UTF-8 安全截断调用：%s", want)
+		}
+	}
+	// ④ 助手必须**只在超长时**才截断（否则正常文案会被莫名缩短）
+	if !strings.Contains(s, "if #s <= maxBytes then return s end") {
+		t.Error("utf8Clip 必须对未超长的输入原样返回")
+	}
+	// ⑤ 回退逻辑必须处理续字节（10xxxxxx）与孤立首字节
+	if !strings.Contains(s, "elseif b >= 0xC0 then") {
+		t.Error("utf8Clip 必须回退孤立的 UTF-8 首字节（否则末尾仍是半个字符）")
+	}
+	t.Log("✓ 截断已 UTF-8 安全")
+}

internal/core/channels_lua_locals_test.go

@@ -0,0 +1,73 @@
+package core
+
+import (
+	"os/exec"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// ★ channels.lua 必须留出顶层 local 余量 —— 否则**下一次顶层改动就编译失败**。
+//
+// 实测事实（2026-10-16）：该文件的主 chunk 曾**顶到 Lua 上限 200**，
+// 往顶部加**哪怕 1 个**顶层 local 就报
+//
+//	main function has more than 200 local variables
+//
+// 而这炸的不是某个功能 —— 是**整个渠道插件**（插件加载失败 ⇒ 全渠道不可用）。
+//
+// ⚠️ 判据为什么用 luajit 而不是 luac：
+//
+//	内核链接的是 libluajit-5.1.so.2；而 `luac`（Lua 5.4）对同一文件给出
+//	**不同的**结论。用错工具会得到假绿。
+//
+// ⚠️ 判据为什么是「注入 N 个 local 仍能编译」而不是「数一遍 local」：
+//
+//	主 chunk 的 local 数受**作用域嵌套**影响，静态计数不可靠（同一个文件
+//	用不同脚本数出 228/232/248 三个数）。而"能不能再加"是**决定性**的，
+//	也正是我们真正需要的性质。
+func TestChannelsLuaHasLocalHeadroom(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := exec.LookPath("luajit"); err != nil {
+		t.Skip("luajit 不在 PATH（判据需要与内核相同的 Lua 实现）")
+	}
+
+	const headroom = 10
+	for _, n := range []int{1, headroom} {
+		probe := strings.Repeat("local __headroom = 1\n", n) + src
+		cmd := exec.Command("luajit", "-e", "local f,e=loadfile(arg[1]); if not f then io.stderr:write(tostring(e)) os.exit(1) end", "/dev/stdin")
+		cmd.Stdin = strings.NewReader(probe)
+		if out, err := cmd.CombinedOutput(); err != nil {
+			t.Fatalf("★ 顶层 local 余量不足：加 %d 个 local 就无法编译 ⇒ "+
+				"下一次顶层改动会**整插件加载失败**（全渠道不可用）\n  %s\n"+
+				"修法：把纯常量收进 plugin.K 表（挂表字段不占 local 槽位）", n, strings.TrimSpace(string(out)))
+		}
+	}
+	t.Logf("✓ channels.lua 仍有 ≥%d 个顶层 local 余量", headroom)
+}
+
+// 配对判据：常量必须确实在 plugin.K 里（防止有人把余量"省"出来的同时又
+// 把常量改回裸 local —— 那会让下一个改动的余量再次归零）。
+func TestChannelsConstantsLiveInPluginK(t *testing.T) {
+	src, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(src)
+	if !strings.Contains(s, "plugin.K = {") {
+		t.Fatal("必须有 plugin.K 常量表（它是 local 余量的来源）")
+	}
+	// 抽样：这些曾占用 local 槽位的纯常量必须已挂表
+	for _, n := range []string{"STORE_NAME", "SESSION_TTL", "B64_ALPHABET", "MODELS_DEV_URL"} {
+		if !regexp.MustCompile(`(?m)^\s+` + n + ` = `).MatchString(s) {
+			t.Errorf("%s 应定义在 plugin.K 表内", n)
+		}
+		if regexp.MustCompile(`(?m)^local ` + n + ` = `).MatchString(s) {
+			t.Errorf("%s 又变回裸 local 了（会吃掉 local 余量）", n)
+		}
+	}
+	t.Log("✓ 纯常量已集中在 plugin.K")
+}

internal/core/channels_orphan_source_test.go

@@ -0,0 +1,169 @@
+package core
+
+import (
+	"testing"
+)
+
+// ★ 孤儿源必须能被识别、且**只删该删的**。
+//
+// 真实事故（2026-10-17 生产实测）：`channels-buddy-585b335b64cf` 的账号早已删除，
+// 源却仍在 config.yaml 里对外服务 —— 独占服务 hy4-preview-x（404），
+// 对 6 个共享模型则排在正常源**前面**先被尝试（每次白付 ~3.4s 上游往返）。
+//
+// 这是 v2.0.28（remove_source 漏声明）的**存量残骸**：修声明只防新增，不清理存量。
+func TestChannelsReapOrphanSources(t *testing.T) {
+	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.Fatalf("加载插件: %v", err)
+	}
+	// 生产里 channels 被授予这些（见 plugin.kernel 声明）；夹具必须同样授权，
+	// 否则 add_source 会被拒 ⇒ 造不出孤儿源。
+	if err := ps.SetPluginKernelPermission("channels",
+		[]string{"add_source", "remove_source", "list_sources", "status"}, false); err != nil {
+		t.Fatalf("授权: %v", err)
+	}
+
+	// 装载前先清空账号池：这样插件初始化流程自己注册的源也一并算孤儿。
+	cleanup := func() interface{} {
+		r, err := ps.Call("channels", "reap_orphan_sources", map[string]interface{}{
+			"dry_run": false,
+		})
+		if err != nil {
+			t.Fatalf("reap_orphan_sources: %v", err)
+		}
+		return r
+	}
+	cleanup()
+
+	// 造出**真实形态**：走 account_add 登记账号（它会注册源），
+	// 再用 hidden 探针把账号从池里摘掉 —— 模拟 v2.0.28 事故的残留形态
+	// （账号已删、撤源被拒 ⇒ 源留下继续对外服务）。
+	// 不走 account_delete：那条路径的收尾已被 TestAccountDelete* 覆盖，
+	// 而我们要的恰恰是"源留下了"这个状态。
+	if r, err := ps.Call("channels", "account_add", map[string]interface{}{
+		"platform": "buddy", "account_id": "deadbeef1234", "credential": "test-cred",
+	}); err != nil {
+		t.Fatalf("account_add: %v", err)
+	} else if j := jsonOf(t, r); j["error"] != nil {
+		t.Fatalf("account_add 报错: %v", j["error"])
+	}
+	// ★ 第二个孤儿：账号 id **含 `-`**。这个用例是判别性的 ——
+	//   用 `name:match("^channels%-(.+)-(.+)$")` 解析会被 Lua 的**贪婪** `-`
+	//   切成 plat="buddy-dead"/acct="acct"（未知平台）⇒ 源被跳过 ⇒ **孤儿漏杀**。
+	//   （实测：只有这个用例能把"按已知平台前缀匹配"与"贪婪匹配"区分开；
+	//     不含 `-` 的 id 两种实现结果相同，咬不住。）
+	if r, err := ps.Call("channels", "account_add", map[string]interface{}{
+		"platform": "buddy", "account_id": "dead-acct-1", "credential": "test-cred",
+	}); err != nil {
+		t.Fatalf("account_add(2): %v", err)
+	} else if j := jsonOf(t, r); j["error"] != nil {
+		t.Fatalf("account_add(2) 报错: %v", j["error"])
+	}
+	// 运维手工源：名字与账号源形态无关 ⇒ 绝不碰
+	if r, err := ps.Call("channels", "__add_source_for_test", map[string]interface{}{
+		"name": "my-handmade-source", "base_url": "http://127.0.0.1:1",
+		"adapter": "openai", "models": []interface{}{"m1"},
+	}); err != nil {
+		t.Fatalf("注册手工源: %v", err)
+	} else if j := jsonOf(t, r); j["error"] != nil {
+		// ★ 必须看 json 里的 error：内核把失败放在返回体里，
+		//   Go 侧 err 仍是 nil ⇒ 只查 err 会让"源根本没注册"静默通过。
+		t.Fatalf("注册手工源报错: %v", j["error"])
+	}
+	// 摘账号（保留源）
+	for _, id := range []string{"deadbeef1234", "dead-acct-1"} {
+		if _, err := ps.Call("channels", "__forget_account_probe", map[string]interface{}{
+			"platform": "buddy", "account_id": id,
+		}); err != nil {
+			t.Fatalf("摘账号 %s: %v", id, err)
+		}
+	}
+
+	// ① dry_run（默认）只报告、不删
+	res, err := ps.Call("channels", "reap_orphan_sources", map[string]interface{}{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	j := jsonOf(t, res)
+	orphans, _ := j["orphans"].([]interface{})
+	seen := map[string]bool{}
+	for _, o := range orphans {
+		if s, _ := o.(string); s != "" {
+			seen[s] = true
+		}
+	}
+	for _, want := range []string{"channels-buddy-deadbeef1234", "channels-buddy-dead-acct-1"} {
+		if !seen[want] {
+			t.Fatalf("★ 没识别出孤儿源 %s（dry_run 应报告它）\n"+
+				"  若 id 含 `-` 的那个漏了 ⇒ 说明用了贪婪 match 解析名字，应改为按已知平台前缀匹配\n"+
+				"  实得 %v", want, seen)
+		}
+	}
+	if seen["my-handmade-source"] {
+		t.Fatalf("★ 误伤运维手工源（名字不匹配账号源形态，绝不能碰）")
+	}
+	if j["dry_run"] != true {
+		t.Fatalf("dry_run 必须默认开启（破坏性操作不得默认生效），实得 %v", j["dry_run"])
+	}
+	if j["removed"].(float64) != 0 {
+		t.Fatalf("dry_run=true 时不得真删，实得 removed=%v", j["removed"])
+	}
+
+	// ② 确认 dry_run 真的没删（看源列表）
+	after, err := ps.Call("channels", "__list_sources_probe", map[string]interface{}{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	names := sourceNames(jsonOf(t, after))
+	if !names["channels-buddy-deadbeef1234"] {
+		t.Fatalf("dry_run 竟真删了！源列表: %v", names)
+	}
+	// 手工源必须存活（名字不匹配账号源形态 ⇒ 不该被识别为孤儿）
+	if !names["my-handmade-source"] {
+		t.Fatalf("dry_run 时就丢了手工源？源列表: %v", names)
+	}
+
+	// ③ 真删：孤儿消失、手工源存活
+	res, err = ps.Call("channels", "reap_orphan_sources", map[string]interface{}{"dry_run": false})
+	if err != nil {
+		t.Fatal(err)
+	}
+	j = jsonOf(t, res)
+	if j["ok"] != true {
+		t.Fatalf("清理应成功，实得 %v", j)
+	}
+	after, err = ps.Call("channels", "__list_sources_probe", map[string]interface{}{})
+	if err != nil {
+		t.Fatal(err)
+	}
+	names = sourceNames(jsonOf(t, after))
+	for _, dead := range []string{"channels-buddy-deadbeef1234", "channels-buddy-dead-acct-1"} {
+		if names[dead] {
+			t.Fatalf("★ 孤儿源 %s 未被清掉（它会继续对外服务无凭据的请求）: %v", dead, names)
+		}
+	}
+	if !names["my-handmade-source"] {
+		t.Fatalf("★ 误删了运维手工源: %v", names)
+	}
+	t.Logf("✓ 孤儿源已清、手工源存活")
+}
+
+// sourceNames 把 __list_sources_probe 的返回摊平成 name→true。
+func sourceNames(j map[string]interface{}) map[string]bool {
+	out := map[string]bool{}
+	if arr, ok := j["sources"].([]interface{}); ok {
+		for _, x := range arr {
+			if m, ok := x.(map[string]interface{}); ok {
+				if s, ok := m["name"].(string); ok {
+					out[s] = true
+				}
+			}
+		}
+	}
+	return out
+}

internal/core/channels_remove_source_perm_test.go

@@ -48,6 +48,13 @@ func TestAccountDeleteRemovesItsSource(t *testing.T) {
 		if !strings.Contains(joined, "remove_source") {
 			t.Fatalf("记录里应点明是哪个内核动作被拒（便于给运维可操作提示），实得: %s", joined)
 		}
+		// ★ 必须带上**真正的原因**（not granted），而不是"无返回"这类空话。
+		//  内核桥失败时**第一个返回值是 nil、原因在第二个返回值里** ——
+		//  只接第一个返回值就会把原因丢掉（我第一版正是如此）。
+		if !strings.Contains(joined, "not granted") {
+			t.Fatalf("记录里必须含内核给出的**真实原因**（not granted），"+
+				"否则运维无从下手（只接 call 的第一个返回值就会丢掉原因）；实得: %s", joined)
+		}
 		t.Logf("✓ 撤源失败已可见: %s", joined)
 	})
 }

internal/core/channels_trae_chat_headers_test.go

@@ -0,0 +1,117 @@
+package core
+
+import (
+	"strings"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ TRAE 的**推理请求**必须用 Cloud-IDE-JWT 头族，不是 Bearer。
+//
+// 真实缺陷（用户报「无法使用 channel 注册的模型」，2026-10-17）：
+//
+//	Doubao-Seed-2.1-Pro / seed-code-pro-0430 / glm-5-turbo 全部
+//	401「We're sorry, but we are not able to authenticate you」
+//	因为 channels-trae 适配器**只有 4 个 transform、没有 build_headers**
+//	⇒ 内核兜底发 `Authorization: Bearer <api_key>`。
+//
+// 参考 trae.ts 端点表：对话也是 Cloud-IDE-JWT（traeSOLOHeaders）。
+//
+// ★ 这与「额度不可用」是**同一根因的两个出口**：额度端点（checkin_status /
+//
+//	balance）漏了头、已修；推理端点（本判据）也漏了，但当时没一起修。
+//	⇒ 教训：修「某一族请求的鉴权」时必须把所有**该族的出口**列出来逐个对齐。
+func TestTraeChatHeadersUseCloudIDEJWT(t *testing.T) {
+	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.Fatalf("加载插件: %v", err)
+	}
+
+	// 走真实的 BuildHeaders（内核调用适配器的那条路径）
+	hdrs, err := c.VM().BuildHeaders("channels-trae", map[string]interface{}{
+		"api_key": "ACCESS-TOKEN-X",
+		"source": map[string]interface{}{
+			"name": "channels-trae-test",
+			"meta": map[string]interface{}{
+				"uid":        "3428695215186675",
+				"device_id":  "dev-abc",
+				"machine_id": "mach-xyz",
+			},
+		},
+	})
+	if err != nil {
+		t.Fatalf("BuildHeaders: %v", err)
+	}
+	auth := hdrs["Authorization"]
+	if !strings.HasPrefix(auth, "Cloud-IDE-JWT ") {
+		t.Fatalf("★ 推理请求鉴权必须是 Cloud-IDE-JWT，实得 %q\n"+
+			"  用 Bearer 会得到 401「not able to authenticate you」，"+
+			"表现为「channel 注册的模型全都不能用」", auth)
+	}
+	if !strings.Contains(auth, "ACCESS-TOKEN-X") {
+		t.Fatalf("Authorization 应携带 access_token，实得 %q", auth)
+	}
+	// 设备身份头必须来自 meta（适配器沙箱读不到凭据）
+	for k, want := range map[string]string{
+		"X-Uid":        "3428695215186675",
+		"X-Device-Id":  "dev-abc",
+		"X-Machine-Id": "mach-xyz",
+	} {
+		if got := hdrs[k]; got != want {
+			t.Fatalf("★ %s 应为 %q（来自源 meta），实得 %q", k, want, got)
+		}
+	}
+	// 参考 traeSOLOHeaders 的成对 token 头
+	for _, k := range []string{"X-Cloudide-Token", "X-Ide-Token"} {
+		if hdrs[k] != "ACCESS-TOKEN-X" {
+			t.Fatalf("%s 应与 access_token 相同，实得 %q", k, hdrs[k])
+		}
+	}
+	t.Logf("✓ trae 推理头: %s（X-Uid=%s）", auth, hdrs["X-Uid"])
+}
+
+// 配对判据：源 meta 缺失时不得崩、也要给出 Cloud-IDE-JWT（只是没有设备头）。
+func TestTraeChatHeadersTolerateMissingMeta(t *testing.T) {
+	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)
+	}
+	hdrs, err := c.VM().BuildHeaders("channels-trae", map[string]interface{}{
+		"api_key": "T",
+	})
+	if err != nil {
+		t.Fatalf("BuildHeaders 不该因缺 meta 报错: %v", err)
+	}
+	if !strings.HasPrefix(hdrs["Authorization"], "Cloud-IDE-JWT ") {
+		t.Fatalf("即使没有 meta 也必须是 Cloud-IDE-JWT，实得 %q", hdrs["Authorization"])
+	}
+}
+
+// ★ 源必须携带设备身份（meta），否则适配器拿不到 uid。
+func TestTraeSourceCarriesDeviceIdentityInMeta(t *testing.T) {
+	b, err := readBundledChannels(t)
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(b)
+	if !strings.Contains(s, "source_meta_from_credential") {
+		t.Fatal("trae 平台应声明 source_meta_from_credential=true —— " +
+			"否则源的 meta 为空、适配器无法派生 X-Uid / X-Device-Id")
+	}
+	if !strings.Contains(s, "src.meta") {
+		t.Fatal("syncAccountSource 应把设备身份写进 src.meta")
+	}
+}
+
+var _ = lua.HandlerRequest{}

internal/core/channels_trae_credits_hdr_test.go

@@ -0,0 +1,71 @@
+package core
+
+import (
+	"strings"
+	"testing"
+)
+
+// ★ TRAE 的**签到状态 / 积分余额**必须用 Cloud-IDE-JWT + 设备身份头，
+// 不能用默认的 `Authorization: Bearer`。
+//
+// 真实缺陷（用户报「显示额度不可用」，2026-10-17）：
+//
+//	同一账号**签到领取成功**（claim_fn 走 traceCheckinHeaders），
+//	但 credits/status 返回
+//	  "We're sorry, but we are not able to authenticate you..."
+//	因为 checkin_status / balance 既没 auth 也没 headers_fn
+//	⇒ fetchAccountJSON 退回默认 Bearer。
+//
+// 参考 trae.ts 端点表逐行写明这三个端点都是 Cloud-IDE-JWT。
+//
+// ⚠️ 只加 `auth = "cloud-ide-jwt"` **没用**：该字段只被 claim_fn 的绑定循环
+//
+//	读取（line ~9033），fetchAccountJSON 只认 headers_fn —— 第一版我就只加了
+//	声明，等于没改。
+//
+// ⚠️ 为什么不用 httptest 假上游断言：那需要 set_endpoints 改 URL + 凭据落到
+//
+//	池账号 ref + 路径匹配全部对齐，任一环节错都会让"没发请求"看起来像
+//	"头不对"（我在这上面耗了三轮，全是夹具问题）。判据直接咬**被测对象**：
+//	spec.headers_fn 的产出。
+func TestTraeCreditsEndpointsUseCloudIDEJWT(t *testing.T) {
+	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.Fatalf("加载插件: %v", err)
+	}
+
+	// 通过真实函数取 trae 的两个 spec 的 headers_fn 产出。
+	// 凭据带 uid ⇒ 设备身份头由 uid 确定性派生。
+	out, err := ps.Call("channels", "__cred_headers_probe", map[string]interface{}{
+		"platform": "trae",
+		"credential": `{"access_token":"ACCESS-X","uid":"3428695215186675",` +
+			`"device_id":"d1","machine_id":"m1"}`,
+	})
+	if err != nil {
+		t.Fatalf("__cred_headers_probe: %v", err)
+	}
+	j := jsonOf(t, out)
+	for _, which := range []string{"checkin_status", "balance"} {
+		h, ok := j[which].(map[string]interface{})
+		if !ok {
+			t.Fatalf("探针应回报 %s 的头，实得 %v", which, j)
+		}
+		auth, _ := h["Authorization"].(string)
+		if !strings.HasPrefix(auth, "Cloud-IDE-JWT ") {
+			t.Fatalf("★ %s 的鉴权必须是 Cloud-IDE-JWT，实得 %q\n"+
+				"  用默认 Bearer 会得到「not able to authenticate you」，"+
+				"而同一账号的签到领取却是成功的 —— 这个矛盾就是缺陷", which, auth)
+		}
+		for _, k := range []string{"X-Device-Id", "X-Market-User-Id", "X-User-Region"} {
+			if v, _ := h[k].(string); v == "" {
+				t.Fatalf("★ %s 缺 %s —— 参考实测简化头会失败", which, k)
+			}
+		}
+		t.Logf("✓ %s: %s (device=%v)", which, auth, h["X-Device-Id"])
+	}
+}

internal/core/channels_trae_exchange_shape_test.go

@@ -0,0 +1,124 @@
+package core
+
+import (
+	"fmt"
+	"strings"
+	"sync/atomic"
+	"testing"
+
+	"llmsproxy/internal/lua"
+)
+
+// ★ TRAE ExchangeToken 的凭据在 **Result 里**，不在顶层。
+//
+// 真实缺陷（用户报「trae 登录还是不行」，2026-10-17）：
+//
+//	会话落定为 state=failed，message = "TRAE ExchangeToken 响应缺少 Token"
+//	而实测上游 HTTP 200，body 是：
+//	  {"ResponseMetadata":{...},"Result":{"Token":"eyJ...","RefreshToken":"..."}}
+//	代码读 `rec.Token` ⇒ 恒 nil ⇒ 误报「缺少 Token」。
+//	参考 parseTraeExchangeResponse 明确先取 `data.Result ?? data.result`。
+//
+// ★★ 为什么此前所有 trae 判据都是绿的（这个缺陷藏了很久的原因）：
+//
+//	**测试夹具返回的是扁平 `{"Token":...}`** —— 与生产形状不一致，
+//	于是「只读顶层」这个错误在夹具里恰好是对的。夹具形状错 = 判据必然虚假通过。
+//	已把夹具改成真实 Result 形状（channels_trae_test.go）。
+//
+// 本判据直接用**两种形状**分别打一次，确保实现同时认 Result 与顶层兜底。
+func TestTraeExchangeReadsResultEnvelope(t *testing.T) {
+	cases := []struct {
+		name string
+		body string
+		want string
+	}{
+		{
+			name: "生产形状：凭据在 Result 里",
+			body: `{"ResponseMetadata":{"RequestId":"x"},"Result":{"Token":"ACCESS-FROM-RESULT",` +
+				`"RefreshToken":"RT-ROTATED","TokenExpireAt":1800000000000}}`,
+			want: "ACCESS-FROM-RESULT",
+		},
+		{
+			name: "兜底：凭据在顶层（上游若改版）",
+			body: `{"Token":"ACCESS-FROM-TOP","RefreshToken":"RT-TOP"}`,
+			want: "ACCESS-FROM-TOP",
+		},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			h := newTraeHarness(t)
+			// 覆盖夹具的响应体为这个形状
+			atomic.StoreInt32(&h.exchOK, 1)
+			h.overrideExchangeBody(tc.body)
+
+			// ★ 必须走**池路径**（UI 真实流程）：先建占位账号再带 account_id
+			//   发登录。beginAndCallback 不带 account_id ⇒ 凭据落到
+			//   `channels:trae`（无池账号），也就无法回读 —— 我第一版就这么写，
+			//   判据报"池里应有账号，实得 0"，与真因（形状）无关。
+			aid, nonce := h.addAccountAndStartLogin("trae")
+			status, body := h.invokeCallback(map[string]string{
+				"state": nonce, "refreshToken": "RT-FROM-CALLBACK",
+				"userInfo": `{"UserID":"u1","ScreenName":"tester","TenantID":"t1"}`,
+			})
+			if status != 200 {
+				t.Fatalf("回调应成功：status=%d body=%s", status, body)
+			}
+			if strings.Contains(body, "缺少 Token") {
+				t.Fatalf("★ 又没解出 Token（形状=%s）—— 检查是否只读了顶层", tc.name)
+			}
+			// 凭据必须真的落进 secrets，且新 refresh 被轮换保存。
+			// ⚠️ 账号 id 是**随机生成**的（account_add 用 newToken():sub(1,12)），
+			//    不能硬编码 —— 用 account_list 拿真实 id。
+			cred := h.credentialFor(aid)
+			if !strings.Contains(cred, tc.want) {
+				t.Fatalf("落盘凭据里应有 access token %q，实得 %q", tc.want, cred)
+			}
+			if !strings.Contains(cred, "refresh_token") {
+				t.Fatalf("★ 轮换后的 refreshToken 必须保存 —— 旧 refresh 已被上游作废，"+
+					"不存新值会让下次续期必然失败。实得 %q", cred)
+			}
+			t.Logf("✓ %s → access=%s", tc.name, tc.want)
+		})
+	}
+}
+
+// overrideExchangeBody 让夹具的 ExchangeToken 返回指定 body。
+func (h *traeHarness) overrideExchangeBody(body string) {
+	h.t.Helper()
+	h.exchBody = body
+}
+
+// credentialFor 读回某账号落盘的凭据原文。
+//
+// 用 Plugins.GetSecret（内核级读取）而不是 __read_cred_probe：
+// 探针那版我传错过入参（它吃 ref），返回 len:0，让判据看起来像"凭据没落盘"。
+// GetSecret 是 TestTraeCallbackPoolPath 已在用的正规入口。
+// addAccountAndStartLogin 建占位账号并带 account_id 发起登录，返回 (账号id, nonce)。
+// 这是 UI 真实流程（见 TestTraeCallbackPoolPath）。
+func (h *traeHarness) addAccountAndStartLogin(platform string) (string, string) {
+	h.t.Helper()
+	add, err := h.ps.InvokeHandler("channels", "account_add", &lua.HandlerRequest{
+		Method: "POST", Body: fmt.Sprintf(`{"platform":%q}`, platform),
+	})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	aid, _ := add.JSON.(map[string]interface{})["account_id"].(string)
+	out, err := h.ps.InvokeHandler("channels", "start_login", &lua.HandlerRequest{
+		Method: "POST", Body: fmt.Sprintf(`{"platform":%q,"account_id":%q}`, platform, aid),
+	})
+	if err != nil {
+		h.t.Fatal(err)
+	}
+	nonce, _ := out.JSON.(map[string]interface{})["session"].(map[string]interface{})["nonce"].(string)
+	return aid, nonce
+}
+
+func (h *traeHarness) credentialFor(accountID string) string {
+	h.t.Helper()
+	v, ok, err := h.ps.GetSecret("channels", "channels:trae:"+accountID)
+	if err != nil || !ok {
+		return ""
+	}
+	return v
+}

internal/core/channels_trae_solo_sse_test.go

@@ -0,0 +1,130 @@
+package core
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// ★ TRAE 的流式转换必须把 **SOLO 自定义 SSE** 摊平成内核要的 **UnifiedChunk**。
+//
+// 真实缺陷（用户报「无法使用 channel 注册的模型」，2026-10-17）：
+//
+//	① 我原先 `return __prelude.openai_stream_chunk(raw_chunk)` —— SOLO 帧形如
+//	   {"response":"###","reasoning_content":null,"tool_calls":null}
+//	   没有 `choices` 字段 ⇒ 每帧都解析不出 ⇒ 上游 HTTP 200 + 118 正常帧，
+//	   客户端却得到 `empty stream`。
+//	② 修了 ① 之后我返回 OpenAI 外壳 `{choices:[{delta:{...}}]}` —— 仍不对：
+//	   内核 `json.Unmarshal(unified, &UnifiedChunk)` 直接解成**扁平结构**，
+//	   外壳字段全被丢弃 ⇒ 91 帧全是空 content。
+//
+// ⚠️ 内核只把 `data:` 行交给适配器（`event:` 行在 provider.go 被丢弃），
+//
+//	因此判别帧类型只能靠内容特征。
+func TestTraeSoloSSEToUnifiedChunk(t *testing.T) {
+	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)
+	}
+
+	// ① 正文帧 → content（**扁平**，不是 choices[].delta）
+	out, err := c.VM().Transform("channels-trae", "transform_stream_chunk",
+		`{"response":"Hello","reasoning_content":null,"tool_calls":null}`)
+	if err != nil {
+		t.Fatalf("transform: %v", err)
+	}
+	var ck map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &ck); err != nil {
+		t.Fatalf("产出不是 JSON: %q", out)
+	}
+	if got, _ := ck["content"].(string); got != "Hello" {
+		t.Fatalf("★ 正文必须摊平到顶层 content，实得 %q（原始产出 %s）\n"+
+			"  返回 {choices:[{delta:...}]} 外壳会被内核丢弃", got, out)
+	}
+	if _, has := ck["choices"]; has {
+		t.Fatalf("★ 不得返回 OpenAI 外壳（choices）—— 内核按 UnifiedChunk 解析，外壳会被忽略: %s", out)
+	}
+
+	// ② 推理帧 → reasoning_content
+	out, err = c.VM().Transform("channels-trae", "transform_stream_chunk",
+		`{"response":"","reasoning_content":"We","tool_calls":null}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(out), &ck); err != nil {
+		t.Fatalf("推理帧产出不是 JSON: %q", out)
+	}
+	if got, _ := ck["reasoning_content"].(string); got != "We" {
+		t.Fatalf("★ 推理必须进 reasoning_content，实得 %q（%s）", got, out)
+	}
+
+	// ③ done 帧
+	out, err = c.VM().Transform("channels-trae", "transform_stream_chunk", `{"finish_reason":"stop"}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(out), &ck); err != nil {
+		t.Fatalf("done 帧产出不是 JSON: %q", out)
+	}
+	if ck["done"] != true {
+		t.Fatalf("★ done 帧必须 done=true，实得 %s", out)
+	}
+	if ck["finish_reason"] != "stop" {
+		t.Fatalf("finish_reason 应为 stop，实得 %s", out)
+	}
+
+	// ④ usage 帧
+	out, err = c.VM().Transform("channels-trae", "transform_stream_chunk",
+		`{"prompt_tokens":10,"completion_tokens":5,"total_tokens":15}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := json.Unmarshal([]byte(out), &ck); err != nil {
+		t.Fatalf("usage 帧产出不是 JSON: %q", out)
+	}
+	u, _ := ck["usage"].(map[string]interface{})
+	if u == nil || u["total"] != 15.0 {
+		t.Fatalf("★ usage 必须摊平为 {prompt,completion,total}，实得 %s", out)
+	}
+
+	// ⑤ 工具调用：function_call → function 归一化
+	out, err = c.VM().Transform("channels-trae", "transform_stream_chunk",
+		`{"response":"","reasoning_content":null,"tool_calls":[{"function_call":{"name":"f","arguments":"{}"}}]}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(out, "function_call") {
+		t.Fatalf("★ SOLO 的 function_call 必须归一化为 function，实得 %s", out)
+	}
+	if !strings.Contains(out, `"function"`) {
+		t.Fatalf("工具调用缺 function 字段: %s", out)
+	}
+	t.Logf("✓ SOLO SSE 全部摊平正确")
+}
+
+// 配对判据：无关帧不得产出垃圾。
+func TestTraeSoloSSEDropsUnknownFrames(t *testing.T) {
+	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)
+	}
+	// metadata 帧（上游确实会发，且无正文）
+	out, err := c.VM().Transform("channels-trae", "transform_stream_chunk",
+		`{"model":"","session_id":"abc","prompt_completion_id":0}`)
+	if err != nil {
+		t.Fatalf("metadata 帧不该报错: %v", err)
+	}
+	if out != "" {
+		t.Fatalf("无正文的 metadata 帧应产出空串（不制造垃圾帧），实得 %q", out)
+	}
+}

internal/core/channels_trae_test.go

@@ -16,11 +16,12 @@ import (
 // traeHarness：TRAE callback 流的测试台。假上游模拟 ExchangeToken；
 // 回调用 InvokeHandler 直打 oauth_callback（Query 表 = 平台重定向回来的参数）。
 type traeHarness struct {
-	t       *testing.T
-	ps      *lua.Plugins
-	ts      *httptest.Server
-	exchHit int32
-	exchOK  int32 // 1=成功 0=失败（atomic）
+	t        *testing.T
+	ps       *lua.Plugins
+	ts       *httptest.Server
+	exchHit  int32
+	exchOK   int32  // 1=成功 0=失败（atomic）
+	exchBody string // 非空时覆盖夹具的响应体（供形状判据用）
 }
 
 func newTraeHarness(t *testing.T) *traeHarness {
@@ -45,7 +46,23 @@ func newTraeHarness(t *testing.T) *traeHarness {
 				t.Errorf("ExchangeToken 请求体缺 %s: %s", want, body)
 			}
 		}
-		fmt.Fprintf(w, `{"Token":"ACCESS-%d","RefreshToken":"RT-NEW-%d"}`, n, n)
+		// ★★ 必须是**真实上游的形状**：凭据在 `Result` 里，不在顶层。
+		//
+		// 实测（2026-10-17 用真实 refreshToken 直打 ExchangeToken）：
+		//   {"ResponseMetadata":{...},"Result":{"Token":"eyJ...","RefreshToken":"...",
+		//    "TokenExpireAt":...,"RefreshExpireAt":...}}
+		//
+		// ⚠️ 这条夹具原先返回**扁平** `{"Token":...}` —— 于是「代码只读顶层」
+		//    这个真缺陷被夹具**完美掩盖**：所有 trae 判据都绿，真实登录却报
+		//    「响应缺少 Token」。夹具形状与生产不一致 = 判据必然虚假通过。
+		if h.exchBody != "" {
+			fmt.Fprint(w, h.exchBody)
+			return
+		}
+		fmt.Fprintf(w, `{"ResponseMetadata":{"RequestId":"r%d"},`+
+			`"Result":{"ClientID":"en1oxy7wnw8j9n","Token":"ACCESS-%d",`+
+			`"RefreshToken":"RT-NEW-%d","TokenExpireAt":1800000000000,`+
+			`"TokenExpireDuration":1209600000,"RefreshExpireAt":1807755929432}}`, n, n, n)
 	}))
 	t.Cleanup(h.ts.Close)
 

internal/core/channels_upstream_gaps_test.go

@@ -27,8 +27,12 @@ func TestUpstreamGapsAreDocumented(t *testing.T) {
 	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") {
+		// 明文端点（OpenAI 兼容）：参考 QODER_CHAT_PATH。
+		// ⚠ 断言 **URL 的两半**而不是那一整串字面量：本仓已把"路径从 base_url
+		// 移到 endpoint"（内核 URL = base_url + endpoint）—— 继续钉死整串会让
+		// 一个纯粹的形态重构把这条**语义**判据弄红，那是判据在咬自己。
+		if !strings.Contains(s, `base_url = "https://api2-v2.qoder.sh"`) ||
+			!strings.Contains(s, `endpoint = "/model/v1/chat/completions"`) {
 			t.Fatal("qoder 的 chat 端点变了 —— 若改成加密端点 agent_chat_generation，" +
 				"则**必须**同时实现信封解包（qoder-envelope）与 WASM 签名，" +
 				"否则响应会被当成畸形数据")

internal/core/channels_utf8clip_test.go

@@ -0,0 +1,38 @@
+package core
+
+import (
+	"testing"
+	"unicode/utf8"
+)
+
+// 行为验证（不只是静态断言）：utf8Clip 对中文截断后必须是合法 UTF-8。
+func TestUtf8ClipBehaviour(t *testing.T) {
+	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)
+	}
+
+	s := "能力元数据源 5.6MB 超过内核 4MiB 响应上限（刻意的堆保护，不为此放宽）—— 能力增强不可用，已退回兜底表"
+	for _, n := range []int{10, 40, 119, 120, 121, 400} {
+		out, err := ps.Call("channels", "__utf8_clip_probe", map[string]interface{}{"s": s, "n": n})
+		if err != nil {
+			t.Fatal(err)
+		}
+		got, _ := jsonOf(t, out)["out"].(string)
+		if !utf8.ValidString(got) {
+			t.Errorf("n=%d 结果不是合法 UTF-8: %q", n, got)
+		}
+		if n < len(s) && len(got) > n {
+			t.Errorf("n=%d 结果超出字节上限: %d", n, len(got))
+		}
+		if n >= len(s) && got != s {
+			t.Errorf("n=%d 未超长时应原样返回", n)
+		}
+		t.Logf("n=%-4d → %q (valid=%v, bytes=%d)", n, got, utf8.ValidString(got), len(got))
+	}
+}

internal/core/channels_zcode_identity_test.go

@@ -252,14 +252,16 @@ func TestZcodeAdapterKeepsAnthropicProtocolConversion(t *testing.T) {
 	})
 }
 
-// ★ 基座（anthropic.lua）读不到时必须**响亮失败**，不得静默退化。
+// ★ 基座（anthropic.lua）读不到时必须在**安装期响亮失败**，不得静默退化。
 //
 // 反例危害：若"尽力而为"（只注入身份块、不作协议转换），会产出一个身份块
 // 看着正确的请求，而 tools/图像/流式结构全未转换 —— 上游可能 200，但模型
 // 拿不到工具定义，症状是"模型变笨了"，与准入毫不相干，排查会完全跑偏。
 //
-// 判据看的是**适配器的真实产出**：把适配器目录指到空目录（基座不可得），
-// transform_request 必须返回错误而不是原样透传。
+// ⚠ 判据随设计更新（v2.0.37）：基座**不再由适配器自己读**（适配器沙箱没有
+//
+//	fs，那样必然失败且静默降级）。现在由**插件主体**读好并内联 ⇒ 基座不可得
+//	时应在**安装期**就失败（返回 err），而不是等到运行期才发现。
 func TestZcodeAdapterFailsLoudlyWithoutAnthropicBase(t *testing.T) {
 	// 隔离目录：插件目录下没有兄弟 adapters/ 目录 ⇒ 基座读不到
 	dir := t.TempDir()
@@ -278,21 +280,26 @@ func TestZcodeAdapterFailsLoudlyWithoutAnthropicBase(t *testing.T) {
 	if err := ps.LoadSource("channels", src); err != nil {
 		t.Fatal(err)
 	}
-	vm := c.VM()
-	if vm == nil {
-		t.Fatal("VM 不可用")
+	// 用空目录重新安装：基座不可得 ⇒ 必须**安装期**失败且原因点明 anthropic
+	res, err := ps.Call("channels", "__adapter_install_probe", map[string]interface{}{
+		"adapters_dir": filepath.Join(dir, "adapters-no-base"),
+	})
+	if err != nil {
+		t.Fatal(err)
 	}
-	// 插件自装时若基座读不到，适配器仍应装载（身份块是静态的），
-	// 但调用必须报错
-	out, err := vm.Transform("channels-zcode", "transform_request",
-		`{"model":"m","messages":[{"role":"user","content":"hi"}]}`)
-	if err == nil {
-		t.Fatalf("基座不可得时必须报错，却成功产出了：%s", out)
+	j := res.(map[string]interface{})["json"].(map[string]interface{})
+	zc, ok := j["zcode_reinstall"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("安装探针应回报 zcode_reinstall 结果，实得 %v", j)
 	}
-	if !strings.Contains(err.Error(), "基座") {
-		t.Fatalf("错误信息应点明基座问题（可定位），实得 %v", err)
+	if zc["ok"] == true {
+		t.Fatalf("基座不可得时安装必须失败（否则运行期才炸、且是逐帧炸），实得 %v", zc)
 	}
-	t.Logf("✓ 基座缺失时响亮失败: %v", err)
+	msg, _ := zc["err"].(string)
+	if !strings.Contains(msg, "anthropic") {
+		t.Fatalf("错误信息应点明基座问题（可定位），实得 %q", msg)
+	}
+	t.Logf("✓ 基座缺失时安装期响亮失败: %s", msg)
 }
 
 // ★ 日期块必须**幂等**：已以 <system-reminder> 开头则不重复插。

internal/lua/adapter_buddy_test.go

@@ -0,0 +1,116 @@
+package lua
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// loadBuddyAdapter 装载内置 buddy 适配器。
+func loadBuddyAdapter(t *testing.T) *VM {
+	t.Helper()
+	src, err := bundledAdapters.ReadFile("adapters/buddy.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	t.Cleanup(vm.Stop)
+	if err := vm.LoadAdapterSource("buddy", string(src)); err != nil {
+		t.Fatalf("装载失败: %v", err)
+	}
+	return vm
+}
+
+// ★ buddy 适配器：两个厂商要求，各有实测依据。
+//
+// ① glm-5.1 **必须**带非空 reasoning_effort（否则上游 400 + 11150）
+// ② 流式请求必须带 Accept: text/event-stream（否则只回空帧、completion_tokens=0）
+func TestBuddyAdapterEffortAndHeaders(t *testing.T) {
+	vm := loadBuddyAdapter(t)
+
+	// ① glm-5.1 → 补 medium
+	out, err := vm.Transform("buddy", "transform_request",
+		`{"model":"glm-5.1","messages":[{"role":"user","content":"hi"}],"max_tokens":100,"stream":true}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var b map[string]interface{}
+	if err := json.Unmarshal([]byte(out), &b); err != nil {
+		t.Fatalf("%v\n%s", err, out)
+	}
+	if b["reasoning_effort"] != "medium" {
+		t.Errorf("glm-5.1 必须补 reasoning_effort=medium（否则上游 11150），实得 %v", b["reasoning_effort"])
+	}
+
+	// ② 其它模型**不补**（避免把单模型要求扩成全平台行为）
+	out2, err := vm.Transform("buddy", "transform_request",
+		`{"model":"hy3","messages":[{"role":"user","content":"hi"}],"max_tokens":100,"stream":true}`)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var b2 map[string]interface{}
+	json.Unmarshal([]byte(out2), &b2)
+	if b2["reasoning_effort"] != nil {
+		t.Errorf("hy3 不该被补 reasoning_effort（实测不需要），实得 %v", b2["reasoning_effort"])
+	}
+
+	// ③ 调用方已给档位时**尊重它**
+	out3, _ := vm.Transform("buddy", "transform_request",
+		`{"model":"glm-5.1","messages":[{"role":"user","content":"hi"}],"reasoning_effort":"high","stream":true}`)
+	var b3 map[string]interface{}
+	json.Unmarshal([]byte(out3), &b3)
+	if b3["reasoning_effort"] != "high" {
+		t.Errorf("调用方给的档位必须保留，实得 %v", b3["reasoning_effort"])
+	}
+
+	// ④ 头：Accept 必须是 SSE
+	h, err := vm.BuildHeaders("buddy", map[string]interface{}{"api_key": "TOK"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if h["Accept"] != "text/event-stream" {
+		t.Errorf("Accept 必须是 text/event-stream（否则上游只回空帧），实得 %q", h["Accept"])
+	}
+	for _, k := range []string{"X-Domain", "X-Product", "X-Product-Code"} {
+		if h[k] == "" {
+			t.Errorf("缺少 buddy 身份头 %s", k)
+		}
+	}
+	t.Logf("✓ glm-5.1 补 effort；hy3 不补；Accept=%s", h["Accept"])
+}
+
+// 配对判据：协议转换必须与 openai 一致（buddy 只是补两个字段，不该改转换）。
+func TestBuddyAdapterKeepsOpenAIWire(t *testing.T) {
+	vm := loadBuddyAdapter(t)
+	chunk := `{"id":"x","object":"chat.completion.chunk","created":1,"model":"m","choices":[{"index":0,"delta":{"content":"hi","reasoning_content":"think"},"finish_reason":null}]}`
+	out, err := vm.Transform("buddy", "transform_stream_chunk", chunk)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !strings.Contains(out, `"content":"hi"`) || !strings.Contains(out, `"reasoning_content":"think"`) {
+		t.Errorf("流式转换必须保留 content 与 reasoning_content，实得 %s", out)
+	}
+}
+
+// ★ 回归护栏：适配器**必须**定义全部四个转换函数。
+//
+// 真实事故（2026-10-16）：我第一版把基座继承写成"在适配器里读兄弟适配器源码"，
+// 而适配器运行在**另一个沙箱 VM**（无 __llmsproxy_plugin_dir、无文件系统），
+// 于是基座加载**静默失败** ⇒ 适配器只有 transform_request，
+// **缺 transform_stream_chunk** ⇒ 内核无法解析 SSE ⇒ 上游明明回了 39 帧正文，
+// 网关却记 completion_tokens=0、客户端看到**空回复**。
+// 更糟的是：hy3/glm-5.3/kimi-k3-1 全被它弄坏，而 glm-5.2 因多源兜底
+// "看起来正常" ⇒ 症状指向错误方向。
+//
+// ⇒ 判据必须咬住「四个转换函数都存在」，而不是"某个模型能回话"
+//
+//	（后者会被别的源兜底掩盖 —— 本会话已栽过两次）。
+func TestBuddyAdapterDefinesAllTransforms(t *testing.T) {
+	vm := loadBuddyAdapter(t)
+	for _, fn := range []string{"transform_request", "transform_response", "transform_stream_chunk", "transform_error"} {
+		if !vm.HasFn("buddy", fn) {
+			t.Errorf("适配器缺 %s ⇒ 内核该路径会静默降级（流式会变成空回复）", fn)
+		}
+	}
+	t.Log("✓ 四个转换函数齐备")
+}

internal/lua/adapter_opencodezen_reasoning_test.go

@@ -0,0 +1,112 @@
+package lua
+
+import (
+	"encoding/json"
+	"strings"
+	"testing"
+)
+
+// loadZenVM 装载 opencodezen 适配器（照 adapter_opencodezen_test.go 的方式）。
+func loadZenVM(t *testing.T) *VM {
+	t.Helper()
+	src, err := bundledAdapters.ReadFile("adapters/opencodezen.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	vm := NewVM(t.TempDir())
+	t.Cleanup(vm.Stop)
+	if err := vm.LoadAdapterSource("opencodezen", string(src)); err != nil {
+		t.Fatalf("加载失败: %v", err)
+	}
+	return vm
+}
+
+// ★ assistant 回合的 reasoning_content **必须回传**给 opencode 上游。
+//
+// 真实缺陷（生产实测，2026-10-16）：
+//
+//	provider localzen: api error 400: Upstream request failed: [invalid_request_error]
+//	The `reasoning_content` in the thinking mode must be passed back to the API.
+//
+// 根因：transform_request 里写了 `msg.reasoning_content = nil`，理由是
+// "Zen 免费池不接受回传"。该假设**方向反了** —— 上游要的就是它。
+//
+// ★★ 这个缺陷极难归因，因为失败是**交替**出现的：
+// 只有当上一轮**真的产出了 reasoning**（thinking 模型 + reasoning_effort 开启）
+// 时，回放那段历史才会被拒；普通回合照常 200。审计里表现为成串 502 紧随一个
+// 成功的长上下文请求（实测 prompt_tokens=139330）之后。
+//
+// 判据必须**咬住「被剥掉」这个具体行为**，而不是"请求成功" —— 后者在
+// 非 thinking 回合下永远为真，测不出这个缺陷。
+func TestOpenCodeZenKeepsAssistantReasoningContent(t *testing.T) {
+	vm := loadZenVM(t)
+
+	body := map[string]interface{}{
+		"model":  "deepseek-v4.1-flash-free",
+		"stream": true,
+		"messages": []map[string]interface{}{
+			{"role": "user", "content": "1+1=?"},
+			{
+				"role":    "assistant",
+				"content": "2",
+				// 这段正是 agent 回放历史时会带上的东西
+				"reasoning_content": "一加一等于二。",
+			},
+			{"role": "user", "content": "再加一"},
+		},
+	}
+	raw, err := json.Marshal(body)
+	if err != nil {
+		t.Fatal(err)
+	}
+	out, err := vm.Transform("opencodezen", "transform_request", string(raw))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// 解析出站体，找 assistant 回合
+	var sent struct {
+		Messages []map[string]interface{} `json:"messages"`
+	}
+	if err := json.Unmarshal([]byte(out), &sent); err != nil {
+		t.Fatalf("出站体不是合法 JSON: %v\n%s", err, out)
+	}
+	var found bool
+	for _, m := range sent.Messages {
+		if m["role"] != "assistant" {
+			continue
+		}
+		found = true
+		rc, _ := m["reasoning_content"].(string)
+		if rc == "" {
+			t.Fatalf("assistant 回合的 reasoning_content 被剥掉了 ⇒ 上游会回 "+
+				"`The reasoning_content in the thinking mode must be passed back to the API`\n"+
+				"出站 messages: %s", out)
+		}
+		if rc != "一加一等于二。" {
+			t.Errorf("reasoning_content 被改写：%q", rc)
+		}
+	}
+	if !found {
+		t.Fatalf("没找到 assistant 回合（判据失效）\n%s", out)
+	}
+	t.Log("✓ assistant 的 reasoning_content 已保留")
+}
+
+// ★ 反向：**空的** reasoning_content 应被丢掉（不要把空串发给上游）。
+// 与上一条配对 —— 缺了这条，"改成无条件保留"这类过度修正不会被发现。
+func TestOpenCodeZenDropsEmptyReasoningContent(t *testing.T) {
+	vm := loadZenVM(t)
+
+	raw := `{"model":"m","stream":true,"messages":[
+	  {"role":"assistant","content":"hi","reasoning_content":""}
+	]}`
+	out, err := vm.Transform("opencodezen", "transform_request", raw)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if strings.Contains(out, `"reasoning_content":""`) {
+		t.Errorf("空的 reasoning_content 不该发给上游（多余字段，部分上游会挑），实得: %s", out)
+	}
+	t.Log("✓ 空 reasoning_content 已丢弃")
+}

internal/lua/adapter_prelude.go

@@ -343,6 +343,39 @@ function __prelude.openai_error(status, body)
     return resp.detail
   end
 
+  -- 7/8/9. 网关与腾讯系形状（实测漏过，见函数头注释）。
+  --     error_code 与 error_msg 同现时拼起来 —— 只看 msg 会丢掉可分类的码
+  --     （参考 llm-adapter.ts:531 把两者都放进 parts 再 join）。
+  local msg = nil
+  if type(resp.error_msg) == "string" and resp.error_msg ~= "" then
+    msg = resp.error_msg
+  elseif type(resp.msg) == "string" and resp.msg ~= "" then
+    msg = resp.msg
+  end
+  -- 腾讯系（buddy/workbuddy）用 msg + displayMsg.{zh,en}，且**没有** message。
+  -- 参考 buddy-adapter.ts:576 明确：本地化文案最可读，排在**最前**。
+  local localized = nil
+  if type(resp.displayMsg) == "table" then
+    local dm = resp.displayMsg
+    if type(dm.zh) == "string" and dm.zh ~= "" then localized = dm.zh
+    elseif type(dm.en) == "string" and dm.en ~= "" then localized = dm.en end
+  end
+  if msg then
+    local code = nil
+    if type(resp.error_code) == "string" and resp.error_code ~= "" then
+      code = resp.error_code
+    elseif resp.code ~= nil and type(resp.code) ~= "string" then
+      code = tostring(resp.code)
+    end
+    local detail = code and (code .. ": " .. msg) or msg
+    if localized then return localized .. " " .. detail end
+    return detail
+  end
+  if localized then return localized end
+  if type(resp.error_code) == "string" and resp.error_code ~= "" then
+    return resp.error_code
+  end
+
   return nil
 end
 

internal/lua/adapter_prelude_error_shapes_test.go

@@ -0,0 +1,99 @@
+package lua
+
+import (
+	"testing"
+)
+
+// ★ 上游错误体抽取必须覆盖**网关与腾讯系**形状 —— 这两类实测都漏过。
+//
+// 发现路径（2026-10-16 读生产日志）：
+//
+//	unhandled upstream error body (adapter "openai" lacks transform_error):
+//	  status=404 body={"error_msg":"404 Route Not Found"}
+//	unhandled upstream error body (adapter "buddy" lacks transform_error):
+//	  status=400 body={"code":11101,"msg":"Non-stream chat request is not supported"}
+//
+// 两者都是 `{"error_msg":...}` / `{"msg":...}` —— 旧实现只认
+// error/message/detail，于是返回 nil ⇒ 客户端只看到
+// `api error 404: unknown error`，而 body 里明明有可用文案。
+//
+// ⚠️ 那两个适配器**都定义了** transform_error（openai.lua:139、buddy.lua:166），
+// 内核却报 "lacks" ⇒ 一句会把排查带偏的诊断（已另行修正内核文案）。
+func TestPreludeErrorExtractionCoversGatewayShapes(t *testing.T) {
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	// 用**仓库里的真实** openai 适配器（含共享前导），不是自造桩：
+	// 判据必须走真实实现，否则"补了形状"这件事根本没被验。
+	src, err := bundledAdapters.ReadFile("adapters/openai.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := vm.LoadAdapterSource("openai", string(src)); err != nil {
+		t.Fatalf("装载 openai 适配器: %v", err)
+	}
+
+	cases := []struct {
+		name, body, want string
+	}{
+		{"APISIX error_msg",
+			`{"error_msg":"404 Route Not Found"}`, "404 Route Not Found"},
+		{"腾讯 msg（buddy 11101）",
+			`{"code":11101,"msg":"Non-stream chat request is currently not supported"}`,
+			"11101: Non-stream chat request is currently not supported"},
+		{"error_code + error_msg",
+			`{"error_code":"APIG.0301","error_msg":"verify ak sk signature fail"}`,
+			"APIG.0301: verify ak sk signature fail"},
+		{"腾讯 displayMsg 本地化（最可读，排最前）",
+			`{"code":11101,"msg":"Non-stream chat request is currently not supported",` +
+				`"displayMsg":{"en":"Invalid request. Please retry","zh":"请求内容不合法，请重试"}}`,
+			"请求内容不合法，请重试 11101: Non-stream chat request is currently not supported"},
+		{"仅 displayMsg",
+			`{"displayMsg":{"zh":"只有本地化文案"}}`, "只有本地化文案"},
+		{"仅 error_code",
+			`{"error_code":"InferHub.4291.200"}`, "InferHub.4291.200"},
+		// 回归：原有的 6 种形状不得丢
+		{"OpenAI 信封", `{"error":{"message":"boom"}}`, "boom"},
+		{"裸字符串 error", `{"error":"boom"}`, "boom"},
+		{"扁平 code/message", `{"message":"boom"}`, "boom"},
+		{"FastAPI detail", `{"detail":"boom"}`, "boom"},
+		{"HTML title", `<html><title>413 Too Large</title></html>`, "413 Too Large"},
+		{"裸文本", "plain failure line\nmore", "plain failure line"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			got, ok, err := vm.TransformError("openai", 400, c.body)
+			if err != nil {
+				t.Fatalf("TransformError: %v", err)
+			}
+			if !ok {
+				t.Fatalf("★ 抽不出消息（返回 ok=false）⇒ 客户端只会看到 "+
+					"'unknown error'，而 body 里明明有：%s", c.body)
+			}
+			if got != c.want {
+				t.Fatalf("抽出的文案不对\n  实得: %q\n  期望: %q", got, c.want)
+			}
+		})
+	}
+}
+
+// 配对判据：真正**没有** transform_error 的适配器仍应返回 ok=false
+// （不能为了让上面那条通过就把"抽不出"和"没这个钩子"混为一谈）。
+func TestPreludeErrorExtractionStillReportsUnknownShapes(t *testing.T) {
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	src, err := bundledAdapters.ReadFile("adapters/openai.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := vm.LoadAdapterSource("openai", string(src)); err != nil {
+		t.Fatalf("装载 openai 适配器: %v", err)
+	}
+	// 一个确实认不出的 JSON（没有 message/error/detail/msg/error_msg）
+	got, ok, err := vm.TransformError("openai", 400, `{"weird":true}`)
+	if err != nil {
+		t.Fatalf("TransformError: %v", err)
+	}
+	if ok {
+		t.Fatalf("认不出的形状不该硬凑文案，实得 %q", got)
+	}
+}

internal/lua/adapter_zcode_base_test.go

@@ -0,0 +1,97 @@
+package lua
+
+import (
+	"os"
+	"regexp"
+	"strings"
+	"testing"
+)
+
+// ★ zcode 适配器**源码模板**必须真的能把 anthropic 基座合并进来。
+//
+// 背景：此前适配器在**沙箱里自己读 anthropic.lua** ⇒ 必然失败（沙箱无 fs、
+// 无 plugin_dir）且**静默降级** ⇒ 只有它自己定义的 2 个函数，缺 7 个
+// ⇒ 每次调用内核报 "missing transform_response" ⇒ 渠道**完全不可用**。
+// 该缺陷一直潜伏，因为 zcode 从来没有凭据 ⇒ 源未注册 ⇒ 从未被调用过。
+//
+// ⚠️ **本判据的边界（务必如实理解）**：它在测试里**自己**做占位符替换，
+//
+//	所以它证明的是「**模板形态**正确 + 合并逻辑能吃下基座」，
+//	而**不能**证明「installZcodeAdapter 真的内联了非空基座」——
+//	把安装处的 `asrc` 换成空串，本判据**不会**报红（已实测）。
+//	安装接线由 internal/core 的端到端判据覆盖：
+//	  TestZcodeAdapterInjectsOfficialIdentityBlocks
+//	  TestZcodeAdapterKeepsAnthropicProtocolConversion（工具调用/图像块存活）
+//	  TestZcodeAdapterFailsLoudlyWithoutAnthropicBase（基座不可得 ⇒ 安装期报错）
+//	这三条**会**咬住"内联空基座"这个变异（已实测）。
+//	⇒ 教训：判据自己复现被测逻辑时，必须说清它到底覆盖了哪一段。
+func TestZcodeAdapterInheritsAnthropicBase(t *testing.T) {
+	psrc, _ := os.ReadFile("plugins/channels.lua")
+	s := string(psrc)
+	diag := regexp.MustCompile(`(?s)local ZCODE_DIAG_SRC = \[===\[(.*?)\]===\]`).FindStringSubmatch(s)[1]
+	ad := regexp.MustCompile(`(?s)local ZCODE_ADAPTER_SRC = \[===\[(.*?)\]===\]`).FindStringSubmatch(s)[1]
+	asrc, err := bundledAdapters.ReadFile("adapters/anthropic.lua")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	full := "local Z = (function()\n" + diag + "\nend)()\n" + ad
+	// ⚠ 占位符不等于"适配器里能读到基座"：真正要验的是**装载后 9 个函数都在**。
+	//   故这里按 installZcodeAdapter 的同一手法内联，再逐函数断言。
+	if strings.Contains(full, "__INLINE_ANTHROPIC_SRC__") {
+		full = strings.ReplaceAll(full, "__INLINE_ANTHROPIC_SRC__", quoteLua(string(asrc)))
+	} else {
+		t.Fatal("适配器源码必须有基座占位符（基座由插件主体内联；" +
+			"适配器沙箱里读不到文件）")
+	}
+
+	vm := NewVM(t.TempDir())
+	defer vm.Stop()
+	if err := vm.LoadAdapterSource("channels-zcode", full); err != nil {
+		t.Fatalf("装载失败: %v", err)
+	}
+	want := []string{"transform_request", "transform_response", "transform_stream_chunk",
+		"transform_error", "serialize_chunk", "serialize_close", "serialize_open_preamble",
+		"serialize_response", "deserialize_request"}
+	var lack []string
+	for _, f := range want {
+		if !vm.HasFn("channels-zcode", f) {
+			lack = append(lack, f)
+		}
+	}
+	if len(lack) > 0 {
+		t.Fatalf("★ zcode 仍缺 %d 个函数（%v）⇒ 基座继承失败 ⇒ "+
+			"每次调用都会报 'missing <fn>' ⇒ 渠道完全不可用", len(lack), lack)
+	}
+	// 行为验证：基座的 transform_response 必须真的能转换 anthropic 响应
+	out, err := vm.Transform("channels-zcode", "transform_response",
+		`{"id":"m1","type":"message","role":"assistant","content":[{"type":"text","text":"hi"}],"stop_reason":"end_turn","usage":{"input_tokens":1,"output_tokens":2}}`)
+	if err != nil {
+		t.Fatalf("transform_response 调用失败: %v", err)
+	}
+	if !strings.Contains(out, "hi") {
+		t.Errorf("基座 transform_response 未产出内容: %s", out)
+	}
+	t.Logf("✓ zcode 继承基座成功（9/9 函数），transform_response → %s", out)
+}
+
+func quoteLua(s string) string {
+	var b strings.Builder
+	b.WriteByte('"')
+	for i := 0; i < len(s); i++ {
+		switch c := s[i]; c {
+		case '"':
+			b.WriteString(`\"`)
+		case '\\':
+			b.WriteString(`\\`)
+		case '\n':
+			b.WriteString(`\n`)
+		case '\r':
+			b.WriteString(`\r`)
+		default:
+			b.WriteByte(c)
+		}
+	}
+	b.WriteByte('"')
+	return b.String()
+}

internal/lua/adapters/buddy.lua

@@ -0,0 +1,201 @@
+local adapter = {}
+
+adapter.name = "buddy"
+adapter.version = "1.0.0"
+adapter.endpoint = "/chat/completions"
+adapter.headers = {}
+
+-- Claude-behind-OpenAI upstreams (tabitoken, 扇贝, …) convert /chat/completions
+-- to the Anthropic Messages API internally, so they inherit Anthropic's
+-- tool id rule: ^[a-zA-Z0-9_-]{1,64}$, enforced by rejecting the WHOLE request
+-- with "Invalid tool use format" / "tool_use.id: String should match pattern".
+-- Plain OpenAI has no such rule, so an OpenAI-compatible model can mint an id
+-- like "bash:0" (observed from moonshotai/kimi-k3). In a fan-out router that id
+-- is replayed to every other source, so one such id kills every Claude slot at
+-- once and an AUTO request falls through all tiers.
+--
+-- safe_tool_id is pure and deterministic, so a tool_calls entry and its
+-- matching tool_call_id are rewritten identically within one request. A
+-- rewritten id keeps an 8-hex digest of the ORIGINAL id, without which two
+-- distinct ids could collapse into one ("a:b" and "a_b") and become an
+-- unpaired/duplicate tool call. Already-legal ids are returned untouched, so
+-- well-behaved traffic is byte-identical to before.
+-- (anthropic.lua carries the same helper; Lua adapters have no shared prelude.)
+local TOOL_ID_MAX = 64
+
+local function safe_tool_id(id)
+    if type(id) ~= "string" or id == "" then return id end
+    local clean = string.gsub(id, "[^A-Za-z0-9_-]", "_")
+    if clean == id and #clean <= TOOL_ID_MAX then
+        return clean
+    end
+    local digest = string.sub(sha256_hex(id), 1, 8)
+    local keep = TOOL_ID_MAX - #digest - 1
+    if #clean > keep then clean = string.sub(clean, 1, keep) end
+    return clean .. "_" .. digest
+end
+
+-- 需要补 reasoning_effort 的模型 → 补哪个档位。
+--
+-- 唯一出处：参考 product.ts:237 声明 glm-5.1 的 reasoningEfforts 只有 ['medium']。
+-- 但实测**任何非空档位都被接受**，故这里取 medium（与参考声明一致）。
+local NEED_EFFORT = {
+    ["glm-5.1"] = "medium",
+}
+
+-- OpenAI /chat/completions format (pass-through, strip provider-specific fields)
+function adapter.transform_request(raw_body)
+    local ok, req = pcall(json.decode, raw_body)
+    if not ok then return raw_body end
+    -- The gateway's private control fields are GONE from the body (v2): the
+    -- neutral `thinking` field carries that intent and each adapter maps it in
+    -- its own protocol terms. These upstreams have no thinking switch at all,
+    -- so the field is simply dropped here — which is what the nil-ing below
+    -- used to do, except the field being dropped is no longer the kernel's
+    -- private one.
+    req.thinking = nil
+    req.extra_body = nil
+    -- ★★ buddy 的 glm-5.1 **要求请求体里有非空的 reasoning_effort**，
+    --    否则上游回 400：
+    --      {"code":11150,"msg":"the reasoning effort value is not supported
+    --       by the current model"}
+    --    实测（2026-10-16，逐字对照实验）：
+    --      glm-5.1 裸（无该字段）             → 400 11150  ✗
+    --      glm-5.1 + reasoning_effort:medium  → 200        ✓
+    --      glm-5.1 空串                       → 400 11150  ✗
+    --      任何**非空**档位均可（low/medium/high/xhigh/max/minimal 逐个 200）
+    --    而其余 15 个 buddy 模型裸跑全 200（多带该字段也无害）—— 即这是
+    --    glm-5.1 **独有**的要求。
+    -- ⚠️ 只对**已实测需要**的模型补（而不是一律补）：一律补会把"某个模型的
+    --    特殊要求"扩成"全平台行为"，将来上游若对某些模型收紧就会一次性弄坏
+    --    所有模型。
+    if NEED_EFFORT[req.model or ""] and
+       not (type(req.reasoning_effort) == "string" and req.reasoning_effort ~= "") and
+       req.reasoning_effort == nil then
+        req.reasoning_effort = NEED_EFFORT[req.model]
+    end
+    if req.messages then
+        for _, msg in ipairs(req.messages) do
+            msg.reasoning_content = nil
+            if msg.tool_call_id ~= nil then
+                msg.tool_call_id = safe_tool_id(msg.tool_call_id)
+            end
+            if type(msg.tool_calls) == "table" then
+                for _, tc in ipairs(msg.tool_calls) do
+                    if type(tc) == "table" and tc.id ~= nil then
+                        tc.id = safe_tool_id(tc.id)
+                    end
+                end
+            end
+        end
+    end
+    return json.encode(req)
+end
+
+function adapter.transform_response(raw_body)
+    -- 非流式 OpenAI 响应 → 统一信封。此前在 openai/groq/kimicode/mistral/github
+    -- 五个适配器里**逐字节相同**（各 2206B，diff 为空），已抽到共享前导。
+    return __prelude.openai_response(raw_body)
+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). 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,
+        }
+        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 }
+        elseif (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
+            uses.prompt_tokens_details = { cached_tokens = chunk.usage.prompt_cache_hit_tokens }
+        end
+    end
+
+    if not chunk.choices or #chunk.choices == 0 then
+        if uses ~= nil then
+            -- usage-only chunk is not a content/finish signal; the gateway
+            -- emits its own terminal stop chunk and merges this usage.
+            return json.encode({ usage = uses, done = false })
+        end
+        return ""
+    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
+    if delta.reasoning_content then
+        unified.reasoning_content = delta.reasoning_content
+    end
+    if delta.tool_calls then
+        -- Sanitize on the way OUT too: an id this upstream happily minted (it
+        -- does not validate them) becomes a landmine once the client replays
+        -- it to a Claude upstream. Only the first fragment of a streamed call
+        -- carries an id; later argument fragments have none and are untouched.
+        for _, tc in ipairs(delta.tool_calls) do
+            if type(tc) == "table" and tc.id ~= nil then
+                tc.id = safe_tool_id(tc.id)
+            end
+        end
+        unified.tool_calls = delta.tool_calls
+    end
+    return json.encode(unified)
+end
+
+-- 错误收敛：标准 OpenAI 信封 {error:{message,...}}
+function adapter.transform_error(status, body)
+    -- OpenAI 风格错误体抽消息。此前在 deepseek/github/groq/kimicode/
+    -- openai/sensenova 六个适配器里逐字节相同（各 293B），已抽到共享前导。
+    return __prelude.openai_error(status, body)
+end
+
+
+-- ★ build_headers：buddy 要求客户端身份头 + 流式的 Accept。
+--
+-- 实测（2026-10-16）：不发 `Accept: text/event-stream` 时上游接受请求（200）
+-- 但只回一帧空内容（completion_tokens=0），既不报错也不产出正文 —— 表现是
+-- "模型不回答"，极易误判成模型坏了或额度不足。
+-- 参考 buddy-adapter.ts 的 send() 固定发该头。
+--
+-- 身份头照参考 credentialRequestHeaders + CODEBUDDY 产品配置：
+-- X-Domain 用产品域（不用凭据里的 domain 快照，那是登录时的区域，
+-- 跨产品迁移后会指错区）；X-Product 是**部署类型**（SaaS）；X-Product-Code
+-- 是产品码（codebuddy）。
+function adapter.build_headers(meta)
+    local h = {
+        ["Accept"] = "text/event-stream",
+        ["Content-Type"] = "application/json",
+        ["X-Domain"] = "copilot.tencent.com",
+        ["X-Product"] = "SaaS",
+        ["X-Product-Code"] = "codebuddy",
+        ["User-Agent"] = "CodeBuddyIDE/1.106.1",
+    }
+    -- Authorization 由内核在 buildHeaders 之后补（值为源的 api_key）——
+    -- 这里显式给出同一份，保证与其它 buddy 请求形态一致。
+    if type(meta) == "table" and type(meta.api_key) == "string" and meta.api_key ~= "" then
+        h["Authorization"] = "Bearer " .. meta.api_key
+    end
+    return h
+end
+
+return adapter

internal/lua/adapters/opencodezen.lua

@@ -11,8 +11,14 @@ adapter.endpoint = "/chat/completions"
 --
 --   * 本适配器（Zen）服务免费池 / 按量付费池。免费模型必须带 opencode 客户端
 --     指纹（UA + x-opencode-*），否则上游拒绝："free tier can only be used in
---     OpenCode"。Zen 的免费池以非 thinking 模型为主，历史上回传
---     reasoning_content 会引出上游报错，故这里剥掉（Go 侧相反，见 opencodego.lua）。
+--     OpenCode"。
+--     ★ reasoning_content：**保留**（与 Go 侧一致）。此前这里写「剥掉」是基于
+--     「免费池以非 thinking 模型为主、回传会报错」的假设，**生产实测已证伪** ——
+--     剥掉恰恰会引发
+--       The `reasoning_content` in the thinking mode must be passed back to the API
+--     （详见 transform_request 内的长注释：失败只在「上一轮真的产出了 reasoning」
+--     时才出现，故表现为同一会话里成功/失败交替，极难归因）。
+--     参考的共享序列化器（openai-compat.ts）也是「有就回传」。
 --   * Go 订阅读者请看 opencodego.lua：那边**必须**回传 reasoning_content，
 --     否则 thinking 模式直接 400。
 --
@@ -219,26 +225,50 @@ function adapter.transform_request(raw_body)
             if type(msg.role) == "string" and not ROLE_WHITELIST[msg.role] then
                 msg.role = "system"
             end
-            -- Zen 免费池不接受回传 reasoning_content（Go 侧相反）
-            msg.reasoning_content = nil
+              -- ★ 必须**保留** reasoning_content（不再剥离）。
+              --
+              -- 历史：这里原先写 `msg.reasoning_content = nil`，理由是「Zen 免费池
+              -- 不接受回传」。**生产实测证伪**（2026-10-16）：
+              --   provider localzen: api error 400: Upstream request failed:
+              --   [invalid_request_error] The `reasoning_content` in the thinking
+              --   mode must be passed back to the API.
+              -- 失败形态很隐蔽：**同一模型同一会话里成功与失败交替出现** ——
+              -- 因为只有当上一轮**真的产出了 reasoning**（thinking 模型、
+              -- reasoning_effort 开启、长上下文）时，回放该历史才会被拒；
+              -- 剥掉之后，客户端看到的 502 与「上一轮想过」这件事毫无关联。
+              -- 审计文件里能看到成串 502 紧跟在一个 prompt_tokens=139330 的
+              -- 成功请求之后 —— 那正是「想了、但下一轮我们没把它还回去」。
+              --
+              -- 参考实现（`openai-compat.ts` 的 serializeMessages，opencode 适配器
+              -- 直接复用）在 assistant 回合携带 reasoning 时**就带上**该字段：
+              --   `...reasoning.length > 0 ? { reasoning_content: reasoning } : {}`
+              -- 即「有就回传」，没有额外条件 —— 与本适配器此前的假设方向相反。
+              --
+              -- ⚠️ 不改成「仅当 thinking 开启才回传」：我们**无法**从请求里可靠
+              -- 判定上游是否处于 thinking 模式（真正知道的是上游）。而「有就回传」
+              -- 是零风险方向 —— 上游不需要时忽略即可（实测传与不传同为 200），
+              -- 需要时缺了就是硬 400。
+              if type(msg.reasoning_content) == "string" and msg.reasoning_content == "" then
+                  msg.reasoning_content = nil
+              end
             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
+                      -- 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).
+                  -- 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 = ""

internal/provider/provider.go

@@ -1459,8 +1459,18 @@ func (p *Provider) apiErrReason(status int, raw string) string {
 			return fmt.Sprintf("api error %d: %s", status, types.OneLine(trimmed, 200))
 		}
 	}
-	log.Printf("[provider] unhandled upstream error body (adapter %q lacks transform_error): status=%d body=%.300s",
-		p.adapter, status, types.OneLine(raw, 300))
+	// ⚠️ 措辞必须**区分两种原因**（实测教训）：适配器**有** transform_error 钩子
+	// 但它返回 nil（不认识的错误体）是**常见**情况，而"真的没这个钩子"是另一回事。
+	// 原先一律说 "lacks transform_error" —— 我照着这句话去适配器里找那个函数，
+	// 查了几轮才发现函数明明在、只是抽不出消息。
+	// 这里直接问内核要事实，不再猜（判据也据此断言）。
+	if p.vm.HasFn(p.adapter, "transform_error") {
+		log.Printf("[provider] unhandled upstream error body (adapter %q: transform_error returned no reason for this shape): status=%d body=%.300s",
+			p.adapter, status, types.OneLine(raw, 300))
+	} else {
+		log.Printf("[provider] unhandled upstream error body (adapter %q defines no transform_error): status=%d body=%.300s",
+			p.adapter, status, types.OneLine(raw, 300))
+	}
 	return fmt.Sprintf("api error %d: unknown error", status)
 }
 

internal/provider/registry.go

@@ -117,13 +117,17 @@ func (r *Registry) Resolve(model string) []*Provider {
 // pinning prefix and returns the bare model id when that source serves it;
 // otherwise it returns the input unchanged.
 func (r *Registry) EffectiveModel(model string) string {
-	sep := strings.IndexAny(model, "-:/")
-	if sep < 1 || sep == len(model)-1 {
+	model = strings.TrimSpace(model)
+	if model == "" {
 		return model
 	}
-	src, m := model[:sep], model[sep+1:]
 	r.mu.RLock()
 	defer r.mu.RUnlock()
+	// 与 ResolvePinned 同一个拆分器：源名可含 `-`，不能用第一个分隔符切。
+	src, m, ok := splitPinned(model, r.providers)
+	if !ok {
+		return model
+	}
 	for _, p := range r.providers {
 		if strings.EqualFold(p.Name(), src) && p.ModelByID(m) != nil {
 			return m
@@ -135,13 +139,16 @@ func (r *Registry) EffectiveModel(model string) string {
 // ResolvePinned resolves "source-model" / "source:model" / "source/model" to
 // the exact source, or nil if the source does not serve that model.
 func (r *Registry) ResolvePinned(model string) *Provider {
-	sep := strings.IndexAny(model, "-:/")
-	if sep < 1 || sep == len(model)-1 {
+	model = strings.TrimSpace(model)
+	if model == "" {
 		return nil
 	}
-	src, m := model[:sep], model[sep+1:]
 	r.mu.RLock()
 	defer r.mu.RUnlock()
+	src, m, ok := splitPinned(model, r.providers)
+	if !ok {
+		return nil
+	}
 	for _, p := range r.providers {
 		if !strings.EqualFold(p.Name(), src) {
 			continue
@@ -153,6 +160,54 @@ func (r *Registry) ResolvePinned(model string) *Provider {
 	return nil
 }
 
+// splitPinned 把 "源名 + 分隔符 + 模型名" 拆开。
+//
+// ★★ 不能用 `IndexAny(model, "-:/")` 找**第一个**分隔符。
+// 源名本身常常含 `-`（本仓的渠道源是 `channels-<平台>-<账号id>`），
+// 于是 `channels-trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro` 会被切成
+//
+//	src="channels"、model="trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro"
+//
+// ⇒ 源名永不匹配 ⇒ Resolve() 返回 nil ⇒ 客户端看到
+// `model "channels-trae-xxx:Doubao-Seed-2.1-Pro" is not configured`。
+//
+// 真实缺陷（用户报「无法使用 channel 注册的模型」，2026-10-17）：
+// WebUI 的模型下拉框用 `源名:模型名` 作为 option value（这是**有意**的：
+// 44 个模型被多个源同时提供，必须能指定从哪个源调用），而网关解不开它。
+//
+// 修法：**按已知源名做最长前缀匹配**，命中的那个源名才是真正的分隔点。
+// 这样既支持含 `-` 的源名，也保留 "src:model" / "src/model" 等旧写法。
+func splitPinned(model string, providers []*Provider) (src, m string, ok bool) {
+	// ① 最长源名前缀匹配（唯一可靠的办法：源名是已知集合）
+	best := ""
+	for _, p := range providers {
+		n := p.Name()
+		if n == "" || len(n) >= len(model) {
+			continue
+		}
+		if !strings.HasPrefix(strings.ToLower(model), strings.ToLower(n)) {
+			continue
+		}
+		// 源名之后必须紧跟一个分隔符
+		if c := model[len(n)]; c != ':' && c != '/' && c != '-' {
+			continue
+		}
+		if len(n) > len(best) {
+			best = n
+		}
+	}
+	if best != "" {
+		return best, model[len(best)+1:], true
+	}
+	// ② 兜底：旧行为（第一个分隔符）。仅当没有任何源名匹配时才走到这里，
+	//    保持对非源名形态（例如第三方模型名自带 ":" 的）的兼容。
+	sep := strings.IndexAny(model, "-:/")
+	if sep < 1 || sep == len(model)-1 {
+		return "", "", false
+	}
+	return model[:sep], model[sep+1:], true
+}
+
 // ProviderForModel returns the provider owning the model id (nil if unknown).
 // When the same model exists on multiple sources, returns the first (source
 // config order). Callers that need a specific source use ProviderForSlot.
@@ -205,10 +260,10 @@ type ModelKindInfo struct {
 
 // ModelStatus is a web-UI friendly snapshot per source.
 type SourceStatus struct {
-	Name          string   `json:"name"`
-	Adapter       string   `json:"adapter"`
-	BaseURL       string   `json:"base_url"`
-	Models        []string `json:"models"`
+	Name    string   `json:"name"`
+	Adapter string   `json:"adapter"`
+	BaseURL string   `json:"base_url"`
+	Models  []string `json:"models"`
 	// ModelKinds parallels Models: Models[i] is ModelKinds[i].ID.
 	//
 	// It exists because a flat []string cannot answer "is gpt-image-2
@@ -217,15 +272,15 @@ type SourceStatus struct {
 	// callers that only need names; this is purely additive and omitted when
 	// empty, so an older UI keeps working.
 	ModelKinds    []ModelKindInfo `json:"model_kinds,omitempty"`
-	Available     bool     `json:"available"`
-	Healthy       bool     `json:"healthy"`
-	MaxConcurrent int      `json:"max_concurrent"`
-	LiveAvailable bool     `json:"live_available"`
-	LastError     string   `json:"last_error,omitempty"`
-	LastChecked   int64    `json:"last_checked,omitempty"`
-	FailCount     int      `json:"fail_count,omitempty"`
-	BackoffUntil  int64    `json:"backoff_until,omitempty"`
-	Permanent     bool     `json:"permanent,omitempty"`
+	Available     bool            `json:"available"`
+	Healthy       bool            `json:"healthy"`
+	MaxConcurrent int             `json:"max_concurrent"`
+	LiveAvailable bool            `json:"live_available"`
+	LastError     string          `json:"last_error,omitempty"`
+	LastChecked   int64           `json:"last_checked,omitempty"`
+	FailCount     int             `json:"fail_count,omitempty"`
+	BackoffUntil  int64           `json:"backoff_until,omitempty"`
+	Permanent     bool            `json:"permanent,omitempty"`
 	// RecentOK / RecentErr count real gateway requests served by this source
 	// within the last 300s (drives the status column so a source that is
 	// actually serving traffic can never be shown as down just because a

internal/provider/registry_pinned_name_test.go

@@ -0,0 +1,98 @@
+package provider
+
+import "testing"
+
+// ★ `源名:模型名` 这种限定写法，源名本身**含 `-`** 时必须仍能解开。
+//
+// 真实缺陷（用户报「无法使用 channel 注册的模型」，2026-10-17）：
+//
+//	WebUI 的模型下拉框用 `源名:模型名` 作为 option value —— 这是**有意**的：
+//	本实例有 44 个模型被多个源同时提供（glm-5.2 被 6 个源提供），
+//	用户必须能指定「从哪个源调用」。
+//
+//	但 ResolvePinned 用 `IndexAny(model, "-:/")` 找**第一个**分隔符，
+//	而渠道源名形如 `channels-trae-b8dd6b3df30e`（含 `-`）⇒ 被切成
+//
+//	  src="channels"、model="trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro"
+//
+//	⇒ 源名永不匹配 ⇒ Resolve() 返回 nil
+//	⇒ 客户端看到 `model "channels-trae-xxx:..." is not configured`。
+func TestResolvePinnedWithHyphenatedSourceName(t *testing.T) {
+	cases := []struct {
+		name    string
+		sources map[string][]string // 源名 → 模型
+		input   string
+		wantSrc string
+		wantMdl string
+		wantOK  bool
+	}{
+		{
+			name: "渠道源名含两个 -（真实形态）",
+			sources: map[string][]string{
+				"channels-trae-b8dd6b3df30e": {"Doubao-Seed-2.1-Pro", "glm-5.2"},
+				"channels-buddy-buddy-main":  {"hy4-preview", "glm-5.2"},
+			},
+			input:   "channels-trae-b8dd6b3df30e:Doubao-Seed-2.1-Pro",
+			wantSrc: "channels-trae-b8dd6b3df30e",
+			wantMdl: "Doubao-Seed-2.1-Pro",
+			wantOK:  true,
+		},
+		{
+			name: "同名模型跨源：必须能选中第二个源",
+			sources: map[string][]string{
+				"channels-trae-b8dd6b3df30e": {"glm-5.2"},
+				"channels-buddy-buddy-main":  {"glm-5.2"},
+			},
+			input:   "channels-buddy-buddy-main:glm-5.2",
+			wantSrc: "channels-buddy-buddy-main",
+			wantMdl: "glm-5.2",
+			wantOK:  true,
+		},
+		{
+			name: "斜杠写法仍要支持",
+			sources: map[string][]string{
+				"channels-trae-b8dd6b3df30e": {"glm-5.2"},
+			},
+			input:   "channels-trae-b8dd6b3df30e/glm-5.2",
+			wantSrc: "channels-trae-b8dd6b3df30e",
+			wantMdl: "glm-5.2",
+			wantOK:  true,
+		},
+		{
+			// 自带 ":" 的第三方模型名，且**没有**任何源名与之匹配 ⇒ 走旧兜底。
+			// ⚠️ 不能拿 "our-free-model_cohere/..." 当例子：本实例真有一个叫
+			//    `our-free-model_cohere` 的源，而仓库里还有叫 `our` 的源 ——
+			//    最长前缀匹配会正确命中 `our`，那个例子的预期是我写错了。
+			name: "无源名匹配时走旧兜底",
+			sources: map[string][]string{
+				"channels-trae-b8dd6b3df30e": {"glm-5.2"},
+			},
+			input:   "vendor-lib/thing:free",
+			wantSrc: "vendor",
+			wantMdl: "lib/thing:free",
+			wantOK:  true,
+		},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var ps []*Provider
+			for name, models := range c.sources {
+				ps = append(ps, newTestProvider(t, src(name, "http://127.0.0.1:1", "openai", models...)))
+			}
+			src, m, ok := splitPinned(c.input, ps)
+			if ok != c.wantOK {
+				t.Fatalf("ok 应为 %v，实得 %v（输入 %q）", c.wantOK, ok, c.input)
+			}
+			if !ok {
+				return
+			}
+			if src != c.wantSrc {
+				t.Fatalf("★ 源名解析错：期望 %q，实得 %q\n"+
+					"  输入 %q —— 源名含 `-` 时不能按第一个分隔符切", c.wantSrc, src, c.input)
+			}
+			if m != c.wantMdl {
+				t.Fatalf("模型名解析错：期望 %q，实得 %q", c.wantMdl, m)
+			}
+		})
+	}
+}