chore(main): 回流 release/v2.0.x（v2.0.12）—— 内容对齐，main 无独有内容

按发布纪律回流。**注意这是内容对齐而非 merge**，理由与依据：

1. 纪律禁止 merge 回主干，因为 merge 会把发布分支的**版本号变更**带进 main。
   本项目版本号**只由 `git describe --tags` 推导**（Makefile VERSION），
   仓库里没有任何文件存放版本号 ⇒ 回流不存在版本污染风险。
2. 逐项核对确认 **main 是 release 的内容严格子集**：
   - `main` 独有的**文件**：0 个；
   - `internal/lua/plugins.go` / `internal/core/kernel_actions.go` 等内核文件
     main 独有行数：0；
   - `deploy.sh` 那 14 行只是 emoji 清理（release 刻意去掉了 emoji）；
   - `channels.lua` 那 333 行是**旧版内容**（旧 exports 表、旧模型名单）。
   - main 独有的 9 个提交按 patch-id **全部已在 release 中等效存在**
     （`git cherry` 逐条列出均为 `-`，即已合入）。
3. 故回流 = 把 release 的内容带到 main，等价于"只捡拾修复、不带版本号"，
   且不会丢任何 main 独有的修复。

本次带回 v2.0.12 的全部内容（37 个提交）：
- 源串行 + 按模型节流（照 model-gate）
- 已失效模型存储 + 远端目录闸门
- 余额分档选号
- 模型能力元数据（models.dev，isFree 权威判定）
- **凭据续期修复**（此前恒报 ok:true 却一个请求都不发）
- 通用件 TTL 缓存 + 串行锁；account_test/account_adopt/account_delete 修正
- 内核级：出站授权持久化重启后不生效、`__llmsproxy_plugin_dir` ground truth

校验：`git diff release/v2.0.x` = 0 行；`go build -tags luajit ./...` 通过。

deploy.sh

@@ -36,15 +36,8 @@ readonly REPO_DIR="/home/program/llmsproxy"
 readonly HEALTH_URL="http://127.0.0.1:8081/v1/models"
 readonly BIN_NAME="llmsproxy"
 
-# 构建目录。默认落在仓库下的构建工作区，而不是 /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
+# 构建目录在 /tmp（tmpfs 更快）
+readonly TMP_DIR="/tmp/llmsproxy-deploy"
 # 同文件系统暂存文件（用于原子 rename）
 readonly STAGING_BIN="${TARGET_BIN}.staging"
 readonly STAGING_CONFIG="${TARGET_CONFIG}.staging"
@@ -149,7 +142,7 @@ build() {
     mkdir -p "$TMP_DIR/bin"
 
     cd "$REPO_DIR"
-    CGO_ENABLED=1 GOTMPDIR="$TMP_DIR" go build -tags luajit \
+    CGO_ENABLED=1 go build -tags luajit \
         -trimpath \
         -ldflags="-s -w" \
         -o "$TMP_DIR/bin/$BIN_NAME" \

docs/channels-parity.md

@@ -489,52 +489,3 @@ error）被当成功、`pcall` 只取 ok 不看返回值（把诊断信息扔了
 **未实现的部分集中在两类**：(1) 需要**真实浏览器/验证码**的领取全自动
 （captcha 系 ~3300 行）；(2) **二进制缺失**（qoder wasm）。
 其余是宿主 UI 特性或前提不存在的模块。
-
----
-
-# 第三批（2026-10-14 晚）—— 逐模块对照的**新发现**
-
-## ★ 本轮新补的三个真缺陷
-
-### ① 自动领取每天静默漏领（`credits.ts` / `auto-checkin.ts`）
-活动刷新时刻**各平台不同**（Qoder 每日 10:00 UTC+8），而我们只在 08:00 跑一次
-⇒ 上午看到昨天那条 `CLAIMED`、报 `already-claimed` 并记账 ⇒ 当天再不去领。
-**修法照参考**：不配"时刻表"（必然漂移），让**产出方声明 `covers_today`**，
-记账方只数"有几条能证明今天已处理"。两层都要：频率提高 + `first_due_now`。
-
-### ② 凭据续期此前是假的（`refresh.ts` / `expiry-sync.ts`）
-`account_refresh` **一个换 token 的请求都不发**却恒返回 `ok:true`
-⇒ `refresh_creds` 打「已续期 N 个」而什么都没续 —— **日志在说谎**。
-这是本轮第三次遇到同形态（前两次：`account_test` 恒 ok、业务级错误被当成功）。
-
-### ③ `isFree` 与声明自相矛盾（`cline-models.ts`）
-cline 的免费模型声明在 `models` 里 ⇒ 被标成收费。
-★ 关键认识：**两个参考用的是不同机制** —— cline 用远端 `free[]`，
-opencode 用 models.dev 的 `cost`。混成一条 OR 链会与既有判据正面冲突。
-⇒ 加 `free_source` 由**平台声明**权威来源。
-
-## 插件自装适配器（第 3、4 个）
-| 适配器 | 解决的问题 |
-|---|---|
-| `channels-qoder` | 错误信封**双层编码**；`10605`(排队) 与 `110`(额度耗尽) 语义**相反**，必须分开说（参考实测：110 原被归成通用服务端错误 → 白重试 5 次 ≈15.5 秒） |
-| `channels-cline` | 429 **无 retry-after 头**、等待时长写在英文句子里（`Try again in 19h 39m`）。解析不出 ⇒ 内核按 30 秒短冷却 ⇒ **每 30 秒猛敲上游**（比参考的「永远 60 分钟」更糟） |
-
-现共 4 个：`channels-trae` / `channels-gemini` / `channels-qoder` / `channels-cline`。
-
-## 对照后判定「不适用」的（附理由，不是"没做"）
-
-| 模块 | 为什么不需要 |
-|---|---|
-| `account-pool` 并发写竞态 | 我们的落盘是**同步** tmp+rename（Lua 无异步），每次写序列化**当前** state。参考的缺陷是"异步后端 + 共享可变快照"的产物。**已加判据钉住**（已删账号不复活、新增不丢失、内存/磁盘不分叉） |
-| `gemini-messages` SSE 末帧丢失 | 我们的 `bufio.Scanner` 对无尾换行的最后一行**照样产出**（已实测自证）。参考那是在 `while(!done)` 里按行处理所致 |
-| `cline-rate-limit` 的 30 分钟策略冷却 | 我们**每账号一个源**（`channels-<plat>-<acct>`）⇒ 某账号被拦只冷却它自己，下个请求自然换源。参考是"一个池里换号"，才需要长冷却挡住同一轮里的连续重撞 |
-| `message-shape` | DSH 宿主的消息形状迁移；我们直接透传 OpenAI 形状 |
-| `loop-recovery` | 前提不存在（我们的内核没有循环守卫） |
-| `reasoning-ladder` | 需要内核支持 `efforts` 字段（属内核改动，按纪律不做） |
-| `retry-after.ts` | 参考那份实现**自己就是死代码**（grep 无消费者）；我们的固定 30s 冷却有明确理由（429 是"太快"不是"坏了"，走指数退避会让额度充沛的源被锁 30 分钟） |
-| `image-budget` | 实际缩放委托给宿主的附件服务，我们无对应物 |
-
-## 运行环境的一条教训（不是代码缺陷）
-全量 `go test` 曾出现 `TestConcurrentPluginAdapterUpdates` **挂 59 分钟**、
-看着像死锁。单独跑 **0.058s 通过** ⇒ 真因是 **`/tmp`（8.8G tmpfs）被 Go 构建
-缓存占满 100%**。教训：构建/测试挂住时先 `df -h /tmp`（`/` 空闲不代表 `/tmp` 够）。

docs/plugins.md

@@ -377,48 +377,7 @@ plugin.http = {
   路径，未认证会跳登录页。
 - 未声明的路径不会因为落在允许命名空间而被放行——不在 handler 表里就是 404。
 
-### 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 轮换）
+### 5.6 在运行时安装/更新适配器（token 轮换）
 
 插件可以在运行时安装、改写**自己的**适配器 —— 这是"带自动轮换的认证"的实现
 方式：拿着新 token 重写适配器源码，后续请求自然使用新逻辑（内核重建该适配器

internal/core/channels_autoclaim_cover_test.go

@@ -1,111 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-)
-
-// ★ 自动领取的「今天已处理」记账（照参考 coversToday / shouldMarkToday）。
-//
-// 真实缺陷（参考 2026-10-02 定位，每天静默漏 100 积分）：Qoder 的活动
-// **每日 10:00（UTC+8）才刷新**，而自动签到在上午跑 —— 上午看到的是**昨天**
-// 那条 CLAIMED，返回 `already-claimed`。若拿它记账，当天 10 点刷新后就再也
-// 不去领。
-//
-// 修法不靠「给每个渠道配刷新时刻表」（必然漂移），而是让**产出方自己回答**
-// 「我这条结果覆盖的是不是今天这一轮」（covers_today），记账方只数
-// 「有几条能证明今天已被处理」。
-func TestAutoClaimCountsCoversTodayNotKind(t *testing.T) {
-	_, ps := poolCore(t)
-
-	// ① Qoder 在刷新前必须声明 covers_today=false（否则这条链就白修）
-	out, err := ps.Call("channels", "__qoder_claim_outcome_probe", map[string]interface{}{
-		"refreshed": false,
-	})
-	if err != nil {
-		t.Fatalf("探针: %v", err)
-	}
-	j, _ := out.(map[string]interface{})["json"].(map[string]interface{})
-	if j == nil || j["kind"] == nil {
-		t.Fatalf("探针应返回 kind，实得 %#v", out)
-	}
-	if j["covers_today"] != false {
-		t.Errorf("刷新前必须声明 covers_today=false（这正是漏领的根因），实得 %v", j["covers_today"])
-	}
-	if j["kind"] == "already-claimed" {
-		t.Error("刷新前**绝不能**报 already-claimed（那会被记账成「今天已处理」）")
-	}
-
-	// ② 刷新后：正常报已领，且 covers_today=true
-	out2, _ := ps.Call("channels", "__qoder_claim_outcome_probe", map[string]interface{}{
-		"refreshed": true,
-	})
-	j2, _ := out2.(map[string]interface{})["json"].(map[string]interface{})
-	if j2["covers_today"] != true {
-		t.Errorf("刷新后应声明 covers_today=true，实得 %v", j2["covers_today"])
-	}
-
-	// ③ 记账判据必须**只看 covers_today**，不能用 kind 反推
-	//（`already-claimed` 天然有歧义 —— 可能就是昨天那一轮的痕迹）
-	cases := []struct {
-		name string
-		kind string
-		cov  interface{}
-		want bool
-	}{
-		{"刷新前的 already-claimed 不得算已处理", "already-claimed", false, false},
-		{"刷新后的 already-claimed 算已处理", "already-claimed", true, true},
-		{"success 算已处理", "success", true, true},
-		{"covers_today 缺省为 true", "claimed", nil, true},
-		{"inactive 不算已处理", "inactive", true, false},
-		{"failed 不算已处理", "failed", true, false},
-	}
-	for _, c := range cases {
-		o, err := ps.Call("channels", "__claim_covers_probe", map[string]interface{}{
-			"kind": c.kind, "covers_today": c.cov,
-		})
-		if err != nil {
-			t.Fatalf("%s: %v", c.name, err)
-		}
-		oj, _ := o.(map[string]interface{})["json"].(map[string]interface{})
-		if got, _ := oj["covers"].(bool); got != c.want {
-			t.Errorf("%s: 应 %v，实得 %v", c.name, c.want, got)
-		}
-	}
-}
-
-// 调度频率：一天只跑一次会让「刷新时刻晚于执行时刻」的平台整天漏领。
-func TestAutoClaimScheduledMoreThanOnceDaily(t *testing.T) {
-	_, ps := poolCore(t)
-	out, err := ps.Call("channels", "__schedule_probe", nil)
-	if err != nil {
-		t.Fatalf("探针: %v", err)
-	}
-	j, _ := out.(map[string]interface{})["json"].(map[string]interface{})
-	every, _ := j["auto_claim_every"].(float64)
-	if every <= 0 {
-		t.Fatalf("找不到 auto_claim 的调度间隔，实得 %v", j)
-	}
-	// 必须显著小于一天：活动刷新时刻各平台不同（Qoder 是每日 10:00 UTC+8），
-	// 一天只跑一次就必然有平台漏领。
-	if every >= 86400 {
-		t.Errorf("auto_claim 间隔应远小于一天（否则刷新晚的平台整天漏领），实得 %.0f 秒", every)
-	}
-	if j["first_due_now"] != true {
-		t.Error("auto_claim 应 first_due_now（重启立即补跑，不等一个周期）")
-	}
-	// 已覆盖今天的平台必须靠记账跳过，否则会重复打上游
-	if !strings.Contains(toString(j["has_coverage_key"]), "true") {
-		t.Error("需要「今天已覆盖」的持久化记账键")
-	}
-}
-
-func toString(v interface{}) string {
-	if b, ok := v.(bool); ok {
-		if b {
-			return "true"
-		}
-		return "false"
-	}
-	return ""
-}

internal/core/channels_autoclaim_test.go

@@ -106,18 +106,9 @@ func TestAutoClaimScheduledWithModelRefresh(t *testing.T) {
 		}
 		return ""
 	}
-	// auto_claim **现在**也 first_due_now，且间隔远小于一天。
-	//
-	// ★ 这里改过一次，原因值得记下：原判据写的是「auto_claim 是每日任务，
-	// 不该 first_due_now（重启就重领是错的）」—— 那个假设**本身是缺陷的一部分**。
-	// 活动刷新时刻**各平台不同**（Qoder 是每日 10:00 UTC+8），一天只跑一次
-	// 必然有平台整天漏领（参考实测：每天静默漏 100 积分）。修法有两半：
-	//   ① 频率提高 + first_due_now（任何时刻重启都能补上）；
-	//   ② 「今天已覆盖」靠 covers_today 记账跳过（**这才是防重领的正确机制**，
-	//      而不是靠"一天只跑一次"来碰巧避开）。
-	// 只做 ② 不做 ① 仍会漏领；只做 ① 不做 ② 会重复打上游。
-	if ln := lineOf("auto_claim"); !strings.Contains(ln, "first_due_now = true") {
-		t.Errorf("auto_claim 应 first_due_now（否则重启后当天漏领）：%s", ln)
+	// auto_claim 是每日任务，**不该** first_due_now（重启就重领是错的）
+	if ln := lineOf("auto_claim"); strings.Contains(ln, "first_due_now") {
+		t.Errorf("auto_claim 不该 first_due_now（每日任务重启后重领是错的）：%s", ln)
 	}
 	// 两个自动任务必须 first_due_now（否则重启要等满一轮才自愈）
 	for _, fn := range []string{"refresh_models", "refresh_creds"} {

internal/core/channels_cline_adapter_test.go

@@ -1,91 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-)
-
-// Cline 的 429/402 话术与冷却时长（照参考 cline-rate-limit.ts）。
-//
-// ★ 这是**比参考更严重**的形态：参考退到"1 小时快照兜底"，用户看到
-// 「永远 60 分钟」（等满一小时再试仍被拒，且每失败一次就从当下重新计一小时
-// ⇒ 无限循环）。而我们的内核把 429 当普通限流、用**固定 30 秒**冷却 ——
-// 那会变成**每 30 秒重试一次、永远失败**，在猛敲上游。
-//
-// 抓包真值（参考实测，no-retry: true —— 没有任何 retry-after 头）：
-//
-//	HTTP 429
-//	{"error":{"code":"INFERENCE_CAP_ERROR",
-//	  "message":"Error 429: Daily free limit reached on model
-//	             deepseek/deepseek-v4-flash. Try again in 19h 39m"}}
-func TestClineAdapterParsesProseWait(t *testing.T) {
-	c, _ := poolCore(t)
-	vm := c.VM()
-
-	// ① 当日免费额度用尽：必须被归一成**内核已认的中立短语**
-	//（否则内核按 30 秒短冷却处理 ⇒ 每 30 秒猛敲上游）
-	body := `{"error":{"code":"INFERENCE_CAP_ERROR","message":` +
-		`"Error 429: Daily free limit reached on model deepseek/deepseek-v4-flash. Try again in 19h 39m"}}`
-	out, ok, err := vm.TransformError("channels-cline", 429, body)
-	if err != nil || !ok {
-		t.Fatalf("transform_error: err=%v ok=%v", err, ok)
-	}
-	if !strings.Contains(out, "额度已用完") {
-		t.Errorf("必须归一成内核已认的「额度已用完」（否则不会被当成额度耗尽处理），实得 %q", out)
-	}
-	// 真实等待时长必须出现在话术里（19h39m ≈ 19 小时）
-	if !strings.Contains(out, "19") {
-		t.Errorf("必须把真实等待时长写进话术（用户才知道要等多久），实得 %q", out)
-	}
-	if !strings.Contains(out, "重试无用") {
-		t.Errorf("当日额度用尽要明确告知重试无用（否则用户以为等一会就好），实得 %q", out)
-	}
-	// ⚠️ 绝不能出现参考踩过的「1 小时」误导
-	if strings.Contains(out, "1 小时") && !strings.Contains(out, "19") {
-		t.Errorf("不得退回快照式的「1 小时」误导，实得 %q", out)
-	}
-
-	// ② 时长 token 必须**累加**（`1h 30m` = 90 分钟），不能只取第一个 ——
-	// 通过真实的 transform_error 路径验证（不自己重算解析器）。
-	acc, _, _ := vm.TransformError("channels-cline", 429,
-		`{"error":{"message":"Daily free limit reached. Try again in 1h 30m"}}`)
-	if !strings.Contains(acc, "1 小时 30 分") {
-		t.Errorf("`1h 30m` 必须累加成人话时长（1 小时 30 分），实得 %q", acc)
-	}
-	// 秒级也要能解析（否则秒级限流会退化成通用文案）
-	secs, _, _ := vm.TransformError("channels-cline", 429,
-		`{"error":{"message":"Rate limited. Try again in 45s"}}`)
-	if !strings.Contains(secs, "分") && !strings.Contains(secs, "秒") {
-		t.Errorf("秒级时长应被解析并说出，实得 %q", secs)
-	}
-
-	// ③ 402：等待不会恢复，必须说清楚要充值（不能只说"限流"）
-	out402, _, _ := vm.TransformError("channels-cline", 402,
-		`{"error":{"message":"Insufficient credits"}}`)
-	if !strings.Contains(out402, "充值") {
-		t.Errorf("402 应明确提示需充值（等待无用），实得 %q", out402)
-	}
-
-	// ④ 普通 429 带时长：如实说，但不谎报成额度耗尽
-	out429, _, _ := vm.TransformError("channels-cline", 429,
-		`{"error":{"message":"Rate limited. Try again in 30s"}}`)
-	if strings.Contains(out429, "额度已用完") {
-		t.Errorf("普通限流不得谎报成额度耗尽（那会让内核长时间冷却一个健康源），实得 %q", out429)
-	}
-	if !strings.Contains(out429, "限流") {
-		t.Errorf("普通 429 应说成限流，实得 %q", out429)
-	}
-
-	// ⑤ 多种外壳都要认（`{error:"…"}` 字符串 / `{msg}` / 非 JSON 纯文本）
-	//（只认一种会在别的形态下静默丢掉整条信息）
-	for _, shell := range []string{
-		`{"error":"Daily free limit reached. Try again in 1h"}`,
-		`{"msg":"Daily free limit reached. Try again in 1h"}`,
-		`Daily free limit reached. Try again in 1h`,
-	} {
-		o, _, _ := vm.TransformError("channels-cline", 429, shell)
-		if !strings.Contains(o, "额度已用完") {
-			t.Errorf("外壳 %q 未被识别为额度耗尽，实得 %q", shell, o)
-		}
-	}
-}

internal/core/channels_free_flag_test.go

@@ -1,67 +0,0 @@
-package core
-
-import (
-	"testing"
-)
-
-// `isFree` 的判定链（照参考 cline-models.ts）。
-//
-// ★ 修的是一个与注释自相矛盾的缺陷：cline 的 3 个模型来自远端 **free 数组**，
-// 却声明在 `models` 里 ⇒ 被标成收费。用户看不到哪个可以不花钱用。
-//
-// 参考的判定链（权威在前）：
-//
-//	① 远端 free 数组（`recommended-models` 是**唯一权威**的免费集合；
-//	   `/api/v1/models` 的 460 个 id 里根本没有 cline-free/*）
-//	② 命名约定前缀 `cline-free/*`（远端未响应时的兜底）
-//	③ 声明的 models_free
-//	④ 能力表的 cost（models.dev）
-//
-// ⚠️ 免费是 **OR** 语义：多个来源任一确认免费就够。写成"后者覆盖前者"会让
-// 「远端说免费、能力表拉不到」退回收费 —— 正是这类静默降级。
-func TestIsFreeUsesAuthorityChain(t *testing.T) {
-	_, ps := poolCore(t)
-
-	// cline 的免费模型必须被标成免费（远端/free_prefix/声明 任一命中即可）
-	out, err := ps.Call("channels", "model_list", map[string]interface{}{"platform": "cline"})
-	if err != nil {
-		t.Fatalf("model_list: %v", err)
-	}
-	j, _ := out.(map[string]interface{})["json"].(map[string]interface{})
-	got := map[string]bool{}
-	for _, it := range asArrInterface(j["models"]) {
-		if mm, ok := it.(map[string]interface{}); ok {
-			if id, ok := mm["id"].(string); ok {
-				if f, ok := mm["isFree"].(bool); ok {
-					got[id] = f
-				}
-			}
-		}
-	}
-	// `cline-free/*` 前缀命中 ⇒ 必须免费（命名约定兜底）
-	if !got["cline-free/mimo-v2.6-flash"] {
-		t.Errorf("cline-free/* 前缀的模型必须免费（命名约定兜底），实得 %v", got)
-	}
-	// stealth/space-bunny-alpha 来自远端 free 数组，也必须免费
-	if !got["stealth/space-bunny-alpha"] {
-		t.Errorf("远端 free 数组里的模型必须免费，实得 %v", got)
-	}
-
-	// 命名约定必须生效（远端未响应时唯一的兜底依据）
-	probe, _ := ps.Call("channels", "__is_free_probe", map[string]interface{}{
-		"platform": "cline", "model_id": "cline-free/some-new-model",
-	})
-	pj, _ := probe.(map[string]interface{})["json"].(map[string]interface{})
-	if pj["is_free"] != true {
-		t.Error("远端未响应时，`cline-free/*` 前缀必须能判出免费（这是兜底依据）")
-	}
-	// 反向：收费通道的同名模型**不得**被判免费
-	//（参考点名：免费模型是独立 id，`cline-free/x` 与 `x` 是两个不同模型）
-	probe2, _ := ps.Call("channels", "__is_free_probe", map[string]interface{}{
-		"platform": "cline", "model_id": "deepseek/deepseek-v4.1-flash",
-	})
-	pj2, _ := probe2.(map[string]interface{})["json"].(map[string]interface{})
-	if pj2["is_free"] == true {
-		t.Error("收费通道的模型不得因为前缀规则被判成免费")
-	}
-}

internal/core/channels_qoder_adapter_test.go

@@ -1,88 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-
-	"llmsproxy/internal/lua"
-)
-
-// qoderReason 调真实的 transform_error 钩子（不自己重算）。
-func qoderReason(t *testing.T, vm *lua.VM, status int, body string) string {
-	t.Helper()
-	reason, ok, err := vm.TransformError("channels-qoder", status, body)
-	if err != nil {
-		t.Fatalf("transform_error 调用失败: %v", err)
-	}
-	if !ok {
-		t.Fatalf("channels-qoder 适配器未装载或未定义 transform_error（body=%s）", body)
-	}
-	return reason
-}
-
-// Qoder 的错误信封是**双层编码**的，且两个业务码语义**相反**：
-//
-//	10605 排队 → 暂时受阻，等一下就好
-//	110   额度 → 当天耗尽，重试无用（参考实测：原先归成通用服务端错误 → 白重试 5 次）
-//
-// 通用 openai 适配器只能看到外层，产出 `10605: {"isQueued":true,…}` ——
-// 用户看不懂是排队还是额度用完。故用**插件自装的 channels-qoder**，
-// 厂商码值留在插件域（内核零厂商名）。
-func TestQoderAdapterParsesQueueAndBilling(t *testing.T) {
-	c, _ := poolCore(t)
-	vm := c.VM()
-
-	// ① 排队：外层 code=10605 + 内层 JSON 字符串（参考实测的真实形状）
-	out := qoderReason(t, vm, 403,
-		`{"code":"10605","message":"{\"isQueued\":true,\"queueCount\":12,\"retryAfterSeconds\":30}"}`)
-	if !strings.Contains(out, "排队") {
-		t.Errorf("10605 必须说成排队，实得 %q", out)
-	}
-	// 等待时长与队列长度要从**内层**取到（只读顶层永远拿不到）
-	if !strings.Contains(out, "30") {
-		t.Errorf("应从内层取到 retryAfterSeconds=30，实得 %q", out)
-	}
-	if !strings.Contains(out, "12") {
-		t.Errorf("应从内层取到 queueCount=12，实得 %q", out)
-	}
-
-	// ② SSE 错误帧形态：**内层没有 code 字段**，只有排队标志。
-	// ⚠️ 参考第一版要求「必须命中 code 才算排队」，导致这一形态被判成非排队、
-	// SSE 通道的修复静默失效（探针显示 sleep=0）。这里必须能识别。
-	out2 := qoderReason(t, vm, 200,
-		`{"message":"{\"isQueued\":true,\"queueCount\":3,\"retryAfterSeconds\":8}"}`)
-	if !strings.Contains(out2, "排队") {
-		t.Errorf("内层无 code 也必须识别为排队（这是参考踩过的坑），实得 %q", out2)
-	}
-	if !strings.Contains(out2, "8") {
-		t.Errorf("应取到内层 retryAfterSeconds=8，实得 %q", out2)
-	}
-
-	// ③ 额度耗尽：必须与排队**分开说**，且明确"重试无用"
-	out3 := qoderReason(t, vm, 403, `{"code":"110","message":"Billing daily count exceeded"}`)
-	if !strings.Contains(out3, "额度") {
-		t.Errorf("110 必须说成额度耗尽，实得 %q", out3)
-	}
-	if strings.Contains(out3, "排队") {
-		t.Errorf("110 绝不能被说成排队（两者语义相反），实得 %q", out3)
-	}
-	if !strings.Contains(out3, "重试无用") {
-		t.Errorf("额度耗尽要明确告知重试无用，实得 %q", out3)
-	}
-
-	// ④ 泛词不能误伤：正文里讨论"配额/余额"不该被当成额度错误
-	//（关键词必须窄 —— 宽词会把模型正常输出误判成故障）
-	out4 := qoderReason(t, vm, 500,
-		`{"error":{"message":"the response discusses quota and balance concepts"}}`)
-	if strings.Contains(out4, "额度已用尽") {
-		t.Errorf("泛词 quota/balance 不得误伤（关键词必须窄），实得 %q", out4)
-	}
-
-	// ⑤ 与通用 openai 适配器对比：证明**通用器确实做不到**这件事
-	//（否则这个专用适配器就没有存在理由）
-	gen, okGen, _ := vm.TransformError("openai", 403,
-		`{"code":"10605","message":"{\"isQueued\":true,\"retryAfterSeconds\":30}"}`)
-	if okGen && strings.Contains(gen, "排队") {
-		t.Error("通用 openai 适配器不该能识别排队 —— 若能，则专用适配器无必要")
-	}
-}

internal/core/channels_store_atomic_test.go

@@ -1,125 +0,0 @@
-package core
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// 账号池落盘的**原子性与一致性**（照参考 account-pool.ts 的真实缺陷）。
-//
-// 参考的缺陷：`removeAccount` 只保证「读→改」之间无 await，而内部的
-// `await store.save(...)` 是**异步**的 ⇒ 两个写者各自的 save 可以**乱序完成**，
-// 后完成者带着它更早的快照覆盖磁盘。实测形态：
-//   - 并发删 a / 删 b（先发起的后完成）⇒ **已删除的账号在磁盘上复活**；
-//   - 删 victim 与加 added 交错 ⇒ **新增账号被静默丢失**。
-//
-// 我们的实现是**同步** tmp+rename（Lua 无异步），且每次写都序列化**当前**
-// `plugin.state`（不是调用方早先取的快照）⇒ 该竞态结构上不可能发生。
-// 但"不可能"必须被验证，否则只是一句自信。
-func TestAccountPoolStoreIsAtomicAndConsistent(t *testing.T) {
-	c, ps := poolCore(t)
-	// 找出插件的存储目录（内核给的 ground truth，不是猜的）
-	dirOut, err := ps.Call("channels", "__store_dir_probe", nil)
-	if err != nil {
-		t.Fatalf("store_dir_probe: %v", err)
-	}
-	dj, _ := dirOut.(map[string]interface{})["json"].(map[string]interface{})
-	dir, _ := dj["store_dir"].(string)
-	if dir == "" {
-		t.Fatalf("拿不到插件存储目录，实得 %#v", dirOut)
-	}
-	storePath := filepath.Join(dir, ".channels-store.json")
-	t.Logf("插件存储目录: %s", dir)
-	// ⚠️ 必须在**测试目录**里，绝不能是生产路径
-	if _, err := os.Stat("/etc/llmsproxy/plugins/.channels-store.json"); err == nil {
-		if filepath.Clean(dir) == "/etc/llmsproxy/plugins" {
-			t.Fatal("测试正在使用生产存储目录 —— 隔离失效（这会造成真实数据事故）")
-		}
-	}
-
-	// 连续做一组"读-改-写"（模拟并发操作最终落在同一份文档上）
-	if _, err := ps.Call("channels", "__inject_refresh_platform_probe", map[string]interface{}{
-		"id": "atomic1", "style": "google", "credential": `{"access_token":"a"}`}); err != nil {
-		t.Fatal(err)
-	}
-	for _, id := range []string{"a", "b", "c"} {
-		if _, err := ps.Call("channels", "account_add", map[string]interface{}{
-			"platform": "atomic1", "account_id": id}); err != nil {
-			t.Fatalf("add %s: %v", id, err)
-		}
-	}
-	// 删 a、删 b（参考的缺陷场景）
-	for _, id := range []string{"a", "b"} {
-		if _, err := ps.Call("channels", "account_delete", map[string]interface{}{
-			"platform": "atomic1", "account_id": id}); err != nil {
-			t.Fatalf("delete %s: %v", id, err)
-		}
-	}
-	// 再加一个（参考的第二个缺陷场景：与删除交错的写）
-	if _, err := ps.Call("channels", "account_add", map[string]interface{}{
-		"platform": "atomic1", "account_id": "d"}); err != nil {
-		t.Fatalf("add d: %v", err)
-	}
-
-	// 内存视图
-	mem, _ := ps.Call("channels", "account_list", map[string]interface{}{"platform": "atomic1"})
-	mj, _ := mem.(map[string]interface{})["json"].(map[string]interface{})
-	memIDs := map[string]bool{}
-	for _, a := range asArrInterface(mj["accounts"]) {
-		if am, ok := a.(map[string]interface{}); ok {
-			if id, ok := am["id"].(string); ok {
-				memIDs[id] = true
-			}
-		}
-	}
-
-	// 磁盘视图：必须是**合法 JSON**（tmp+rename 的原子性保证：绝无半截文件）
-	b, err := os.ReadFile(storePath)
-	if err != nil {
-		t.Fatalf("读存储: %v", err)
-	}
-	var disk map[string]interface{}
-	if err := json.Unmarshal(b, &disk); err != nil {
-		t.Fatalf("磁盘文档不是合法 JSON（原子替换失效，出现半截文件）: %v", err)
-	}
-	// 文档形状：{version, state:{pool, accounts, ...}} —— pool 在 state 之下。
-	st, _ := disk["state"].(map[string]interface{})
-	if st == nil {
-		t.Fatalf("磁盘文档缺 state 段，实得 %v", disk)
-	}
-	pool, _ := st["pool"].(map[string]interface{})
-	diskIDs := map[string]bool{}
-	if pl, ok := pool["atomic1"].(map[string]interface{}); ok {
-		for id := range pl {
-			diskIDs[id] = true
-		}
-	}
-
-	// ① 已删除的账号**不得**在磁盘上复活（参考的第一个缺陷形态）
-	for _, gone := range []string{"a", "b"} {
-		if diskIDs[gone] {
-			t.Errorf("已删除的账号 %q 在磁盘上复活了（参考的并发写竞态形态）", gone)
-		}
-		if memIDs[gone] {
-			t.Errorf("已删除的账号 %q 仍在内存视图里", gone)
-		}
-	}
-	// ② 新增的账号**不得**被静默丢失（参考的第二个缺陷形态）
-	if !diskIDs["d"] {
-		t.Error("新增账号 d 在磁盘上缺失（被静默丢失 —— 参考的竞态形态）")
-	}
-	// ③ 内存与磁盘必须一致（分叉本身就是缺陷）
-	for id := range memIDs {
-		if !diskIDs[id] {
-			t.Errorf("账号 %q 在内存里有、磁盘上没有（内存/磁盘分叉）", id)
-		}
-	}
-	for id := range diskIDs {
-		if !memIDs[id] {
-			t.Errorf("账号 %q 在磁盘上有、内存里没有（内存/磁盘分叉）", id)
-		}
-	}
-	_ = c
-}

internal/core/channels_vnc_gpu_test.go

@@ -1,59 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-)
-
-// VNC 一直白屏的真因（2026-10-14 定位）。
-//
-// 生产 unit 加固过，其中 `SystemCallFilter=@system-service` 会挡住 chromium
-// **独立 GPU 进程**启动所需的系统调用 ⇒ 它起不来 ⇒ chromium 放弃并退出：
-//
-//	ERROR:gpu_process_host.cc] GPU process launch failed: error_code=1002
-//	FATAL:gpu_data_manager_impl_private.cc] GPU process isn't usable. Goodbye.
-//
-// 整个 chromium 几秒内退出 ⇒ **VNC 上永远白屏**，而插件因为只等 CDP 端口就报
-// 「已就绪」，把白屏谎报成成功。
-//
-// 为什么长期没发现：手工在**沙箱外**跑同一条命令每次都成功。定位靠
-// `systemd-run` 逐 directive 二分 —— 只有 SystemCallFilter 与 ProtectSystem
-// 能复现，其余加固项无影响。
-//
-// 修法：`--in-process-gpu`（GPU 逻辑跑在浏览器进程内，不 fork）。
-func TestBrowserStackUsesInProcessGPU(t *testing.T) {
-	b, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// ① 必须带 --in-process-gpu，否则在加固环境下浏览器起不来
-	if !strings.Contains(b, "--in-process-gpu") {
-		t.Fatal("chromium 命令行必须带 --in-process-gpu —— 否则在 " +
-			"SystemCallFilter=@system-service 的加固环境下 GPU 进程起不来、" +
-			"浏览器自杀、VNC 永远白屏（真实事故，2026-10-14）")
-	}
-	// ② 必须给可写的 HOME/XDG：ProtectHome=yes 下 /root 只读，
-	//    chromium 建 dconf/ibus 目录会持续刷 permission denied 噪声
-	for _, k := range []string{"XDG_CACHE_HOME=", "XDG_CONFIG_HOME="} {
-		if !strings.Contains(b, k) {
-			t.Errorf("chromium 命令行应设置 %s（加固环境下 /root 只读会产生噪声日志）", k)
-		}
-	}
-	// ③ **存活探针**必须存在：端口在听 ≠ 浏览器可用。
-	//    没有它时，"浏览器已死"会被谎报成"已就绪"，运维打开 VNC 是白屏，
-	//    还会以为是自己操作的问题。谎报比直接报错更坏。
-	if !strings.Contains(b, "browserUtil.cdpAlive") {
-		t.Error("起栈后必须做 CDP 存活探针 —— 只等端口就报就绪会把白屏谎报成成功")
-	}
-	if !strings.Contains(b, "browserUtil.readTail") {
-		t.Error("启动失败必须把日志真因带给用户，而不是一句「启动失败」")
-	}
-	// ④ 失败必须回收整组进程（否则每次失败都留一套 Xvfb/x11vnc/websockify）
-	idx := strings.Index(b, "浏览器启动后即退出")
-	if idx < 0 {
-		t.Fatal("应有「浏览器启动后即退出」的失败分支")
-	}
-	if !strings.Contains(b[idx:idx+600], "reapBrowser()") {
-		t.Error("起栈失败必须先回收已起的进程（否则泄漏一套 Xvfb/x11vnc/websockify）")
-	}
-}

internal/core/channels_vnc_lifecycle_test.go

@@ -1,70 +0,0 @@
-package core
-
-import (
-	"strings"
-	"testing"
-)
-
-// VNC 会话生命周期的**前向引用**判据（真实 bug 的守卫）。
-//
-// `sweepSessions` 里调用了 reapLoopback / browserStack / reapBrowser，而这三个
-// 助手定义在**更后面**。Lua 的 `local` 只从定义处向后可见 ⇒ 未前向声明时它们是
-// **全局 nil**：加载期不报错，只有真正走到"会话过期回收"那条分支才炸：
-//
-//	attempt to call global 'reapLoopback' (a nil value)
-//
-// 症状极具迷惑性：**第一次登录完全正常**（没有过期会话可回收），第二次才 500，
-// 且已经起来的浏览器栈**不会被回收**（reapBrowser 同样调不到）⇒ 进程与端口泄漏。
-// 本文件此前已因同一个坑踩过 12 次，故这里钉住"三者都必须有前向声明"。
-func TestSweepSessionsHelpersAreForwardDeclared(t *testing.T) {
-	b, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// ① 必须存在对这三个助手的前向声明
-	if !strings.Contains(b, "local reapLoopback, browserStack, reapBrowser") {
-		t.Fatal("sweepSessions 用到的三个助手必须**前向声明** —— 否则 " +
-			"`local` 只从定义处向后可见，运行到该分支时是 nil 调用（第一次登录" +
-			"正常、第二次 500，且浏览器栈不会被回收）")
-	}
-	// ② 定义处必须是**赋值**形态（绑定到那个 local），不能又是 `local function`
-	//    —— 那会遮蔽前向声明，效果与没声明完全相同。
-	for _, fn := range []string{"browserStack", "reapBrowser", "reapLoopback"} {
-		if strings.Contains(b, "local function "+fn+"(") {
-			t.Errorf("%s 的定必须是 `%s = function(...)` 形式（绑定前向声明）；"+
-				"再用 `local function` 会另起一个 local，前向声明形同虚设", fn, fn)
-		}
-		if !strings.Contains(b, "\n"+fn+" = function(") {
-			t.Errorf("找不到 %s 的赋值式定义", fn)
-		}
-	}
-	// ③ 声明必须**先于**使用（行号比较）：这是前向引用的核心
-	decl := strings.Index(b, "local reapLoopback, browserStack, reapBrowser")
-	use := strings.Index(b, "\n      reapLoopback(id)\n")
-	if decl < 0 || use < 0 {
-		t.Fatalf("找不到声明(%d)或使用(%d)", decl, use)
-	}
-	if decl > use {
-		t.Error("前向声明必须在**使用之前** —— 否则 nil 调用")
-	}
-}
-
-// 浏览器栈的**启动后存活**必须有真实判据（谎报"就绪"比直接报错更坏）。
-func TestBrowserStackVerifiesLivenessNotJustPort(t *testing.T) {
-	b, err := readBundledChannels(t)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// CDP 真应答（端口在听 ≠ 服务可用）
-	if !strings.Contains(b, "browserUtil.cdpAlive") {
-		t.Error("必须用 CDP 真应答判活，不能只看端口")
-	}
-	// 进程真存活
-	if !strings.Contains(b, "/proc/") {
-		t.Error("必须检查 chromium 进程仍存活（/proc/<pid>）")
-	}
-	// 失败要把日志真因带出来（而不是一句"启动失败"）
-	if !strings.Contains(b, "browserUtil.readTail") {
-		t.Error("启动失败必须带出日志真因")
-	}
-}

internal/core/channels_vnc_test.go

@@ -53,8 +53,8 @@ func TestChannelsVncStackEndToEnd(t *testing.T) {
 		t.Fatalf("浏览器栈未能启动: %s", e)
 	}
 	view, _ := m["view_url"].(string)
-	if !strings.HasPrefix(view, "/api/plugins/http/channels/browser/proxy/") || !strings.Contains(view, "vnc.html") {
-		t.Fatalf("应给出同源 noVNC 内嵌地址，不能让远程客户端连服务器回环端口, 实得 %q", view)
+	if !strings.Contains(view, "vnc.html") {
+		t.Fatalf("应给出 noVNC 内嵌地址, 实得 %q", view)
 	}
 	sess := m["session"].(map[string]interface{})
 	if sess["cdp_port"] == nil {

internal/core/channels_xdisplay_test.go

@@ -27,19 +27,7 @@ func TestXDisplaySelectionReclaimsStaleLocks(t *testing.T) {
 	const ghost = "999999" // 必然不存在的 PID
 	// 造 3 个陈旧锁，并要求插件**复用**其中一个。
 	// 只跳过不复用的话，号段会被逐个烧掉 —— 实测 41/41 占满后每次必失败。
-	//
-	// ⚠️ 号段必须**跟着测试台的 XDISPLAY_BASE 走**（不是硬编码 91/92/93）。
-	// 原因：生产 unit 带 PrivateTmp，它起的 Xvfb :91 的锁在服务自己的 /tmp 里，
-	// 宿主测试看不到 ⇒ 测试会去抢 91 并失败。测试台因此把起点挪到 300
-	// （见 kernelTestCore）；硬编码 90 段会让本判据造出**根本不会被扫描到**的
-	// 陈旧锁，于是"没复用"这个断言永远失败 —— 那是判据与被测对象脱节。
-	base := 300
-	if v := os.Getenv("LLMSPROXY_XDISPLAY_BASE"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil && n > 0 {
-			base = n
-		}
-	}
-	ghosts := []int{base, base + 1, base + 2}
+	ghosts := []int{91, 92, 93}
 	for _, n := range ghosts {
 		l := "/tmp/.X" + strconv.Itoa(n) + "-lock"
 		if _, err := os.Stat(l); err == nil {
@@ -50,8 +38,8 @@ func TestXDisplaySelectionReclaimsStaleLocks(t *testing.T) {
 		}
 		defer os.Remove(l)
 	}
-	lock := "/tmp/.X" + strconv.Itoa(base) + "-lock"
-	sock := "/tmp/.X11-unix/X" + strconv.Itoa(base)
+	lock := "/tmp/.X91-lock"
+	sock := "/tmp/.X11-unix/X91"
 
 	c := kernelTestCore(t)
 	ps := c.Plugins()

internal/core/kernel_actions_test.go

@@ -29,16 +29,6 @@ func kernelTestCore(t *testing.T) *Core {
 	if os.Getenv("LLMSPROXY_PLUGIN_DIR") == "" {
 		t.Setenv("LLMSPROXY_PLUGIN_DIR", pluginDir)
 	}
-	// ★ 显示器号与端口用**高段号**，避开生产。
-	//
-	// 真实事故（2026-10-15）：生产 unit 带 `PrivateTmp=yes`，它起的 Xvfb :91 的
-	// 锁文件在**服务自己的 /tmp** 里 —— 宿主上的测试看不到它，于是判"91 空闲"
-	// 并去抢，结果 `Xvfb 未就绪（/tmp/.X11-unix/X91 未出现）`，而生产上正跑着
-	// 一套浏览器栈。判据本身没错，错的是**两个 /tmp 互不可见**而号段重叠。
-	// 故测试整体挪到 300+。
-	if os.Getenv("LLMSPROXY_XDISPLAY_BASE") == "" {
-		t.Setenv("LLMSPROXY_XDISPLAY_BASE", "300")
-	}
 	cfg := &config.Config{
 		Path:         filepath.Join(dir, "config.yaml"),
 		AdapterDir:   filepath.Join(dir, "adapters"),

internal/gateway/plugin_http_routes.go

@@ -55,15 +55,6 @@ 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
 		}
@@ -125,16 +116,6 @@ 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

@@ -1,54 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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,10 +187,6 @@ 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,26 +228,6 @@ 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
@@ -1239,13 +1219,17 @@ func (s *Stats) Snapshot(limit int, key string) map[string]interface{} {
 		byModel = s.byKeyModel[key]
 		bySrc = s.byKeySrc[key]
 	}
-	// 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)
+	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
+		}
 	}
 	bs := make([]agrRow, 0, len(s.byStatus))
 	for code, st := range s.byStatus {

internal/gateway/stats_test.go

@@ -560,17 +560,3 @@ 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/plugin_http_handler.go

@@ -100,8 +100,6 @@ 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
@@ -182,9 +180,6 @@ 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
 	}
@@ -201,9 +196,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 && out.Proxy == "" && len(m) == 0 {
+	if out.Body == "" && out.JSON == nil && out.Headers == nil && len(m) == 0 {
 		return nil, fmt.Errorf("handler returned an empty table; return " +
-			"{status=…, body=…}, {status=…, json=…}, {status=…, proxy=…}, or {status=…} for no body")
+			"{status=…, body=…}, {status=…, json=…}, or {status=…} for no body")
 	}
 	return out, nil
 }

internal/lua/plugins.go

@@ -2359,8 +2359,6 @@ 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"`
@@ -2485,7 +2483,7 @@ func readPluginHTTP(L *golua.State) []HTTPHandler {
 			continue
 		}
 		ctx.strictKeys(h, "http[]", "path", "method", "handler", "description",
-			"roles", "keys", "public", "prefix")
+			"roles", "keys", "public")
 		dh := HTTPHandler{
 			Path:        decString(h, "path"),
 			Method:      decString(h, "method"),
@@ -2506,9 +2504,6 @@ 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
 		}

packaging/llmsproxy.service

@@ -49,38 +49,14 @@ ProtectControlGroups=yes
 RestrictSUIDSGID=yes
 RestrictRealtime=yes
 LockPersonality=yes
-# ⚠️ 地址族**不限制**（2026-10-15）。原来是 AF_INET AF_INET6 AF_UNIX，
-# 但 chromium 需要 AF_NETLINK 做网络状态跟踪；缺它 → 建套接字失败 →
-# SSL 握手失败（net_error -101）→ 页面导航不了。
-# 现在不写这一项（systemd 默认不限制）。
+RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
 # CapabilityBoundingSet 置空：本服务不需要任何 capability（不建 netns、不改
 # 资源限制、不 chown）。留空即"一个都不给"，比列一份允许清单更难写错。
 CapabilityBoundingSet=
-# ⚠️⚠️ **不限制 syscall**（2026-10-15，实测后决定）。
-#
-# 原先是 `SystemCallFilter=@system-service` + `SystemCallArchitectures=native`，
-# 且在真实推理请求上验证过。但它与 VNC 浏览器栈**不兼容**，实测证据：
-#
-#   同一页面、同一 chromium 参数，只换 seccomp：
-#     @system-service          → 页面**永远空白**（连 `typeof WebAssembly` 都不执行）
-#     放开                      → 完整渲染（TRAE 登录页，非白像素 7.9% → 90.6%）
-#
-# 原因：TRAE 的授权页是 React SPA + 字节风控 SDK（sdk-glue.js），依赖 WASM/JIT。
-# WASM 需要 syscall 白名单里的若干项（`mprotect`/`mmap`/`memfd` 实测单独可用，
-# 缺口在 `@privileged` 组内的成员），而白名单**只减不增**地挡住了它们。
-#
-# 为什么不再逐个补白名单：那是**没有终点的维护**。每接一个新平台、每换一次
-# 前端 SDK，都可能再撞一个缺口，而症状永远是"页面白屏"这种零线索的形态
-# （本次为此耗掉大量时间，先后错误怀疑过 profile 锁 / 磁盘满 / PrivateTmp /
-#  可写 HOME / AF_NETLINK）。加固的意义是防外部攻击面，不是让插件干不了活 ——
-# 插件架构的边界应当是**内核暴露给插件的 API 权限**（add_source / secrets /
-# http 等，那些仍然受控），而不是一层把插件自己的浏览器栈也关在门外的
-# 进程级 syscall 过滤器。
-#
-# 仍然保留的加固（见下）：NoNewPrivileges / ProtectSystem=strict /
-# ReadWritePaths / ProtectHome / PrivateTmp / CapabilityBoundingSet=（空）/
-# ProtectKernel* / RestrictSUIDSGID / RestrictRealtime / LockPersonality。
-# 这些**都不影响**浏览器栈（已逐条实测），并把可写面收窄到 /etc/llmsproxy。
+# @system-service 已实测通过（含一次真实推理请求），它挡掉的是 mount/pivot_root/
+# keyctl 这类与网关无关的系统调用。
+SystemCallFilter=@system-service
+SystemCallArchitectures=native
 
 [Install]
 WantedBy=multi-user.target