chore: 同步到上游 1.12.0-panel + 凭证同步/独立启动器/保活

代码追上上游 1.12.0（基线 1b6abaa0 -> 47613d8），其中包含与定时任务直接相关的修复：
fix(scheduler): 槽位等待改为墙钟校验的分段睡眠——修复睡眠冻结 timer 导致的时点顺延
fix(scheduler): 暂停号口径修正
feat(scheduler): 保号任务可覆盖已禁用账号 include_disabled_in_tasks
其余：模型锁池视图、暂停选号 paused、模型级阻塞不再伪装成「没有可用账号」、
上游超时识别止损（不换号/不罚号）、sanitizeMessages 补洗 reasoning 等。

同时带上新增的凭证同步（internal/syncer / cmd/sync）、独立启动器（cmd/launcher）
与 Space 保活工作流。持久化仍走私有 Storage Bucket（/app/storage），不受影响。

.dockerignore

@@ -1,24 +1,28 @@
-auths/
-data/
-storage/
-*.tmp
-.git/
-.github/
-.gitignore
-docs/
-scripts/__pycache__/
-# 根目录已提交/未提交的二进制产物不进构建上下文（与 .gitignore 对齐）
-/login
-/credit
-/wb2api
-/signin_bin
-/wb2api.exe
-/login.exe
-/credit.exe
-# 真实配置不进镜像；镜像内模板是 config.default.json
-config.json
-PLAN.md
-SPEC.md
-LOOP.md
-README.md
-README.upstream.md
+auths/
+data/
+storage/
+*.tmp
+.git/
+.github/
+.gitignore
+docs/
+scripts/__pycache__/
+# 根目录已提交/未提交的二进制产物不进构建上下文（与 .gitignore 对齐）
+/login
+/credit
+/wb2api
+/wb2api-launcher
+/wb2api-sync
+/signin_bin
+/wb2api.exe
+/wb2api-launcher.exe
+/wb2api-sync.exe
+/login.exe
+/credit.exe
+# 真实配置不进镜像；镜像内模板是 config.default.json
+config.json
+PLAN.md
+SPEC.md
+LOOP.md
+README.md
+README.upstream.md

.github/workflows/go-binaries.yml

@@ -0,0 +1,156 @@
+name: go-binaries
+
+# 可运行二进制构建/发布：
+#   - PR / push main → 测试 + 五平台编译验证（产物仅存 artifact，不发布）
+#   - push v* tag    → 同上 + 打包上传到 GitHub Release（zip/tar.gz + checksums）
+# 固化的发布纪律（曾两次人祸，见仓库 HANDOFF）：-s -w 剥离、二进制版本串 == 源码
+# appVersion、tag 版本 == 源码版本（-ci 后缀的测试 tag 豁免，用于演练发布线）。
+on:
+  push:
+    branches: [main]
+    tags: ["v*"]
+  pull_request:
+    paths:
+      - "go.mod"
+      - "go.sum"
+      - "cmd/**"
+      - "internal/**"
+      - "config.example.json"
+      - ".github/workflows/go-binaries.yml"
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+      # ubuntu runner 自带 node → panel 包的 JS 运行时冒烟测试（TestAppJSTopLevelSmoke）会真实执行
+      - run: go test ./...
+
+  build:
+    needs: test
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { goos: windows, goarch: amd64, ext: .zip }
+          - { goos: linux, goarch: amd64, ext: .tar.gz }
+          - { goos: linux, goarch: arm64, ext: .tar.gz }
+          - { goos: darwin, goarch: amd64, ext: .tar.gz }
+          - { goos: darwin, goarch: arm64, ext: .tar.gz }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version-file: go.mod
+
+      - name: 取源码版本号
+        id: ver
+        run: echo "v=$(grep -oP 'appVersion = "\K[^"]+' cmd/server/main.go)" >> "$GITHUB_OUTPUT"
+
+      - name: 构建（剥离符号，对齐本地发布口径）
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: go build -ldflags "-s -w" -o "wb2api${{ matrix.goos == 'windows' && '.exe' || '' }}" ./cmd/server
+
+      # 启动器单独构建：它是**独立程序**，作用是把新版的 wb2api 二进制换进去就能升级，
+      # 启动器本身不用动。所以刻意不参与上面的版本串断言（它有自己独立的版本号）。
+      - name: 构建启动器（独立，不参与网关版本串断言）
+        env:
+          GOOS: ${{ matrix.goos }}
+          GOARCH: ${{ matrix.goarch }}
+          CGO_ENABLED: 0
+        run: |
+          LEXT="${{ matrix.goos == 'windows' && '.exe' || '' }}"
+          go build -ldflags "-s -w" -o "wb2api-launcher${LEXT}" ./cmd/launcher
+          ls -la "wb2api-launcher${LEXT}"
+
+      # 版本串断言：二进制必须含源码 appVersion（防交叉编译矩阵里编错树/漏 ldflags）
+      - name: 断言二进制版本串
+        run: |
+          BIN="wb2api${{ matrix.goos == 'windows' && '.exe' || '' }}"
+          if ! grep -qa "${{ steps.ver.outputs.v }}" "$BIN"; then
+            echo "::error::binary missing version string ${{ steps.ver.outputs.v }}"
+            exit 1
+          fi
+          echo "version assert OK: ${{ steps.ver.outputs.v }}"
+
+      - name: 打包（windows=zip 三件套，其余=tar.gz）
+        run: |
+          V="${{ steps.ver.outputs.v }}"
+          V="${V%-panel}"   # 文件名不带 -panel 后缀（wb2api-panel-v1.2.3-... 既有惯例）
+          case "${{ matrix.goos }}" in
+            windows)
+              NAME="wb2api-panel-v${V}-windows-amd64.zip"
+              zip -q "$NAME" wb2api.exe wb2api-launcher.exe config.example.json README.md
+              ;;
+            *)
+              NAME="wb2api-panel-v${V}-${{ matrix.goos }}-${{ matrix.goarch }}.tar.gz"
+              tar czf "$NAME" wb2api wb2api-launcher config.example.json README.md
+              ;;
+          esac
+          echo "name=$NAME" >> "$GITHUB_ENV"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: ${{ env.name }}
+          path: ${{ env.name }}
+          retention-days: 7
+
+  # 仅 tag 触发：校验 tag == 源码版本（-ci 演练 tag 豁免）→ 汇总资产 → 建 Release
+  publish:
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0   # 取历史 tag 算 compare 链接
+      - name: tag 与源码版本一致性断言
+        run: |
+          SRC=$(grep -oP 'appVersion = "\K[^"]+' cmd/server/main.go)
+          SRC="${SRC%-panel}"   # appVersion 带 -panel 后缀，比对前剥掉
+          TAG="${GITHUB_REF_NAME#v}"
+          if [[ "$GITHUB_REF_NAME" != *-ci ]]; then
+            if [[ "$TAG" != "$SRC" ]]; then
+              echo "::error::tag $GITHUB_REF_NAME 与源码 appVersion=$SRC 不一致（先提交版本号再打 tag）"
+              exit 1
+            fi
+          else
+            echo "演练 tag（-ci 后缀）跳过一致性断言：tag=$TAG src=$SRC"
+          fi
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          merge-multiple: true
+      - name: checksums
+        run: cd dist && sha256sum *.zip *.tar.gz > checksums.txt && ls -la
+      - name: 上一版 tag（compare 链接用）
+        id: prev
+        run: |
+          PREV=$(git describe --tags --abbrev=0 "${GITHUB_REF_NAME}^" 2>/dev/null || true)
+          echo "prev=${PREV}" >> "$GITHUB_OUTPUT"
+      - uses: softprops/action-gh-release@v2
+        with:
+          name: ${{ github.ref_name }}-panel
+          prerelease: ${{ contains(github.ref_name, '-') }}
+          body: |
+            CI 自动构建发布（五平台二进制 + checksums）。
+
+            完整变更：https://github.com/${{ github.repository }}/compare/${{ steps.prev.outputs.prev }}...${{ github.ref_name }}
+          files: dist/*

.github/workflows/space-keepalive.yml

@@ -0,0 +1,78 @@
+name: hf-space-keepalive
+
+# 作用：定时给 Hugging Face Space 打一次 /healthz，阻止它因「48 小时无 HTTP 流量」被暂停。
+# 为什么需要它：Space 一被暂停，它里面的定时任务（签到 / 活跃 / 保活）就全部停摆，
+# 而唤醒要等 30~60 秒冷启动。
+#
+# 为什么用 GitHub Actions 而不是 Cloudflare Cron：
+#   Cloudflare 免费版**每个账号只有 5 个 cron 触发器**。如果那 5 个已经被别的 Worker 占了，
+#   再给本 Worker 加 cron 会直接报 `code: 10072`（本仓库实测踩过）。GH Actions 没有这个限制。
+#
+# 为什么 6 小时一次就够：HF 的判定阈值是 **48 小时**，所以哪怕 GitHub 的定时任务
+# 延迟几十分钟（高峰期常见）也毫无影响。刻意避开整点（:17）以减少排队。
+#
+# ⚠️⚠️ 必须打 Space 的**直连域名**（*.hf.space），**不要**改成公网入口
+#      cli.3216gemini.dpdns.org —— 实测那个入口的 `/healthz` 是 **Cloudflare 自己
+#      应答的 `ok`**（响应带 cf-ray，但既没有网关的 `x-service`，也没有 HF 的
+#      `link: …/spaces/a3216/gcli2api` 头），请求根本没到 Space。拿它做保活
+#      等于白 ping：返回 200 看着很健康，Space 却照样被暂停。
+#      （该入口只在 `/healthz` 上做了短路，`/status`、`/panel/*` 等仍是透传到 Space 的。）
+#
+# ⚠️ 两个 GitHub 侧的限制，知道一下就好：
+#   1. 定时工作流只在**默认分支**上生效（所以这个文件要合进 main）。
+#   2. 仓库连续 60 天没有任何提交/活动，GitHub 会自动停用定时工作流并给你发邮件；
+#      到时在 Actions 页面点一下 "Enable workflow" 即可（或随便提交一次）。
+
+on:
+  schedule:
+    - cron: "17 */6 * * *"
+  workflow_dispatch: # 也支持手动跑一次（Actions 页面 → Run workflow）
+
+permissions: {}
+
+concurrency:
+  group: hf-space-keepalive
+  cancel-in-progress: false
+
+jobs:
+  ping:
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: 唤醒 / 保活 HF Space
+        run: |
+          set -uo pipefail
+
+          # 直连 Space 的域名（*.hf.space）。**不要**改成 cli.3216gemini.dpdns.org：
+          # 那个入口的 /healthz 由 Cloudflare 自己回 "ok"，请求到不了 Space，
+          # 拿它保活是无效的（详见文件头注释）。
+          # 想顺带把公网入口也探一遍，可以加进来 —— 但它只证明边缘在，不证明 Space 醒着。
+          URLS=(
+            "https://a3216-gcli2api.hf.space/healthz"
+          )
+
+          fail=0
+          for url in "${URLS[@]}"; do
+            echo "::group::$url"
+            ok=0
+            # 冷启动可能要 30~60s，给足超时并重试三次。
+            for attempt in 1 2 3; do
+              code=$(curl -s -o /dev/null -w '%{http_code}' -m 90 "$url" || echo "000")
+              echo "第 ${attempt} 次: HTTP ${code}"
+              # 关键判据：只要拿到了**任何** HTTP 状态码，就说明 Space 是醒着的。
+              # 503 是网关「当前没有可用账号可服务」的业务语义，对保活而言完全正常。
+              # 只有 000（连不上/超时）才算这次没打到。
+              if [ "$code" != "000" ]; then
+                ok=1
+                break
+              fi
+              sleep 20
+            done
+            echo "::endgroup::"
+            if [ "$ok" -ne 1 ]; then
+              echo "::error::$url 三次都拿不到响应（Space 可能真的挂了，或正在长时间冷启动）"
+              fail=1
+            fi
+          done
+
+          exit "$fail"

.gitignore

@@ -1,47 +1,58 @@
-# Auth & secrets
-auths/
-data/
-*.key
-*.pem
-*.env
-.env
-.env.*
-
-# Binaries (anchored to repo root only — bare "login"/"credit" would also ignore cmd/login/, cmd/credit/)
-/login
-/credit
-/wb2api
-/signin_bin
-
-# Config with secrets (use config.example.json)
-config.json
-
-# Build artifacts
-*.tmp
-__pycache__/
-
-# Backups (contains auth tokens)
-backups/
-
-# IDE
-.idea/
-.vscode/
-LOOP.md
-PLAN.md
-SPEC.md
-docs/
-
-# 设计/计划文档（但 README.md 与 go:embed 的内置提示词必须进版本库）
-*.md
-!README.md
-!internal/prompt/defaultprompt.md
-
-# Windows binaries
-/wb2api.exe
-/login.exe
-/credit.exe
-
-# 本地验证工具（判据逆向过程脚本，结论沉淀于 data/desktop-task-protocol.md）
-/cmd/desktopverify*/
-*.zip
-server.exe
+# Auth & secrets
+auths/
+data/
+*.key
+*.pem
+*.env
+.env
+.env.*
+# wrangler 本地变量（Cloudflare Worker 的 api_key 等，绝不进版本库）
+.dev.vars
+.dev.vars.*
+# ……但模板必须能进版本库（里面只有占位符，没有真密钥）
+!.dev.vars.example
+.wrangler/
+
+# Binaries (anchored to repo root only — bare "login"/"credit" would also ignore cmd/login/, cmd/credit/)
+/login
+/credit
+/wb2api
+/wb2api-launcher
+/wb2api-sync
+/signin_bin
+
+# Config with secrets (use config.example.json)
+config.json
+
+# Build artifacts
+*.tmp
+__pycache__/
+
+# Backups (contains auth tokens)
+backups/
+
+# IDE
+.idea/
+.vscode/
+LOOP.md
+PLAN.md
+SPEC.md
+docs/
+
+# 设计/计划文档（但 README.md 与 go:embed 的内置提示词必须进版本库）
+*.md
+!README.md
+!internal/prompt/defaultprompt.md
+
+# Windows binaries
+/wb2api.exe
+/wb2api-launcher.exe
+/wb2api-sync.exe
+/login.exe
+/credit.exe
+
+# 本地验证工具（判据逆向过程脚本，结论沉淀于 data/desktop-task-protocol.md）
+/cmd/desktopverify*/
+*.zip
+server.exe
+.DS_Store

Dockerfile

@@ -1,39 +1,42 @@
-# syntax=docker/dockerfile:1
-# ---------------------------------------------------------------- build stage
-FROM golang:1.23-alpine AS build
-WORKDIR /src
-COPY go.mod go.sum ./
-RUN go mod download
-COPY . .
-# 全静态二进制：镜像里直接跑脚本，无需 libc。
-RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api ./cmd/server \
- && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/signin_bin ./cmd/signin \
- && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/login ./cmd/login \
- && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/credit ./cmd/credit
-
-# -------------------------------------------------------------- runtime stage
-FROM alpine:3.20
-# python3：login.sh 的 JSON 解析 + 入口脚本的配置校验；tzdata：Asia/Shanghai。
-RUN apk add --no-cache wget ca-certificates tzdata python3 bash \
- && mkdir -p /app/auths /app/data
-ENV TZ=Asia/Shanghai
-WORKDIR /app
-
-COPY --from=build /out/wb2api /app/wb2api
-COPY --from=build /out/signin_bin /app/signin_bin
-COPY --from=build /out/login /app/login
-COPY --from=build /out/credit /app/credit
-COPY login.sh signin.sh credit.sh /app/
-COPY scripts/probe_active.py /app/scripts/probe_active.py
-# config.default.json 只是「镜像内模板」：仅当持久卷上还没有 config.json 时被拷过去一次。
-# 真正的运行配置住在私有 Storage Bucket 上（见 docker-entrypoint.sh），公开仓库里不放 api_key。
-COPY config.default.json /app/config.json
-COPY docker-entrypoint.sh /app/docker-entrypoint.sh
-RUN sed -i 's/\r$//' /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh \
- && chmod 755 /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh
-
-# 以 root 运行：Storage Bucket 卷由挂载器创建，非 root 用户可能写不进去。
-EXPOSE 7861
-HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \
-  CMD wget -qO- http://127.0.0.1:7861/healthz || exit 1
-ENTRYPOINT ["/app/docker-entrypoint.sh"]
+# syntax=docker/dockerfile:1
+# ---------------------------------------------------------------- build stage
+FROM golang:1.23-alpine AS build
+WORKDIR /src
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+# 全静态二进制：镜像里直接跑脚本，无需 libc。
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api ./cmd/server \
+ && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/wb2api-launcher ./cmd/launcher \
+ && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/signin_bin ./cmd/signin \
+ && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/login ./cmd/login \
+ && CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /out/credit ./cmd/credit
+
+# -------------------------------------------------------------- runtime stage
+FROM alpine:3.20
+# python3：login.sh 的 JSON 解析 + 入口脚本的配置校验；tzdata：Asia/Shanghai。
+RUN apk add --no-cache wget ca-certificates tzdata python3 bash \
+ && mkdir -p /app/auths /app/data
+ENV TZ=Asia/Shanghai
+WORKDIR /app
+
+COPY --from=build /out/wb2api /app/wb2api
+# 独立启动器：本地/容器里都能「先同步凭证、再拉起网关」，且换 wb2api 版本时它不用重编。
+COPY --from=build /out/wb2api-launcher /app/wb2api-launcher
+COPY --from=build /out/signin_bin /app/signin_bin
+COPY --from=build /out/login /app/login
+COPY --from=build /out/credit /app/credit
+COPY login.sh signin.sh credit.sh /app/
+COPY scripts/probe_active.py /app/scripts/probe_active.py
+# config.default.json 只是「镜像内模板」：仅当持久卷上还没有 config.json 时被拷过去一次。
+# 真正的运行配置住在私有 Storage Bucket 上（见 docker-entrypoint.sh），公开仓库里不放 api_key。
+COPY config.default.json /app/config.json
+COPY docker-entrypoint.sh /app/docker-entrypoint.sh
+RUN sed -i 's/\r$//' /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh \
+ && chmod 755 /app/login.sh /app/signin.sh /app/credit.sh /app/docker-entrypoint.sh
+
+# 以 root 运行：Storage Bucket 卷由挂载器创建，非 root 用户可能写不进去。
+EXPOSE 7861
+HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \
+  CMD wget -qO- http://127.0.0.1:7861/healthz || exit 1
+ENTRYPOINT ["/app/docker-entrypoint.sh"]

LICENSE

@@ -1,22 +1,22 @@
-MIT License
-
-Copyright (c) 2026 Sliverkiss (original project: https://github.com/Sliverkiss/workbuddy2api)
-Copyright (c) 2026 linguo2625469 (this fork: https://github.com/linguo2625469/workbuddy2api-panel)
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Sliverkiss (original project: https://github.com/Sliverkiss/workbuddy2api)
+Copyright (c) 2026 linguo2625469 (this fork: https://github.com/linguo2625469/workbuddy2api-panel)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,67 +1,160 @@
----
-title: WorkBuddy2API Panel
-emoji: 🧩
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-app_port: 7861
-pinned: false
-short_description: WorkBuddy 账号池网关，带面板，数据落私有存储桶
----
-
-# WorkBuddy2API Panel — Hugging Face Spaces 部署
-
-把腾讯 WorkBuddy 账号变成 OpenAI 兼容 API 的多账号网关（上游：
-[linguo2625469/workbuddy2api-panel](https://github.com/linguo2625469/workbuddy2api-panel)）。
-本目录是**面向 HF Spaces 的部署分支**：唯一的改动是「持久化」。
-
-## 这个分支改了什么
-
-Spaces 的容器根文件系统是 ephemeral 的 —— 重启、休眠唤醒、重新构建都会清空。
-原版把账号和状态放在容器内的 `./auths`、`./data`，在 Spaces 上等于每次重启都要重新登录账号。
-
-本分支的做法：
-
-- 一个**私有 Storage Bucket** 以卷的形式挂载到容器 `/app/storage`（读写）；
-- `docker-entrypoint.sh` 把运行配置指到卷上：
-  - `/app/storage/config.json` — 运行配置（含 `api_key`，私有卷上，公开仓库里没有）
-  - `/app/storage/auths/*.json` — 账号凭证
-  - `/app/storage/data/{state,usage,model,output_probes}.json`、`data/request-logs/` — 运行状态与请求归档
-- 启动时做一次「写 + rename」自检（程序所有落盘都走 tmp+rename，FUSE 卷不支持 rename 的话持久化就是假的）；
-- **安全闸门**：`api_key` 为空等于完全关闭鉴权，入口脚本检测到空 key 会直接拒绝启动。
-
-## 一次性配置（已经做完，此处仅为记录）
-
-```python
-from huggingface_hub import HfApi, Volume
-api = HfApi()
-api.create_bucket("a3216/wb2api-storage", private=True, exist_ok=True)
-api.set_space_volumes(
-    "a3216/gcli2api",
-    volumes=[Volume(type="bucket", source="a3216/wb2api-storage", mount_path="/app/storage")],
-)
-```
-
-`set_space_volumes` 是**替换**语义；要追加卷，先读 `get_space_runtime(...).volumes` 再一起传进去。
-
-## 环境变量
-
-| 变量 | 作用 |
-| --- | --- |
-| `WB2A_API_KEY` | 覆盖配置文件里的 `api_key`（本项目默认不设，key 存在卷上的 config.json 里） |
-| `WB2A_PERSIST_DIR` | 卷挂载点，默认 `/app/storage` |
-| `WB2A_LISTEN` / `WB2A_AUTH_DIR` / `WB2A_STATE_FILE` … | 上游已有的同名覆盖，见上游 README |
-
-## 运维
-
-- **改 API 密钥**：面板「配置」页改完即热生效，并写回 `/app/storage/config.json`，重启不丢。
-- **加账号**：面板里走 OAuth 添加，或把 `workbuddy-*.json` 丢进桶的 `auths/`。
-- **备份**：桶本身就是备份。本地拉一份：
-  `hf buckets sync hf://buckets/a3216/wb2api-storage ./backup`
-- **看日志**：`hf spaces logs a3216/gcli2api`（构建日志加 `--build`）。
-- **免费硬件会自动休眠**：cpu-basic 上 48 小时没有 HTTP 流量就被暂停，下次有人访问自动唤醒。
-  唤醒后账号和状态从桶里恢复；网关的定时任务（签到/领积分）在暂停期间不会执行。
-
-## 说明
-
-上游项目与本文档的许可证见 `LICENSE`（上游为 MIT，本分支的部署脚本同样遵循）。
+---
+title: WorkBuddy2API Panel
+emoji: 🧩
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_port: 7861
+pinned: false
+short_description: WorkBuddy 账号池网关，带面板，数据落私有存储桶
+---
+
+# WorkBuddy2API Panel — Hugging Face Spaces 部署
+
+把腾讯 WorkBuddy 账号变成 OpenAI 兼容 API 的多账号网关（上游：
+[linguo2625469/workbuddy2api-panel](https://github.com/linguo2625469/workbuddy2api-panel)）。
+本目录是**面向 HF Spaces 的部署分支**：唯一的改动是「持久化」。
+
+## 这个分支改了什么
+
+Spaces 的容器根文件系统是 ephemeral 的 —— 重启、休眠唤醒、重新构建都会清空。
+原版把账号和状态放在容器内的 `./auths`、`./data`，在 Spaces 上等于每次重启都要重新登录账号。
+
+本分支的做法：
+
+- 一个**私有 Storage Bucket** 以卷的形式挂载到容器 `/app/storage`（读写）；
+- `docker-entrypoint.sh` 把运行配置指到卷上：
+  - `/app/storage/config.json` — 运行配置（含 `api_key`，私有卷上，公开仓库里没有）
+  - `/app/storage/auths/*.json` — 账号凭证
+  - `/app/storage/data/{state,usage,model,output_probes}.json`、`data/request-logs/` — 运行状态与请求归档
+- 启动时做一次「写 + rename」自检（程序所有落盘都走 tmp+rename，FUSE 卷不支持 rename 的话持久化就是假的）；
+- **安全闸门**：`api_key` 为空等于完全关闭鉴权，入口脚本检测到空 key 会直接拒绝启动。
+
+## 一次性配置（已经做完，此处仅为记录）
+
+```python
+from huggingface_hub import HfApi, Volume
+api = HfApi()
+api.create_bucket("a3216/wb2api-storage", private=True, exist_ok=True)
+api.set_space_volumes(
+    "a3216/gcli2api",
+    volumes=[Volume(type="bucket", source="a3216/wb2api-storage", mount_path="/app/storage")],
+)
+```
+
+`set_space_volumes` 是**替换**语义；要追加卷，先读 `get_space_runtime(...).volumes` 再一起传进去。
+
+## 本地 ↔ 桶：凭证同步与独立启动器
+
+**要解决的问题**：同一批账号常常要两处跑 —— 本地机器给工具提供低延迟 API，Space 负责定时签到。
+两边各自维护 `auths/` 就会不同步：本地新加的号 Space 不知道（签到漏掉），
+Space 刷新过的 token 本地还在用旧的；最糟的是两边**同时** refresh 同一个账号，
+refreshToken 轮换后只有一方拿到新的，另一方直接掉线。
+
+`wb2api-launcher` 就是为此而生：**先同步、后启动**。
+
+```bash
+# 独立 exe：不需要 Go / Python / PowerShell
+wb2api-launcher              # 同步 → 拉起网关 → 后台每 5 分钟对账
+wb2api-launcher -status      # 只看两边差异，不启动网关（有差异退出码 2）
+wb2api-launcher -sync-only   # 同步一次就退出
+wb2api-launcher -no-sync     # 离线启动（用本地已有凭证）
+wb2api-launcher -h           # 全部选项
+```
+
+它是个**独立程序**：与网关之间只有两个契约 ——「`wb2api -config <路径>` 能被拉起来」
+和 `config.json` 里那几个键，不引用网关内部实现。所以**上游更新时你只需要换 `wb2api`，
+启动器不用动**；同步引擎直接编在里面，也不需要第二个二进制。
+`start.ps1` / `start.sh` 只是「没有二进制就 `go build`，然后 exec 启动器」的引导壳。
+
+配置见 `config.example.json` 的 `sync` 段：
+
+```json
+"sync": {
+  "bucket": "a3216/wb2api-storage",
+  "token_file": "./data/hf_token.txt",
+  "writer": "auto"
+}
+```
+
+两个方向的通道**刻意不同**（实测结论，不是设计偏好）：
+
+| 方向 | 通道 | 为什么 |
+| --- | --- | --- |
+| **读** | HF Hub REST（纯 HTTPS） | 不触发 Space 冷启动，它休眠/暂停时照样能拉 —— 启动那一次同步必须快 |
+| **写** | 官方 `hf` CLI | Bucket 上传必须先做 **Xet 内容寻址上传**，拿文件 SHA-256 当 `xetHash` 会被服务端拒绝（`File not found in Xet storage`）。该协议不适合在 Go 里重造 |
+
+冲突裁决（两端都有且内容不同时，按优先级）：能被网关解析的一方赢 → **`expiresAt` 更晚的一方赢**
+（"谁刷新过用谁的"，这条直接治凭证不同步）→ refreshToken 非空的一方赢 → mtime 更晚的一方赢 →
+全平取本端（保证裁决确定性，否则两端会互相覆盖成无限拉锯）。
+刻意**不做字段级合并**：accessToken 与 refreshToken 必须成对来自同一次刷新，拼起来只会造出永远刷不动的凭证。
+也**不会删除账号** —— 删除只能在面板显式操作。
+
+> ⚠️ **定时任务只能由一边跑。** 两边同时开签到/保活会互抢 refreshToken（轮换后只有一方拿到新的，
+> 另一方直接掉线），这是同步工具救不了的**并发写冲突**。推荐分工：**Space 跑定时任务，本地只做 API** ——
+> 把本地 `schedule.*_enabled` 全设 `false` 即可，网关处理请求时本来就会按需刷新 token，不影响可用性。
+>
+> ⚠️ **手动禁用 / 暂停不会被同步。** `disabled` / `paused` 是每端各自的运维意图，不属于凭证。
+> 要两边一致请分别在两端面板里设置；也不要靠 `-include-data state.json` 去"抹平"它
+> （那会把对端的冷却/熔断状态一起搬过来）。
+
+## 保活：别让 Space 睡过去
+
+cpu-basic 免费硬件**连续 48 小时没有任何 HTTP 流量就被暂停**，暂停期间网关的定时任务
+（签到 / 领积分）不会执行。给它一个稳定的定时流量即可。
+
+### 方案 A：GitHub Actions（推荐，不占 CF 配额）
+
+仓库自带 `.github/workflows/space-keepalive.yml`：每 6 小时 ping 一次 Space 的 `/healthz`。
+
+**为什么 6 小时就够**：HF 的判定阈值是 **48 小时**，所以有 8 倍余量；GitHub 定时任务
+偶发延迟几十分钟毫无影响。它把**任何 HTTP 状态码都算成功**——`503` 是"当前没有可用账号"
+的业务语义，但 Space 是醒着的，保活目的已经达到；只有连不上（`000`）才需要关注。
+
+定时工作流只在**默认分支**生效；仓库连续 60 天无活动时 GitHub 会自动停用它
+（Actions 页面点一下重新启用，或随便提交一次）。
+
+> ⚠️ **保活必须打 Space 的直连域名（`*.hf.space`），不能打公网入口 `cli.3216gemini.dpdns.org`。**
+> 实测那个入口的 `/healthz` 是 **Cloudflare 自己应答的 `ok`**
+> （响应带 `cf-ray`，但既没有网关的 `x-service`，也没有 HF 的 `link: …/spaces/a3216/gcli2api` 头），
+> **请求根本没到 Space** —— 拿它做保活会稳定返回 200、看着很健康，而 Space 照样被暂停。
+> 该入口只在 `/healthz` 上短路，`/status`、`/panel/*` 仍是透传的。
+> 工作流里因此写死直连域名并注明了���因，**别"顺手优化"掉**。
+
+### 方案 B：Cloudflare Worker + Cron
+
+`deploy/cloudflare-worker/` 是一份单文件 Worker：反代 `cli.3216gemini.dpdns.org/*`
+（响应体流式回传，不破坏 SSE）+ `scheduled()` 保活。部署前可以先用
+`node dev-server.mjs` 在本地把它验一遍（该脚本原样 import 同一个 `worker.js`，转发到真实 Space）。
+
+> ⚠️ **Cloudflare 免费版的 cron 限制是「每个账号 5 个」，不是每个 Worker 5 个。**
+> 名额满了 `wrangler deploy` 会给出**半成功**结果：`Uploaded` / `Deployed` 都成功，但紧接着
+> `✘ [ERROR] ... reached the Workers Free limit of 5 cron triggers per account [code: 10072]`
+> —— Worker 代码上线了、cron 没加上，于是它**空转，谁也唤不醒**。要么腾一个名额，要么用方案 A。
+>
+> 另外：`wrangler deploy` 打印的 `*.workers.dev` 地址在国内常因 DNS 污染而连不上，
+> 这不代表部署失败；`wrangler tail` 若报 400，是它走的 WebSocket 被本地抓包代理挡了，
+> 换 Dashboard → Worker → Logs 看即可。
+
+## 环境变量
+
+| 变量 | 作用 |
+| --- | --- |
+| `WB2A_API_KEY` | 覆盖配置文件里的 `api_key`（本项目默认不设，key 存在卷上的 config.json 里） |
+| `WB2A_PERSIST_DIR` | 卷挂载点，默认 `/app/storage` |
+| `WB2A_LISTEN` / `WB2A_AUTH_DIR` / `WB2A_STATE_FILE` … | 上游已有的同名覆盖，见上游 README |
+
+## 运维
+
+- **改 API 密钥**：面板「配置」页改完即热生效，并写回 `/app/storage/config.json`，重启不丢。
+- **加账号**：面板里走 OAuth 添加，或把 `workbuddy-*.json` 丢进桶的 `auths/`。
+- **备份**：桶本身就是备份。本地拉一份：
+  `hf buckets sync hf://buckets/a3216/wb2api-storage ./backup`
+- **看日志**：`hf spaces logs a3216/gcli2api`（构建日志加 `--build`）。
+- **免费硬件会自动休眠**：cpu-basic 上 48 小时没有 HTTP 流量就被暂停，下次有人访问自动唤醒。
+  唤醒后账号和状态从桶里恢复；网关的定时任务（签到/领积分）在暂停期间不会执行。
+  → **保活方案见 [保活：别让 Space 睡过去](#保活别让-space-睡过去)。**
+
+## 说明
+
+上游项目与本文档的许可证见 `LICENSE`（上游为 MIT，本分支的部署脚本同样遵循）。

cmd/credit/main.go

@@ -1,294 +1,294 @@
-// credit.go — WorkBuddy 积分查询（全部账号 + 总计），JSON 输出到 stdout。
-//
-// 用法:
-//
-//	go run ./cmd/credit        # 或编译后 ./credit
-//
-// 输出结构:
-//
-//	{"service":"workbuddy","ts":N,
-//	 "total":{"remain":N,"used":N,"size":N,"accounts":N,"ok":N,"failed":N},
-//	 "accounts":[{"uid","nickname","remain","used","size","packages","ok","error?"}]}
-//
-// 接口与聚合逻辑：POST codebuddy.cn/v2/billing/meter/get-user-resource，聚合所有 package 的
-// Cycle* 字段，TotalDosage 作 size 下限。
-package main
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-	"time"
-)
-
-const billingBaseCN = "https://www.codebuddy.cn"
-
-// billingBaseGlobal 国际版计费域。global 账号打 CN 域会得到 401：
-// www.codebuddy.cn 不认 workbuddy.ai 的 token（实测 401，workbuddy.ai 同 token 为 code=0）。
-const billingBaseGlobal = "https://www.workbuddy.ai"
-
-// billingBaseFor 按账号 realm 选择计费域。
-//
-// 判定口径与 internal/auth.Realm() 一致：显式 realm=global 或 domain 落在
-// workbuddy.ai 家族，都按国际版处理。cmd/credit 早先对所有账号硬编码 CN 域，
-// 导致 global 账号余额查询恒返回 401（面板显示的是池内缓存值，不是实时的）。
-func billingBaseFor(af *authFile) string {
-	if strings.EqualFold(strings.TrimSpace(af.Auth.Realm), "global") {
-		return billingBaseGlobal
-	}
-	d := strings.ToLower(strings.TrimSpace(af.Auth.Domain))
-	if d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai") {
-		return billingBaseGlobal
-	}
-	return billingBaseCN
-}
-
-type authFile struct {
-	Auth struct {
-		AccessToken string `json:"accessToken"`
-		Domain      string `json:"domain"`
-		Realm       string `json:"realm"`
-	} `json:"auth"`
-	Account struct {
-		UID          string `json:"uid"`
-		EnterpriseID string `json:"enterpriseId"`
-		Nickname     string `json:"nickname"`
-	} `json:"account"`
-}
-
-type accountResult struct {
-	UID      string `json:"uid"`
-	Nickname string `json:"nickname"`
-	Remain   *int64 `json:"remain"`
-	Used     *int64 `json:"used"`
-	Size     *int64 `json:"size"`
-	Packages int    `json:"packages,omitempty"`
-	OK       bool   `json:"ok"`
-	Error    string `json:"error,omitempty"`
-}
-
-type resourcePackage struct {
-	CapacityRemain      int64 `json:"CapacityRemain"`
-	CapacityUsed        int64 `json:"CapacityUsed"`
-	CapacitySize        int64 `json:"CapacitySize"`
-	CycleCapacityRemain int64 `json:"CycleCapacityRemain"`
-	CycleCapacityUsed   int64 `json:"CycleCapacityUsed"`
-	CycleCapacitySize   int64 `json:"CycleCapacitySize"`
-}
-
-// packageRemainUsed 与 billing.go:203-258 一致
-func packageRemainUsed(a resourcePackage) (remain, used, size int64) {
-	if a.CycleCapacitySize > 0 {
-		remain = a.CycleCapacityRemain
-		size = a.CycleCapacitySize
-		if remain < 0 {
-			remain = 0
-		}
-		if remain > size {
-			remain = size
-		}
-		used = size - remain
-		if a.CycleCapacityUsed > used {
-			used = a.CycleCapacityUsed
-			if size >= used {
-				remain = size - used
-			}
-		}
-		return remain, used, size
-	}
-	remain = a.CapacityRemain
-	used = a.CapacityUsed
-	size = a.CapacitySize
-	if used == 0 && size > remain {
-		used = size - remain
-	}
-	return remain, used, size
-}
-
-func fetchUserResource(af *authFile) (remain, used, size int64, packs int, err error) {
-	now := time.Now()
-	body, _ := json.Marshal(map[string]any{
-		"PageNumber":               1,
-		"PageSize":                 100,
-		"ProductCode":              "p_tcaca",
-		"Status":                   []int{0, 3},
-		"PackageEndTimeRangeBegin": now.Format("2006-01-02 15:04:05"),
-		"PackageEndTimeRangeEnd":   now.Add(365 * 101 * 24 * time.Hour).Format("2006-01-02 15:04:05"),
-	})
-	base := billingBaseFor(af)
-	// global 域无 /v2 前缀（与 internal/upstream 的 billingMeterPaths 同口径）。
-	path := "/v2/billing/meter/get-user-resource"
-	if base == billingBaseGlobal {
-		path = "/billing/meter/get-user-resource"
-	}
-	req, err := http.NewRequest(http.MethodPost, base+path, bytes.NewReader(body))
-	if err != nil {
-		return 0, 0, 0, 0, err
-	}
-	req.Header.Set("Authorization", "Bearer "+af.Auth.AccessToken)
-	req.Header.Set("Accept", "application/json")
-	req.Header.Set("Content-Type", "application/json")
-	if af.Account.UID != "" {
-		req.Header.Set("X-User-Id", af.Account.UID)
-	}
-	if af.Account.EnterpriseID != "" {
-		req.Header.Set("X-Enterprise-Id", af.Account.EnterpriseID)
-		req.Header.Set("X-Tenant-Id", af.Account.EnterpriseID)
-	}
-	if af.Auth.Domain != "" {
-		req.Header.Set("X-Domain", af.Auth.Domain)
-	}
-	client := &http.Client{Timeout: 20 * time.Second}
-	resp, err := client.Do(req)
-	if err != nil {
-		return 0, 0, 0, 0, err
-	}
-	defer resp.Body.Close()
-	if resp.StatusCode >= 400 {
-		return 0, 0, 0, 0, fmt.Errorf("http %d", resp.StatusCode)
-	}
-	var env struct {
-		Code int    `json:"code"`
-		Msg  string `json:"msg"`
-		Data struct {
-			Response struct {
-				Data struct {
-					TotalDosage int64             `json:"TotalDosage"`
-					Accounts    []resourcePackage `json:"Accounts"`
-				} `json:"Data"`
-			} `json:"Response"`
-		} `json:"data"`
-	}
-	if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
-		return 0, 0, 0, 0, err
-	}
-	if env.Code != 0 {
-		return 0, 0, 0, 0, fmt.Errorf("code=%d %s", env.Code, env.Msg)
-	}
-	for _, a := range env.Data.Response.Data.Accounts {
-		r, u, s := packageRemainUsed(a)
-		remain += r
-		used += u
-		size += s
-	}
-	packs = len(env.Data.Response.Data.Accounts)
-	if size > 0 {
-		if derived := size - remain; derived > used {
-			used = derived
-		}
-	}
-	if dosage := env.Data.Response.Data.TotalDosage; dosage > size {
-		size = dosage
-		if derived := size - remain; derived > used {
-			used = derived
-		}
-	}
-	return remain, used, size, packs, nil
-}
-
-func main() {
-	pretty := len(os.Args) > 1 && os.Args[1] == "-pretty"
-	authDir := "./auths"
-	if v := os.Getenv("WB2A_AUTH_DIR"); v != "" {
-		authDir = v
-	}
-	files, _ := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json"))
-	sort.Strings(files)
-
-	accounts := make([]accountResult, 0, len(files))
-	for _, f := range files {
-		var af authFile
-		raw, err := os.ReadFile(f)
-		if err != nil || json.Unmarshal(raw, &af) != nil {
-			continue
-		}
-		res := accountResult{UID: af.Account.UID, Nickname: af.Account.Nickname}
-		if af.Auth.AccessToken == "" {
-			res.Error = "no accessToken"
-			accounts = append(accounts, res)
-			continue
-		}
-		remain, used, size, packs, err := fetchUserResource(&af)
-		if err != nil {
-			res.Error = err.Error()
-		} else {
-			res.Remain = &remain
-			res.Used = &used
-			res.Size = &size
-			res.Packages = packs
-			res.OK = true
-		}
-		accounts = append(accounts, res)
-		time.Sleep(200 * time.Millisecond)
-	}
-
-	var totalRemain, totalUsed, totalSize int64
-	okCount := 0
-	for _, a := range accounts {
-		if a.OK {
-			okCount++
-			if a.Remain != nil {
-				totalRemain += *a.Remain
-			}
-			if a.Used != nil {
-				totalUsed += *a.Used
-			}
-			if a.Size != nil {
-				totalSize += *a.Size
-			}
-		}
-	}
-	out := map[string]any{
-		"service": "workbuddy",
-		"ts":      time.Now().Unix(),
-		"total": map[string]any{
-			"remain":   totalRemain,
-			"used":     totalUsed,
-			"size":     totalSize,
-			"accounts": len(accounts),
-			"ok":       okCount,
-			"failed":   len(accounts) - okCount,
-		},
-		"accounts": accounts,
-	}
-	if pretty {
-		printPretty(accounts, totalRemain, totalUsed, totalSize, okCount)
-		return
-	}
-	raw, _ := json.Marshal(out)
-	fmt.Println(string(raw))
-}
-
-// printPretty 人类可读日报：四行汇总，无账号明细。
-func printPretty(accounts []accountResult, totalRemain, totalUsed, totalSize int64, okCount int) {
-	withBalance := 0
-	var failed []string
-	for _, a := range accounts {
-		if a.OK && a.Remain != nil && *a.Remain > 0 {
-			withBalance++
-		}
-		if !a.OK {
-			name := a.Nickname
-			if name == "" && len(a.UID) >= 8 {
-				name = a.UID[:8]
-			}
-			failed = append(failed, name+" "+a.Error)
-		}
-	}
-	pct := int64(0)
-	if totalSize > 0 {
-		pct = totalRemain * 100 / totalSize
-	}
-	fmt.Printf("📊 WorkBuddy 积分日报\n")
-	fmt.Printf("账号: %d/%d\n", withBalance, len(accounts))
-	fmt.Printf("总计: %d/%d\n", totalRemain, totalSize)
-	fmt.Printf("剩余: %d%%\n", pct)
-	for _, f := range failed {
-		fmt.Printf("⚠️ %s\n", f)
-	}
-}
+// credit.go — WorkBuddy 积分查询（全部账号 + 总计），JSON 输出到 stdout。
+//
+// 用法:
+//
+//	go run ./cmd/credit        # 或编译后 ./credit
+//
+// 输出结构:
+//
+//	{"service":"workbuddy","ts":N,
+//	 "total":{"remain":N,"used":N,"size":N,"accounts":N,"ok":N,"failed":N},
+//	 "accounts":[{"uid","nickname","remain","used","size","packages","ok","error?"}]}
+//
+// 接口与聚合逻辑：POST codebuddy.cn/v2/billing/meter/get-user-resource，聚合所有 package 的
+// Cycle* 字段，TotalDosage 作 size 下限。
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+	"time"
+)
+
+const billingBaseCN = "https://www.codebuddy.cn"
+
+// billingBaseGlobal 国际版计费域。global 账号打 CN 域会得到 401：
+// www.codebuddy.cn 不认 workbuddy.ai 的 token（实测 401，workbuddy.ai 同 token 为 code=0）。
+const billingBaseGlobal = "https://www.workbuddy.ai"
+
+// billingBaseFor 按账号 realm 选择计费域。
+//
+// 判定口径与 internal/auth.Realm() 一致：显式 realm=global 或 domain 落在
+// workbuddy.ai 家族，都按国际版处理。cmd/credit 早先对所有账号硬编码 CN 域，
+// 导致 global 账号余额查询恒返回 401（面板显示的是池内缓存值，不是实时的）。
+func billingBaseFor(af *authFile) string {
+	if strings.EqualFold(strings.TrimSpace(af.Auth.Realm), "global") {
+		return billingBaseGlobal
+	}
+	d := strings.ToLower(strings.TrimSpace(af.Auth.Domain))
+	if d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai") {
+		return billingBaseGlobal
+	}
+	return billingBaseCN
+}
+
+type authFile struct {
+	Auth struct {
+		AccessToken string `json:"accessToken"`
+		Domain      string `json:"domain"`
+		Realm       string `json:"realm"`
+	} `json:"auth"`
+	Account struct {
+		UID          string `json:"uid"`
+		EnterpriseID string `json:"enterpriseId"`
+		Nickname     string `json:"nickname"`
+	} `json:"account"`
+}
+
+type accountResult struct {
+	UID      string `json:"uid"`
+	Nickname string `json:"nickname"`
+	Remain   *int64 `json:"remain"`
+	Used     *int64 `json:"used"`
+	Size     *int64 `json:"size"`
+	Packages int    `json:"packages,omitempty"`
+	OK       bool   `json:"ok"`
+	Error    string `json:"error,omitempty"`
+}
+
+type resourcePackage struct {
+	CapacityRemain      int64 `json:"CapacityRemain"`
+	CapacityUsed        int64 `json:"CapacityUsed"`
+	CapacitySize        int64 `json:"CapacitySize"`
+	CycleCapacityRemain int64 `json:"CycleCapacityRemain"`
+	CycleCapacityUsed   int64 `json:"CycleCapacityUsed"`
+	CycleCapacitySize   int64 `json:"CycleCapacitySize"`
+}
+
+// packageRemainUsed 与 billing.go:203-258 一致
+func packageRemainUsed(a resourcePackage) (remain, used, size int64) {
+	if a.CycleCapacitySize > 0 {
+		remain = a.CycleCapacityRemain
+		size = a.CycleCapacitySize
+		if remain < 0 {
+			remain = 0
+		}
+		if remain > size {
+			remain = size
+		}
+		used = size - remain
+		if a.CycleCapacityUsed > used {
+			used = a.CycleCapacityUsed
+			if size >= used {
+				remain = size - used
+			}
+		}
+		return remain, used, size
+	}
+	remain = a.CapacityRemain
+	used = a.CapacityUsed
+	size = a.CapacitySize
+	if used == 0 && size > remain {
+		used = size - remain
+	}
+	return remain, used, size
+}
+
+func fetchUserResource(af *authFile) (remain, used, size int64, packs int, err error) {
+	now := time.Now()
+	body, _ := json.Marshal(map[string]any{
+		"PageNumber":               1,
+		"PageSize":                 100,
+		"ProductCode":              "p_tcaca",
+		"Status":                   []int{0, 3},
+		"PackageEndTimeRangeBegin": now.Format("2006-01-02 15:04:05"),
+		"PackageEndTimeRangeEnd":   now.Add(365 * 101 * 24 * time.Hour).Format("2006-01-02 15:04:05"),
+	})
+	base := billingBaseFor(af)
+	// global 域无 /v2 前缀（与 internal/upstream 的 billingMeterPaths 同口径）。
+	path := "/v2/billing/meter/get-user-resource"
+	if base == billingBaseGlobal {
+		path = "/billing/meter/get-user-resource"
+	}
+	req, err := http.NewRequest(http.MethodPost, base+path, bytes.NewReader(body))
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+	req.Header.Set("Authorization", "Bearer "+af.Auth.AccessToken)
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	if af.Account.UID != "" {
+		req.Header.Set("X-User-Id", af.Account.UID)
+	}
+	if af.Account.EnterpriseID != "" {
+		req.Header.Set("X-Enterprise-Id", af.Account.EnterpriseID)
+		req.Header.Set("X-Tenant-Id", af.Account.EnterpriseID)
+	}
+	if af.Auth.Domain != "" {
+		req.Header.Set("X-Domain", af.Auth.Domain)
+	}
+	client := &http.Client{Timeout: 20 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, 0, 0, 0, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode >= 400 {
+		return 0, 0, 0, 0, fmt.Errorf("http %d", resp.StatusCode)
+	}
+	var env struct {
+		Code int    `json:"code"`
+		Msg  string `json:"msg"`
+		Data struct {
+			Response struct {
+				Data struct {
+					TotalDosage int64             `json:"TotalDosage"`
+					Accounts    []resourcePackage `json:"Accounts"`
+				} `json:"Data"`
+			} `json:"Response"`
+		} `json:"data"`
+	}
+	if err := json.NewDecoder(resp.Body).Decode(&env); err != nil {
+		return 0, 0, 0, 0, err
+	}
+	if env.Code != 0 {
+		return 0, 0, 0, 0, fmt.Errorf("code=%d %s", env.Code, env.Msg)
+	}
+	for _, a := range env.Data.Response.Data.Accounts {
+		r, u, s := packageRemainUsed(a)
+		remain += r
+		used += u
+		size += s
+	}
+	packs = len(env.Data.Response.Data.Accounts)
+	if size > 0 {
+		if derived := size - remain; derived > used {
+			used = derived
+		}
+	}
+	if dosage := env.Data.Response.Data.TotalDosage; dosage > size {
+		size = dosage
+		if derived := size - remain; derived > used {
+			used = derived
+		}
+	}
+	return remain, used, size, packs, nil
+}
+
+func main() {
+	pretty := len(os.Args) > 1 && os.Args[1] == "-pretty"
+	authDir := "./auths"
+	if v := os.Getenv("WB2A_AUTH_DIR"); v != "" {
+		authDir = v
+	}
+	files, _ := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json"))
+	sort.Strings(files)
+
+	accounts := make([]accountResult, 0, len(files))
+	for _, f := range files {
+		var af authFile
+		raw, err := os.ReadFile(f)
+		if err != nil || json.Unmarshal(raw, &af) != nil {
+			continue
+		}
+		res := accountResult{UID: af.Account.UID, Nickname: af.Account.Nickname}
+		if af.Auth.AccessToken == "" {
+			res.Error = "no accessToken"
+			accounts = append(accounts, res)
+			continue
+		}
+		remain, used, size, packs, err := fetchUserResource(&af)
+		if err != nil {
+			res.Error = err.Error()
+		} else {
+			res.Remain = &remain
+			res.Used = &used
+			res.Size = &size
+			res.Packages = packs
+			res.OK = true
+		}
+		accounts = append(accounts, res)
+		time.Sleep(200 * time.Millisecond)
+	}
+
+	var totalRemain, totalUsed, totalSize int64
+	okCount := 0
+	for _, a := range accounts {
+		if a.OK {
+			okCount++
+			if a.Remain != nil {
+				totalRemain += *a.Remain
+			}
+			if a.Used != nil {
+				totalUsed += *a.Used
+			}
+			if a.Size != nil {
+				totalSize += *a.Size
+			}
+		}
+	}
+	out := map[string]any{
+		"service": "workbuddy",
+		"ts":      time.Now().Unix(),
+		"total": map[string]any{
+			"remain":   totalRemain,
+			"used":     totalUsed,
+			"size":     totalSize,
+			"accounts": len(accounts),
+			"ok":       okCount,
+			"failed":   len(accounts) - okCount,
+		},
+		"accounts": accounts,
+	}
+	if pretty {
+		printPretty(accounts, totalRemain, totalUsed, totalSize, okCount)
+		return
+	}
+	raw, _ := json.Marshal(out)
+	fmt.Println(string(raw))
+}
+
+// printPretty 人类可读日报：四行汇总，无账号明细。
+func printPretty(accounts []accountResult, totalRemain, totalUsed, totalSize int64, okCount int) {
+	withBalance := 0
+	var failed []string
+	for _, a := range accounts {
+		if a.OK && a.Remain != nil && *a.Remain > 0 {
+			withBalance++
+		}
+		if !a.OK {
+			name := a.Nickname
+			if name == "" && len(a.UID) >= 8 {
+				name = a.UID[:8]
+			}
+			failed = append(failed, name+" "+a.Error)
+		}
+	}
+	pct := int64(0)
+	if totalSize > 0 {
+		pct = totalRemain * 100 / totalSize
+	}
+	fmt.Printf("📊 WorkBuddy 积分日报\n")
+	fmt.Printf("账号: %d/%d\n", withBalance, len(accounts))
+	fmt.Printf("总计: %d/%d\n", totalRemain, totalSize)
+	fmt.Printf("剩余: %d%%\n", pct)
+	for _, f := range failed {
+		fmt.Printf("⚠️ %s\n", f)
+	}
+}

cmd/launcher/flags.go

@@ -0,0 +1,119 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"os"
+	"strings"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/syncer"
+)
+
+// usageHead 帮助文本前半段。
+const usageHead = `wb2api-launcher —— WorkBuddy2API 独立启动器（同步凭证 + 拉起网关 + 后台对账）
+
+用法:
+  wb2api-launcher [标志]
+
+常用:
+  wb2api-launcher                     同步一次 → 启动网关 → 后台每 5 分钟对账
+  wb2api-launcher -status             只看两边差异，不启动网关（有差异退出码 2）
+  wb2api-launcher -sync-only          同步一次就退出
+  wb2api-launcher -no-sync            离线启动（跳过同步，用本地已有凭证）
+  wb2api-launcher -no-watch           不起后台对账
+  wb2api-launcher -mode pull          只拉不推
+  wb2api-launcher -version            打印版本
+
+标志:
+`
+
+// usageTail 帮助文本后半段。
+const usageTail = `
+退出码:
+  0  正常（网关退出时原样透出它的退出码）
+  1  启动阶段失败
+  2  -status 模式下存在未同步的差异
+
+配置查找:
+  config.json 默认取启动器同目录；相对路径一律以 config.json 所在目录为基准，
+  网关子进程的工作目录也会被切到那里 —— 保证"同步写的目录"就是"网关读的目录"。
+`
+
+// parseFlags 解析命令行。返回 (选项, 是否只打印版本, error)。
+func parseFlags(args []string) (options, bool, error) {
+	var (
+		opt         options
+		showVersion bool
+		modeStr     string
+		statusOnly  bool
+	)
+
+	fs := flag.NewFlagSet("wb2api-launcher", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	fs.Usage = func() {
+		fmt.Fprint(os.Stderr, usageHead)
+		fs.PrintDefaults()
+		fmt.Fprint(os.Stderr, usageTail)
+	}
+
+	fs.StringVar(&opt.configPath, "config", "", "配置文件路径（默认：启动器同目录的 config.json）")
+	fs.StringVar(&opt.serverBin, "server", "", "网关二进制路径（默认：同目录的 wb2api(.exe)，再找 PATH）")
+
+	fs.StringVar(&modeStr, "mode", "sync", "同步方向：sync / pull / push")
+	fs.BoolVar(&statusOnly, "status", false, "只看差异不写入，也不启动网关（等价 -mode sync -dry-run -sync-only）")
+	fs.BoolVar(&opt.syncOnly, "sync-only", false, "同步一次后退出，不启动网关")
+
+	fs.BoolVar(&opt.noSync, "no-sync", false, "跳过同步，直接启动网关")
+	fs.BoolVar(&opt.noWatch, "no-watch", false, "不起后台定时对账")
+	fs.DurationVar(&opt.interval, "interval", 5*time.Minute, "后台对账间隔")
+	fs.DurationVar(&opt.shutdownGrace, "shutdown-grace", 10*time.Second, "退出时等待网关优雅收尾的宽限期")
+	fs.BoolVar(&opt.quiet, "quiet", false, "减少输出（仍会打印同步结果与告警）")
+
+	// 同步参数覆盖（不写 config.json 也能跑）
+	fs.StringVar(&opt.bucket, "bucket", "", "HF 桶 ID，如 a3216/wb2api-storage")
+	fs.StringVar(&opt.token, "token", "", "HF token（更推荐写进 config.json 的 sync.token_file）")
+	fs.StringVar(&opt.endpoint, "endpoint", "", "HF 端点（默认 https://huggingface.co）")
+	fs.StringVar(&opt.include, "include-data", "", "额外同步的 data/ 文件名，逗号分隔（默认只同步凭证）")
+	fs.StringVar(&opt.writer, "writer", "", "写入通道：auto / hf / relay")
+	fs.StringVar(&opt.relayURL, "relay-url", "", "中转网关地址（relay 写入通道用）")
+	fs.StringVar(&opt.restart, "restart-space", "", "推了新凭证后重启该 Space，如 a3216/gcli2api")
+	fs.StringVar(&opt.caBundle, "ca-bundle", "", "额外 CA 证书包（PEM）；本机跑抓包代理时给 hf CLI 用")
+	fs.BoolVar(&opt.dryRun, "dry-run", false, "只展示将要做什么，不写任何东西")
+
+	fs.BoolVar(&showVersion, "version", false, "打印版本后退出")
+
+	if err := fs.Parse(args); err != nil {
+		if err == flag.ErrHelp {
+			// -h 走 Usage（已经打印过了），按成功退出。
+			return opt, true, nil
+		}
+		return opt, false, err
+	}
+	if rest := fs.Args(); len(rest) > 0 {
+		return opt, false, fmt.Errorf("未知参数: %s（用 -h 看帮助）", strings.Join(rest, " "))
+	}
+	if showVersion {
+		return opt, true, nil
+	}
+
+	mode, reportOnly, err := syncer.ParseCommand(modeStr)
+	if err != nil {
+		return opt, false, err
+	}
+	opt.mode = mode
+	// modeStr 写 "status" 时 ParseCommand 已告知只报告。
+	opt.reportOnly = reportOnly
+
+	// -status 等价于「按 sync 算一遍，但不落地、不启动网关」。
+	if statusOnly {
+		opt.mode = syncer.ModeSync
+		opt.reportOnly = true
+		opt.syncOnly = true
+	}
+	// 只报告就不可能写入：把 dry-run 也定死，避免出现自相矛盾的组合。
+	if opt.reportOnly {
+		opt.dryRun = true
+	}
+	return opt, false, nil
+}

cmd/launcher/main.go

@@ -0,0 +1,484 @@
+// wb2api-launcher —— WorkBuddy2API 的**独立启动器**。
+//
+// 为什么是一个独立 exe 而不是 shell 脚本：
+//
+//   - 上游作者更新时，你只需要替换 wb2api.exe（网关本体），启动器完全不动。
+//     启动器只做三件事——同步凭证、拉起网关、转发信号——不依赖网关的任何内部实现，
+//     也不依赖 go / python / bash / PowerShell 环境。
+//   - 同步引擎（internal/syncer）直接**编进这个 exe**，不再需要第二个 wb2api-sync
+//     二进制；后台定时对账也在同一个进程里跑，不会留下孤儿进程。
+//
+// 启动顺序刻意是「先同步、后启动」：网关只在启动时扫一遍 auths/（没有文件监听），
+// 在它扫描之前把远端凭证落下来，网关启动时就自然加载到最新的一批账号。
+//
+// 用法：
+//
+//	wb2api-launcher.exe                     # 同步 + 启动网关 + 后台对账
+//	wb2api-launcher.exe -status             # 只看两边差异，不启动网关
+//	wb2api-launcher.exe -sync-only          # 同步一次就退出
+//	wb2api-launcher.exe -no-sync            # 离线启动（跳过同步）
+//	wb2api-launcher.exe -no-watch           # 不起后台对账
+//	wb2api-launcher.exe -mode pull          # 只拉不推
+//
+// 退出码：网关的退出码原样透出；启动阶段失败返回 1；-status 有差异返回 2。
+package main
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/syncer"
+)
+
+// version 版本号（-version）。做成变量便于 -ldflags 注入。
+var version = "1.0.0"
+
+// 退出码约定。
+const (
+	exitOK      = 0
+	exitError   = 1
+	exitPending = 2 // -status 模式下存在未同步的差异
+)
+
+func main() {
+	if err := run(); err != nil {
+		fmt.Fprintf(os.Stderr, "\n[launcher] 失败: %v\n", err)
+		os.Exit(exitError)
+	}
+}
+
+// options 是解析后的启动参数。
+type options struct {
+	configPath string
+	serverBin  string
+
+	mode       syncer.Mode
+	reportOnly bool
+
+	noSync   bool
+	noWatch  bool
+	syncOnly bool
+	quiet    bool
+
+	interval      time.Duration
+	shutdownGrace time.Duration
+
+	// sync 覆盖项（不写 config.json 也能用）
+	bucket   string
+	token    string
+	endpoint string
+	include  string
+	writer   string
+	restart  string
+	caBundle string
+	relayURL string
+	dryRun   bool
+}
+
+func run() error {
+	opt, showVersion, err := parseFlags(os.Args[1:])
+	if err != nil {
+		return err
+	}
+	if showVersion {
+		fmt.Printf("wb2api-launcher %s (%s/%s)\n", version, runtime.GOOS, runtime.GOARCH)
+		return nil
+	}
+
+	exePath, err := os.Executable()
+	if err != nil {
+		return fmt.Errorf("无法定位启动器自身路径: %w", err)
+	}
+	exeDir := filepath.Dir(exePath)
+
+	// 配置文件默认放在启动器旁边——"解压到目录、双击"即可用。
+	if opt.configPath == "" {
+		opt.configPath = filepath.Join(exeDir, "config.json")
+	} else if !filepath.IsAbs(opt.configPath) {
+		opt.configPath = filepath.Join(exeDir, opt.configPath)
+	}
+	absCfg, err := filepath.Abs(opt.configPath)
+	if err != nil {
+		return err
+	}
+	cfgDir := filepath.Dir(absCfg)
+
+	ensureConfig(absCfg, exeDir, cfgDir)
+
+	// 关键：把工作目录切到 config.json 所在目录，再启动网关。
+	// 这样配置里的相对路径（./auths、./data/state.json）对"启动器的同步"和
+	// "网关子进程"是**同一个**目录，不会出现同步写 A、网关读 B 的错位。
+	if err := os.Chdir(cfgDir); err != nil {
+		return fmt.Errorf("切换工作目录到 %s 失败: %w", cfgDir, err)
+	}
+
+	syncCfg, err := loadSyncConfig(absCfg, opt)
+	if err != nil {
+		return err
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	var engine *syncer.Engine
+	if !opt.noSync {
+		engine, err = newEngine(ctx, syncCfg, opt)
+		if err != nil {
+			// 同步配置不全不是致命错误：照样能把网关拉起来（离线自用）。
+			info("同步未启用：%v", err)
+		}
+	}
+
+	if engine != nil {
+		if code := preflightSync(ctx, engine, opt); code != exitOK {
+			if opt.syncOnly || opt.reportOnly {
+				os.Exit(code)
+			}
+			// 启动阶段同步失败不阻断启动：断网/中转挂了不该让你连本地网关都用不了。
+		}
+	}
+
+	if opt.syncOnly || opt.reportOnly {
+		return nil
+	}
+
+	serverBin, err := findServer(opt.serverBin, exeDir)
+	if err != nil {
+		return err
+	}
+
+	info("网关二进制：%s", serverBin)
+	info("配置：%s", absCfg)
+	info("运行目录：%s", cfgDir)
+
+	child := exec.Command(serverBin, "-config", absCfg)
+	child.Stdin = os.Stdin
+	child.Stdout = os.Stdout
+	child.Stderr = os.Stderr
+	child.Dir = cfgDir
+	if err := child.Start(); err != nil {
+		return fmt.Errorf("启动网关失败 (%s): %w", serverBin, err)
+	}
+	info("网关已启动 (PID %d)", child.Process.Pid)
+
+	// 后台对账：跑在同一个进程里��不会留下孤儿进程。
+	if engine != nil && !opt.noWatch {
+		go watchLoop(ctx, engine, opt)
+	}
+
+	// 等子进程退出。Ctrl-C 在这个控制台里会同时送到启动器与网关，
+	// 网关收到后会 Flush() 落盘再做优雅停机——所以这里给一段宽限期让它自己收尾。
+	done := make(chan error, 1)
+	go func() { done <- child.Wait() }()
+
+	select {
+	case werr := <-done:
+		return exitCodeOf(werr)
+	case <-ctx.Done():
+		info("收到中断信号，等待网关优雅退出（最多 %s）...", opt.shutdownGrace)
+		if err := waitOrKill(child, done, opt.shutdownGrace); err != nil {
+			return err
+		}
+		return nil
+	}
+}
+
+// waitOrKill 给子进程一段宽限期自行退出，超时才强杀。
+//
+// 为什么优先"等"而不是直接 Kill：网关在收到 SIGINT/SIGTERM 时会先
+// Pool.Flush() 把内存状态落盘再 Shutdown；直接杀掉会丢掉最后一次状态落盘
+// （积分/冷却/连登计数都是攒在内存里定时刷的）。
+func waitOrKill(child *exec.Cmd, done <-chan error, grace time.Duration) error {
+	select {
+	case <-done:
+		info("网关已优雅退出")
+	case <-time.After(grace):
+		info("宽限期已到，强制结束网关进程")
+		if child.Process != nil {
+			_ = child.Process.Kill()
+		}
+		<-done
+	}
+	return nil
+}
+
+// exitCodeOf 把 Wait 的错误翻译成退出码。
+func exitCodeOf(err error) error {
+	if err == nil {
+		return nil
+	}
+	var ee *exec.ExitError
+	if errors.As(err, &ee) {
+		// 原样透出子进程退出码，便于外层脚本判断。
+		os.Exit(ee.ExitCode())
+	}
+	return err
+}
+
+// preflightSync 启动前同步一次。返回退出码。
+func preflightSync(ctx context.Context, engine *syncer.Engine, opt options) int {
+	fmt.Println()
+	info("━━ 启动前同步（模式 %s）━━", opt.mode)
+	plan, res, err := engine.Sync(ctx, opt.mode, opt.dryRun)
+	if err != nil {
+		warn("同步失败：%v", err)
+		warn("按本地已有凭证继续启动，本次不做远端对账。")
+		return exitError
+	}
+	printPlan(plan, res, opt)
+	if res.Failed > 0 {
+		warn("%d 个文件同步失败，按本地已有凭证继续启动。", res.Failed)
+		return exitError
+	}
+	if opt.reportOnly && plan.Changes() > 0 {
+		return exitPending
+	}
+	if plan.Changes() == 0 {
+		info("已与中转一致（无改动）")
+	}
+
+	// 本地一个凭证都没有时，网关起来是空池（/healthz 503），把原因说清楚。
+	if n := countAuthFiles(engine.Config().AuthDir); n == 0 {
+		warn("auths/ 里没有任何账号 —— 网关会以空池启动（/healthz 会返回 503）。")
+		warn("  检查 config.json 的 sync.bucket / sync.token。")
+	}
+	return exitOK
+}
+
+// watchLoop 常驻后台对账：把本地运行期刷新出来的新 token 持续推回中转。
+func watchLoop(ctx context.Context, engine *syncer.Engine, opt options) {
+	t := time.NewTicker(opt.interval)
+	defer t.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-t.C:
+			plan, res, err := engine.Sync(ctx, syncer.ModeSync, false)
+			switch {
+			case err != nil:
+				warn("[后台对账] 出错：%v", err)
+			case res.Failed > 0:
+				warn("[后台对账] 上传 %d / 下载 %d / 失败 %d", res.Uploaded, res.Downloaded, res.Failed)
+			case plan.Changes() > 0:
+				info("[后台对账] 上传 %d / 下载 %d", res.Uploaded, res.Downloaded)
+				for _, a := range plan.Actions {
+					if a.Op == syncer.OpNoop {
+						continue
+					}
+					info("  %s %s  (%s)", opIcon(a.Op), a.Path, a.Reason)
+				}
+			}
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// 配置
+// ---------------------------------------------------------------------------
+
+// loadSyncConfig 读取 config.json 的 sync 段并叠加命令行覆盖。
+func loadSyncConfig(cfgPath string, opt options) (syncer.Config, error) {
+	cfg, err := syncer.LoadConfigFile(cfgPath)
+	if err != nil && !os.IsNotExist(err) {
+		return syncer.Config{}, fmt.Errorf("读取 %s 失败: %w", cfgPath, err)
+	}
+	if opt.bucket != "" {
+		cfg.Bucket = opt.bucket
+	}
+	if opt.token != "" {
+		cfg.Token = opt.token
+	}
+	if opt.endpoint != "" {
+		cfg.Endpoint = opt.endpoint
+	}
+	if opt.writer != "" {
+		cfg.Writer = opt.writer
+	}
+	if opt.relayURL != "" {
+		cfg.RelayURL = opt.relayURL
+	}
+	if opt.restart != "" {
+		cfg.RestartSpace = opt.restart
+	}
+	if opt.caBundle != "" {
+		cfg.CABundle = opt.caBundle
+	}
+	if opt.include != "" {
+		var list []string
+		for _, p := range strings.Split(opt.include, ",") {
+			if p = strings.TrimSpace(p); p != "" {
+				list = append(list, p)
+			}
+		}
+		cfg.IncludeData = list
+	}
+	if cfg.Token == "" && cfg.TokenFile == "" {
+		if t := strings.TrimSpace(os.Getenv("HF_TOKEN")); t != "" {
+			cfg.Token = t
+		}
+	}
+	cfg.Normalize()
+	if cfg.AuthDir == "" {
+		cfg.AuthDir = "auths"
+	}
+	if cfg.DataDir == "" {
+		cfg.DataDir = "data"
+	}
+	return cfg, nil
+}
+
+// newEngine 构造同步引擎；必要时先从桶里取中转的 api_key（relay 写入通道用）。
+func newEngine(ctx context.Context, cfg syncer.Config, opt options) (*syncer.Engine, error) {
+	if cfg.Bucket == "" {
+		return nil, fmt.Errorf("config.json 的 sync.bucket 为空（未配置中转桶）")
+	}
+	eng, err := syncer.New(cfg)
+	if err != nil {
+		return nil, err
+	}
+	if eng.WriterName() == "relay" && eng.Config().RelayKey == "" {
+		if key, kerr := eng.FetchRemoteAPIKey(ctx); kerr == nil {
+			cfg.RelayKey = key
+			if eng, err = syncer.New(cfg); err != nil {
+				return nil, err
+			}
+		}
+	}
+	return eng, nil
+}
+
+// ensureConfig 首启兜底：没有 config.json 时从 config.example.json 复制一份。
+//
+// 刻意不在这里生成带随机 api_key 的最小配置：网关自己首启就会生成推荐配置
+// （含 crypto/rand 的 api_key），启动器不该抢着替它写一份半成品。
+func ensureConfig(cfgPath, exeDir, cfgDir string) {
+	if _, err := os.Stat(cfgPath); err == nil {
+		return
+	}
+	for _, cand := range []string{
+		filepath.Join(cfgDir, "config.example.json"),
+		filepath.Join(exeDir, "config.example.json"),
+	} {
+		if raw, err := os.ReadFile(cand); err == nil {
+			if werr := os.WriteFile(cfgPath, raw, 0o600); werr == nil {
+				warn("未找到 config.json，已从 %s 复制一份。请按需修改（尤其是 api_key 与 sync 段）。", filepath.Base(cand))
+				return
+			}
+		}
+	}
+	info("未找到 config.json，也没有 config.example.json —— 交给网关自行生成默认配置。")
+}
+
+// findServer 定位网关二进制。
+//
+// 查找顺序：-server 显式指定 → 启动器同目录（Windows 下 wb2api.exe）→ PATH。
+// 这样"把新下载的 wb2api.exe 丢到启动器旁边"就是完整的升级动作。
+func findServer(explicit, exeDir string) (string, error) {
+	names := []string{"wb2api"}
+	if runtime.GOOS == "windows" {
+		names = []string{"wb2api.exe", "wb2api"}
+	}
+	if explicit != "" {
+		p := explicit
+		if !filepath.IsAbs(p) {
+			p = filepath.Join(exeDir, explicit)
+		}
+		if st, err := os.Stat(p); err == nil && !st.IsDir() {
+			return p, nil
+		}
+		return "", fmt.Errorf("-server 指定的文件不存在: %s", p)
+	}
+	for _, n := range names {
+		p := filepath.Join(exeDir, n)
+		if st, err := os.Stat(p); err == nil && !st.IsDir() {
+			return p, nil
+		}
+	}
+	for _, n := range names {
+		if p, err := exec.LookPath(n); err == nil {
+			return p, nil
+		}
+	}
+	return "", fmt.Errorf("找不到网关二进制 wb2api（找了 %s 与 PATH）。\n"+
+		"  把 wb2api.exe 放在启动器同目录，或用 -server 指定路径", strings.Join(names, " / "))
+}
+
+// countAuthFiles 数本地凭证文件个数。
+func countAuthFiles(dir string) int {
+	entries, err := os.ReadDir(dir)
+	if err != nil {
+		return 0
+	}
+	n := 0
+	for _, e := range entries {
+		if !e.IsDir() && strings.HasSuffix(strings.ToLower(e.Name()), ".json") {
+			n++
+		}
+	}
+	return n
+}
+
+// ---------------------------------------------------------------------------
+// 输出
+// ---------------------------------------------------------------------------
+
+func info(format string, a ...any) {
+	fmt.Printf("[launcher] "+format+"\n", a...)
+}
+
+func warn(format string, a ...any) {
+	fmt.Printf("[launcher] ⚠ "+format+"\n", a...)
+}
+
+func opIcon(op syncer.Op) string {
+	switch op {
+	case syncer.OpUpload:
+		return "↑"
+	case syncer.OpDownload:
+		return "↓"
+	default:
+		return "="
+	}
+}
+
+// printPlan 打印对账结果（只列有动作的行，一致的不刷屏）。
+func printPlan(plan *syncer.Plan, res *syncer.Result, opt options) {
+	cfgWriter := ""
+	if plan.Writer != "" {
+		cfgWriter = plan.Writer
+	} else {
+		cfgWriter = "(只读)"
+	}
+	info("桶 %s · 写入通道 %s · 本地 %d / 远端 %d 个文件",
+		plan.Bucket, cfgWriter, plan.LocalFiles, plan.RemoteFiles)
+
+	for _, a := range plan.Actions {
+		if a.Op == syncer.OpNoop && !a.Conflict {
+			continue
+		}
+		line := fmt.Sprintf("  %s %-8s %s", opIcon(a.Op), a.Op, a.Path)
+		if a.Conflict {
+			line += "  [冲突]"
+		}
+		fmt.Println(line)
+		fmt.Printf("        %s\n", a.Reason)
+		if a.Err != "" {
+			fmt.Printf("        ✗ %s\n", a.Err)
+		}
+	}
+	info("汇总：上传 %d / 下载 %d / 跳过 %d / 失败 %d",
+		res.Uploaded, res.Downloaded, res.Skipped, res.Failed)
+	for _, e := range res.Errors {
+		warn("%s", e)
+	}
+}

cmd/login/main.go

@@ -1,336 +1,336 @@
-// login.go — WorkBuddy OAuth 登录（设备授权流程，CN realm；--realm=global 供国际版）。
-//
-// 两个子命令，由 login.sh 顺序驱动：
-//
-//	login [--realm=cn|global] url   → POST /v2/plugin/auth/state?platform=CLI 拿 state+authUrl，
-//	                                  state 落 /tmp/wb2api-login-state.json，stdout 打印授权 URL
-//	login [--realm=cn|global] poll  → 读 state，GET /v2/plugin/auth/token?state= 一次，
-//	                                  成功再 GET /v2/plugin/login/account?state= 拿 uid/nickname，
-//	                                  stdout 打印完整 token+account JSON（含 realm 键）
-//
-// --realm 默认 cn。按 realm 切换上游端点与 Origin/Referer：
-//
-//	cn     → https://copilot.tencent.com（Origin: https://www.codebuddy.cn）
-//	global → https://www.workbuddy.ai（Origin: https://www.workbuddy.ai）
-//
-// state 落盘带 realm，poll 读回校验与命令行 --realm 一致（防混域）。
-// 无 PKCE（workbuddy 设备流由服务端签发 state）。
-package main
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/http/cookiejar"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-
-	auth2 "github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-)
-
-// 上游常量：CN → copilot.tencent.com（Origin 为 codebuddy.cn）；global → www.workbuddy.ai
-// （base 与 Origin/Referer 同域）。端点 URL 由 realmConfig 按 realm 动态拼出，不再硬编码。
-const (
-	upstreamBaseCN      = "https://copilot.tencent.com"
-	upstreamBaseGlobal  = "https://www.workbuddy.ai"
-	clientUA            = "CLI/2.63.2 CodeBuddy/2.63.2"
-	originRefererCN     = "https://www.codebuddy.cn"
-	originRefererGlobal = "https://www.workbuddy.ai"
-)
-
-// 登录 state 落盘路径（var 便于测试替换临时文件）
-// Portable across OSes: the upstream hardcoded "/tmp/...", which on
-// Windows resolves to <drive>:\tmp\... and aborts the OAuth flow with
-// "The system cannot find the path specified". os.TempDir() is /tmp on Linux.
-var stateFile = filepath.Join(os.TempDir(), "wb2api-login-state.json")
-
-// exitFunc 供测试替换（默认 os.Exit；测试持临时替换为 panic 以进程内捕获 fatal）。
-var exitFunc = os.Exit
-
-// realmConfig 按 realm 返回上游 base 与 Origin/Referer origin：global →
-// (www.workbuddy.ai, www.workbuddy.ai)；cn/非法/缺省 → (copilot.tencent.com, codebuddy.cn)。
-func realmConfig(realm string) (base, origin string) {
-	if realm == realmGlobal {
-		return upstreamBaseGlobal, originRefererGlobal
-	}
-	return upstreamBaseCN, originRefererCN
-}
-
-// commonHeaders 按 origin 设置通用请求头（Origin/Referer 随 realm 变化）。
-// 返回 func(*http.Request)，由调用方按 realm 选定的 origin 构造一次后复用。
-func commonHeaders(origin string) func(*http.Request) {
-	return func(req *http.Request) {
-		req.Header.Set("Content-Type", "application/json")
-		req.Header.Set("Accept", "application/json, text/plain, */*")
-		req.Header.Set("X-Requested-With", "XMLHttpRequest")
-		req.Header.Set("Origin", origin)
-		req.Header.Set("Referer", origin+"/")
-		req.Header.Set("User-Agent", clientUA)
-	}
-}
-
-// apiEnvelope 与 main.go:429-433 一致
-type apiEnvelope struct {
-	Code int             `json:"code"`
-	Msg  string          `json:"msg"`
-	Data json.RawMessage `json:"data"`
-}
-
-// doJSON 与 oauth.go:33-66 一致：{code,msg,data} 信封，code!=0 → error
-func doJSON(client *http.Client, method, fullURL string, headers func(*http.Request), body io.Reader) (json.RawMessage, int, error) {
-	req, err := http.NewRequest(method, fullURL, body)
-	if err != nil {
-		return nil, 0, err
-	}
-	if headers != nil {
-		headers(req)
-	} else {
-		// 缺省头：CN origin（与原 commonHeaders() 行为一致，零回归）
-		commonHeaders(originRefererCN)(req)
-	}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer resp.Body.Close()
-	raw, _ := io.ReadAll(resp.Body)
-	if resp.StatusCode >= 400 {
-		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode)
-	}
-	if resp.StatusCode >= 300 {
-		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream redirect %d", resp.StatusCode)
-	}
-	var env apiEnvelope
-	if err := json.Unmarshal(raw, &env); err != nil {
-		return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err)
-	}
-	if env.Code != 0 {
-		return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg)
-	}
-	return env.Data, resp.StatusCode, nil
-}
-
-func fatal(format string, args ...any) {
-	fmt.Fprintf(os.Stderr, "login: "+format+"\n", args...)
-	exitFunc(1)
-}
-
-type loginState struct {
-	State string `json:"state"`
-	Realm string `json:"realm,omitempty"` // url 落盘时写回的 realm，poll 读回校验防混域
-}
-
-// realm 取值枚举（与 internal/auth 的 Realm() 归一化输出一致）。
-const (
-	realmCN     = "cn"
-	realmGlobal = "global"
-)
-
-// parseRealmArgs 解析开头的 --realm=cn|global（或分离式 --realm <v>）flag，缺省 cn。
-// 大小写不敏感归一化；非法值/缺值报错。桌椅剩余参数（子命令）顺序不变。
-func parseRealmArgs(args []string) (realm string, rest []string, err error) {
-	realm = realmCN
-	for i := 0; i < len(args); i++ {
-		a := args[i]
-		switch {
-		case a == "--realm":
-			if i+1 >= len(args) {
-				return "", nil, fmt.Errorf("--realm requires a value")
-			}
-			v := strings.ToLower(strings.TrimSpace(args[i+1]))
-			if v != realmCN && v != realmGlobal {
-				return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", args[i+1])
-			}
-			realm = v
-			i++
-		case strings.HasPrefix(a, "--realm="):
-			v := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(a, "--realm=")))
-			if v != realmCN && v != realmGlobal {
-				return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", v)
-			}
-			realm = v
-		default:
-			rest = append(rest, a)
-		}
-	}
-	return realm, rest, nil
-}
-
-// resolveRealmInput 把交互式选域的一行输入归一化为 realm（纯函数，login.sh 交互分支
-// 的核心决策，可测）。规则：
-//
-//	"1"/"cn"（大小写不敏感）/""（回车默认）→ cn
-//	"2"/"global" → global
-//	其他 → ("", false)（调用方回默认 cn）
-func resolveRealmInput(input string) (string, bool) {
-	switch strings.ToLower(strings.TrimSpace(input)) {
-	case "", "1", "cn":
-		return realmCN, true
-	case "2", "global":
-		return realmGlobal, true
-	}
-	return "", false
-}
-
-// promptRealm 交互式选域：向 out 打印选项提示（out 接 stderr，stdout 留给 realm 本身），
-// 从 in 读一行，返回归一化 realm。非法输入警告后回落 cn；EOF（非交互/管道）回落 cn。
-func promptRealm(in io.Reader, out io.Writer) string {
-	fmt.Fprintln(out, "选择登录版本: 1) 国内版(cn) 2) 国际版(global) [默认 1/cn]: ")
-	line, err := bufio.NewReader(in).ReadString('\n')
-	if err != nil && line == "" {
-		// EOF/非交互 → 回落默认 cn
-		return realmCN
-	}
-	if realm, ok := resolveRealmInput(line); ok {
-		return realm
-	}
-	fmt.Fprintln(out, "无效选择，默认国内版 cn")
-	return realmCN
-}
-
-// validateRealmMatch 校验 state 文件 realm 与命令行 --realm 一致（防混域）：
-// state 无 realm（旧文件）放行；非空且不一致 → error。
-func validateRealmMatch(stateRealm, cliRealm string) error {
-	if stateRealm != "" && stateRealm != cliRealm {
-		return fmt.Errorf("realm mismatch: state file realm=%q, command --realm=%q（url 与 poll 需同一 realm）", stateRealm, cliRealm)
-	}
-	return nil
-}
-
-// runURL 执行 url 子命令：向 upstreamBase 的 state 端点 POST 取授权 URL，
-// state 落盘（带 realm），stdout 打印 authURL。out 接 stdout；stateFile 为落盘路径
-// （可注入临时文件便于测试）。空 realm 视为缺省（调用方已归一）。
-func runURL(base, origin, realm, statePath string, client *http.Client, out io.Writer) {
-	headers := commonHeaders(origin)
-	data, _, err := doJSON(client, http.MethodPost, base+"/v2/plugin/auth/state?platform=CLI", headers, bytes.NewReader([]byte("{}")))
-	if err != nil {
-		fatal("auth state failed: %v", err)
-	}
-	var st struct {
-		State   string `json:"state"`
-		AuthURL string `json:"authUrl"`
-	}
-	if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" {
-		fatal("auth state: missing state or authUrl")
-	}
-	raw, _ := json.Marshal(loginState{State: st.State, Realm: realm})
-	if err := os.WriteFile(statePath, raw, 0o600); err != nil {
-		fatal("write state: %v", err)
-	}
-	fmt.Fprintln(out, st.AuthURL)
-}
-
-// runPoll 执行 poll 子命令：读 state 文件（realm 校验），向 upstreamBase 的 token 端点
-// GET 一次，成功再 GET login/account（带 Bearer），stdout 打印完整 token+account JSON。
-// statePath 可注入临时文件便于测试。
-func runPoll(base, origin, realm, statePath string, client *http.Client, out io.Writer) {
-	raw, err := os.ReadFile(statePath)
-	if err != nil {
-		fatal("read state: %v (先跑 login url)", err)
-	}
-	var ls loginState
-	if err := json.Unmarshal(raw, &ls); err != nil {
-		fatal("parse state: %v", err)
-	}
-	// 防混域：state 落盘 realm 与命令行 --realm 不一致则拒绝（url 与 poll 必须同域）
-	if err := validateRealmMatch(ls.Realm, realm); err != nil {
-		fatal("%v", err)
-	}
-	headers := commonHeaders(origin)
-	// handlePollLogin (oauth.go:108-162)：auth/token 是权威登录状态端点，
-	// pending 时业务 code 非 0（"login ing"），完成时 code=0 + token bundle
-	tokRaw, status, errTok := doJSON(client, http.MethodGet, base+"/v2/plugin/auth/token?state="+ls.State, headers, nil)
-	if errTok != nil {
-		if status == 0 || status >= 500 {
-			fatal("token endpoint error: %v", errTok)
-		}
-		fatal("登录未完成（waiting for login）。请确认已在浏览器完成登录再按 y")
-	}
-	var tok struct {
-		AccessToken  string `json:"accessToken"`
-		RefreshToken string `json:"refreshToken"`
-		ExpiresIn    int64  `json:"expiresIn"`
-		Domain       string `json:"domain"`
-	}
-	if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" {
-		fatal("登录未完成（waiting for login）。请确认已在浏览器完成登录再按 y")
-	}
-	// login/account 拿 uid/nickname（带 Bearer）
-	var acct struct {
-		UID          string `json:"uid"`
-		EnterpriseID string `json:"enterpriseId"`
-		Nickname     string `json:"nickname"`
-	}
-	acctHeaders := func(r *http.Request) {
-		headers(r)
-		r.Header.Set("Authorization", "Bearer "+tok.AccessToken)
-	}
-	if acctRaw, _, errAcct := doJSON(client, http.MethodGet, base+"/v2/plugin/login/account?state="+ls.State, acctHeaders, nil); errAcct == nil {
-		_ = json.Unmarshal(acctRaw, &acct)
-	}
-	oraw, _ := json.Marshal(buildLoginOutput(tok, realm, acct))
-	fmt.Fprintln(out, string(oraw))
-	os.Remove(statePath)
-}
-
-// buildLoginOutput 组装 poll 输出的完整 JSON（login.sh 据此落盘 auth 文件）。
-// realm 永不空：显式 --realm 优先（ResolveRealm 处理），否则按上游返回的 domain 推断——
-// 保证登录落盘的 auth 文件恒带 realm 键。
-func buildLoginOutput(tok struct {
-	AccessToken  string `json:"accessToken"`
-	RefreshToken string `json:"refreshToken"`
-	ExpiresIn    int64  `json:"expiresIn"`
-	Domain       string `json:"domain"`
-}, realm string, acct struct {
-	UID          string `json:"uid"`
-	EnterpriseID string `json:"enterpriseId"`
-	Nickname     string `json:"nickname"`
-}) map[string]any {
-	return map[string]any{
-		"access_token":  tok.AccessToken,
-		"refresh_token": tok.RefreshToken,
-		"expires_in":    tok.ExpiresIn,
-		"domain":        tok.Domain,
-		"realm":         auth2.ResolveRealm(realm, tok.Domain),
-		"uid":           acct.UID,
-		"enterprise_id": acct.EnterpriseID,
-		"nickname":      acct.Nickname,
-	}
-}
-
-func main() {
-	realm, rest, err := parseRealmArgs(os.Args[1:])
-	if err != nil {
-		fatal("%v (usage: login [--realm=cn|global] <url|poll|realm>)", err)
-	}
-	if len(rest) < 1 {
-		fatal("usage: login [--realm=cn|global] <url|poll>")
-	}
-	// 每个流程独立 cookie jar（oauth.go:22-29：多账号登录互不串会话）
-	jar, _ := cookiejar.New(nil)
-	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
-
-	base, origin := realmConfig(realm)
-
-	switch rest[0] {
-	case "url":
-		runURL(base, origin, realm, stateFile, client, os.Stdout)
-
-	case "poll":
-		runPoll(base, origin, realm, stateFile, client, os.Stdout)
-
-	case "realm":
-		// 交互式选域（login.sh 无 --realm 传参且 stdin 为 tty 时调用）。
-		// 提示打到 stderr，stdout 只输出归一化 realm，供 $( ) 捕获。
-		realm := promptRealm(os.Stdin, os.Stderr)
-		fmt.Println(realm)
-
-	default:
-		fatal("unknown subcommand %q (want url|poll|realm)", rest[0])
-	}
-}
+// login.go — WorkBuddy OAuth 登录（设备授权流程，CN realm；--realm=global 供国际版）。
+//
+// 两个子命令，由 login.sh 顺序驱动：
+//
+//	login [--realm=cn|global] url   → POST /v2/plugin/auth/state?platform=CLI 拿 state+authUrl，
+//	                                  state 落 /tmp/wb2api-login-state.json，stdout 打印授权 URL
+//	login [--realm=cn|global] poll  → 读 state，GET /v2/plugin/auth/token?state= 一次，
+//	                                  成功再 GET /v2/plugin/login/account?state= 拿 uid/nickname，
+//	                                  stdout 打印完整 token+account JSON（含 realm 键）
+//
+// --realm 默认 cn。按 realm 切换上游端点与 Origin/Referer：
+//
+//	cn     → https://copilot.tencent.com（Origin: https://www.codebuddy.cn）
+//	global → https://www.workbuddy.ai（Origin: https://www.workbuddy.ai）
+//
+// state 落盘带 realm，poll 读回校验与命令行 --realm 一致（防混域）。
+// 无 PKCE（workbuddy 设备流由服务端签发 state）。
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/cookiejar"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	auth2 "github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+)
+
+// 上游常量：CN → copilot.tencent.com（Origin 为 codebuddy.cn）；global → www.workbuddy.ai
+// （base 与 Origin/Referer 同域）。端点 URL 由 realmConfig 按 realm 动态拼出，不再硬编码。
+const (
+	upstreamBaseCN      = "https://copilot.tencent.com"
+	upstreamBaseGlobal  = "https://www.workbuddy.ai"
+	clientUA            = "CLI/2.63.2 CodeBuddy/2.63.2"
+	originRefererCN     = "https://www.codebuddy.cn"
+	originRefererGlobal = "https://www.workbuddy.ai"
+)
+
+// 登录 state 落盘路径（var 便于测试替换临时文件）
+// Portable across OSes: the upstream hardcoded "/tmp/...", which on
+// Windows resolves to <drive>:\tmp\... and aborts the OAuth flow with
+// "The system cannot find the path specified". os.TempDir() is /tmp on Linux.
+var stateFile = filepath.Join(os.TempDir(), "wb2api-login-state.json")
+
+// exitFunc 供测试替换（默认 os.Exit；测试持临时替换为 panic 以进程内捕获 fatal）。
+var exitFunc = os.Exit
+
+// realmConfig 按 realm 返回上游 base 与 Origin/Referer origin：global →
+// (www.workbuddy.ai, www.workbuddy.ai)；cn/非法/缺省 → (copilot.tencent.com, codebuddy.cn)。
+func realmConfig(realm string) (base, origin string) {
+	if realm == realmGlobal {
+		return upstreamBaseGlobal, originRefererGlobal
+	}
+	return upstreamBaseCN, originRefererCN
+}
+
+// commonHeaders 按 origin 设置通用请求头（Origin/Referer 随 realm 变化）。
+// 返回 func(*http.Request)，由调用方按 realm 选定的 origin 构造一次后复用。
+func commonHeaders(origin string) func(*http.Request) {
+	return func(req *http.Request) {
+		req.Header.Set("Content-Type", "application/json")
+		req.Header.Set("Accept", "application/json, text/plain, */*")
+		req.Header.Set("X-Requested-With", "XMLHttpRequest")
+		req.Header.Set("Origin", origin)
+		req.Header.Set("Referer", origin+"/")
+		req.Header.Set("User-Agent", clientUA)
+	}
+}
+
+// apiEnvelope 与 main.go:429-433 一致
+type apiEnvelope struct {
+	Code int             `json:"code"`
+	Msg  string          `json:"msg"`
+	Data json.RawMessage `json:"data"`
+}
+
+// doJSON 与 oauth.go:33-66 一致：{code,msg,data} 信封，code!=0 → error
+func doJSON(client *http.Client, method, fullURL string, headers func(*http.Request), body io.Reader) (json.RawMessage, int, error) {
+	req, err := http.NewRequest(method, fullURL, body)
+	if err != nil {
+		return nil, 0, err
+	}
+	if headers != nil {
+		headers(req)
+	} else {
+		// 缺省头：CN origin（与原 commonHeaders() 行为一致，零回归）
+		commonHeaders(originRefererCN)(req)
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(resp.Body)
+	if resp.StatusCode >= 400 {
+		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode)
+	}
+	if resp.StatusCode >= 300 {
+		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream redirect %d", resp.StatusCode)
+	}
+	var env apiEnvelope
+	if err := json.Unmarshal(raw, &env); err != nil {
+		return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err)
+	}
+	if env.Code != 0 {
+		return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg)
+	}
+	return env.Data, resp.StatusCode, nil
+}
+
+func fatal(format string, args ...any) {
+	fmt.Fprintf(os.Stderr, "login: "+format+"\n", args...)
+	exitFunc(1)
+}
+
+type loginState struct {
+	State string `json:"state"`
+	Realm string `json:"realm,omitempty"` // url 落盘时写回的 realm，poll 读回校验防混域
+}
+
+// realm 取值枚举（与 internal/auth 的 Realm() 归一化输出一致）。
+const (
+	realmCN     = "cn"
+	realmGlobal = "global"
+)
+
+// parseRealmArgs 解析开头的 --realm=cn|global（或分离式 --realm <v>）flag，缺省 cn。
+// 大小写不敏感归一化；非法值/缺值报错。桌椅剩余参数（子命令）顺序不变。
+func parseRealmArgs(args []string) (realm string, rest []string, err error) {
+	realm = realmCN
+	for i := 0; i < len(args); i++ {
+		a := args[i]
+		switch {
+		case a == "--realm":
+			if i+1 >= len(args) {
+				return "", nil, fmt.Errorf("--realm requires a value")
+			}
+			v := strings.ToLower(strings.TrimSpace(args[i+1]))
+			if v != realmCN && v != realmGlobal {
+				return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", args[i+1])
+			}
+			realm = v
+			i++
+		case strings.HasPrefix(a, "--realm="):
+			v := strings.ToLower(strings.TrimSpace(strings.TrimPrefix(a, "--realm=")))
+			if v != realmCN && v != realmGlobal {
+				return "", nil, fmt.Errorf("invalid --realm %q (want cn|global)", v)
+			}
+			realm = v
+		default:
+			rest = append(rest, a)
+		}
+	}
+	return realm, rest, nil
+}
+
+// resolveRealmInput 把交互式选域的一行输入归一化为 realm（纯函数，login.sh 交互分支
+// 的核心决策，可测）。规则：
+//
+//	"1"/"cn"（大小写不敏感）/""（回车默认）→ cn
+//	"2"/"global" → global
+//	其他 → ("", false)（调用方回默认 cn）
+func resolveRealmInput(input string) (string, bool) {
+	switch strings.ToLower(strings.TrimSpace(input)) {
+	case "", "1", "cn":
+		return realmCN, true
+	case "2", "global":
+		return realmGlobal, true
+	}
+	return "", false
+}
+
+// promptRealm 交互式选域：向 out 打印选项提示（out 接 stderr，stdout 留给 realm 本身），
+// 从 in 读一行，返回归一化 realm。非法输入警告后回落 cn；EOF（非交互/管道）回落 cn。
+func promptRealm(in io.Reader, out io.Writer) string {
+	fmt.Fprintln(out, "选择登录版本: 1) 国内版(cn) 2) 国际版(global) [默认 1/cn]: ")
+	line, err := bufio.NewReader(in).ReadString('\n')
+	if err != nil && line == "" {
+		// EOF/非交互 → 回落默认 cn
+		return realmCN
+	}
+	if realm, ok := resolveRealmInput(line); ok {
+		return realm
+	}
+	fmt.Fprintln(out, "无效选择，默认国内版 cn")
+	return realmCN
+}
+
+// validateRealmMatch 校验 state 文件 realm 与命令行 --realm 一致（防混域）：
+// state 无 realm（旧文件）放行；非空且不一致 → error。
+func validateRealmMatch(stateRealm, cliRealm string) error {
+	if stateRealm != "" && stateRealm != cliRealm {
+		return fmt.Errorf("realm mismatch: state file realm=%q, command --realm=%q（url 与 poll 需同一 realm）", stateRealm, cliRealm)
+	}
+	return nil
+}
+
+// runURL 执行 url 子命令：向 upstreamBase 的 state 端点 POST 取授权 URL，
+// state 落盘（带 realm），stdout 打印 authURL。out 接 stdout；stateFile 为落盘路径
+// （可注入临时文件便于测试）。空 realm 视为缺省（调用方已归一）。
+func runURL(base, origin, realm, statePath string, client *http.Client, out io.Writer) {
+	headers := commonHeaders(origin)
+	data, _, err := doJSON(client, http.MethodPost, base+"/v2/plugin/auth/state?platform=CLI", headers, bytes.NewReader([]byte("{}")))
+	if err != nil {
+		fatal("auth state failed: %v", err)
+	}
+	var st struct {
+		State   string `json:"state"`
+		AuthURL string `json:"authUrl"`
+	}
+	if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" {
+		fatal("auth state: missing state or authUrl")
+	}
+	raw, _ := json.Marshal(loginState{State: st.State, Realm: realm})
+	if err := os.WriteFile(statePath, raw, 0o600); err != nil {
+		fatal("write state: %v", err)
+	}
+	fmt.Fprintln(out, st.AuthURL)
+}
+
+// runPoll 执行 poll 子命令：读 state 文件（realm 校验），向 upstreamBase 的 token 端点
+// GET 一次，成功再 GET login/account（带 Bearer），stdout 打印完整 token+account JSON。
+// statePath 可注入临时文件便于测试。
+func runPoll(base, origin, realm, statePath string, client *http.Client, out io.Writer) {
+	raw, err := os.ReadFile(statePath)
+	if err != nil {
+		fatal("read state: %v (先跑 login url)", err)
+	}
+	var ls loginState
+	if err := json.Unmarshal(raw, &ls); err != nil {
+		fatal("parse state: %v", err)
+	}
+	// 防混域：state 落盘 realm 与命令行 --realm 不一致则拒绝（url 与 poll 必须同域）
+	if err := validateRealmMatch(ls.Realm, realm); err != nil {
+		fatal("%v", err)
+	}
+	headers := commonHeaders(origin)
+	// handlePollLogin (oauth.go:108-162)：auth/token 是权威登录状态端点，
+	// pending 时业务 code 非 0（"login ing"），完成时 code=0 + token bundle
+	tokRaw, status, errTok := doJSON(client, http.MethodGet, base+"/v2/plugin/auth/token?state="+ls.State, headers, nil)
+	if errTok != nil {
+		if status == 0 || status >= 500 {
+			fatal("token endpoint error: %v", errTok)
+		}
+		fatal("登录未完成（waiting for login）。请确认已在浏览器完成登录再按 y")
+	}
+	var tok struct {
+		AccessToken  string `json:"accessToken"`
+		RefreshToken string `json:"refreshToken"`
+		ExpiresIn    int64  `json:"expiresIn"`
+		Domain       string `json:"domain"`
+	}
+	if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" {
+		fatal("登录未完成（waiting for login）。请确认已在浏览器完成登录再按 y")
+	}
+	// login/account 拿 uid/nickname（带 Bearer）
+	var acct struct {
+		UID          string `json:"uid"`
+		EnterpriseID string `json:"enterpriseId"`
+		Nickname     string `json:"nickname"`
+	}
+	acctHeaders := func(r *http.Request) {
+		headers(r)
+		r.Header.Set("Authorization", "Bearer "+tok.AccessToken)
+	}
+	if acctRaw, _, errAcct := doJSON(client, http.MethodGet, base+"/v2/plugin/login/account?state="+ls.State, acctHeaders, nil); errAcct == nil {
+		_ = json.Unmarshal(acctRaw, &acct)
+	}
+	oraw, _ := json.Marshal(buildLoginOutput(tok, realm, acct))
+	fmt.Fprintln(out, string(oraw))
+	os.Remove(statePath)
+}
+
+// buildLoginOutput 组装 poll 输出的完整 JSON（login.sh 据此落盘 auth 文件）。
+// realm 永不空：显式 --realm 优先（ResolveRealm 处理），否则按上游返回的 domain 推断——
+// 保证登录落盘的 auth 文件恒带 realm 键。
+func buildLoginOutput(tok struct {
+	AccessToken  string `json:"accessToken"`
+	RefreshToken string `json:"refreshToken"`
+	ExpiresIn    int64  `json:"expiresIn"`
+	Domain       string `json:"domain"`
+}, realm string, acct struct {
+	UID          string `json:"uid"`
+	EnterpriseID string `json:"enterpriseId"`
+	Nickname     string `json:"nickname"`
+}) map[string]any {
+	return map[string]any{
+		"access_token":  tok.AccessToken,
+		"refresh_token": tok.RefreshToken,
+		"expires_in":    tok.ExpiresIn,
+		"domain":        tok.Domain,
+		"realm":         auth2.ResolveRealm(realm, tok.Domain),
+		"uid":           acct.UID,
+		"enterprise_id": acct.EnterpriseID,
+		"nickname":      acct.Nickname,
+	}
+}
+
+func main() {
+	realm, rest, err := parseRealmArgs(os.Args[1:])
+	if err != nil {
+		fatal("%v (usage: login [--realm=cn|global] <url|poll|realm>)", err)
+	}
+	if len(rest) < 1 {
+		fatal("usage: login [--realm=cn|global] <url|poll>")
+	}
+	// 每个流程独立 cookie jar（oauth.go:22-29：多账号登录互不串会话）
+	jar, _ := cookiejar.New(nil)
+	client := &http.Client{Timeout: 30 * time.Second, Jar: jar}
+
+	base, origin := realmConfig(realm)
+
+	switch rest[0] {
+	case "url":
+		runURL(base, origin, realm, stateFile, client, os.Stdout)
+
+	case "poll":
+		runPoll(base, origin, realm, stateFile, client, os.Stdout)
+
+	case "realm":
+		// 交互式选域（login.sh 无 --realm 传参且 stdin 为 tty 时调用）。
+		// 提示打到 stderr，stdout 只输出归一化 realm，供 $( ) 捕获。
+		realm := promptRealm(os.Stdin, os.Stderr)
+		fmt.Println(realm)
+
+	default:
+		fatal("unknown subcommand %q (want url|poll|realm)", rest[0])
+	}
+}

cmd/login/realm_test.go

@@ -1,169 +1,169 @@
-package main
-
-import (
-	"bytes"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-// TestParseRealmArgs 覆盖 --realm 参数解析：缺省 cn、等号/分离式写法、
-// 非法值/缺值报错、大小写归一、剥离 flag 后剩余参数保持相对顺序。
-func TestParseRealmArgs(t *testing.T) {
-	cases := []struct {
-		name      string
-		args      []string
-		wantRealm string
-		wantRest  []string
-		wantErr   bool
-	}{
-		{name: "缺省 cn", args: []string{"url"}, wantRealm: "cn", wantRest: []string{"url"}},
-		{name: "等号 global 在前", args: []string{"--realm=global", "url"}, wantRealm: "global", wantRest: []string{"url"}},
-		{name: "等号 cn 在后", args: []string{"poll", "--realm=cn"}, wantRealm: "cn", wantRest: []string{"poll"}},
-		{name: "分离式 global", args: []string{"--realm", "global", "url"}, wantRealm: "global", wantRest: []string{"url"}},
-		{name: "非法值报错", args: []string{"--realm=foo", "url"}, wantErr: true},
-		{name: "分离式缺值报错", args: []string{"--realm", "url"}, wantErr: true},
-		{name: "大小写归一", args: []string{"--realm=GLOBAL", "url"}, wantRealm: "global", wantRest: []string{"url"}},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			realm, rest, err := parseRealmArgs(c.args)
-			if c.wantErr {
-				if err == nil {
-					t.Fatalf("parseRealmArgs(%v) err=nil, want error", c.args)
-				}
-				return
-			}
-			if err != nil {
-				t.Fatalf("parseRealmArgs(%v) err=%v", c.args, err)
-			}
-			if realm != c.wantRealm {
-				t.Errorf("realm=%q want %q", realm, c.wantRealm)
-			}
-			if !reflect.DeepEqual(rest, c.wantRest) {
-				t.Errorf("rest=%v want %v", rest, c.wantRest)
-			}
-		})
-	}
-}
-
-// TestResolveRealmInput 覆盖交互式选域的输入→realm 映射（login.sh 交互分支的核心决策）：
-// "1"/"cn"/""（回车默认）→ cn；"2"/"global" → global；大小写不敏感；非法 → ("",false)。
-func TestResolveRealmInput(t *testing.T) {
-	cases := []struct {
-		input string
-		want  string
-	}{
-		{input: "1", want: "cn"},
-		{input: "cn", want: "cn"},
-		{input: "CN", want: "cn"},
-		{input: "", want: "cn"}, // 回车默认
-		{input: "2", want: "global"},
-		{input: "global", want: "global"},
-		{input: "GLOBAL", want: "global"},
-	}
-	for _, c := range cases {
-		got, ok := resolveRealmInput(c.input)
-		if !ok {
-			t.Errorf("resolveRealmInput(%q) ok=false want true", c.input)
-			continue
-		}
-		if got != c.want {
-			t.Errorf("resolveRealmInput(%q)=%q want %q", c.input, got, c.want)
-		}
-	}
-	// 非法输入 → (false)。
-	for _, bad := range []string{"3", "cnn", "globalx", "foo"} {
-		if got, ok := resolveRealmInput(bad); ok {
-			t.Errorf("resolveRealmInput(%q)=(%q,true) want (_,false)", bad, got)
-		}
-	}
-}
-
-// TestPromptRealm 覆盖 promptRealm 的 I/O 行为（out 将接 os.Stderr，stdout 只出 realm）：
-//
-//	1 / 2 / 回车默认 → 分别输出来 cn / global / cn；均打印"选择登录版本"提示；
-//	非法输入 → 警告并回落 cn；EOF（非交互直接管道）→ 回落 cn。
-func TestPromptRealm(t *testing.T) {
-	cases := []struct {
-		name     string
-		input    string
-		want     string
-		wantHint bool // 输出中出现"选择登录版本"提示
-	}{
-		{name: "选 cn", input: "1\n", want: "cn", wantHint: true},
-		{name: "选 global", input: "2\n", want: "global", wantHint: true},
-		{name: "回车默认 cn", input: "\n", want: "cn", wantHint: true},
-		{name: "非法回落 cn", input: "foo\n", want: "cn", wantHint: true},
-		{name: "EOF 回落 cn", input: "", want: "cn", wantHint: true},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			var out bytes.Buffer
-			got := promptRealm(strings.NewReader(c.input), &out)
-			if got != c.want {
-				t.Errorf("promptRealm(%q)=%q want %q", c.input, got, c.want)
-			}
-			if c.wantHint && !strings.Contains(out.String(), "选择登录版本") {
-				t.Errorf("prompt should contain '选择登录版本', got %q", out.String())
-			}
-		})
-	}
-}
-
-// TestRealmSubcommandSelection 通过命令形式验证 realm 子命令（login.sh 交互分支调用）：
-// 子命令剥离 --realm，剩余参数为首个 "realm"。
-func TestRealmSubcommandSelection(t *testing.T) {
-	realm, rest, err := parseRealmArgs([]string{"realm"})
-	if err != nil {
-		t.Fatalf("parseRealmArgs(realm) err=%v", err)
-	}
-	if realm != "cn" {
-		t.Errorf("realm default=%q want cn", realm)
-	}
-	if len(rest) != 1 || rest[0] != "realm" {
-		t.Errorf("rest=%v want [realm]", rest)
-	}
-}
-
-// TestBuildLoginOutputRealmAlwaysSet 登录产物（login.sh 据此落盘 auth 文件）恒含 realm 键：
-// 显式 --realm 优先，缺省时按 domain 推断（echo 出的 global 账号即便未显式指定也带 global）。
-// 这是「登录落盘永远带 realm 标识」契约的测试载体。
-func TestBuildLoginOutputRealmAlwaysSet(t *testing.T) {
-	tok := struct {
-		AccessToken  string `json:"accessToken"`
-		RefreshToken string `json:"refreshToken"`
-		ExpiresIn    int64  `json:"expiresIn"`
-		Domain       string `json:"domain"`
-	}{AccessToken: "at", RefreshToken: "rt", ExpiresIn: 3600, Domain: "www.codebuddy.cn"}
-	acct := struct {
-		UID          string `json:"uid"`
-		EnterpriseID string `json:"enterpriseId"`
-		Nickname     string `json:"nickname"`
-	}{UID: "u1", Nickname: "n1"}
-
-	cases := []struct {
-		name      string
-		realm     string
-		domain    string
-		wantRealm string
-	}{
-		{name: "显式 global 优先", realm: "global", domain: "www.codebuddy.cn", wantRealm: "global"},
-		{name: "显式 cn 优先", realm: "cn", domain: "www.workbuddy.ai", wantRealm: "cn"},
-		{name: "缺省按 domain 推断 global", realm: "", domain: "www.workbuddy.ai", wantRealm: "global"},
-		{name: "缺省空 domain 回落 cn", realm: "", domain: "", wantRealm: "cn"},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			tok.Domain = c.domain
-			out := buildLoginOutput(tok, c.realm, acct)
-			m, ok := out["realm"].(string)
-			if !ok {
-				t.Fatalf("missing realm key in login output: %v", out)
-			}
-			if m != c.wantRealm {
-				t.Errorf("realm=%q want %q", m, c.wantRealm)
-			}
-		})
-	}
-}
+package main
+
+import (
+	"bytes"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+// TestParseRealmArgs 覆盖 --realm 参数解析：缺省 cn、等号/分离式写法、
+// 非法值/缺值报错、大小写归一、剥离 flag 后剩余参数保持相对顺序。
+func TestParseRealmArgs(t *testing.T) {
+	cases := []struct {
+		name      string
+		args      []string
+		wantRealm string
+		wantRest  []string
+		wantErr   bool
+	}{
+		{name: "缺省 cn", args: []string{"url"}, wantRealm: "cn", wantRest: []string{"url"}},
+		{name: "等号 global 在前", args: []string{"--realm=global", "url"}, wantRealm: "global", wantRest: []string{"url"}},
+		{name: "等号 cn 在后", args: []string{"poll", "--realm=cn"}, wantRealm: "cn", wantRest: []string{"poll"}},
+		{name: "分离式 global", args: []string{"--realm", "global", "url"}, wantRealm: "global", wantRest: []string{"url"}},
+		{name: "非法值报错", args: []string{"--realm=foo", "url"}, wantErr: true},
+		{name: "分离式缺值报错", args: []string{"--realm", "url"}, wantErr: true},
+		{name: "大小写归一", args: []string{"--realm=GLOBAL", "url"}, wantRealm: "global", wantRest: []string{"url"}},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			realm, rest, err := parseRealmArgs(c.args)
+			if c.wantErr {
+				if err == nil {
+					t.Fatalf("parseRealmArgs(%v) err=nil, want error", c.args)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatalf("parseRealmArgs(%v) err=%v", c.args, err)
+			}
+			if realm != c.wantRealm {
+				t.Errorf("realm=%q want %q", realm, c.wantRealm)
+			}
+			if !reflect.DeepEqual(rest, c.wantRest) {
+				t.Errorf("rest=%v want %v", rest, c.wantRest)
+			}
+		})
+	}
+}
+
+// TestResolveRealmInput 覆盖交互式选域的输入→realm 映射（login.sh 交互分支的核心决策）：
+// "1"/"cn"/""（回车默认）→ cn；"2"/"global" → global；大小写不敏感；非法 → ("",false)。
+func TestResolveRealmInput(t *testing.T) {
+	cases := []struct {
+		input string
+		want  string
+	}{
+		{input: "1", want: "cn"},
+		{input: "cn", want: "cn"},
+		{input: "CN", want: "cn"},
+		{input: "", want: "cn"}, // 回车默认
+		{input: "2", want: "global"},
+		{input: "global", want: "global"},
+		{input: "GLOBAL", want: "global"},
+	}
+	for _, c := range cases {
+		got, ok := resolveRealmInput(c.input)
+		if !ok {
+			t.Errorf("resolveRealmInput(%q) ok=false want true", c.input)
+			continue
+		}
+		if got != c.want {
+			t.Errorf("resolveRealmInput(%q)=%q want %q", c.input, got, c.want)
+		}
+	}
+	// 非法输入 → (false)。
+	for _, bad := range []string{"3", "cnn", "globalx", "foo"} {
+		if got, ok := resolveRealmInput(bad); ok {
+			t.Errorf("resolveRealmInput(%q)=(%q,true) want (_,false)", bad, got)
+		}
+	}
+}
+
+// TestPromptRealm 覆盖 promptRealm 的 I/O 行为（out 将接 os.Stderr，stdout 只出 realm）：
+//
+//	1 / 2 / 回车默认 → 分别输出来 cn / global / cn；均打印"选择登录版本"提示；
+//	非法输入 → 警告并回落 cn；EOF（非交互直接管道）→ 回落 cn。
+func TestPromptRealm(t *testing.T) {
+	cases := []struct {
+		name     string
+		input    string
+		want     string
+		wantHint bool // 输出中出现"选择登录版本"提示
+	}{
+		{name: "选 cn", input: "1\n", want: "cn", wantHint: true},
+		{name: "选 global", input: "2\n", want: "global", wantHint: true},
+		{name: "回车默认 cn", input: "\n", want: "cn", wantHint: true},
+		{name: "非法回落 cn", input: "foo\n", want: "cn", wantHint: true},
+		{name: "EOF 回落 cn", input: "", want: "cn", wantHint: true},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			var out bytes.Buffer
+			got := promptRealm(strings.NewReader(c.input), &out)
+			if got != c.want {
+				t.Errorf("promptRealm(%q)=%q want %q", c.input, got, c.want)
+			}
+			if c.wantHint && !strings.Contains(out.String(), "选择登录版本") {
+				t.Errorf("prompt should contain '选择登录版本', got %q", out.String())
+			}
+		})
+	}
+}
+
+// TestRealmSubcommandSelection 通过命令形式验证 realm 子命令（login.sh 交互分支调用）：
+// 子命令剥离 --realm，剩余参数为首个 "realm"。
+func TestRealmSubcommandSelection(t *testing.T) {
+	realm, rest, err := parseRealmArgs([]string{"realm"})
+	if err != nil {
+		t.Fatalf("parseRealmArgs(realm) err=%v", err)
+	}
+	if realm != "cn" {
+		t.Errorf("realm default=%q want cn", realm)
+	}
+	if len(rest) != 1 || rest[0] != "realm" {
+		t.Errorf("rest=%v want [realm]", rest)
+	}
+}
+
+// TestBuildLoginOutputRealmAlwaysSet 登录产物（login.sh 据此落盘 auth 文件）恒含 realm 键：
+// 显式 --realm 优先，缺省时按 domain 推断（echo 出的 global 账号即便未显式指定也带 global）。
+// 这是「登录落盘永远带 realm 标识」契约的测试载体。
+func TestBuildLoginOutputRealmAlwaysSet(t *testing.T) {
+	tok := struct {
+		AccessToken  string `json:"accessToken"`
+		RefreshToken string `json:"refreshToken"`
+		ExpiresIn    int64  `json:"expiresIn"`
+		Domain       string `json:"domain"`
+	}{AccessToken: "at", RefreshToken: "rt", ExpiresIn: 3600, Domain: "www.codebuddy.cn"}
+	acct := struct {
+		UID          string `json:"uid"`
+		EnterpriseID string `json:"enterpriseId"`
+		Nickname     string `json:"nickname"`
+	}{UID: "u1", Nickname: "n1"}
+
+	cases := []struct {
+		name      string
+		realm     string
+		domain    string
+		wantRealm string
+	}{
+		{name: "显式 global 优先", realm: "global", domain: "www.codebuddy.cn", wantRealm: "global"},
+		{name: "显式 cn 优先", realm: "cn", domain: "www.workbuddy.ai", wantRealm: "cn"},
+		{name: "缺省按 domain 推断 global", realm: "", domain: "www.workbuddy.ai", wantRealm: "global"},
+		{name: "缺省空 domain 回落 cn", realm: "", domain: "", wantRealm: "cn"},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			tok.Domain = c.domain
+			out := buildLoginOutput(tok, c.realm, acct)
+			m, ok := out["realm"].(string)
+			if !ok {
+				t.Fatalf("missing realm key in login output: %v", out)
+			}
+			if m != c.wantRealm {
+				t.Errorf("realm=%q want %q", m, c.wantRealm)
+			}
+		})
+	}
+}

cmd/server/config.go

@@ -1,616 +1,658 @@
-// config.go 加载 JSON 配置 + 环境变量覆盖。
-package main
-
-import (
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/prompt"
-)
-
-// Config 顶层配置。
-type Config struct {
-	Listen    string `json:"listen"`     // ":7863"
-	APIKey    string `json:"api_key"`    // 空 = 不鉴权
-	AuthDir   string `json:"auth_dir"`   // ./auths
-	StateFile string `json:"state_file"` // ./data/state.json
-
-	Panel struct {
-		// PackageDetailLimit 积分构成页单账号默认展示的最近到期包数；<=0 回落 5。
-		PackageDetailLimit int `json:"package_detail_limit"`
-	} `json:"panel"`
-
-	Logging struct {
-		// RequestArchiveEnabled 请求元数据 JSONL 归档开关，缺省 true。
-		RequestArchiveEnabled bool `json:"request_archive_enabled"`
-		// RequestRetentionDays 归档保留天数，缺省 7；<=0 回落默认。
-		RequestRetentionDays int `json:"request_retention_days"`
-		// RequestArchiveMaxMB 归档总上限（MiB），缺省 100；<=0 回落默认。
-		RequestArchiveMaxMB int `json:"request_archive_max_mb"`
-		// RequestClientInfo 是否在请求日志（归档事件 + stdout 流水行 + 面板运行
-		// 日志）里记录调用来源：客户端 IP 与 User-Agent。缺省 true。
-		//
-		// 为什么做成开关而不是恒开：来源信息是排查"谁在打网关"的第一手线索，
-		// 但它比 token 计数敏感（IP 属个人信息），共享部署/多租户场景可能需要
-		// 关掉。关闭后 Event.ClientIP/UserAgent 保持为空，归档里不出现该字段。
-		// 热生效（经 livecfg 快照），无需重启。
-		RequestClientInfo bool `json:"request_client_info"`
-	} `json:"logging"`
-
-	Cooldown struct {
-		// hard_credit / err_threshold / err_cooldown 三个历史键已退役：
-		// 硬冷却固定为次日 04:00（CooldownUntilTomorrow4AM），连续错误语义并入熔断器。
-		// 旧 config 中的这些键因 JSON 未知字段而自然忽略，不报错。
-		SoftRate string `json:"soft_rate"` // "600s"，软限流冷却基数
-		// SoftRateMax 软冷却指数退避的封顶，默认 "2h"。
-		// 空值回落默认，非法值报错（处理风格同 soft_rate）。
-		SoftRateMax string `json:"soft_rate_max"` // "2h"
-	} `json:"cooldown"`
-
-	Schedule struct {
-		CheckinHours   []int `json:"checkin_hours"`   // [9,21]
-		TravelHours    []int `json:"travel_hours"`    // [9,21]
-		ActivityHours  []int `json:"activity_hours"`  // [10]
-		KeepaliveHours []int `json:"keepalive_hours"` // [22]
-		BlackcatHours  []int `json:"blackcat_hours"`  // [23] 夜猫子窗口（23:00–08:00 计数）
-		GrowthHours    []int `json:"growth_hours"`    // [1] 成长任务队列（Sequential 族每日零点解锁，01:00 自动扫描执行）
-		// CheckinEnabled/TravelEnabled/ActivityEnabled/KeepaliveEnabled/BlackcatEnabled 显式禁用开关（缺省 true）。
-		//
-		// 为什么用独立 bool 而不是空数组/哨兵值表意"禁用"：
-		//   - 空数组与 null 在老语义里已被"未配置 → 回落默认"占用，改判会静默翻转
-		//     所有老 config 的行为（用户只想删掉一行，结果关掉了签到）；bool 缺省 true
-		//     则对老配置零影响，向后完全兼容。
-		//   - 开关与取值解耦：禁用时仍保留用户显式配的小时，重新启用无需补配。
-		//   - 无需猜测哨兵（[-1] 之类），非法小时一律报错并提示改用本开关。
-		// 旧 config 里的该键因 JSON 未知字段而自然忽略，不报错。
-		CheckinEnabled   bool `json:"checkin_enabled"`   // 缺省 true；false = 关签到
-		TravelEnabled    bool `json:"travel_enabled"`    // 缺省 true；false = 完全停猫猫旅行
-		ActivityEnabled  bool `json:"activity_enabled"`  // 缺省 true；false = 停活跃上报
-		KeepaliveEnabled bool `json:"keepalive_enabled"` // 缺省 true；false = 关 token 保活
-		BlackcatEnabled  bool `json:"blackcat_enabled"`  // 缺省 true；false = 关夜猫子
-		GrowthEnabled    bool `json:"growth_enabled"`    // 缺省 true；false = 关成长任务自动排程
-
-		// 余额后台周期刷新：两次签到时点之间 credits 也能保持新鲜（面板/状态观测用）。
-		// 解冻语义同签到（余额 > 0 的冷却账号自动解冻），但不做签到不刷 token。
-		BalanceRefreshEnabled bool `json:"balance_refresh_enabled"` // 缺省 true；false = 关闭
-		BalanceRefreshMinutes int  `json:"balance_refresh_minutes"` // 缺省 5；<=0 回落 5
-	} `json:"schedule"`
-
-	Global struct {
-		// Enabled global realm 路由开关。缺省 true：Realm() 正常把 realm=global/
-		// domain=workbuddy.ai 的账号判为 global 并路由 global base/路径。
-		// 显式 "enabled": false 关闭（逃生门，纯 CN 锁定：即便 auth 写了 realm=global
-		// 也不路由，auth.Realm() 双保险的第一道闸）。纯 CN 部署行为不变：CN 账号
-		// 恒判 cn，global base 只在 realm=global 的账号上���使用。
-		Enabled bool `json:"enabled"`
-		// ChatBase / BillingBase 国际版上游 base 覆盖；空 = 回落内置默认
-		// https://www.workbuddy.ai（internal/upstream.defaultGlobalBase）。
-		ChatBase    string `json:"chat_base"`
-		BillingBase string `json:"billing_base"`
-	} `json:"global"`
-
-	Upstream struct {
-		// TimeoutSeconds 短 RPC（refresh/checkin/balance/FetchModels）总时长上限，默认 120。
-		TimeoutSeconds int `json:"timeout_seconds"`
-		// HeaderTimeoutSeconds 聊天 SSE 首字节前（响应头）上限；<=0 回落 TimeoutSeconds。
-		HeaderTimeoutSeconds int `json:"header_timeout_seconds"`
-		// IdleTimeoutSeconds 聊天 SSE 流中空闲上限（活跃吐数据续命不掐）；<=0 回落默认 300。
-		IdleTimeoutSeconds int `json:"idle_timeout_seconds"`
-		// UserAgent 出站 User-Agent 显式覆盖（非空时全路径生效，优先于默认三段式）。
-		// 全部出站请求生效：chat/refresh/checkin/balance/report/travel/FetchModels。
-		// 默认值已对齐官方 WorkBuddy 桌面形态（三段式），用户仍可配完全自定义值改写。
-		UserAgent string `json:"user_agent"`
-		// ClientVersion WorkBuddy 客户端版本段（出站 UA 的 `WorkBuddy/<ver>` 与归属头
-		// X-IDE-Version）。空 = 内置默认（对齐官方 5.5.4 分发包）。
-		ClientVersion string `json:"client_version"`
-		// CliVersion 出站 UA 中 `CLI/<ver>` 段的版本。空 = 内置默认（官方内置 CLI 2.137.1）。
-		CliVersion string `json:"cli_version"`
-		// ClientName 用量归属头取值（X-Product / X-IDE-Name / X-IDE-Type / X-IDE-Version）。
-		// 空 = 旧行为 X-Product="SaaS" 不设 X-IDE-*；配 "WorkBuddy" 则四头跟随。
-		ClientName string `json:"client_name"`
-		// DeviceToken 设备风控 Token（X-Device-Token 头）全局兜底；空 = 不注入。
-		// 每号 auth 文件的 device_token 键优先于本项。
-		DeviceToken string `json:"device_token"`
-		// DeviceTokenFile device token 文件路径兜底（宿主落盘的桌面端 token，5 分钟读取缓存）。
-		DeviceTokenFile string `json:"device_token_file"`
-		// PassthroughIP 是否透传客户端 IP 给上游（默认 false，反代安全边界）。
-		PassthroughIP bool `json:"passthrough_ip"`
-	} `json:"upstream"`
-
-	Features struct {
-		// SanitizeBlacklistFingerprints 出站请求体黑名单指纹脱敏（默认 true；false 完全还原）。
-		SanitizeBlacklistFingerprints bool `json:"sanitize_blacklist_fingerprints"`
-	} `json:"features"`
-
-	Prompt struct {
-		// Mode passthrough（默认）= 透传客户端原始 system（降级重试仍会切到 Degraded）；
-		// custom = 网关用自有系统提示词替换客户端 system/developer；
-		// append = 两者并用：开头连续 system/developer 块后插网关 system，既有消息逐字不动（issue #129）。
-		Mode string `json:"mode"` // "passthrough" / "custom" / "append"
-		// File 提示词文件路径；空 = 内置默认 defaultprompt.md；
-		// 路径非空但不可读 → 启动报错（fail fast，避免静默回落到内置默认）。
-		File string `json:"file"`
-	} `json:"prompt"`
-
-	// PromptText 解析后的系统提示词文本（custom/append 模式使用）。
-	PromptText string `json:"-"`
-
-	Upstash struct {
-		URL   string `json:"url"`   // 空 = 纯内存模式；支持完整 rediss:// URL 或 https://xxx.upstash.io host
-		Token string `json:"token"` // url 非完整连接串时用于组装 rediss://default:<token>@<host>:6379
-	} `json:"upstash"`
-
-	Pool struct {
-		MaxInFlight        int    `json:"max_in_flight"`        // 单账号最大在途请求数，0 = 不限
-		MaxInFlightGlobal  int    `json:"max_in_flight_global"` // global 域单账号在途上限（WAF 风控紧域压低并发），0 = 回落默认 2
-		BreakerThreshold   int    `json:"breaker_threshold"`    // 连续失败次数触发熔断，默认 3
-		BreakerCooldown    string `json:"breaker_cooldown"`     // 基础熔断时长，默认 "30m"
-		BreakerCooldownMax string `json:"breaker_cooldown_max"` // 指数退避封顶，默认 "6h"
-		// 连败降权（issue #114）：ErrClient/传输层这类「不罚号」失败连续计数，达阈
-		// 临时出池。与冷却/熔断并存取更长者不叠加。默认 5 次 / 10m。
-		DegradeThreshold   int     `json:"degrade_threshold"`    // 连败次数触发降权，默认 5
-		DegradeCooldown    string  `json:"degrade_cooldown"`     // 降权时长（固定，非指数退避），默认 "10m"
-		DegradeCooldownMax string  `json:"degrade_cooldown_max"` // 降权时长的上限钳制，默认 "2h"（仅当 cooldown 超该值才钳制）
-		IdleWeightPerHour  float64 `json:"idle_weight_per_hour"` // 闲置补偿：每小时未用 +0.5 权重
-		IdleWeightMax      float64 `json:"idle_weight_max"`      // 闲置补偿封顶，默认 5.0
-		// PreferExpiring 最早到期优先路由开关，默认 true。开启且 expiring_soon 窗口内
-		// 存在有效批次时，按最早到期时间排序；关闭后完全不使用到期信息选号。
-		PreferExpiring bool `json:"prefer_expiring"`
-		// ExpiringSoon 快过期积分窗口（如 "168h"=7天）：签到/余额刷新时，到期时间在
-		// 此窗口内的积分进入优先集，再按最早到期排序。空/0 = 禁用该路由门槛。
-		ExpiringSoon string `json:"expiring_soon"`
-		// CostExploreInterval costTier 条件探索窗口（issue #136 方案 a′）：tier 0
-		// 垄断层存在且 tier 1 有成员时，距上次探索 ≥ 窗口则本次 pick 生效层切
-		// tier 1-only（探索=搭车改道，零新增上游请求；成功即毕业，失败走既有
-		// 错误策略）。默认 "30m"（≤48 次/天/模型）；"0" 关停（完全回到现状行为）；
-		// 空值回落默认。
-		CostExploreInterval string `json:"cost_explore_interval"`
-		// CreditFloor 积分保底：账号余额低于该值时，对实测收费模型（tier 2）不再
-		// 参与选号——防止收费请求把余额打穿、连免费模型都 402 冷却到次日签到。
-		// tier 0（免费）/ tier 1（无观测）不受限；签到回血越过 floor 自动恢复。
-		// 默认 0 = 关闭；负值钳 0。
-		CreditFloor int64 `json:"credit_floor"`
-	} `json:"pool"`
-
-	SessionSticky struct {
-		Enabled    bool   `json:"enabled"`     // 默认 true
-		TTL        string `json:"ttl"`         // 会话绑定 TTL，默认 "30m"
-		GCInterval string `json:"gc_interval"` // 会话 GC 周期，默认 "5m"
-	} `json:"session_sticky"`
-
-	// 解析后
-	SoftRateDur            time.Duration `json:"-"`
-	SoftRateMaxDur         time.Duration `json:"-"`
-	BreakerCooldownDur     time.Duration `json:"-"`
-	BreakerCooldownMaxD    time.Duration `json:"-"`
-	DegradeCooldownDur     time.Duration `json:"-"`
-	DegradeCooldownMaxD    time.Duration `json:"-"`
-	SessionTTL             time.Duration `json:"-"`
-	SessionGCInterval      time.Duration `json:"-"`
-	BalanceRefreshInterval time.Duration `json:"-"` // 0 = 不启动（enabled=false）
-	ExpiringSoonDur        time.Duration `json:"-"`
-	// CostExploreIntervalDur 解析后的 costTier 探索窗口（issue #136）；0 = 关停。
-	CostExploreIntervalDur time.Duration `json:"-"`
-}
-
-// Default 默认配置。
-func Default() *Config {
-	c := &Config{
-		Listen:    ":7863",
-		APIKey:    "",
-		AuthDir:   "./auths",
-		StateFile: "./data/state.json",
-	}
-	c.Cooldown.SoftRate = "600s"
-	c.Cooldown.SoftRateMax = "2h"
-	c.Panel.PackageDetailLimit = 5
-	c.Logging.RequestArchiveEnabled = true
-	c.Logging.RequestRetentionDays = 7
-	c.Logging.RequestArchiveMaxMB = 100
-	// 缺省 true 靠显式赋值实现（同 Schedule 开关）：JSON 里键缺席时字段保留此值，
-	// 只有显式 false 才关闭来源记录。
-	c.Logging.RequestClientInfo = true
-	c.Schedule.CheckinHours = []int{9, 21}
-	c.Schedule.TravelHours = []int{9, 21}
-	c.Schedule.ActivityHours = []int{10}
-	c.Schedule.KeepaliveHours = []int{22}
-	c.Schedule.BlackcatHours = []int{23}
-	c.Schedule.GrowthHours = []int{1}
-	// 开关「缺省 true」靠这几行实现：Load 先取 Default() 再 json.Unmarshal 覆盖，
-	// 键缺席（或为 null）时字段原样保留 true，只有显式 false 才关。
-	c.Schedule.CheckinEnabled = true
-	c.Schedule.GrowthEnabled = true
-	c.Schedule.TravelEnabled = true
-	c.Schedule.ActivityEnabled = true
-	c.Schedule.KeepaliveEnabled = true
-	c.Schedule.BlackcatEnabled = true
-	c.Schedule.BalanceRefreshEnabled = true
-	c.Schedule.BalanceRefreshMinutes = 5
-	c.Upstream.TimeoutSeconds = 120
-	// HeaderTimeoutSeconds/IdleTimeoutSeconds 默认 0（未设置态），回落见 normalize()。
-	c.Upstream.HeaderTimeoutSeconds = 0
-	c.Upstream.IdleTimeoutSeconds = 0
-	// Global.Enabled 缺省 true（纯 CN 行为不变：CN 账号恒判 cn，global base 不被使用）；
-	// ChatBase/BillingBase 缺省空（回落内置默认）。
-	c.Global.Enabled = true
-	c.Features.SanitizeBlacklistFingerprints = true
-	c.Prompt.Mode = "passthrough" // 缺省 passthrough：透传客户端原始 system（对齐上游；custom 由用户显式选择）
-	c.Pool.MaxInFlight = 3
-	// MaxInFlightGlobal 缺省 2：global 域 WAF 风控更紧，压低单号并发（WAF 403 修复
-	// P1-1）；0/负数 normalize 回落默认（与 max_in_flight 的 0=不限语义不同，分档键
-	// 的 0 没有合理语义，回退分档默认最稳）。
-	c.Pool.MaxInFlightGlobal = 2
-	c.Pool.BreakerThreshold = 3
-	c.Pool.BreakerCooldown = "30m"
-	c.Pool.BreakerCooldownMax = "6h"
-	c.Pool.DegradeThreshold = 5
-	c.Pool.DegradeCooldown = "10m"
-	c.Pool.DegradeCooldownMax = "2h"
-	c.Pool.IdleWeightPerHour = 0.5
-	c.Pool.IdleWeightMax = 5.0
-	c.Pool.PreferExpiring = true
-	c.Pool.ExpiringSoon = "168h" // 快过期窗口默认 7 天：官方活动奖励积分多在两周内过期
-	// costTier 探索默认 30m（issue #136：垄断破除 + 搭车改道零新增请求）；"0" 关停。
-	c.Pool.CostExploreInterval = "30m"
-	c.SessionSticky.Enabled = true
-	c.SessionSticky.TTL = "30m"
-	c.SessionSticky.GCInterval = "5m"
-	return c
-}
-
-// Load 从文件读，再用 WB2A_* env 覆盖。
-func Load(path string) (*Config, error) {
-	c := Default()
-	if path != "" {
-		// 目录检查：Docker bind mount 在宿主机文件缺失时会静默创建同名目录，
-		// 直接 ReadFile 会报 "Incorrect function" 之类晦涩错误，这里给出可操作提示。
-		if st, statErr := os.Stat(path); statErr == nil && st.IsDir() {
-			return nil, fmt.Errorf("config %s 是目录而非文件——"+
-				"Docker 部署时若宿主机缺少 config.json，bind mount 会创建同名目录。"+
-				"请先 `cp config.example.json config.json` 或删除该目录（程序会自动生成配置）", path)
-		}
-		raw, err := os.ReadFile(path)
-		if err != nil {
-			return nil, fmt.Errorf("read config: %w", err)
-		}
-		if _, err := ParseConfigInto(raw, c); err != nil {
-			return nil, err
-		}
-	}
-	applyEnv(c)
-	if err := c.normalize(); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-// ParseConfigInto 把 JSON 覆盖到 c 上并 normalize（不做 env、不读文件）。
-// 面板保存配置走这条路径：与 Load 完全同一套解析/校验逻辑，避免两处漂移。
-func ParseConfigInto(raw []byte, c *Config) (*Config, error) {
-	if err := json.Unmarshal(raw, c); err != nil {
-		return nil, fmt.Errorf("parse config: %w", err)
-	}
-	if err := c.normalize(); err != nil {
-		return nil, err
-	}
-	return c, nil
-}
-
-// ParseConfig 基于默认值解析一段配置 JSON（等价于 Load 的文件分支，但不读环境变量）。
-func ParseConfig(raw []byte) (*Config, error) {
-	return ParseConfigInto(raw, Default())
-}
-
-// WriteDefault 在 path 落一份推荐配置（首次运行自动生成，双击即开免手工复制样例）。
-// 值取自 Default()（含超时/熔断/签到排程等推荐值），api_key 用 crypto/rand 随机生成：
-// 安全默认优于示例占位符（listen 绑定 0.0.0.0，空 key 会把网关裸暴露给局域网）。
-// 返回生成的 key 供启动日志透出。已存在时经 O_EXCL 原子拒绝，绝不改写用户配置。
-func WriteDefault(path string) (string, error) {
-	raw := make([]byte, 18)
-	if _, err := rand.Read(raw); err != nil {
-		return "", fmt.Errorf("gen api_key: %w", err)
-	}
-	key := "sk-" + base64.RawURLEncoding.EncodeToString(raw)
-	c := Default()
-	c.APIKey = key
-	_ = c.normalize() // Default() 全合法，normalize 仅补齐 header/idle 超时的展示值
-	out, err := json.MarshalIndent(c, "", "  ")
-	if err != nil {
-		return "", fmt.Errorf("marshal config: %w", err)
-	}
-	if dir := filepath.Dir(path); dir != "" && dir != "." {
-		if err := os.MkdirAll(dir, 0o755); err != nil {
-			return "", fmt.Errorf("mkdir config dir: %w", err)
-		}
-	}
-	// O_EXCL 原子拒绝覆盖：即使调用方漏判"不存在"，也绝不悄悄改写用户已有配置。
-	f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
-	if err != nil {
-		return "", fmt.Errorf("write config: %w", err)
-	}
-	defer f.Close()
-	if _, err := f.Write(out); err != nil {
-		return "", fmt.Errorf("write config: %w", err)
-	}
-	return key, nil
-}
-
-func applyEnv(c *Config) {
-	if v := os.Getenv("WB2A_LISTEN"); v != "" {
-		c.Listen = v
-	}
-	if v := os.Getenv("WB2A_API_KEY"); v != "" {
-		c.APIKey = v
-	}
-	if v := os.Getenv("WB2A_AUTH_DIR"); v != "" {
-		c.AuthDir = v
-	}
-	if v := os.Getenv("WB2A_STATE_FILE"); v != "" {
-		c.StateFile = v
-	}
-	if v := os.Getenv("WB2A_SOFT_RATE"); v != "" {
-		c.Cooldown.SoftRate = v
-	}
-	if v := os.Getenv("WB2A_SOFT_RATE_MAX"); v != "" {
-		c.Cooldown.SoftRateMax = v
-	}
-	if v := os.Getenv("WB2A_TIMEOUT_SECONDS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil {
-			c.Upstream.TimeoutSeconds = n
-		}
-	}
-	if v := os.Getenv("WB2A_HEADER_TIMEOUT_SECONDS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil {
-			c.Upstream.HeaderTimeoutSeconds = n
-		}
-	}
-	if v := os.Getenv("WB2A_IDLE_TIMEOUT_SECONDS"); v != "" {
-		if n, err := strconv.Atoi(v); err == nil {
-			c.Upstream.IdleTimeoutSeconds = n
-		}
-	}
-	if v := os.Getenv("WB2A_USER_AGENT"); v != "" {
-		c.Upstream.UserAgent = v
-	}
-	if v := os.Getenv("WB2A_CLIENT_VERSION"); v != "" {
-		c.Upstream.ClientVersion = v
-	}
-	if v := os.Getenv("WB2A_CLI_VERSION"); v != "" {
-		c.Upstream.CliVersion = v
-	}
-	if v := os.Getenv("WB2A_CLIENT_NAME"); v != "" {
-		c.Upstream.ClientName = v
-	}
-	if v := os.Getenv("WB2A_DEVICE_TOKEN"); v != "" {
-		c.Upstream.DeviceToken = v
-	}
-	if v := os.Getenv("WB2A_DEVICE_TOKEN_FILE"); v != "" {
-		c.Upstream.DeviceTokenFile = v
-	}
-	if v := os.Getenv("WB2A_PASSTHROUGH_IP"); v != "" {
-		if b, err := strconv.ParseBool(v); err == nil {
-			c.Upstream.PassthroughIP = b
-		}
-	}
-	if v := os.Getenv("WB2A_SANITIZE_FINGERPRINTS"); v != "" {
-		if b, err := strconv.ParseBool(v); err == nil {
-			c.Features.SanitizeBlacklistFingerprints = b
-		}
-	}
-	if v := os.Getenv("WB2A_PROMPT_MODE"); v != "" {
-		c.Prompt.Mode = v
-	}
-	if v := os.Getenv("WB2A_PROMPT_FILE"); v != "" {
-		c.Prompt.File = v
-	}
-	if v := os.Getenv("WB2A_EXPIRING_SOON"); v != "" {
-		c.Pool.ExpiringSoon = v
-	}
-	if v := os.Getenv("WB2A_PREFER_EXPIRING"); v != "" {
-		if b, err := strconv.ParseBool(v); err == nil {
-			c.Pool.PreferExpiring = b
-		}
-	}
-}
-
-func (c *Config) normalize() error {
-	var err error
-	if c.Panel.PackageDetailLimit <= 0 {
-		c.Panel.PackageDetailLimit = 5
-	}
-	if c.Logging.RequestRetentionDays <= 0 {
-		c.Logging.RequestRetentionDays = 7
-	}
-	if c.Logging.RequestArchiveMaxMB <= 0 {
-		c.Logging.RequestArchiveMaxMB = 100
-	}
-	if c.SoftRateDur, err = time.ParseDuration(c.Cooldown.SoftRate); err != nil {
-		return fmt.Errorf("cooldown.soft_rate: %w", err)
-	}
-	// 空值回落默认 2h（Default() 已置值；此兜底覆盖显式 "" 与 Default() 被绕过的场景）。
-	if c.Cooldown.SoftRateMax == "" {
-		c.Cooldown.SoftRateMax = "2h"
-	}
-	if c.SoftRateMaxDur, err = time.ParseDuration(c.Cooldown.SoftRateMax); err != nil {
-		return fmt.Errorf("cooldown.soft_rate_max: %w", err)
-	}
-	if c.BreakerCooldownDur, err = time.ParseDuration(c.Pool.BreakerCooldown); err != nil {
-		return fmt.Errorf("pool.breaker_cooldown: %w", err)
-	}
-	if c.BreakerCooldownMaxD, err = time.ParseDuration(c.Pool.BreakerCooldownMax); err != nil {
-		return fmt.Errorf("pool.breaker_cooldown_max: %w", err)
-	}
-	if c.DegradeCooldownDur, err = time.ParseDuration(c.Pool.DegradeCooldown); err != nil {
-		return fmt.Errorf("pool.degrade_cooldown: %w", err)
-	}
-	if c.DegradeCooldownMaxD, err = time.ParseDuration(c.Pool.DegradeCooldownMax); err != nil {
-		return fmt.Errorf("pool.degrade_cooldown_max: %w", err)
-	}
-	if c.SessionTTL, err = time.ParseDuration(c.SessionSticky.TTL); err != nil {
-		return fmt.Errorf("session_sticky.ttl: %w", err)
-	}
-	if c.SessionGCInterval, err = time.ParseDuration(c.SessionSticky.GCInterval); err != nil {
-		return fmt.Errorf("session_sticky.gc_interval: %w", err)
-	}
-	// 快过期窗口：空 = 禁用（ExpiringSoonDur 0）；非空必须可解析（拼写错误 fail fast）。
-	if c.Pool.ExpiringSoon != "" {
-		if c.ExpiringSoonDur, err = time.ParseDuration(c.Pool.ExpiringSoon); err != nil {
-			return fmt.Errorf("pool.expiring_soon: %w", err)
-		}
-	}
-	if c.ExpiringSoonDur < 0 {
-		c.ExpiringSoonDur = 0
-		c.Pool.ExpiringSoon = "0"
-	}
-	// costTier 探索窗口（issue #136）：空值回落默认 30m（Default 已置；此兜底覆盖
-	// 显式 ""）；"0" 是合法值（关停，完全回到现状行为），不回落；负值钳 0 同关停
-	//（"−5m" 无合理语义）。
-	if c.Pool.CostExploreInterval == "" {
-		c.Pool.CostExploreInterval = "30m"
-	}
-	if c.CostExploreIntervalDur, err = time.ParseDuration(c.Pool.CostExploreInterval); err != nil {
-		return fmt.Errorf("pool.cost_explore_interval: %w", err)
-	}
-	if c.CostExploreIntervalDur < 0 {
-		c.CostExploreIntervalDur = 0
-	}
-	// 积分保底：负值钳 0（= 关闭）。0 是合法默认（关闭），无需空值回落。
-	if c.Pool.CreditFloor < 0 {
-		c.Pool.CreditFloor = 0
-	}
-	if c.Pool.BreakerThreshold <= 0 {
-		c.Pool.BreakerThreshold = 3
-	}
-	// 连败降权参数缺省归一（非法/未设置回落默认，与 breaker_threshold 同风格）。
-	if c.Pool.DegradeThreshold <= 0 {
-		c.Pool.DegradeThreshold = 5
-	}
-	if c.Pool.DegradeCooldown == "" {
-		c.Pool.DegradeCooldown = "10m"
-	}
-	if c.Pool.DegradeCooldownMax == "" {
-		c.Pool.DegradeCooldownMax = "2h"
-	}
-	// global 在途分档：0/负数视为未设置回落默认 2（WAF 403 修复 P1-1）。
-	if c.Pool.MaxInFlightGlobal <= 0 {
-		c.Pool.MaxInFlightGlobal = 2
-	}
-	if c.Pool.IdleWeightPerHour <= 0 {
-		c.Pool.IdleWeightPerHour = 0.5
-	}
-	if c.Pool.IdleWeightMax <= 0 {
-		c.Pool.IdleWeightMax = 5.0
-	}
-	if c.Upstream.TimeoutSeconds <= 0 {
-		c.Upstream.TimeoutSeconds = 120
-	}
-	// header 缺省回落 timeout（保"首字节前换号"既有语义）；idle 缺省走内置大值。
-	// 任务书约定：0 一律视为"未设置"走默认，真正的"禁用"留待后续（避免歧义）。
-	if c.Upstream.HeaderTimeoutSeconds <= 0 {
-		c.Upstream.HeaderTimeoutSeconds = c.Upstream.TimeoutSeconds
-	}
-	if c.Upstream.IdleTimeoutSeconds <= 0 {
-		c.Upstream.IdleTimeoutSeconds = 300
-	}
-	if !strings.HasPrefix(c.Listen, ":") && !strings.Contains(c.Listen, ":") {
-		c.Listen = ":" + c.Listen
-	}
-	// 空数组与 null 反序列化后覆盖掉 Default() 的排程值（键缺席才保留），在此补齐。
-	// 空 = 未配置 → 回落默认；「禁用」一律走 *_enabled=false，两者互不混淆。
-	if len(c.Schedule.CheckinHours) == 0 {
-		c.Schedule.CheckinHours = []int{9, 21}
-	}
-	if len(c.Schedule.TravelHours) == 0 {
-		c.Schedule.TravelHours = []int{9, 21}
-	}
-	if len(c.Schedule.ActivityHours) == 0 {
-		c.Schedule.ActivityHours = []int{10}
-	}
-	if len(c.Schedule.KeepaliveHours) == 0 {
-		c.Schedule.KeepaliveHours = []int{22}
-	}
-	if len(c.Schedule.BlackcatHours) == 0 {
-		c.Schedule.BlackcatHours = []int{23}
-	}
-	if len(c.Schedule.GrowthHours) == 0 {
-		c.Schedule.GrowthHours = []int{1}
-	}
-	// 余额后台刷新：启用时 minutes<=0 回落默认 5；关闭时 interval 保持 0（不启动）。
-	if c.Schedule.BalanceRefreshEnabled {
-		if c.Schedule.BalanceRefreshMinutes <= 0 {
-			c.Schedule.BalanceRefreshMinutes = 5
-		}
-		c.BalanceRefreshInterval = time.Duration(c.Schedule.BalanceRefreshMinutes) * time.Minute
-	}
-	if err := c.validateScheduleHours(); err != nil {
-		return err
-	}
-	return c.normalizePrompt()
-}
-
-// normalizePrompt 校验 prompt.mode 并按 file 加载提示词文本（custom/append 模式）。
-//
-// mode 非法（非 passthrough/custom/append）启动报错，避免静默回落到某一分支；
-// custom/append 模式下 file 非空但不可读 → 报错（fail fast），file 空 → 用内置默认
-// （两模式共用同一加载路径，PromptText 均非空）。
-// passthrough 模式不加载文本（透传客户端原始 system，文本在降级时用 prompt.Degraded）。
-func (c *Config) normalizePrompt() error {
-	switch m := strings.ToLower(strings.TrimSpace(c.Prompt.Mode)); m {
-	case "", "passthrough":
-		c.Prompt.Mode = "passthrough"
-	case "custom":
-		c.Prompt.Mode = "custom"
-	case "append":
-		c.Prompt.Mode = "append"
-	default:
-		return fmt.Errorf("prompt.mode: %q 不是合法值（passthrough / custom / append）", c.Prompt.Mode)
-	}
-	if c.Prompt.Mode == "custom" || c.Prompt.Mode == "append" {
-		text, err := prompt.Load(c.Prompt.Mode, c.Prompt.File)
-		if err != nil {
-			return err
-		}
-		c.PromptText = text
-	}
-	return nil
-}
-
-// validateScheduleHours 校验排程小时落在 0-23。
-//
-// 为什么不用 `[-1]` 之类的哨兵值表意"禁用"：非法小时被静默吞掉时，用户以为关掉了签到，
-// 实际可能被当成另一个整点照常执行；这里直接快速失败，并在错误信息里指向正确的开关
-// （checkin_enabled / keepalive_enabled），避免用户靠猜哨兵值来配。
-func (c *Config) validateScheduleHours() error {
-	if err := checkHourRange("schedule.checkin_hours", "checkin_enabled", c.Schedule.CheckinHours); err != nil {
-		return err
-	}
-	if err := checkHourRange("schedule.travel_hours", "travel_enabled", c.Schedule.TravelHours); err != nil {
-		return err
-	}
-	if err := checkHourRange("schedule.activity_hours", "activity_enabled", c.Schedule.ActivityHours); err != nil {
-		return err
-	}
-	if err := checkHourRange("schedule.keepalive_hours", "keepalive_enabled", c.Schedule.KeepaliveHours); err != nil {
-		return err
-	}
-	if err := checkHourRange("schedule.blackcat_hours", "blackcat_enabled", c.Schedule.BlackcatHours); err != nil {
-		return err
-	}
-	return checkHourRange("schedule.growth_hours", "growth_enabled", c.Schedule.GrowthHours)
-}
-
-func checkHourRange(field, switchKey string, hours []int) error {
-	for _, h := range hours {
-		if h < 0 || h > 23 {
-			return fmt.Errorf("%s: %d 不是合法小时（0-23）；如要关闭该任务请设 schedule.%s=false", field, h, switchKey)
-		}
-	}
-	return nil
-}
+// config.go 加载 JSON 配置 + 环境变量覆盖。
+package main
+
+import (
+	"crypto/rand"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/prompt"
+)
+
+// Config 顶层配置。
+type Config struct {
+	Listen    string `json:"listen"`     // ":7863"
+	APIKey    string `json:"api_key"`    // 空 = 不鉴权
+	AuthDir   string `json:"auth_dir"`   // ./auths
+	StateFile string `json:"state_file"` // ./data/state.json
+
+	Panel struct {
+		// PackageDetailLimit 积分构成页单账号默认展示的最近到期包数；<=0 回落 5。
+		PackageDetailLimit int `json:"package_detail_limit"`
+	} `json:"panel"`
+
+	Logging struct {
+		// RequestArchiveEnabled 请求元数据 JSONL 归档开关，缺省 true。
+		RequestArchiveEnabled bool `json:"request_archive_enabled"`
+		// RequestRetentionDays 归档保留天数，缺省 7；<=0 回落默认。
+		RequestRetentionDays int `json:"request_retention_days"`
+		// RequestArchiveMaxMB 归档总上限（MiB），缺省 100；<=0 回落默认。
+		RequestArchiveMaxMB int `json:"request_archive_max_mb"`
+		// RequestClientInfo 是否在请求日志（归档事件 + stdout 流水行 + 面板运行
+		// 日志）里记录调用来源：客户端 IP 与 User-Agent。缺省 true。
+		//
+		// 为什么做成开关而不是恒开：来源信息是排查"谁在打网关"的第一手线索，
+		// 但它比 token 计数敏感（IP 属个人信息），共享部署/多租户场景可能需要
+		// 关掉。关闭后 Event.ClientIP/UserAgent 保持为空，归档里不出现该字段。
+		// 热生效（经 livecfg 快照），无需重启。
+		RequestClientInfo bool `json:"request_client_info"`
+	} `json:"logging"`
+
+	Server struct {
+		// ReadTimeout 入站请求读取（含 body 上传）总时长上限（issue #100）。
+		// http.Server 的 ReadTimeout 覆盖整个请求读取：大上下文/文件块请求经
+		// 反代链转发时上传可超过旧固定值 60s，被掐后客户端拿到
+		// 400 "read body: ... i/o timeout"。缺省 "300s"；"0" = 不限制
+		//（慢速 body 可无限占用连接，自担风险）；改动需重启进程。
+		ReadTimeout string `json:"read_timeout"` // "300s"；"0" = 不限制
+	} `json:"server"`
+
+	Cooldown struct {
+		// hard_credit / err_threshold / err_cooldown 三个历史键已退役：
+		// 硬冷却固定为次日 04:00（CooldownUntilTomorrow4AM），连续错误语义并入熔断器。
+		// 旧 config 中的这些键因 JSON 未知字段而自然忽略，不报错。
+		SoftRate string `json:"soft_rate"` // "600s"，软限流冷却基数
+		// SoftRateMax 软冷却指数退避的封顶，默认 "2h"。
+		// 空值回落默认，非法值报错（处理风格同 soft_rate）。
+		SoftRateMax string `json:"soft_rate_max"` // "2h"
+	} `json:"cooldown"`
+
+	Schedule struct {
+		CheckinHours   []int `json:"checkin_hours"`   // [9,21]
+		TravelHours    []int `json:"travel_hours"`    // [9,21]
+		ActivityHours  []int `json:"activity_hours"`  // [10]
+		KeepaliveHours []int `json:"keepalive_hours"` // [22]
+		BlackcatHours  []int `json:"blackcat_hours"`  // [23] 夜猫子窗口（23:00–08:00 计数）
+		GrowthHours    []int `json:"growth_hours"`    // [1] 成长任务队列（Sequential 族每日零点解锁，01:00 自动扫描执行）
+		// CheckinEnabled/TravelEnabled/ActivityEnabled/KeepaliveEnabled/BlackcatEnabled 显式禁用开关（缺省 true）。
+		//
+		// 为什么用独立 bool 而不是空数组/哨兵值表意"禁用"：
+		//   - 空数组与 null 在老语义里已被"未配置 → 回落默认"占用，改判会静默翻转
+		//     所有老 config 的行为（用户只想删掉一行，结果关掉了签到）；bool 缺省 true
+		//     则对老配置零影响，向后完全兼容。
+		//   - 开关与取值解耦：禁用时仍保留用户显式配的小时，重新启用无需补配。
+		//   - 无需猜测哨兵（[-1] 之类），非法小时一律报错并提示改用本开关。
+		// 旧 config 里的该键因 JSON 未知字段而自然忽略，不报错。
+		CheckinEnabled   bool `json:"checkin_enabled"`   // 缺省 true；false = 关签到
+		TravelEnabled    bool `json:"travel_enabled"`    // 缺省 true；false = 完全停猫猫旅行
+		ActivityEnabled  bool `json:"activity_enabled"`  // 缺省 true；false = 停活跃上报
+		KeepaliveEnabled bool `json:"keepalive_enabled"` // 缺省 true；false = 关 token 保活
+		BlackcatEnabled  bool `json:"blackcat_enabled"`  // 缺省 true；false = 关夜猫子
+		GrowthEnabled    bool `json:"growth_enabled"`    // 缺省 true；false = 关成长任务自动排程
+
+		// IncludeDisabledInTasks 让「保号类」定时任务（签到 / 活跃上报 / token 保活 /
+		// 余额刷新）对**已禁用（disabled）**的账号也执行。
+		//
+		// 为什么需要它：面板「禁用」的语义是「不再参与选号」（见面板确认文案），但这四类
+		// 任务此前一律 `if st.Disabled { continue }`，等于把「停用流量」放大成「停止一切
+		// 上游保号行为」——被禁用的号拿不到签到积分、不续 token、余额也不再刷新；而
+		// ReenableIfCredits 明确不复活 disabled 账号（见 pool.state.go），于是签到这条唯一
+		// 的自动回血路径也断了，账号只能靠人工「解冻」回来。
+		//
+		// 对「一次只放开一个号、用禁用做流量开关」的轮换用法（同 IP 多号防风控），闲置
+		// 待命的号恰恰是最需要签到的那批——本开关即为该用法提供出口。
+		//
+		// 缺省 false = 保持既有行为，对老配置零影响。打开后禁用号仍会签到 / 保活，但
+		// **依旧不参与选号**：pool 选号侧的 disabled 过滤不受本开关影响。
+		IncludeDisabledInTasks bool `json:"include_disabled_in_tasks"`
+
+		// 余额后台周期刷新：两次签到时点之间 credits 也能保持新鲜（面板/状态观测用）。
+		// 解冻语义同签到（余额 > 0 的冷却账号自动解冻），但不做签到不刷 token。
+		BalanceRefreshEnabled bool `json:"balance_refresh_enabled"` // 缺省 true；false = 关闭
+		BalanceRefreshMinutes int  `json:"balance_refresh_minutes"` // 缺省 5；<=0 回落 5
+	} `json:"schedule"`
+
+	Global struct {
+		// Enabled global realm 路由开关。缺省 true：Realm() 正常把 realm=global/
+		// domain=workbuddy.ai 的账号判为 global 并路由 global base/路径。
+		// 显式 "enabled": false 关闭（逃生门，纯 CN 锁定：即便 auth 写了 realm=global
+		// 也不路由，auth.Realm() 双保险的第一道闸）。纯 CN 部署行为不变：CN 账号
+		// 恒判 cn，global base 只在 realm=global 的账号上被使用。
+		Enabled bool `json:"enabled"`
+		// ChatBase / BillingBase 国际版上游 base 覆盖；空 = 回落内置默认
+		// https://www.workbuddy.ai（internal/upstream.defaultGlobalBase）。
+		ChatBase    string `json:"chat_base"`
+		BillingBase string `json:"billing_base"`
+	} `json:"global"`
+
+	Upstream struct {
+		// TimeoutSeconds 短 RPC（refresh/checkin/balance/FetchModels）总时长上限，默认 120。
+		TimeoutSeconds int `json:"timeout_seconds"`
+		// HeaderTimeoutSeconds 聊天 SSE 首字节前（响应头）上限；<=0 回落 TimeoutSeconds。
+		HeaderTimeoutSeconds int `json:"header_timeout_seconds"`
+		// IdleTimeoutSeconds 聊天 SSE 流中空闲上限（活跃吐数据续命不掐）；<=0 回落默认 300。
+		IdleTimeoutSeconds int `json:"idle_timeout_seconds"`
+		// UserAgent 出站 User-Agent 显式覆盖（非空时全路径生效，优先于默认三段式）。
+		// 全部出站请求生效：chat/refresh/checkin/balance/report/travel/FetchModels。
+		// 默认值已对齐官方 WorkBuddy 桌面形态（三段式），用户仍可配完全自定义值改写。
+		UserAgent string `json:"user_agent"`
+		// ClientVersion WorkBuddy 客户端版本段（出站 UA 的 `WorkBuddy/<ver>` 与归属头
+		// X-IDE-Version）。空 = 内置默认（对齐官方 5.5.4 分发包）。
+		ClientVersion string `json:"client_version"`
+		// CliVersion 出站 UA 中 `CLI/<ver>` 段的版本。空 = 内置默认（官方内置 CLI 2.137.1）。
+		CliVersion string `json:"cli_version"`
+		// ClientName 用量归属头取值（X-Product / X-IDE-Name / X-IDE-Type / X-IDE-Version）。
+		// 空 = 旧行为 X-Product="SaaS" 不设 X-IDE-*；配 "WorkBuddy" 则四头跟随。
+		ClientName string `json:"client_name"`
+		// DeviceToken 设备风控 Token（X-Device-Token 头）全局兜底；空 = 不注入。
+		// 每号 auth 文件的 device_token 键优先于本项。
+		DeviceToken string `json:"device_token"`
+		// DeviceTokenFile device token 文件路径兜底（宿主落盘的桌面端 token，5 分钟读取缓存）。
+		DeviceTokenFile string `json:"device_token_file"`
+		// PassthroughIP 是否透传客户端 IP 给上游（默认 false，反代安全边界）。
+		PassthroughIP bool `json:"passthrough_ip"`
+	} `json:"upstream"`
+
+	Features struct {
+		// SanitizeBlacklistFingerprints 出站请求体黑名单指纹脱敏（默认 true；false 完全还原）。
+		SanitizeBlacklistFingerprints bool `json:"sanitize_blacklist_fingerprints"`
+	} `json:"features"`
+
+	Prompt struct {
+		// Mode passthrough（默认）= 透传客户端原始 system（降级重试仍会切到 Degraded）；
+		// custom = 网关用自有系统提示词替换客户端 system/developer；
+		// append = 两者并用：开头连续 system/developer 块后插网关 system，既有消息逐字不动（issue #129）。
+		Mode string `json:"mode"` // "passthrough" / "custom" / "append"
+		// File 提示词文件路径；空 = 内置默认 defaultprompt.md；
+		// 路径非空但不可读 → 启动报错（fail fast，避免静默回落到内置默认）。
+		File string `json:"file"`
+	} `json:"prompt"`
+
+	// PromptText 解析后的系统提示词文本（custom/append 模式使用）。
+	PromptText string `json:"-"`
+
+	Upstash struct {
+		URL   string `json:"url"`   // 空 = 纯内存模式；支持完整 rediss:// URL 或 https://xxx.upstash.io host
+		Token string `json:"token"` // url 非完整连接串时用于组装 rediss://default:<token>@<host>:6379
+	} `json:"upstash"`
+
+	Pool struct {
+		MaxInFlight        int    `json:"max_in_flight"`        // 单账号最大在途请求数，0 = 不限
+		MaxInFlightGlobal  int    `json:"max_in_flight_global"` // global 域单账号在途上限（WAF 风控紧域压低并发），0 = 回落默认 2
+		BreakerThreshold   int    `json:"breaker_threshold"`    // 连续失败次数触发熔断，默认 3
+		BreakerCooldown    string `json:"breaker_cooldown"`     // 基础熔断时长，默认 "30m"
+		BreakerCooldownMax string `json:"breaker_cooldown_max"` // 指数退避封顶，默认 "6h"
+		// 连败降权（issue #114）：ErrClient/传输层这类「不罚号」失败连续计数，达阈
+		// 临时出池。与冷却/熔断并存取更长者不叠加。默认 5 次 / 10m。
+		DegradeThreshold   int     `json:"degrade_threshold"`    // 连败次数触发降权，默认 5
+		DegradeCooldown    string  `json:"degrade_cooldown"`     // 降权时长（固定，非指数退避），默认 "10m"
+		DegradeCooldownMax string  `json:"degrade_cooldown_max"` // 降权时长的上限钳制，默认 "2h"（仅当 cooldown 超该值才钳制）
+		IdleWeightPerHour  float64 `json:"idle_weight_per_hour"` // 闲置补偿：每小时未用 +0.5 权重
+		IdleWeightMax      float64 `json:"idle_weight_max"`      // 闲置补偿封顶，默认 5.0
+		// PreferExpiring 快过期积分加权开关，默认 true。开启且 expiring_soon 窗口内
+		// 存在有效批次时，该账号选号权重 ×3（虚拟实例，见 pool 路由加权）；
+		// 不按到期时间排序、与批次金额无关（issue #101 对齐实现口径）。
+		// 关闭后完全不使用到期信息选号。
+		PreferExpiring bool `json:"prefer_expiring"`
+		// ExpiringSoon 快过期积分窗口（如 "168h"=7天）：签到/余额刷新时，到期时间在
+		// 此窗口内的批次令账号命中上述 ×3 加权；窗口开大 → 命中账号变多、
+		// 偏好被稀释。空/0 = 禁用该加权门槛。
+		ExpiringSoon string `json:"expiring_soon"`
+		// CostExploreInterval costTier 条件探索窗口（issue #136 方案 a′）：tier 0
+		// 垄断层存在且 tier 1 有成员时，距上次探索 ≥ 窗口则本次 pick 生效层切
+		// tier 1-only（探索=搭车改道，零新增上游请求；成功即毕业，失败走既有
+		// 错误策略）。默认 "30m"（≤48 次/天/模型）；"0" 关停（完全回到现状行为）；
+		// 空值回落默认。
+		CostExploreInterval string `json:"cost_explore_interval"`
+		// CreditFloor 积分保底：账号余额低于该值时，对实测收费模型（tier 2）不再
+		// 参与选号——防止收费请求把余额打穿、连免费模型都 402 冷却到次日签到。
+		// tier 0（免费）/ tier 1（无观测）不受限；签到回血越过 floor 自动恢复。
+		// 默认 0 = 关闭；负值钳 0。
+		CreditFloor int64 `json:"credit_floor"`
+	} `json:"pool"`
+
+	SessionSticky struct {
+		Enabled    bool   `json:"enabled"`     // 默认 true
+		TTL        string `json:"ttl"`         // 会话绑定 TTL，默认 "30m"
+		GCInterval string `json:"gc_interval"` // 会话 GC 周期，默认 "5m"
+	} `json:"session_sticky"`
+
+	// 解析后
+	SoftRateDur            time.Duration `json:"-"`
+	SoftRateMaxDur         time.Duration `json:"-"`
+	BreakerCooldownDur     time.Duration `json:"-"`
+	BreakerCooldownMaxD    time.Duration `json:"-"`
+	DegradeCooldownDur     time.Duration `json:"-"`
+	DegradeCooldownMaxD    time.Duration `json:"-"`
+	SessionTTL             time.Duration `json:"-"`
+	SessionGCInterval      time.Duration `json:"-"`
+	BalanceRefreshInterval time.Duration `json:"-"` // 0 = 不启动（enabled=false）
+	ExpiringSoonDur        time.Duration `json:"-"`
+	// CostExploreIntervalDur 解析后的 costTier 探索窗口（issue #136）；0 = 关停。
+	CostExploreIntervalDur time.Duration `json:"-"`
+	// ServerReadTimeoutDur 解析后的入站请求读取上限（issue #100）；0 = 不限制。
+	ServerReadTimeoutDur time.Duration `json:"-"`
+}
+
+// Default 默认配置。
+func Default() *Config {
+	c := &Config{
+		Listen:    ":7863",
+		APIKey:    "",
+		AuthDir:   "./auths",
+		StateFile: "./data/state.json",
+	}
+	c.Cooldown.SoftRate = "600s"
+	c.Cooldown.SoftRateMax = "2h"
+	c.Server.ReadTimeout = "300s"
+	c.Panel.PackageDetailLimit = 5
+	c.Logging.RequestArchiveEnabled = true
+	c.Logging.RequestRetentionDays = 7
+	c.Logging.RequestArchiveMaxMB = 100
+	// 缺省 true 靠显式赋值实现（同 Schedule 开关）：JSON 里键缺席时字段保留此值，
+	// 只有显式 false 才关闭来源记录。
+	c.Logging.RequestClientInfo = true
+	c.Schedule.CheckinHours = []int{9, 21}
+	c.Schedule.TravelHours = []int{9, 21}
+	c.Schedule.ActivityHours = []int{10}
+	c.Schedule.KeepaliveHours = []int{22}
+	c.Schedule.BlackcatHours = []int{23}
+	c.Schedule.GrowthHours = []int{1}
+	// 开关「缺省 true」靠这几行实现：Load 先取 Default() 再 json.Unmarshal 覆盖，
+	// 键缺席（或为 null）时字段原样保留 true，只有显式 false 才关。
+	c.Schedule.CheckinEnabled = true
+	c.Schedule.GrowthEnabled = true
+	c.Schedule.TravelEnabled = true
+	c.Schedule.ActivityEnabled = true
+	c.Schedule.KeepaliveEnabled = true
+	c.Schedule.BlackcatEnabled = true
+	c.Schedule.BalanceRefreshEnabled = true
+	c.Schedule.BalanceRefreshMinutes = 5
+	c.Upstream.TimeoutSeconds = 120
+	// HeaderTimeoutSeconds/IdleTimeoutSeconds 默认 0（未设置态），回落见 normalize()。
+	c.Upstream.HeaderTimeoutSeconds = 0
+	c.Upstream.IdleTimeoutSeconds = 0
+	// Global.Enabled 缺省 true（纯 CN 行为不变：CN 账号恒判 cn，global base 不被使用）；
+	// ChatBase/BillingBase 缺省空（回落内置默认）。
+	c.Global.Enabled = true
+	c.Features.SanitizeBlacklistFingerprints = true
+	c.Prompt.Mode = "passthrough" // 缺省 passthrough：透传客户端原始 system（对齐上游；custom 由用户显式选择）
+	c.Pool.MaxInFlight = 3
+	// MaxInFlightGlobal 缺省 2：global 域 WAF 风控更紧，压低单号并发（WAF 403 修复
+	// P1-1）；0/负数 normalize 回落默认（与 max_in_flight 的 0=不限语义不同，分档键
+	// 的 0 没有合理语义，回退分档默认最稳）。
+	c.Pool.MaxInFlightGlobal = 2
+	c.Pool.BreakerThreshold = 3
+	c.Pool.BreakerCooldown = "30m"
+	c.Pool.BreakerCooldownMax = "6h"
+	c.Pool.DegradeThreshold = 5
+	c.Pool.DegradeCooldown = "10m"
+	c.Pool.DegradeCooldownMax = "2h"
+	c.Pool.IdleWeightPerHour = 0.5
+	c.Pool.IdleWeightMax = 5.0
+	c.Pool.PreferExpiring = true
+	c.Pool.ExpiringSoon = "168h" // 快过期窗口默认 7 天：官方活动奖励积分多在两周内过期
+	// costTier 探索默认 30m（issue #136：垄断破除 + 搭车改道零新增请求）；"0" 关停。
+	c.Pool.CostExploreInterval = "30m"
+	c.SessionSticky.Enabled = true
+	c.SessionSticky.TTL = "30m"
+	c.SessionSticky.GCInterval = "5m"
+	return c
+}
+
+// Load 从文件读，再用 WB2A_* env 覆盖。
+func Load(path string) (*Config, error) {
+	c := Default()
+	if path != "" {
+		// 目录检查：Docker bind mount 在宿主机文件缺失时会静默创建同名目录，
+		// 直接 ReadFile 会报 "Incorrect function" 之类晦涩错误，这里给出可操作提示。
+		if st, statErr := os.Stat(path); statErr == nil && st.IsDir() {
+			return nil, fmt.Errorf("config %s 是目录而非文件——"+
+				"Docker 部署时若宿主机缺少 config.json，bind mount 会创建同名目录。"+
+				"请先 `cp config.example.json config.json` 或删除该目录（程序会自动生成配置）", path)
+		}
+		raw, err := os.ReadFile(path)
+		if err != nil {
+			return nil, fmt.Errorf("read config: %w", err)
+		}
+		if _, err := ParseConfigInto(raw, c); err != nil {
+			return nil, err
+		}
+	}
+	applyEnv(c)
+	if err := c.normalize(); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// ParseConfigInto 把 JSON 覆盖到 c 上并 normalize（不做 env、不读文件）。
+// 面板保存配置走这条路径：与 Load 完全同一套解析/校验逻辑，避免两处漂移。
+func ParseConfigInto(raw []byte, c *Config) (*Config, error) {
+	if err := json.Unmarshal(raw, c); err != nil {
+		return nil, fmt.Errorf("parse config: %w", err)
+	}
+	if err := c.normalize(); err != nil {
+		return nil, err
+	}
+	return c, nil
+}
+
+// ParseConfig 基于默认值解析一段配置 JSON（等价于 Load 的文件分支，但不读环境变量）。
+func ParseConfig(raw []byte) (*Config, error) {
+	return ParseConfigInto(raw, Default())
+}
+
+// WriteDefault 在 path 落一份推荐配置（首次运行自动生成，双击即开免手工复制样例）。
+// 值取自 Default()（含超时/熔断/签到排程等推荐值），api_key 用 crypto/rand 随机生成：
+// 安全默认优于示例占位符（listen 绑定 0.0.0.0，空 key 会把网关裸暴露给局域网）。
+// 返回生成的 key 供启动日志透出。已存在时经 O_EXCL 原子拒绝，绝不改写用户配置。
+func WriteDefault(path string) (string, error) {
+	raw := make([]byte, 18)
+	if _, err := rand.Read(raw); err != nil {
+		return "", fmt.Errorf("gen api_key: %w", err)
+	}
+	key := "sk-" + base64.RawURLEncoding.EncodeToString(raw)
+	c := Default()
+	c.APIKey = key
+	_ = c.normalize() // Default() 全合法，normalize 仅补齐 header/idle 超时的展示值
+	out, err := json.MarshalIndent(c, "", "  ")
+	if err != nil {
+		return "", fmt.Errorf("marshal config: %w", err)
+	}
+	if dir := filepath.Dir(path); dir != "" && dir != "." {
+		if err := os.MkdirAll(dir, 0o755); err != nil {
+			return "", fmt.Errorf("mkdir config dir: %w", err)
+		}
+	}
+	// O_EXCL 原子拒绝覆盖：即使调用方漏判"不存在"，也绝不悄悄改写用户已有配置。
+	f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
+	if err != nil {
+		return "", fmt.Errorf("write config: %w", err)
+	}
+	defer f.Close()
+	if _, err := f.Write(out); err != nil {
+		return "", fmt.Errorf("write config: %w", err)
+	}
+	return key, nil
+}
+
+func applyEnv(c *Config) {
+	if v := os.Getenv("WB2A_LISTEN"); v != "" {
+		c.Listen = v
+	}
+	if v := os.Getenv("WB2A_API_KEY"); v != "" {
+		c.APIKey = v
+	}
+	if v := os.Getenv("WB2A_AUTH_DIR"); v != "" {
+		c.AuthDir = v
+	}
+	if v := os.Getenv("WB2A_STATE_FILE"); v != "" {
+		c.StateFile = v
+	}
+	if v := os.Getenv("WB2A_SOFT_RATE"); v != "" {
+		c.Cooldown.SoftRate = v
+	}
+	if v := os.Getenv("WB2A_SOFT_RATE_MAX"); v != "" {
+		c.Cooldown.SoftRateMax = v
+	}
+	if v := os.Getenv("WB2A_TIMEOUT_SECONDS"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil {
+			c.Upstream.TimeoutSeconds = n
+		}
+	}
+	if v := os.Getenv("WB2A_HEADER_TIMEOUT_SECONDS"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil {
+			c.Upstream.HeaderTimeoutSeconds = n
+		}
+	}
+	if v := os.Getenv("WB2A_IDLE_TIMEOUT_SECONDS"); v != "" {
+		if n, err := strconv.Atoi(v); err == nil {
+			c.Upstream.IdleTimeoutSeconds = n
+		}
+	}
+	if v := os.Getenv("WB2A_USER_AGENT"); v != "" {
+		c.Upstream.UserAgent = v
+	}
+	if v := os.Getenv("WB2A_CLIENT_VERSION"); v != "" {
+		c.Upstream.ClientVersion = v
+	}
+	if v := os.Getenv("WB2A_CLI_VERSION"); v != "" {
+		c.Upstream.CliVersion = v
+	}
+	if v := os.Getenv("WB2A_CLIENT_NAME"); v != "" {
+		c.Upstream.ClientName = v
+	}
+	if v := os.Getenv("WB2A_DEVICE_TOKEN"); v != "" {
+		c.Upstream.DeviceToken = v
+	}
+	if v := os.Getenv("WB2A_DEVICE_TOKEN_FILE"); v != "" {
+		c.Upstream.DeviceTokenFile = v
+	}
+	if v := os.Getenv("WB2A_PASSTHROUGH_IP"); v != "" {
+		if b, err := strconv.ParseBool(v); err == nil {
+			c.Upstream.PassthroughIP = b
+		}
+	}
+	if v := os.Getenv("WB2A_SANITIZE_FINGERPRINTS"); v != "" {
+		if b, err := strconv.ParseBool(v); err == nil {
+			c.Features.SanitizeBlacklistFingerprints = b
+		}
+	}
+	if v := os.Getenv("WB2A_PROMPT_MODE"); v != "" {
+		c.Prompt.Mode = v
+	}
+	if v := os.Getenv("WB2A_PROMPT_FILE"); v != "" {
+		c.Prompt.File = v
+	}
+	if v := os.Getenv("WB2A_EXPIRING_SOON"); v != "" {
+		c.Pool.ExpiringSoon = v
+	}
+	if v := os.Getenv("WB2A_PREFER_EXPIRING"); v != "" {
+		if b, err := strconv.ParseBool(v); err == nil {
+			c.Pool.PreferExpiring = b
+		}
+	}
+}
+
+func (c *Config) normalize() error {
+	var err error
+	if c.Panel.PackageDetailLimit <= 0 {
+		c.Panel.PackageDetailLimit = 5
+	}
+	if c.Logging.RequestRetentionDays <= 0 {
+		c.Logging.RequestRetentionDays = 7
+	}
+	if c.Logging.RequestArchiveMaxMB <= 0 {
+		c.Logging.RequestArchiveMaxMB = 100
+	}
+	// 入站读取上限（issue #100）：空值回落默认 300s；"0" 合法（不限制）；
+	// 负值无语义，fail fast（静默钳 0 会把保护悄悄关掉）。
+	if c.Server.ReadTimeout == "" {
+		c.Server.ReadTimeout = "300s"
+	}
+	if c.ServerReadTimeoutDur, err = time.ParseDuration(c.Server.ReadTimeout); err != nil {
+		return fmt.Errorf("server.read_timeout: %w", err)
+	}
+	if c.ServerReadTimeoutDur < 0 {
+		return fmt.Errorf("server.read_timeout: 负时长 %q 无意义", c.Server.ReadTimeout)
+	}
+	if c.SoftRateDur, err = time.ParseDuration(c.Cooldown.SoftRate); err != nil {
+		return fmt.Errorf("cooldown.soft_rate: %w", err)
+	}
+	// 空值回落默认 2h（Default() 已置值；此兜底覆盖显式 "" 与 Default() 被绕过的场景）。
+	if c.Cooldown.SoftRateMax == "" {
+		c.Cooldown.SoftRateMax = "2h"
+	}
+	if c.SoftRateMaxDur, err = time.ParseDuration(c.Cooldown.SoftRateMax); err != nil {
+		return fmt.Errorf("cooldown.soft_rate_max: %w", err)
+	}
+	if c.BreakerCooldownDur, err = time.ParseDuration(c.Pool.BreakerCooldown); err != nil {
+		return fmt.Errorf("pool.breaker_cooldown: %w", err)
+	}
+	if c.BreakerCooldownMaxD, err = time.ParseDuration(c.Pool.BreakerCooldownMax); err != nil {
+		return fmt.Errorf("pool.breaker_cooldown_max: %w", err)
+	}
+	if c.DegradeCooldownDur, err = time.ParseDuration(c.Pool.DegradeCooldown); err != nil {
+		return fmt.Errorf("pool.degrade_cooldown: %w", err)
+	}
+	if c.DegradeCooldownMaxD, err = time.ParseDuration(c.Pool.DegradeCooldownMax); err != nil {
+		return fmt.Errorf("pool.degrade_cooldown_max: %w", err)
+	}
+	if c.SessionTTL, err = time.ParseDuration(c.SessionSticky.TTL); err != nil {
+		return fmt.Errorf("session_sticky.ttl: %w", err)
+	}
+	if c.SessionGCInterval, err = time.ParseDuration(c.SessionSticky.GCInterval); err != nil {
+		return fmt.Errorf("session_sticky.gc_interval: %w", err)
+	}
+	// 快过期窗口：空 = 禁用（ExpiringSoonDur 0）；非空必须可解析（拼写错误 fail fast）。
+	if c.Pool.ExpiringSoon != "" {
+		if c.ExpiringSoonDur, err = time.ParseDuration(c.Pool.ExpiringSoon); err != nil {
+			return fmt.Errorf("pool.expiring_soon: %w", err)
+		}
+	}
+	if c.ExpiringSoonDur < 0 {
+		c.ExpiringSoonDur = 0
+		c.Pool.ExpiringSoon = "0"
+	}
+	// costTier 探索窗口（issue #136）：空值回落默认 30m（Default 已置；此兜底覆盖
+	// 显式 ""）；"0" 是合法值（关停，完全回到现状行为），不回落；负值钳 0 同关停
+	//（"−5m" 无合理语义）。
+	if c.Pool.CostExploreInterval == "" {
+		c.Pool.CostExploreInterval = "30m"
+	}
+	if c.CostExploreIntervalDur, err = time.ParseDuration(c.Pool.CostExploreInterval); err != nil {
+		return fmt.Errorf("pool.cost_explore_interval: %w", err)
+	}
+	if c.CostExploreIntervalDur < 0 {
+		c.CostExploreIntervalDur = 0
+	}
+	// 积分保底：负值钳 0（= 关闭）。0 是合法默认（关闭），无需空值回落。
+	if c.Pool.CreditFloor < 0 {
+		c.Pool.CreditFloor = 0
+	}
+	if c.Pool.BreakerThreshold <= 0 {
+		c.Pool.BreakerThreshold = 3
+	}
+	// 连败降权参数缺省归一（非法/未设置回落默认，与 breaker_threshold 同风格）。
+	if c.Pool.DegradeThreshold <= 0 {
+		c.Pool.DegradeThreshold = 5
+	}
+	if c.Pool.DegradeCooldown == "" {
+		c.Pool.DegradeCooldown = "10m"
+	}
+	if c.Pool.DegradeCooldownMax == "" {
+		c.Pool.DegradeCooldownMax = "2h"
+	}
+	// global 在途分档：0/负数视为未设置回落默认 2（WAF 403 修复 P1-1）。
+	if c.Pool.MaxInFlightGlobal <= 0 {
+		c.Pool.MaxInFlightGlobal = 2
+	}
+	if c.Pool.IdleWeightPerHour <= 0 {
+		c.Pool.IdleWeightPerHour = 0.5
+	}
+	if c.Pool.IdleWeightMax <= 0 {
+		c.Pool.IdleWeightMax = 5.0
+	}
+	if c.Upstream.TimeoutSeconds <= 0 {
+		c.Upstream.TimeoutSeconds = 120
+	}
+	// header 缺省回落 timeout（保"首字节前换号"既有语义）；idle 缺省走内置大值。
+	// 任务书约定：0 一律视为"未设置"走默认，真正的"禁用"留待后续（避免歧义）。
+	if c.Upstream.HeaderTimeoutSeconds <= 0 {
+		c.Upstream.HeaderTimeoutSeconds = c.Upstream.TimeoutSeconds
+	}
+	if c.Upstream.IdleTimeoutSeconds <= 0 {
+		c.Upstream.IdleTimeoutSeconds = 300
+	}
+	if !strings.HasPrefix(c.Listen, ":") && !strings.Contains(c.Listen, ":") {
+		c.Listen = ":" + c.Listen
+	}
+	// 空数组与 null 反序列化后覆盖掉 Default() 的排程值（键缺席才保留），在此补齐。
+	// 空 = 未配置 → 回落默认；「禁用」一律走 *_enabled=false，两者互不混淆。
+	if len(c.Schedule.CheckinHours) == 0 {
+		c.Schedule.CheckinHours = []int{9, 21}
+	}
+	if len(c.Schedule.TravelHours) == 0 {
+		c.Schedule.TravelHours = []int{9, 21}
+	}
+	if len(c.Schedule.ActivityHours) == 0 {
+		c.Schedule.ActivityHours = []int{10}
+	}
+	if len(c.Schedule.KeepaliveHours) == 0 {
+		c.Schedule.KeepaliveHours = []int{22}
+	}
+	if len(c.Schedule.BlackcatHours) == 0 {
+		c.Schedule.BlackcatHours = []int{23}
+	}
+	if len(c.Schedule.GrowthHours) == 0 {
+		c.Schedule.GrowthHours = []int{1}
+	}
+	// 余额后台刷新：启用时 minutes<=0 回落默认 5；关闭时 interval 保持 0（不启动）。
+	if c.Schedule.BalanceRefreshEnabled {
+		if c.Schedule.BalanceRefreshMinutes <= 0 {
+			c.Schedule.BalanceRefreshMinutes = 5
+		}
+		c.BalanceRefreshInterval = time.Duration(c.Schedule.BalanceRefreshMinutes) * time.Minute
+	}
+	if err := c.validateScheduleHours(); err != nil {
+		return err
+	}
+	return c.normalizePrompt()
+}
+
+// normalizePrompt 校验 prompt.mode 并按 file 加载提示词文本（custom/append 模式）。
+//
+// mode 非法（非 passthrough/custom/append）启动报错，避免静默回落到某一分支；
+// custom/append 模式下 file 非空但不可读 → 报错（fail fast），file 空 → 用内置默认
+// （两模式共用同一加载路径，PromptText 均非空）。
+// passthrough 模式不加载文本（透传客户端原始 system，文本在降级时用 prompt.Degraded）。
+func (c *Config) normalizePrompt() error {
+	switch m := strings.ToLower(strings.TrimSpace(c.Prompt.Mode)); m {
+	case "", "passthrough":
+		c.Prompt.Mode = "passthrough"
+	case "custom":
+		c.Prompt.Mode = "custom"
+	case "append":
+		c.Prompt.Mode = "append"
+	default:
+		return fmt.Errorf("prompt.mode: %q 不是合法值（passthrough / custom / append）", c.Prompt.Mode)
+	}
+	if c.Prompt.Mode == "custom" || c.Prompt.Mode == "append" {
+		text, err := prompt.Load(c.Prompt.Mode, c.Prompt.File)
+		if err != nil {
+			return err
+		}
+		c.PromptText = text
+	}
+	return nil
+}
+
+// validateScheduleHours 校验排程小时落在 0-23。
+//
+// 为什么不用 `[-1]` 之类的哨兵值表意"禁用"：非法小时被静默吞掉时，用户以为关掉了签到，
+// 实际可能被当成另一个整点照常执行；这里直接快速失败，并在错误信息里指向正确的开关
+// （checkin_enabled / keepalive_enabled），避免用户靠猜哨兵值来配。
+func (c *Config) validateScheduleHours() error {
+	if err := checkHourRange("schedule.checkin_hours", "checkin_enabled", c.Schedule.CheckinHours); err != nil {
+		return err
+	}
+	if err := checkHourRange("schedule.travel_hours", "travel_enabled", c.Schedule.TravelHours); err != nil {
+		return err
+	}
+	if err := checkHourRange("schedule.activity_hours", "activity_enabled", c.Schedule.ActivityHours); err != nil {
+		return err
+	}
+	if err := checkHourRange("schedule.keepalive_hours", "keepalive_enabled", c.Schedule.KeepaliveHours); err != nil {
+		return err
+	}
+	if err := checkHourRange("schedule.blackcat_hours", "blackcat_enabled", c.Schedule.BlackcatHours); err != nil {
+		return err
+	}
+	return checkHourRange("schedule.growth_hours", "growth_enabled", c.Schedule.GrowthHours)
+}
+
+func checkHourRange(field, switchKey string, hours []int) error {
+	for _, h := range hours {
+		if h < 0 || h > 23 {
+			return fmt.Errorf("%s: %d 不是合法小时（0-23）；如要关闭该任务请设 schedule.%s=false", field, h, switchKey)
+		}
+	}
+	return nil
+}

cmd/server/config_test.go

@@ -1,816 +1,861 @@
-package main
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-	"time"
-)
-
-func TestDefault(t *testing.T) {
-	c := Default()
-	if c.Listen != ":7863" {
-		t.Errorf("listen=%s", c.Listen)
-	}
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if c.SoftRateDur.Seconds() != 600 {
-		t.Errorf("soft=%v want 600s", c.SoftRateDur)
-	}
-}
-
-func TestPanelPackageDetailLimit(t *testing.T) {
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if c.Panel.PackageDetailLimit != 5 {
-		t.Fatalf("default package_detail_limit=%d want 5", c.Panel.PackageDetailLimit)
-	}
-
-	configured, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":8}}`))
-	if err != nil {
-		t.Fatalf("parse configured limit: %v", err)
-	}
-	if configured.Panel.PackageDetailLimit != 8 {
-		t.Fatalf("configured package_detail_limit=%d want 8", configured.Panel.PackageDetailLimit)
-	}
-
-	fallback, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":0}}`))
-	if err != nil {
-		t.Fatalf("parse fallback limit: %v", err)
-	}
-	if fallback.Panel.PackageDetailLimit != 5 {
-		t.Fatalf("fallback package_detail_limit=%d want 5", fallback.Panel.PackageDetailLimit)
-	}
-}
-
-func TestLoggingDefaults(t *testing.T) {
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatal(err)
-	}
-	if !c.Logging.RequestArchiveEnabled || c.Logging.RequestRetentionDays != 7 || c.Logging.RequestArchiveMaxMB != 100 {
-		t.Fatalf("logging defaults = %+v", c.Logging)
-	}
-	// 来源记录（IP/UA）缺省开启：键缺席时必须保持 true，只有显式 false 才关闭。
-	if !c.Logging.RequestClientInfo {
-		t.Fatalf("request_client_info default = false, want true: %+v", c.Logging)
-	}
-	configured, err := ParseConfig([]byte(`{"logging":{"request_archive_enabled":false,"request_retention_days":30,"request_archive_max_mb":500}}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if configured.Logging.RequestArchiveEnabled || configured.Logging.RequestRetentionDays != 30 || configured.Logging.RequestArchiveMaxMB != 500 {
-		t.Fatalf("configured logging = %+v", configured.Logging)
-	}
-	off, err := ParseConfig([]byte(`{"logging":{"request_client_info":false}}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if off.Logging.RequestClientInfo {
-		t.Fatalf("explicit false ignored: %+v", off.Logging)
-	}
-	fallback, err := ParseConfig([]byte(`{"logging":{"request_retention_days":0,"request_archive_max_mb":0}}`))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if fallback.Logging.RequestRetentionDays != 7 || fallback.Logging.RequestArchiveMaxMB != 100 {
-		t.Fatalf("logging fallback = %+v", fallback.Logging)
-	}
-}
-
-func TestLoadFile(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Listen != ":9999" || c.APIKey != "k" {
-		t.Errorf("c=%+v", c)
-	}
-}
-
-func TestEnvOverride(t *testing.T) {
-	t.Setenv("WB2A_LISTEN", ":7777")
-	t.Setenv("WB2A_API_KEY", "envkey")
-	c, err := Load("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Listen != ":7777" || c.APIKey != "envkey" {
-		t.Errorf("c=%+v", c)
-	}
-}
-
-func TestBadDuration(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"not-a-duration"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for bad duration")
-	}
-}
-
-func TestHardCreditKeyIgnored(t *testing.T) {
-	// 退役的 hard_credit 键作为 JSON 未知字段被自然忽略，不报错。
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"cooldown":{"hard_credit":"not-a-duration","soft_rate":"30s"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatalf("hard_credit must be ignored (not validated): %v", err)
-	}
-	if c.SoftRateDur.Seconds() != 30 {
-		t.Errorf("soft_rate=%v want 30s", c.SoftRateDur)
-	}
-}
-
-func TestNewPoolConfigDefaults(t *testing.T) {
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if c.Pool.MaxInFlight != 3 {
-		t.Errorf("max_in_flight=%d want 3", c.Pool.MaxInFlight)
-	}
-	if c.Pool.BreakerThreshold != 3 {
-		t.Errorf("breaker_threshold=%d want 3", c.Pool.BreakerThreshold)
-	}
-	if c.BreakerCooldownDur.Minutes() != 30 {
-		t.Errorf("breaker_cooldown=%v want 30m", c.BreakerCooldownDur)
-	}
-	if c.BreakerCooldownMaxD.Hours() != 6 {
-		t.Errorf("breaker_cooldown_max=%v want 6h", c.BreakerCooldownMaxD)
-	}
-	if c.Pool.IdleWeightPerHour != 0.5 || c.Pool.IdleWeightMax != 5.0 {
-		t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax)
-	}
-	if !c.Pool.PreferExpiring || c.ExpiringSoonDur != 7*24*time.Hour {
-		t.Errorf("expiring defaults: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur)
-	}
-	if c.SoftRateMaxDur.Hours() != 2 {
-		t.Errorf("soft_rate_max=%v want 2h", c.SoftRateMaxDur)
-	}
-	if !c.SessionSticky.Enabled {
-		t.Error("session_sticky.enabled want true")
-	}
-	if c.SessionTTL.Minutes() != 30 || c.SessionGCInterval.Minutes() != 5 {
-		t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval)
-	}
-	if c.Upstash.URL != "" || c.Upstash.Token != "" {
-		t.Errorf("upstash default should be empty: %+v", c.Upstash)
-	}
-}
-
-func TestPoolConfigParsedFromFile(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{
-		"upstash":{"url":"https://foo.upstash.io","token":"tok"},
-		"pool":{
-			"max_in_flight":5,
-			"breaker_threshold":4,
-			"breaker_cooldown":"10m",
-			"breaker_cooldown_max":"2h",
-			"idle_weight_per_hour":0.7,
-			"idle_weight_max":8.0,
-			"prefer_expiring":false,
-			"expiring_soon":"72h"
-		},
-		"session_sticky":{"enabled":false,"ttl":"1h","gc_interval":"2m"}
-	}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Upstash.URL != "https://foo.upstash.io" || c.Upstash.Token != "tok" {
-		t.Errorf("upstash=%+v", c.Upstash)
-	}
-	if c.Pool.MaxInFlight != 5 || c.Pool.BreakerThreshold != 4 {
-		t.Errorf("pool=%+v", c.Pool)
-	}
-	if c.BreakerCooldownDur.Minutes() != 10 || c.BreakerCooldownMaxD.Hours() != 2 {
-		t.Errorf("breaker durations=%v/%v", c.BreakerCooldownDur, c.BreakerCooldownMaxD)
-	}
-	if c.Pool.IdleWeightPerHour != 0.7 || c.Pool.IdleWeightMax != 8.0 {
-		t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax)
-	}
-	if c.Pool.PreferExpiring || c.ExpiringSoonDur != 72*time.Hour {
-		t.Errorf("expiring override: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur)
-	}
-	if c.SessionSticky.Enabled {
-		t.Error("session_sticky.enabled want false from file")
-	}
-	if c.SessionTTL.Hours() != 1 || c.SessionGCInterval.Minutes() != 2 {
-		t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval)
-	}
-}
-
-func TestSoftRateMaxParsedFromFile(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"5m","soft_rate_max":"45m"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.SoftRateDur.Minutes() != 5 {
-		t.Errorf("soft_rate=%v want 5m", c.SoftRateDur)
-	}
-	if c.SoftRateMaxDur.Minutes() != 45 {
-		t.Errorf("soft_rate_max=%v want 45m", c.SoftRateMaxDur)
-	}
-}
-
-func TestLegacyConfigKeepsPreferExpiringEnabled(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"pool":{"idle_weight_max":3}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !c.Pool.PreferExpiring {
-		t.Fatal("missing prefer_expiring must preserve default true")
-	}
-}
-
-func TestNegativeExpiringSoonClampsToDisabled(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"pool":{"expiring_soon":"-1h"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.ExpiringSoonDur != 0 || c.Pool.ExpiringSoon != "0" {
-		t.Fatalf("negative window=%v/%q want 0/0", c.ExpiringSoonDur, c.Pool.ExpiringSoon)
-	}
-}
-
-func TestSoftRateMaxEmptyFallsBackToDefault(t *testing.T) {
-	// 键缺席 → Default() 的 2h 保留（空串无法 ParseDuration）。
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"90s"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.SoftRateMaxDur.Hours() != 2 {
-		t.Errorf("soft_rate_max=%v want 2h fallback", c.SoftRateMaxDur)
-	}
-}
-
-func TestBadSoftRateMax(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate_max":"oops"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for bad soft_rate_max")
-	}
-}
-
-func TestBadBreakerCooldown(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"pool":{"breaker_cooldown":"oops"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for bad breaker_cooldown")
-	}
-}
-
-func TestUpstreamTimeoutDefaults(t *testing.T) {
-	// 默认：header 回落 timeout，idle 回落 300。
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if c.Upstream.TimeoutSeconds != 120 {
-		t.Errorf("timeout_seconds=%d want 120", c.Upstream.TimeoutSeconds)
-	}
-	if c.Upstream.HeaderTimeoutSeconds != 120 {
-		t.Errorf("header_timeout_seconds=%d want fallback 120", c.Upstream.HeaderTimeoutSeconds)
-	}
-	if c.Upstream.IdleTimeoutSeconds != 300 {
-		t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds)
-	}
-}
-
-func TestUpstreamHeaderFallsBackToTimeout(t *testing.T) {
-	// 只设 timeout_seconds：header 回落同值，idle 回落 300。
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":60}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Upstream.HeaderTimeoutSeconds != 60 {
-		t.Errorf("header_timeout_seconds=%d want fallback 60", c.Upstream.HeaderTimeoutSeconds)
-	}
-	if c.Upstream.IdleTimeoutSeconds != 300 {
-		t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds)
-	}
-}
-
-func TestUpstreamExplicitHeaderIdle(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":120,"header_timeout_seconds":30,"idle_timeout_seconds":600}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Upstream.HeaderTimeoutSeconds != 30 {
-		t.Errorf("header_timeout_seconds=%d want 30", c.Upstream.HeaderTimeoutSeconds)
-	}
-	if c.Upstream.IdleTimeoutSeconds != 600 {
-		t.Errorf("idle_timeout_seconds=%d want 600", c.Upstream.IdleTimeoutSeconds)
-	}
-}
-
-func TestUpstreamEnvOverride(t *testing.T) {
-	t.Setenv("WB2A_HEADER_TIMEOUT_SECONDS", "45")
-	t.Setenv("WB2A_IDLE_TIMEOUT_SECONDS", "900")
-	c, err := Load("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Upstream.HeaderTimeoutSeconds != 45 {
-		t.Errorf("header_timeout_seconds=%d want env 45", c.Upstream.HeaderTimeoutSeconds)
-	}
-	if c.Upstream.IdleTimeoutSeconds != 900 {
-		t.Errorf("idle_timeout_seconds=%d want env 900", c.Upstream.IdleTimeoutSeconds)
-	}
-}
-
-// TestRetiredTravelIntervalKeyIgnored 退役的 travel_interval_minutes 键按未知字段忽略，不报错。
-func TestRetiredTravelIntervalKeyIgnored(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"travel_interval_minutes":15,"checkin_hours":[9]}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatalf("retired key should not fail load: %v", err)
-	}
-	if len(c.Schedule.CheckinHours) != 1 || c.Schedule.CheckinHours[0] != 9 {
-		t.Errorf("checkin_hours=%v want [9]（同段其余键照常生效）", c.Schedule.CheckinHours)
-	}
-}
-
-// TestScheduleEnabledByDefault 四个任务的 enabled 开关默认均为 true：
-// 老 config 不写这些键，行为必须与从前完全一致。
-func TestScheduleEnabledByDefault(t *testing.T) {
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
-		t.Errorf("enabled defaults want true/true, got %v/%v",
-			c.Schedule.CheckinEnabled, c.Schedule.KeepaliveEnabled)
-	}
-	if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
-		t.Errorf("travel/activity enabled defaults want true/true, got %v/%v",
-			c.Schedule.TravelEnabled, c.Schedule.ActivityEnabled)
-	}
-	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
-		t.Errorf("travel_hours=%v want [9,21]", c.Schedule.TravelHours)
-	}
-	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
-		t.Errorf("activity_hours=%v want [10]", c.Schedule.ActivityHours)
-	}
-}
-
-// TestScheduleLegacyConfigKeepsRunning 老 config（只写签到/保活小时数组，无新键）加载后仍是启用态，
-// 新开关缺省 true、新 hours 回落默认——对老配置零影响。
-func TestScheduleLegacyConfigKeepsRunning(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"checkin_hours":[9,21],"keepalive_hours":[22]}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
-		t.Errorf("legacy config must stay enabled: %+v", c.Schedule)
-	}
-	if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
-		t.Errorf("new switches must default true on legacy config: %+v", c.Schedule)
-	}
-	if len(c.Schedule.CheckinHours) != 2 {
-		t.Errorf("checkin_hours=%v", c.Schedule.CheckinHours)
-	}
-	// 新 hours 缺省 → 回落默认（非空）。
-	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
-		t.Errorf("travel_hours=%v want default [9,21]", c.Schedule.TravelHours)
-	}
-	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
-		t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours)
-	}
-}
-
-// TestScheduleExplicitDisable 显式 checkin_enabled=false 即可真正关掉签到
-// （issue #27 边界：此前无论怎么配小时都关不掉）。
-func TestScheduleExplicitDisable(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"keepalive_enabled":false}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Schedule.CheckinEnabled || c.Schedule.KeepaliveEnabled {
-		t.Errorf("want both disabled: %+v", c.Schedule)
-	}
-	// 小时数组仍回落默认值（禁用与默认值互不干扰：重新启用无需补配小时）。
-	if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 {
-		t.Errorf("checkin_hours=%v want default [9 21] even when disabled", c.Schedule.CheckinHours)
-	}
-	if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 {
-		t.Errorf("keepalive_hours=%v want default [22] even when disabled", c.Schedule.KeepaliveHours)
-	}
-}
-
-// TestScheduleTravelActivityExplicitDisable 显式关闭旅行/活跃上报开关。
-func TestScheduleTravelActivityExplicitDisable(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"travel_enabled":false,"activity_enabled":false}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Schedule.TravelEnabled || c.Schedule.ActivityEnabled {
-		t.Errorf("want travel/activity disabled: %+v", c.Schedule)
-	}
-	// 签到/保活开关缺省 true（互不干扰）。
-	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
-		t.Errorf("checkin/keepalive should stay enabled: %+v", c.Schedule)
-	}
-	// hours 仍回落默认。
-	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
-		t.Errorf("travel_hours=%v want default [9,21] even when disabled", c.Schedule.TravelHours)
-	}
-	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
-		t.Errorf("activity_hours=%v want default [10] even when disabled", c.Schedule.ActivityHours)
-	}
-}
-
-// TestScheduleTravelActivityInvalidHoursRejected 旅行/活跃非法小时报错并指向正确开关。
-func TestScheduleTravelActivityInvalidHoursRejected(t *testing.T) {
-	cases := []struct{ body, wantSwitch string }{
-		{`{"schedule":{"travel_hours":[25]}}`, "travel_enabled"},
-		{`{"schedule":{"travel_hours":[-1]}}`, "travel_enabled"},
-		{`{"schedule":{"activity_hours":[24]}}`, "activity_enabled"},
-		{`{"schedule":{"activity_hours":[-1]}}`, "activity_enabled"},
-	}
-	for _, tc := range cases {
-		dir := t.TempDir()
-		fp := filepath.Join(dir, "c.json")
-		os.WriteFile(fp, []byte(tc.body), 0o600)
-		_, err := Load(fp)
-		if err == nil {
-			t.Fatalf("want error for %s", tc.body)
-		}
-		if !strings.Contains(err.Error(), tc.wantSwitch) {
-			t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err)
-		}
-	}
-}
-
-// TestScheduleTravelActivityExplicitHours 显式配置旅行/活跃小时。
-func TestScheduleTravelActivityExplicitHours(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"travel_hours":[9,21],"activity_hours":[11]}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
-		t.Errorf("travel_hours=%v want [9 21]", c.Schedule.TravelHours)
-	}
-	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 11 {
-		t.Errorf("activity_hours=%v want [11]", c.Schedule.ActivityHours)
-	}
-}
-
-// TestScheduleDisableKeepsExplicitHours 禁用不擦除用户配置的小时（便于原样恢复）。
-func TestScheduleDisableKeepsExplicitHours(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"checkin_hours":[10,14]}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Schedule.CheckinEnabled {
-		t.Error("checkin should be disabled")
-	}
-	if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 10 || c.Schedule.CheckinHours[1] != 14 {
-		t.Errorf("explicit hours must be preserved: %v", c.Schedule.CheckinHours)
-	}
-}
-
-// TestScheduleEmptyHoursFallsBackToDefault 空数组 / null / 缺省都视同「未配置」→ 回落默认。
-func TestScheduleEmptyHoursFallsBackToDefault(t *testing.T) {
-	cases := map[string]string{
-		"absent":   `{}`,
-		"empty":    `{"schedule":{}}`,
-		"null":     `{"schedule":{"checkin_hours":null,"keepalive_hours":null,"travel_hours":null,"activity_hours":null}}`,
-		"emptyarr": `{"schedule":{"checkin_hours":[],"keepalive_hours":[],"travel_hours":[],"activity_hours":[]}}`,
-	}
-	for name, body := range cases {
-		t.Run(name, func(t *testing.T) {
-			dir := t.TempDir()
-			fp := filepath.Join(dir, "c.json")
-			os.WriteFile(fp, []byte(body), 0o600)
-			c, err := Load(fp)
-			if err != nil {
-				t.Fatal(err)
-			}
-			if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 {
-				t.Errorf("checkin_hours=%v want default [9 21]", c.Schedule.CheckinHours)
-			}
-			if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 {
-				t.Errorf("keepalive_hours=%v want default [22]", c.Schedule.KeepaliveHours)
-			}
-			if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
-				t.Errorf("travel_hours=%v want default [9 21]", c.Schedule.TravelHours)
-			}
-			if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
-				t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours)
-			}
-			if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
-				t.Errorf("empty hours must not imply disabled: %+v", c.Schedule)
-			}
-			if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
-				t.Errorf("empty hours must not imply disabled: %+v", c.Schedule)
-			}
-		})
-	}
-}
-
-// TestScheduleInvalidHourRejected 非法小时快速失败：指向正确的禁用开关，避免用户
-// 猜测哨兵值（[-1] 之类）被静默当成"改到别的整点"。
-func TestScheduleInvalidHourRejected(t *testing.T) {
-	cases := []struct{ body, wantSwitch string }{
-		{`{"schedule":{"checkin_hours":[25]}}`, "checkin_enabled"},
-		{`{"schedule":{"checkin_hours":[-1]}}`, "checkin_enabled"},
-		{`{"schedule":{"keepalive_hours":[-1]}}`, "keepalive_enabled"},
-	}
-	for _, tc := range cases {
-		dir := t.TempDir()
-		fp := filepath.Join(dir, "c.json")
-		os.WriteFile(fp, []byte(tc.body), 0o600)
-		_, err := Load(fp)
-		if err == nil {
-			t.Fatalf("want error for %s", tc.body)
-		}
-		if !strings.Contains(err.Error(), tc.wantSwitch) {
-			t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err)
-		}
-	}
-}
-
-func TestBadSessionTTL(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"session_sticky":{"ttl":"oops"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for bad session_sticky.ttl")
-	}
-}
-
-func TestWriteDefault(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "sub", "config.json") // 顺带验证父目录自动创建
-	key, err := WriteDefault(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	// key 形如 sk-<24字符随机串>，两次生成不重复
-	if !strings.HasPrefix(key, "sk-") || len(key) < 20 {
-		t.Errorf("key=%q want sk-<random>", key)
-	}
-	if key2, _ := WriteDefault(filepath.Join(dir, "another.json")); key2 == key {
-		t.Errorf("two generated keys identical: %q", key)
-	}
-	// 落盘文件可被 Load 正常加载，推荐值齐备且 api_key 生效
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatalf("load generated config: %v", err)
-	}
-	if c.APIKey != key {
-		t.Errorf("api_key=%q want %q", c.APIKey, key)
-	}
-	if c.Listen != ":7863" || c.AuthDir != "./auths" || c.StateFile != "./data/state.json" {
-		t.Errorf("generated defaults off: %+v", c)
-	}
-	if len(c.Schedule.CheckinHours) == 0 || !c.Schedule.CheckinEnabled {
-		t.Errorf("generated schedule off: %+v", c.Schedule)
-	}
-	// 已存在的文件不覆盖：二次写入同一路径必须报错
-	if _, err := WriteDefault(fp); err == nil {
-		t.Error("WriteDefault must refuse to overwrite existing file")
-	}
-}
-
-func TestBalanceRefreshDefaults(t *testing.T) {
-	// 缺省：启用 + 30 分钟
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatal(err)
-	}
-	if !c.Schedule.BalanceRefreshEnabled || c.BalanceRefreshInterval != 5*time.Minute {
-		t.Errorf("default balance refresh: enabled=%v interval=%v", c.Schedule.BalanceRefreshEnabled, c.BalanceRefreshInterval)
-	}
-	// 显式配置 10 分钟
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":10}}`), 0o600)
-	c2, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c2.BalanceRefreshInterval != 10*time.Minute {
-		t.Errorf("interval=%v want 10m", c2.BalanceRefreshInterval)
-	}
-	// 显式关闭：interval 归零（不启动）
-	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_enabled":false}}`), 0o600)
-	c3, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c3.BalanceRefreshInterval != 0 {
-		t.Errorf("disabled interval=%v want 0", c3.BalanceRefreshInterval)
-	}
-	// 启用但 minutes<=0 → 回落默认 30
-	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":-5}}`), 0o600)
-	c4, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c4.BalanceRefreshInterval != 5*time.Minute {
-		t.Errorf("fallback interval=%v want 30m", c4.BalanceRefreshInterval)
-	}
-}
-
-// TestPromptDefaultPassthrough 默认 prompt.mode=passthrough（对齐上游：透传客户端
-// 原始 system 是更保守的缺省）；custom 由用户显式选择，此时 PromptText 为内置默认（非空）。
-func TestPromptDefaultPassthrough(t *testing.T) {
-	c, err := Load("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Prompt.Mode != "passthrough" {
-		t.Errorf("prompt.mode=%q want passthrough", c.Prompt.Mode)
-	}
-	// passthrough 不加载提示词文本（透传客户端 system）；切 custom 时 normalize 会加载。
-}
-
-// TestPromptExplicitPassthrough passthrough 模式不加载文本（透传客户端原始 system）。
-func TestPromptExplicitPassthrough(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"prompt":{"mode":"passthrough"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Prompt.Mode != "passthrough" {
-		t.Errorf("mode=%q want passthrough", c.Prompt.Mode)
-	}
-	if c.PromptText != "" {
-		t.Errorf("passthrough should not load PromptText, got len=%d", len(c.PromptText))
-	}
-}
-
-// TestPromptInvalidMode 非法 mode 启动报错。
-func TestPromptInvalidMode(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"prompt":{"mode":"bogus"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for invalid prompt.mode")
-	}
-}
-
-// TestPromptFileMissing 文件路径非空但��存在 → 启动报错（fail fast）。
-func TestPromptFileMissing(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"prompt":{"mode":"custom","file":"/nonexistent/p.md"}}`), 0o600)
-	if _, err := Load(fp); err == nil {
-		t.Fatal("want error for missing prompt file")
-	}
-}
-
-// TestPromptFileOverride 自定义 file 覆盖内置默认。
-func TestPromptFileOverride(t *testing.T) {
-	dir := t.TempDir()
-	pf := filepath.Join(dir, "my.md")
-	want := "我的自定义人格入口"
-	os.WriteFile(pf, []byte(want), 0o600)
-	cf := filepath.Join(dir, "c.json")
-	// 用 json.Marshal 拼路径：Windows 反斜杠必须转义，手工字符串拼接会产出非法 JSON。
-	cfgJSON, err := json.Marshal(map[string]any{"prompt": map[string]any{"mode": "custom", "file": pf}})
-	if err != nil {
-		t.Fatal(err)
-	}
-	os.WriteFile(cf, cfgJSON, 0o600)
-	c, err := Load(cf)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.PromptText != want {
-		t.Errorf("PromptText=%q want %q", c.PromptText, want)
-	}
-}
-
-// TestPromptEnvOverride env 覆盖 prompt.mode 与 prompt.file。
-func TestPromptEnvOverride(t *testing.T) {
-	t.Setenv("WB2A_PROMPT_MODE", "passthrough")
-	c, err := Load("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Prompt.Mode != "passthrough" {
-		t.Errorf("mode=%q want passthrough", c.Prompt.Mode)
-	}
-}
-
-// TestPromptLegacyConfigNoImpact 旧 config（无 prompt 段）零影响：mode 缺省 passthrough。
-func TestPromptLegacyConfigNoImpact(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Prompt.Mode != "passthrough" {
-		t.Errorf("legacy config should default to passthrough, got %q", c.Prompt.Mode)
-	}
-	if c.Listen != ":9999" {
-		t.Errorf("listen=%q", c.Listen)
-	}
-}
-
-// TestUpstreamUserAgentConfig 配置 upstream.user_agent 与 env WB2A_USER_AGENT 均生效，
-// 缺省空串保持现状（headers 层回落到 clientUA）。
-func TestUpstreamUserAgentConfig(t *testing.T) {
-	// JSON 配置
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"upstream":{"user_agent":"WorkBuddy/1.2.3"}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Upstream.UserAgent != "WorkBuddy/1.2.3" {
-		t.Errorf("user_agent=%q want WorkBuddy/1.2.3", c.Upstream.UserAgent)
-	}
-	// 缺省为空
-	if c2, err := Load(""); err != nil || c2.Upstream.UserAgent != "" {
-		t.Errorf("default user_agent=%q want empty (err=%v)", c2.Upstream.UserAgent, err)
-	}
-	// env 覆盖
-	t.Setenv("WB2A_USER_AGENT", "EnvAgent/9")
-	c3, err := Load("")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c3.Upstream.UserAgent != "EnvAgent/9" {
-		t.Errorf("env user_agent=%q want EnvAgent/9", c3.Upstream.UserAgent)
-	}
-}
-
-// TestLoadConfigPathIsDirectory config 路径是目录时给出可操作提示（Docker bind mount 陷阱）。
-// 复现：compose 挂载 ./config.json 但宿主机缺该文件 → Docker 创建同名目录 → 启动失败。
-// 旧行为只报 "read config: ... Incorrect function" 之类晦涩错误，无从排查。
-func TestLoadConfigPathIsDirectory(t *testing.T) {
-	dir := t.TempDir()
-	asDir := filepath.Join(dir, "config.json")
-	if err := os.Mkdir(asDir, 0o755); err != nil {
-		t.Fatal(err)
-	}
-	_, err := Load(asDir)
-	if err == nil {
-		t.Fatal("want error when config path is a directory")
-	}
-	msg := err.Error()
-	if !strings.Contains(msg, "是目录") {
-		t.Errorf("error should explain it is a directory: %v", err)
-	}
-	if !strings.Contains(msg, "config.example.json") {
-		t.Errorf("error should suggest the fix (cp config.example.json): %v", err)
-	}
-}
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestDefault(t *testing.T) {
+	c := Default()
+	if c.Listen != ":7863" {
+		t.Errorf("listen=%s", c.Listen)
+	}
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.SoftRateDur.Seconds() != 600 {
+		t.Errorf("soft=%v want 600s", c.SoftRateDur)
+	}
+}
+
+func TestPanelPackageDetailLimit(t *testing.T) {
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.Panel.PackageDetailLimit != 5 {
+		t.Fatalf("default package_detail_limit=%d want 5", c.Panel.PackageDetailLimit)
+	}
+
+	configured, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":8}}`))
+	if err != nil {
+		t.Fatalf("parse configured limit: %v", err)
+	}
+	if configured.Panel.PackageDetailLimit != 8 {
+		t.Fatalf("configured package_detail_limit=%d want 8", configured.Panel.PackageDetailLimit)
+	}
+
+	fallback, err := ParseConfig([]byte(`{"panel":{"package_detail_limit":0}}`))
+	if err != nil {
+		t.Fatalf("parse fallback limit: %v", err)
+	}
+	if fallback.Panel.PackageDetailLimit != 5 {
+		t.Fatalf("fallback package_detail_limit=%d want 5", fallback.Panel.PackageDetailLimit)
+	}
+}
+
+func TestLoggingDefaults(t *testing.T) {
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatal(err)
+	}
+	if !c.Logging.RequestArchiveEnabled || c.Logging.RequestRetentionDays != 7 || c.Logging.RequestArchiveMaxMB != 100 {
+		t.Fatalf("logging defaults = %+v", c.Logging)
+	}
+	// 来源记录（IP/UA）缺省开启：键缺席时必须保持 true，只有显式 false 才关闭。
+	if !c.Logging.RequestClientInfo {
+		t.Fatalf("request_client_info default = false, want true: %+v", c.Logging)
+	}
+	configured, err := ParseConfig([]byte(`{"logging":{"request_archive_enabled":false,"request_retention_days":30,"request_archive_max_mb":500}}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if configured.Logging.RequestArchiveEnabled || configured.Logging.RequestRetentionDays != 30 || configured.Logging.RequestArchiveMaxMB != 500 {
+		t.Fatalf("configured logging = %+v", configured.Logging)
+	}
+	off, err := ParseConfig([]byte(`{"logging":{"request_client_info":false}}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if off.Logging.RequestClientInfo {
+		t.Fatalf("explicit false ignored: %+v", off.Logging)
+	}
+	fallback, err := ParseConfig([]byte(`{"logging":{"request_retention_days":0,"request_archive_max_mb":0}}`))
+	if err != nil {
+		t.Fatal(err)
+	}
+	if fallback.Logging.RequestRetentionDays != 7 || fallback.Logging.RequestArchiveMaxMB != 100 {
+		t.Fatalf("logging fallback = %+v", fallback.Logging)
+	}
+}
+
+func TestLoadFile(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Listen != ":9999" || c.APIKey != "k" {
+		t.Errorf("c=%+v", c)
+	}
+}
+
+func TestEnvOverride(t *testing.T) {
+	t.Setenv("WB2A_LISTEN", ":7777")
+	t.Setenv("WB2A_API_KEY", "envkey")
+	c, err := Load("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Listen != ":7777" || c.APIKey != "envkey" {
+		t.Errorf("c=%+v", c)
+	}
+}
+
+func TestBadDuration(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"not-a-duration"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for bad duration")
+	}
+}
+
+func TestHardCreditKeyIgnored(t *testing.T) {
+	// 退役的 hard_credit 键作为 JSON 未知字段被自然忽略，不报错。
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"cooldown":{"hard_credit":"not-a-duration","soft_rate":"30s"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatalf("hard_credit must be ignored (not validated): %v", err)
+	}
+	if c.SoftRateDur.Seconds() != 30 {
+		t.Errorf("soft_rate=%v want 30s", c.SoftRateDur)
+	}
+}
+
+func TestNewPoolConfigDefaults(t *testing.T) {
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.Pool.MaxInFlight != 3 {
+		t.Errorf("max_in_flight=%d want 3", c.Pool.MaxInFlight)
+	}
+	if c.Pool.BreakerThreshold != 3 {
+		t.Errorf("breaker_threshold=%d want 3", c.Pool.BreakerThreshold)
+	}
+	if c.BreakerCooldownDur.Minutes() != 30 {
+		t.Errorf("breaker_cooldown=%v want 30m", c.BreakerCooldownDur)
+	}
+	if c.BreakerCooldownMaxD.Hours() != 6 {
+		t.Errorf("breaker_cooldown_max=%v want 6h", c.BreakerCooldownMaxD)
+	}
+	if c.Pool.IdleWeightPerHour != 0.5 || c.Pool.IdleWeightMax != 5.0 {
+		t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax)
+	}
+	if !c.Pool.PreferExpiring || c.ExpiringSoonDur != 7*24*time.Hour {
+		t.Errorf("expiring defaults: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur)
+	}
+	if c.SoftRateMaxDur.Hours() != 2 {
+		t.Errorf("soft_rate_max=%v want 2h", c.SoftRateMaxDur)
+	}
+	if !c.SessionSticky.Enabled {
+		t.Error("session_sticky.enabled want true")
+	}
+	if c.SessionTTL.Minutes() != 30 || c.SessionGCInterval.Minutes() != 5 {
+		t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval)
+	}
+	if c.Upstash.URL != "" || c.Upstash.Token != "" {
+		t.Errorf("upstash default should be empty: %+v", c.Upstash)
+	}
+}
+
+func TestPoolConfigParsedFromFile(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{
+		"upstash":{"url":"https://foo.upstash.io","token":"tok"},
+		"pool":{
+			"max_in_flight":5,
+			"breaker_threshold":4,
+			"breaker_cooldown":"10m",
+			"breaker_cooldown_max":"2h",
+			"idle_weight_per_hour":0.7,
+			"idle_weight_max":8.0,
+			"prefer_expiring":false,
+			"expiring_soon":"72h"
+		},
+		"session_sticky":{"enabled":false,"ttl":"1h","gc_interval":"2m"}
+	}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Upstash.URL != "https://foo.upstash.io" || c.Upstash.Token != "tok" {
+		t.Errorf("upstash=%+v", c.Upstash)
+	}
+	if c.Pool.MaxInFlight != 5 || c.Pool.BreakerThreshold != 4 {
+		t.Errorf("pool=%+v", c.Pool)
+	}
+	if c.BreakerCooldownDur.Minutes() != 10 || c.BreakerCooldownMaxD.Hours() != 2 {
+		t.Errorf("breaker durations=%v/%v", c.BreakerCooldownDur, c.BreakerCooldownMaxD)
+	}
+	if c.Pool.IdleWeightPerHour != 0.7 || c.Pool.IdleWeightMax != 8.0 {
+		t.Errorf("idle weights=%v/%v", c.Pool.IdleWeightPerHour, c.Pool.IdleWeightMax)
+	}
+	if c.Pool.PreferExpiring || c.ExpiringSoonDur != 72*time.Hour {
+		t.Errorf("expiring override: enabled=%v window=%v", c.Pool.PreferExpiring, c.ExpiringSoonDur)
+	}
+	if c.SessionSticky.Enabled {
+		t.Error("session_sticky.enabled want false from file")
+	}
+	if c.SessionTTL.Hours() != 1 || c.SessionGCInterval.Minutes() != 2 {
+		t.Errorf("session durations=%v/%v", c.SessionTTL, c.SessionGCInterval)
+	}
+}
+
+func TestSoftRateMaxParsedFromFile(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"5m","soft_rate_max":"45m"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.SoftRateDur.Minutes() != 5 {
+		t.Errorf("soft_rate=%v want 5m", c.SoftRateDur)
+	}
+	if c.SoftRateMaxDur.Minutes() != 45 {
+		t.Errorf("soft_rate_max=%v want 45m", c.SoftRateMaxDur)
+	}
+}
+
+func TestLegacyConfigKeepsPreferExpiringEnabled(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"pool":{"idle_weight_max":3}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !c.Pool.PreferExpiring {
+		t.Fatal("missing prefer_expiring must preserve default true")
+	}
+}
+
+func TestNegativeExpiringSoonClampsToDisabled(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"pool":{"expiring_soon":"-1h"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.ExpiringSoonDur != 0 || c.Pool.ExpiringSoon != "0" {
+		t.Fatalf("negative window=%v/%q want 0/0", c.ExpiringSoonDur, c.Pool.ExpiringSoon)
+	}
+}
+
+func TestSoftRateMaxEmptyFallsBackToDefault(t *testing.T) {
+	// 键缺席 → Default() 的 2h 保留（空串无法 ParseDuration）。
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate":"90s"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.SoftRateMaxDur.Hours() != 2 {
+		t.Errorf("soft_rate_max=%v want 2h fallback", c.SoftRateMaxDur)
+	}
+}
+
+func TestBadSoftRateMax(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"cooldown":{"soft_rate_max":"oops"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for bad soft_rate_max")
+	}
+}
+
+func TestBadBreakerCooldown(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"pool":{"breaker_cooldown":"oops"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for bad breaker_cooldown")
+	}
+}
+
+func TestUpstreamTimeoutDefaults(t *testing.T) {
+	// 默认：header 回落 timeout，idle 回落 300。
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.Upstream.TimeoutSeconds != 120 {
+		t.Errorf("timeout_seconds=%d want 120", c.Upstream.TimeoutSeconds)
+	}
+	if c.Upstream.HeaderTimeoutSeconds != 120 {
+		t.Errorf("header_timeout_seconds=%d want fallback 120", c.Upstream.HeaderTimeoutSeconds)
+	}
+	if c.Upstream.IdleTimeoutSeconds != 300 {
+		t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds)
+	}
+}
+
+func TestUpstreamHeaderFallsBackToTimeout(t *testing.T) {
+	// 只设 timeout_seconds：header 回落同值，idle 回落 300。
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":60}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Upstream.HeaderTimeoutSeconds != 60 {
+		t.Errorf("header_timeout_seconds=%d want fallback 60", c.Upstream.HeaderTimeoutSeconds)
+	}
+	if c.Upstream.IdleTimeoutSeconds != 300 {
+		t.Errorf("idle_timeout_seconds=%d want fallback 300", c.Upstream.IdleTimeoutSeconds)
+	}
+}
+
+func TestUpstreamExplicitHeaderIdle(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"upstream":{"timeout_seconds":120,"header_timeout_seconds":30,"idle_timeout_seconds":600}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Upstream.HeaderTimeoutSeconds != 30 {
+		t.Errorf("header_timeout_seconds=%d want 30", c.Upstream.HeaderTimeoutSeconds)
+	}
+	if c.Upstream.IdleTimeoutSeconds != 600 {
+		t.Errorf("idle_timeout_seconds=%d want 600", c.Upstream.IdleTimeoutSeconds)
+	}
+}
+
+func TestUpstreamEnvOverride(t *testing.T) {
+	t.Setenv("WB2A_HEADER_TIMEOUT_SECONDS", "45")
+	t.Setenv("WB2A_IDLE_TIMEOUT_SECONDS", "900")
+	c, err := Load("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Upstream.HeaderTimeoutSeconds != 45 {
+		t.Errorf("header_timeout_seconds=%d want env 45", c.Upstream.HeaderTimeoutSeconds)
+	}
+	if c.Upstream.IdleTimeoutSeconds != 900 {
+		t.Errorf("idle_timeout_seconds=%d want env 900", c.Upstream.IdleTimeoutSeconds)
+	}
+}
+
+// TestRetiredTravelIntervalKeyIgnored 退役的 travel_interval_minutes 键按未知字段忽略，不报错。
+func TestRetiredTravelIntervalKeyIgnored(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"travel_interval_minutes":15,"checkin_hours":[9]}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatalf("retired key should not fail load: %v", err)
+	}
+	if len(c.Schedule.CheckinHours) != 1 || c.Schedule.CheckinHours[0] != 9 {
+		t.Errorf("checkin_hours=%v want [9]（同段其余键照常生效）", c.Schedule.CheckinHours)
+	}
+}
+
+// TestScheduleEnabledByDefault 四个任务的 enabled 开关默认均为 true：
+// 老 config 不写这些键，行为必须与从前完全一致。
+func TestScheduleEnabledByDefault(t *testing.T) {
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
+		t.Errorf("enabled defaults want true/true, got %v/%v",
+			c.Schedule.CheckinEnabled, c.Schedule.KeepaliveEnabled)
+	}
+	if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
+		t.Errorf("travel/activity enabled defaults want true/true, got %v/%v",
+			c.Schedule.TravelEnabled, c.Schedule.ActivityEnabled)
+	}
+	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
+		t.Errorf("travel_hours=%v want [9,21]", c.Schedule.TravelHours)
+	}
+	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
+		t.Errorf("activity_hours=%v want [10]", c.Schedule.ActivityHours)
+	}
+}
+
+// TestScheduleLegacyConfigKeepsRunning 老 config（只写签到/保活小时数组，无新键）加载后仍是启用态，
+// 新开关缺省 true、新 hours 回落默认——对老配置零影响。
+func TestScheduleLegacyConfigKeepsRunning(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"checkin_hours":[9,21],"keepalive_hours":[22]}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
+		t.Errorf("legacy config must stay enabled: %+v", c.Schedule)
+	}
+	if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
+		t.Errorf("new switches must default true on legacy config: %+v", c.Schedule)
+	}
+	if len(c.Schedule.CheckinHours) != 2 {
+		t.Errorf("checkin_hours=%v", c.Schedule.CheckinHours)
+	}
+	// 新 hours 缺省 → 回落默认（非空）。
+	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
+		t.Errorf("travel_hours=%v want default [9,21]", c.Schedule.TravelHours)
+	}
+	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
+		t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours)
+	}
+}
+
+// TestScheduleExplicitDisable 显式 checkin_enabled=false 即可真正关掉签到
+// （issue #27 边界：此前无论怎么配小时都关不掉）。
+func TestScheduleExplicitDisable(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"keepalive_enabled":false}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Schedule.CheckinEnabled || c.Schedule.KeepaliveEnabled {
+		t.Errorf("want both disabled: %+v", c.Schedule)
+	}
+	// 小时数组仍回落默认值（禁用与默认值互不干扰：重新启用无需补配小时）。
+	if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 {
+		t.Errorf("checkin_hours=%v want default [9 21] even when disabled", c.Schedule.CheckinHours)
+	}
+	if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 {
+		t.Errorf("keepalive_hours=%v want default [22] even when disabled", c.Schedule.KeepaliveHours)
+	}
+}
+
+// TestScheduleTravelActivityExplicitDisable 显式关闭旅行/活跃上报开关。
+func TestScheduleTravelActivityExplicitDisable(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"travel_enabled":false,"activity_enabled":false}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Schedule.TravelEnabled || c.Schedule.ActivityEnabled {
+		t.Errorf("want travel/activity disabled: %+v", c.Schedule)
+	}
+	// 签到/保活开关缺省 true（互不干扰）。
+	if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
+		t.Errorf("checkin/keepalive should stay enabled: %+v", c.Schedule)
+	}
+	// hours 仍回落默认。
+	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
+		t.Errorf("travel_hours=%v want default [9,21] even when disabled", c.Schedule.TravelHours)
+	}
+	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
+		t.Errorf("activity_hours=%v want default [10] even when disabled", c.Schedule.ActivityHours)
+	}
+}
+
+// TestScheduleTravelActivityInvalidHoursRejected 旅行/活跃非法小时报错并指向正确开关。
+func TestScheduleTravelActivityInvalidHoursRejected(t *testing.T) {
+	cases := []struct{ body, wantSwitch string }{
+		{`{"schedule":{"travel_hours":[25]}}`, "travel_enabled"},
+		{`{"schedule":{"travel_hours":[-1]}}`, "travel_enabled"},
+		{`{"schedule":{"activity_hours":[24]}}`, "activity_enabled"},
+		{`{"schedule":{"activity_hours":[-1]}}`, "activity_enabled"},
+	}
+	for _, tc := range cases {
+		dir := t.TempDir()
+		fp := filepath.Join(dir, "c.json")
+		os.WriteFile(fp, []byte(tc.body), 0o600)
+		_, err := Load(fp)
+		if err == nil {
+			t.Fatalf("want error for %s", tc.body)
+		}
+		if !strings.Contains(err.Error(), tc.wantSwitch) {
+			t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err)
+		}
+	}
+}
+
+// TestScheduleTravelActivityExplicitHours 显式配置旅行/活跃小时。
+func TestScheduleTravelActivityExplicitHours(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"travel_hours":[9,21],"activity_hours":[11]}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
+		t.Errorf("travel_hours=%v want [9 21]", c.Schedule.TravelHours)
+	}
+	if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 11 {
+		t.Errorf("activity_hours=%v want [11]", c.Schedule.ActivityHours)
+	}
+}
+
+// TestScheduleDisableKeepsExplicitHours 禁用不擦除用户配置的小时（便于原样恢复）。
+func TestScheduleDisableKeepsExplicitHours(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"checkin_enabled":false,"checkin_hours":[10,14]}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Schedule.CheckinEnabled {
+		t.Error("checkin should be disabled")
+	}
+	if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 10 || c.Schedule.CheckinHours[1] != 14 {
+		t.Errorf("explicit hours must be preserved: %v", c.Schedule.CheckinHours)
+	}
+}
+
+// TestScheduleEmptyHoursFallsBackToDefault 空数组 / null / 缺省都视同「未配置」→ 回落默认。
+func TestScheduleEmptyHoursFallsBackToDefault(t *testing.T) {
+	cases := map[string]string{
+		"absent":   `{}`,
+		"empty":    `{"schedule":{}}`,
+		"null":     `{"schedule":{"checkin_hours":null,"keepalive_hours":null,"travel_hours":null,"activity_hours":null}}`,
+		"emptyarr": `{"schedule":{"checkin_hours":[],"keepalive_hours":[],"travel_hours":[],"activity_hours":[]}}`,
+	}
+	for name, body := range cases {
+		t.Run(name, func(t *testing.T) {
+			dir := t.TempDir()
+			fp := filepath.Join(dir, "c.json")
+			os.WriteFile(fp, []byte(body), 0o600)
+			c, err := Load(fp)
+			if err != nil {
+				t.Fatal(err)
+			}
+			if len(c.Schedule.CheckinHours) != 2 || c.Schedule.CheckinHours[0] != 9 || c.Schedule.CheckinHours[1] != 21 {
+				t.Errorf("checkin_hours=%v want default [9 21]", c.Schedule.CheckinHours)
+			}
+			if len(c.Schedule.KeepaliveHours) != 1 || c.Schedule.KeepaliveHours[0] != 22 {
+				t.Errorf("keepalive_hours=%v want default [22]", c.Schedule.KeepaliveHours)
+			}
+			if len(c.Schedule.TravelHours) != 2 || c.Schedule.TravelHours[0] != 9 || c.Schedule.TravelHours[1] != 21 {
+				t.Errorf("travel_hours=%v want default [9 21]", c.Schedule.TravelHours)
+			}
+			if len(c.Schedule.ActivityHours) != 1 || c.Schedule.ActivityHours[0] != 10 {
+				t.Errorf("activity_hours=%v want default [10]", c.Schedule.ActivityHours)
+			}
+			if !c.Schedule.CheckinEnabled || !c.Schedule.KeepaliveEnabled {
+				t.Errorf("empty hours must not imply disabled: %+v", c.Schedule)
+			}
+			if !c.Schedule.TravelEnabled || !c.Schedule.ActivityEnabled {
+				t.Errorf("empty hours must not imply disabled: %+v", c.Schedule)
+			}
+		})
+	}
+}
+
+// TestScheduleInvalidHourRejected 非法小时快速失败：指向正确的禁用开关，避免用户
+// 猜测哨兵值（[-1] 之类）被静默当成"改到别的整点"。
+func TestScheduleInvalidHourRejected(t *testing.T) {
+	cases := []struct{ body, wantSwitch string }{
+		{`{"schedule":{"checkin_hours":[25]}}`, "checkin_enabled"},
+		{`{"schedule":{"checkin_hours":[-1]}}`, "checkin_enabled"},
+		{`{"schedule":{"keepalive_hours":[-1]}}`, "keepalive_enabled"},
+	}
+	for _, tc := range cases {
+		dir := t.TempDir()
+		fp := filepath.Join(dir, "c.json")
+		os.WriteFile(fp, []byte(tc.body), 0o600)
+		_, err := Load(fp)
+		if err == nil {
+			t.Fatalf("want error for %s", tc.body)
+		}
+		if !strings.Contains(err.Error(), tc.wantSwitch) {
+			t.Errorf("error for %s should point at schedule.%s: %v", tc.body, tc.wantSwitch, err)
+		}
+	}
+}
+
+func TestBadSessionTTL(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"session_sticky":{"ttl":"oops"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for bad session_sticky.ttl")
+	}
+}
+
+func TestWriteDefault(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "sub", "config.json") // 顺带验证父目录自动创建
+	key, err := WriteDefault(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// key 形如 sk-<24字符随机串>，两次生成不重复
+	if !strings.HasPrefix(key, "sk-") || len(key) < 20 {
+		t.Errorf("key=%q want sk-<random>", key)
+	}
+	if key2, _ := WriteDefault(filepath.Join(dir, "another.json")); key2 == key {
+		t.Errorf("two generated keys identical: %q", key)
+	}
+	// 落盘文件可被 Load 正常加载，推荐值齐备且 api_key 生效
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatalf("load generated config: %v", err)
+	}
+	if c.APIKey != key {
+		t.Errorf("api_key=%q want %q", c.APIKey, key)
+	}
+	if c.Listen != ":7863" || c.AuthDir != "./auths" || c.StateFile != "./data/state.json" {
+		t.Errorf("generated defaults off: %+v", c)
+	}
+	if len(c.Schedule.CheckinHours) == 0 || !c.Schedule.CheckinEnabled {
+		t.Errorf("generated schedule off: %+v", c.Schedule)
+	}
+	// 已存在的文件不覆盖：二次写入同一路径必须报错
+	if _, err := WriteDefault(fp); err == nil {
+		t.Error("WriteDefault must refuse to overwrite existing file")
+	}
+}
+
+func TestBalanceRefreshDefaults(t *testing.T) {
+	// 缺省：启用 + 30 分钟
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatal(err)
+	}
+	if !c.Schedule.BalanceRefreshEnabled || c.BalanceRefreshInterval != 5*time.Minute {
+		t.Errorf("default balance refresh: enabled=%v interval=%v", c.Schedule.BalanceRefreshEnabled, c.BalanceRefreshInterval)
+	}
+	// 显式配置 10 分钟
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":10}}`), 0o600)
+	c2, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c2.BalanceRefreshInterval != 10*time.Minute {
+		t.Errorf("interval=%v want 10m", c2.BalanceRefreshInterval)
+	}
+	// 显式关闭：interval 归零（不启动）
+	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_enabled":false}}`), 0o600)
+	c3, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c3.BalanceRefreshInterval != 0 {
+		t.Errorf("disabled interval=%v want 0", c3.BalanceRefreshInterval)
+	}
+	// 启用但 minutes<=0 → 回落默认 30
+	os.WriteFile(fp, []byte(`{"schedule":{"balance_refresh_minutes":-5}}`), 0o600)
+	c4, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c4.BalanceRefreshInterval != 5*time.Minute {
+		t.Errorf("fallback interval=%v want 30m", c4.BalanceRefreshInterval)
+	}
+}
+
+// TestPromptDefaultPassthrough 默认 prompt.mode=passthrough（对齐上游：透传客户端
+// 原始 system 是更保守的缺省）；custom 由用户显式选择，此时 PromptText 为内置默认（非空）。
+func TestPromptDefaultPassthrough(t *testing.T) {
+	c, err := Load("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Prompt.Mode != "passthrough" {
+		t.Errorf("prompt.mode=%q want passthrough", c.Prompt.Mode)
+	}
+	// passthrough 不加载提示词文本（透传客户端 system）；切 custom 时 normalize 会加载。
+}
+
+// TestPromptExplicitPassthrough passthrough 模式不加载文本（透传客户端原始 system）。
+func TestPromptExplicitPassthrough(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"prompt":{"mode":"passthrough"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Prompt.Mode != "passthrough" {
+		t.Errorf("mode=%q want passthrough", c.Prompt.Mode)
+	}
+	if c.PromptText != "" {
+		t.Errorf("passthrough should not load PromptText, got len=%d", len(c.PromptText))
+	}
+}
+
+// TestPromptInvalidMode 非法 mode 启动报错。
+func TestPromptInvalidMode(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"prompt":{"mode":"bogus"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for invalid prompt.mode")
+	}
+}
+
+// TestPromptFileMissing 文件路径非空但不存在 → 启动报错（fail fast）。
+func TestPromptFileMissing(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"prompt":{"mode":"custom","file":"/nonexistent/p.md"}}`), 0o600)
+	if _, err := Load(fp); err == nil {
+		t.Fatal("want error for missing prompt file")
+	}
+}
+
+// TestPromptFileOverride 自定义 file 覆盖内置默认。
+func TestPromptFileOverride(t *testing.T) {
+	dir := t.TempDir()
+	pf := filepath.Join(dir, "my.md")
+	want := "我的自定义人格入口"
+	os.WriteFile(pf, []byte(want), 0o600)
+	cf := filepath.Join(dir, "c.json")
+	// 用 json.Marshal ���路径：Windows 反斜杠必须转义，手工字符串拼接会产出非法 JSON。
+	cfgJSON, err := json.Marshal(map[string]any{"prompt": map[string]any{"mode": "custom", "file": pf}})
+	if err != nil {
+		t.Fatal(err)
+	}
+	os.WriteFile(cf, cfgJSON, 0o600)
+	c, err := Load(cf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.PromptText != want {
+		t.Errorf("PromptText=%q want %q", c.PromptText, want)
+	}
+}
+
+// TestPromptEnvOverride env 覆盖 prompt.mode 与 prompt.file。
+func TestPromptEnvOverride(t *testing.T) {
+	t.Setenv("WB2A_PROMPT_MODE", "passthrough")
+	c, err := Load("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Prompt.Mode != "passthrough" {
+		t.Errorf("mode=%q want passthrough", c.Prompt.Mode)
+	}
+}
+
+// TestPromptLegacyConfigNoImpact 旧 config（无 prompt 段）零影响：mode 缺省 passthrough。
+func TestPromptLegacyConfigNoImpact(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"listen":":9999","api_key":"k"}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Prompt.Mode != "passthrough" {
+		t.Errorf("legacy config should default to passthrough, got %q", c.Prompt.Mode)
+	}
+	if c.Listen != ":9999" {
+		t.Errorf("listen=%q", c.Listen)
+	}
+}
+
+// TestUpstreamUserAgentConfig 配置 upstream.user_agent 与 env WB2A_USER_AGENT 均生效，
+// 缺省空串保持现状（headers 层回落到 clientUA）。
+func TestUpstreamUserAgentConfig(t *testing.T) {
+	// JSON 配置
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"upstream":{"user_agent":"WorkBuddy/1.2.3"}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Upstream.UserAgent != "WorkBuddy/1.2.3" {
+		t.Errorf("user_agent=%q want WorkBuddy/1.2.3", c.Upstream.UserAgent)
+	}
+	// 缺省为空
+	if c2, err := Load(""); err != nil || c2.Upstream.UserAgent != "" {
+		t.Errorf("default user_agent=%q want empty (err=%v)", c2.Upstream.UserAgent, err)
+	}
+	// env 覆盖
+	t.Setenv("WB2A_USER_AGENT", "EnvAgent/9")
+	c3, err := Load("")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c3.Upstream.UserAgent != "EnvAgent/9" {
+		t.Errorf("env user_agent=%q want EnvAgent/9", c3.Upstream.UserAgent)
+	}
+}
+
+// TestLoadConfigPathIsDirectory config 路径是目录时给出可操作提示（Docker bind mount 陷阱）。
+// 复现：compose 挂载 ./config.json 但宿主机缺该文件 → Docker 创建同名目录 → 启动失败。
+// 旧行为只报 "read config: ... Incorrect function" 之类晦涩错误，无从排查。
+func TestLoadConfigPathIsDirectory(t *testing.T) {
+	dir := t.TempDir()
+	asDir := filepath.Join(dir, "config.json")
+	if err := os.Mkdir(asDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	_, err := Load(asDir)
+	if err == nil {
+		t.Fatal("want error when config path is a directory")
+	}
+	msg := err.Error()
+	if !strings.Contains(msg, "是目录") {
+		t.Errorf("error should explain it is a directory: %v", err)
+	}
+	if !strings.Contains(msg, "config.example.json") {
+		t.Errorf("error should suggest the fix (cp config.example.json): %v", err)
+	}
+}
+
+// TestServerReadTimeout 入站读取上限（issue #100）：空值回落默认 300s；
+// "0" = 显式不限制（0 是合法值不回落）；负值 fail fast（静默钳 0 会把保护悄悄关掉）。
+func TestServerReadTimeout(t *testing.T) {
+	c := Default()
+	if c.Server.ReadTimeout != "300s" {
+		t.Errorf("default read_timeout=%q want 300s", c.Server.ReadTimeout)
+	}
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.ServerReadTimeoutDur != 300*time.Second {
+		t.Errorf("default dur=%v want 300s", c.ServerReadTimeoutDur)
+	}
+
+	c = Default()
+	c.Server.ReadTimeout = "" // 显式清空 = 未配置 → 回落默认
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize empty: %v", err)
+	}
+	if c.ServerReadTimeoutDur != 300*time.Second {
+		t.Errorf("empty dur=%v want 300s", c.ServerReadTimeoutDur)
+	}
+
+	c = Default()
+	c.Server.ReadTimeout = "0" // 显式 0 = 不限制（http.Server ReadTimeout 0 即无超时）
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize zero: %v", err)
+	}
+	if c.ServerReadTimeoutDur != 0 {
+		t.Errorf("zero dur=%v want 0", c.ServerReadTimeoutDur)
+	}
+
+	c = Default()
+	c.Server.ReadTimeout = "-5s"
+	if err := c.normalize(); err == nil {
+		t.Error("negative read_timeout should fail fast")
+	}
+
+	c = Default()
+	c.Server.ReadTimeout = "bogus"
+	if err := c.normalize(); err == nil {
+		t.Error("unparsable read_timeout should fail fast")
+	}
+}

cmd/server/credit_floor_config_test.go

@@ -1,48 +1,48 @@
-// credit_floor_config_test.go pool.credit_floor 配置测试：
-// 默认 0（关闭，零回归）/ 文件覆盖 / 负值钳 0 / 大值合法。
-package main
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// TestCreditFloorDefault 键缺席 → 默认 0（保底关闭，行为与引入前一致）。
-func TestCreditFloorDefault(t *testing.T) {
-	c := Default()
-	if err := c.normalize(); err != nil {
-		t.Fatalf("normalize: %v", err)
-	}
-	if c.Pool.CreditFloor != 0 {
-		t.Errorf("credit_floor=%d want 0 (default off)", c.Pool.CreditFloor)
-	}
-}
-
-// TestCreditFloorParsedFromFile 显式配置覆盖默认。
-func TestCreditFloorParsedFromFile(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"pool":{"credit_floor":100}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Pool.CreditFloor != 100 {
-		t.Errorf("credit_floor=%d want 100", c.Pool.CreditFloor)
-	}
-}
-
-// TestCreditFloorNegativeClamped 负值钳 0（非法即关闭，不报错：老配置误写不炸启动）。
-func TestCreditFloorNegativeClamped(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "c.json")
-	os.WriteFile(fp, []byte(`{"pool":{"credit_floor":-5}}`), 0o600)
-	c, err := Load(fp)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if c.Pool.CreditFloor != 0 {
-		t.Errorf("credit_floor=%d want 0 (negative clamped)", c.Pool.CreditFloor)
-	}
-}
+// credit_floor_config_test.go pool.credit_floor 配置测试：
+// 默认 0（关闭，零回归）/ 文件覆盖 / 负值钳 0 / 大值合法。
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestCreditFloorDefault 键缺席 → 默认 0（保底关闭，行为与引入前一致）。
+func TestCreditFloorDefault(t *testing.T) {
+	c := Default()
+	if err := c.normalize(); err != nil {
+		t.Fatalf("normalize: %v", err)
+	}
+	if c.Pool.CreditFloor != 0 {
+		t.Errorf("credit_floor=%d want 0 (default off)", c.Pool.CreditFloor)
+	}
+}
+
+// TestCreditFloorParsedFromFile 显式配置覆盖默认。
+func TestCreditFloorParsedFromFile(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"pool":{"credit_floor":100}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Pool.CreditFloor != 100 {
+		t.Errorf("credit_floor=%d want 100", c.Pool.CreditFloor)
+	}
+}
+
+// TestCreditFloorNegativeClamped 负值钳 0（非法即关闭，不报错：老配置误写不炸启动）。
+func TestCreditFloorNegativeClamped(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "c.json")
+	os.WriteFile(fp, []byte(`{"pool":{"credit_floor":-5}}`), 0o600)
+	c, err := Load(fp)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if c.Pool.CreditFloor != 0 {
+		t.Errorf("credit_floor=%d want 0 (negative clamped)", c.Pool.CreditFloor)
+	}
+}

cmd/server/main.go

@@ -1,550 +1,563 @@
-// main.go workbuddy2api 入口：加载配置、构建 pool、起调度器与 HTTP 服务。
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"errors"
-	"flag"
-	"fmt"
-	"io"
-	"io/fs"
-	"log"
-	"net/http"
-	"os"
-	"os/signal"
-	"path/filepath"
-	"syscall"
-	"time"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/livecfg"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/panel"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/pool"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/redisstore"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/reqlog"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/scheduler"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/server"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/session"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/usage"
-)
-
-// appVersion 网关版本（fork 版：面板 + 任务体系），透出到 /panel/api/overview。
-const appVersion = "1.11.11-panel"
-
-// usagePathFor 由 state 文件路径推出用量文件路径：同目录、文件名 usage.json。
-// 这样 config 里改 state_file 时用量数据跟着走，不需要额外配置项。
-func usagePathFor(stateFile string) string { return stateSibling(stateFile, "usage.json") }
-
-// stateSibling 返回与 state 文件同目录的指定文件名路径（相对路径场景回落当前目录）。
-// usage.json（用量记录）与 output_probes.json（模型上限探测）共用本规则。
-func stateSibling(stateFile, name string) string {
-	dir := filepath.Dir(stateFile)
-	if dir == "" || dir == "." {
-		return name
-	}
-	return filepath.Join(dir, name)
-}
-
-func main() {
-	cfgPath := flag.String("config", "config.json", "配置文件路径（默认当前目录 config.json；不存在时自动生成推荐配置）")
-	flag.Parse()
-
-	cfg, err := Load(*cfgPath)
-	if err != nil {
-		// errors.Is 才能看穿 Load 里 fmt.Errorf("%w") 的包装；os.IsNotExist 不行。
-		if errors.Is(err, fs.ErrNotExist) {
-			// 首次运行：目录下没有配置 → 自动落一份推荐配置（含随机 api_key）再加载。
-			// 双击 exe / 裸跑 docker 即开，无需先手工复制样例。
-			if key, werr := WriteDefault(*cfgPath); werr == nil {
-				log.Printf("config %s 不存在，已生成推荐配置（api_key=%s，记录在该文件里，可自行修改）", *cfgPath, key)
-				cfg, err = Load(*cfgPath)
-			}
-			if err != nil {
-				// 生成失败（目录只读等）：退回纯默认 + env（旧行为兜底），不阻塞启动。
-				log.Printf("config %s not found (auto-generate failed), using defaults+env: %v", *cfgPath, err)
-				cfg, err = Load("")
-			}
-		}
-		if err != nil {
-			log.Fatalf("load config: %v", err)
-		}
-	}
-
-	auths, err := auth.LoadDir(cfg.AuthDir)
-	if err != nil {
-		log.Fatalf("load auths: %v", err)
-	}
-	log.Printf("loaded %d account(s) from %s", len(auths), cfg.AuthDir)
-
-	// redisstore：未配置/连接失败 → Noop（纯内存模式，一切功能照常）。
-	store := redisstore.New(cfg.Upstash.URL, cfg.Upstash.Token)
-
-	p := pool.New(cfg.StateFile)
-	// 停机序：先 pool.Close()（最后一次 Flush → SaveState 已提交到 store），
-	// 再 store.Close() 排空在途异步写（最后一笔 Redis 镜像必须写完才关连接）。
-	defer func() {
-		p.Close()
-		_ = store.Close()
-	}()
-	p.SetStore(store)
-	p.RestoreFromSnapshot() // 择新恢复：Redis 快照比本地新才采用，否则本地优先
-	p.SyncToDir(auths)      // 与 auths 目录对齐：新账号加入、已删除文件账号剔除（状态保留）
-
-	// 熔断器 + 在途上限（含 global 分档）+ 连败降权 + 闲置补偿调优（从 config 注入，
-	// 非正值回退默认）。
-	p.SetBreaker(cfg.Pool.BreakerThreshold, cfg.BreakerCooldownDur, cfg.BreakerCooldownMaxD)
-	p.SetMaxInFlight(cfg.Pool.MaxInFlight)
-	p.SetMaxInFlightGlobal(cfg.Pool.MaxInFlightGlobal) // global 域 WAF 风控分档（P1-1）
-	p.SetDegrade(cfg.Pool.DegradeThreshold, cfg.DegradeCooldownDur, cfg.DegradeCooldownMaxD)
-	p.SetSoftRateMax(cfg.SoftRateMaxDur)                 // 软冷却指数退避封顶（soft_rate_max，默认 2h）
-	p.SetCostExploreInterval(cfg.CostExploreIntervalDur) // costTier 探索窗口（issue #136，默认 30m；0 关停）
-	p.SetCreditFloor(cfg.Pool.CreditFloor)               // 积分保底（默认 0 = 关闭）
-	p.SetWeights(cfg.Pool.IdleWeightPerHour, cfg.Pool.IdleWeightMax)
-	p.SetPreferExpiring(cfg.Pool.PreferExpiring)
-
-	// 会话粘性路由（可配关闭）。
-	var sessRouter *session.Router
-	redisMode := "noop"
-	if _, ok := store.(redisstore.Noop); !ok {
-		redisMode = "upstash"
-	}
-	if cfg.SessionSticky.Enabled {
-		sessRouter = session.New(session.Config{
-			TTL:        cfg.SessionTTL,
-			GCInterval: cfg.SessionGCInterval,
-			Store:      store,
-			Available:  p.AvailableUIDs,
-			// realm 感知闭包：带���缀模型名按 realm 过滤可用账号（跨 realm 不泄漏）；
-			// 裸名走 cn（现状零回归）。闭包内部 resolveModel 剥前缀，再按 realm 过滤。
-			AvailableForModel: realmAwareAvailableForModel(p),
-		})
-		sessRouter.LoadFromStore() // 启动时从 Redis 恢复粘性（读操作仅此处）
-		sessRouter.StartGC()
-		defer sessRouter.StopGC()
-	}
-	sessCount := func() int {
-		if sessRouter != nil {
-			return sessRouter.Count()
-		}
-		return 0
-	}
-
-	up := upstream.New()
-
-	// 积分保底的「收费」兜底判据：接上游模型目录的积分倍率表。本地实测台账无观测
-	// 时用它判收费——否则「没学过」恒等于「放行」，高价新模型会把触底号一笔打穿
-	// （kimi-k3-1 实案：全池无观测 → 保底全放行 → 两笔打穿并硬冷却到次日 04:00）。
-	// 位于 up 装配之后：倍率表由探测下发，闭包每次调用读实时快照。
-	p.SetModelRateOf(func(realm, model string) string { return up.ModelRate(realm, model) })
-
-	// 短 RPC 总时长上限（refresh/checkin/balance/FetchModels），语义不变。
-	up.HTTP.Timeout = time.Duration(cfg.Upstream.TimeoutSeconds) * time.Second
-	// 聊天 SSE 首字节前（响应头）上限：cfg 已 normalize（缺省回落 timeout_seconds）。
-	up.HeaderTimeout = time.Duration(cfg.Upstream.HeaderTimeoutSeconds) * time.Second
-	if tr, ok := up.ChatHTTP.Transport.(*http.Transport); ok {
-		tr.ResponseHeaderTimeout = up.HeaderTimeout
-	}
-	// 聊天 SSE 流中空闲上限（S3 空闲监控读取）。
-	up.IdleTimeout = time.Duration(cfg.Upstream.IdleTimeoutSeconds) * time.Second
-	up.SanitizeFingerprints.Store(cfg.Features.SanitizeBlacklistFingerprints)
-	// 出站 UA 与归属头（issue #42 + 上游同步）：
-	// UserAgent 非空则完全覆盖；ClientVersion/CliVersion 缺省对齐官方形态；
-	// ClientName 非空时 chat 路径注入 X-IDE-* 四头（用量归因对齐官方桌面端）。
-	up.UserAgent = cfg.Upstream.UserAgent
-	up.ClientVersion = cfg.Upstream.ClientVersion
-	up.CliVersion = cfg.Upstream.CliVersion
-	up.ClientName = cfg.Upstream.ClientName
-	up.DeviceToken = cfg.Upstream.DeviceToken
-	up.DeviceTokenFile = cfg.Upstream.DeviceTokenFile
-	up.PassthroughIP = cfg.Upstream.PassthroughIP
-	// global realm 路由（config global 段）：上游侧开关（第一道闸）+ base 覆盖；
-	// auth 侧开关（auth.SetGlobalEnabled）是第二道闸，两者同 config global.enabled。
-	up.GlobalEnabled = cfg.Global.Enabled
-	up.ChatBaseGlobal = cfg.Global.ChatBase
-	up.BillingBaseGlobal = cfg.Global.BillingBase
-	auth.SetGlobalEnabled(cfg.Global.Enabled)
-	// model.json 本地缓存接线（context_length/max_output_tokens 四级查找链第 3 级）：
-	// 数据目录与 state.json 同风格（Docker volume 持久化路径）。首次缺失/损坏自动
-	// 回落仓库内嵌种子；models.dev 按需拉取成功后原子写回。
-	upstream.SetModelCatalogPath(stateSibling(cfg.StateFile, "model.json"))
-
-	sch := scheduler.New(scheduler.Config{
-		Pool:           p,
-		Upstream:       up,
-		CheckinHours:   cfg.Schedule.CheckinHours,
-		TravelHours:    cfg.Schedule.TravelHours,
-		ActivityHours:  cfg.Schedule.ActivityHours,
-		KeepaliveHours: cfg.Schedule.KeepaliveHours,
-		BlackcatHours:  cfg.Schedule.BlackcatHours,
-		GrowthHours:    cfg.Schedule.GrowthHours,
-		// 快过期积分优先消耗：签到/余额刷新按此窗口分桶（issue:积分过期）。
-		ExpiringSoonWindow: cfg.ExpiringSoonDur,
-		CheckinDisabled:    !cfg.Schedule.CheckinEnabled,
-		TravelDisabled:     !cfg.Schedule.TravelEnabled,
-		ActivityDisabled:   !cfg.Schedule.ActivityEnabled,
-		KeepaliveDisabled:  !cfg.Schedule.KeepaliveEnabled,
-		BlackcatDisabled:   !cfg.Schedule.BlackcatEnabled,
-		GrowthDisabled:     !cfg.Schedule.GrowthEnabled,
-	})
-	switch {
-	case !cfg.Schedule.CheckinEnabled:
-		log.Printf("签到已禁用（schedule.checkin_enabled=false）")
-	default:
-		log.Printf("签到已启用：%v 点（签到 + 余额查询解冻）", cfg.Schedule.CheckinHours)
-	}
-	switch {
-	case !cfg.Schedule.TravelEnabled:
-		log.Printf("猫猫旅行已禁用（schedule.travel_enabled=false）")
-	default:
-		log.Printf("猫猫旅行已启用：%v 点（独立排程：领养 / 派出 / 领奖）", cfg.Schedule.TravelHours)
-	}
-	switch {
-	case !cfg.Schedule.ActivityEnabled:
-		log.Printf("活跃上报已禁用（schedule.activity_enabled=false）")
-	default:
-		log.Printf("活跃上报已启用：%v 点（每日 1 次，点亮连登 + 解锁 first_buddy）", cfg.Schedule.ActivityHours)
-	}
-	if !cfg.Schedule.KeepaliveEnabled {
-		log.Printf("token 保活已禁用（schedule.keepalive_enabled=false）")
-	} else {
-		log.Printf("token 保活已启用：%v 点", cfg.Schedule.KeepaliveHours)
-	}
-	switch {
-	case !cfg.Schedule.BlackcatEnabled:
-		log.Printf("夜猫子已禁用（schedule.blackcat_enabled=false）")
-	default:
-		log.Printf("夜猫子已启用：%v 点（23:00–08:00 窗口 glm-5.2 对话补足）", cfg.Schedule.BlackcatHours)
-	}
-	switch {
-	case !cfg.Schedule.BalanceRefreshEnabled:
-		log.Printf("余额后台刷新已禁用（schedule.balance_refresh_enabled=false）")
-	case cfg.BalanceRefreshInterval > 0:
-		log.Printf("余额后台刷新：每 %s（签到时点照常额外刷新）", cfg.BalanceRefreshInterval)
-	}
-
-	// 管理面板日志镜像：标准 log（stderr）与 chat 表格日志（stdout）双路复制进
-	// 面板环形缓冲，供 /panel/api/logs 读取；控制台输出行为完全不变。
-	// live 承载可热改字段（api_key/soft_rate/脱敏开关），面板保存配置时在线替换。
-	live := livecfg.New(livecfg.Snapshot{
-		APIKey:               cfg.APIKey,
-		SoftCooldown:         cfg.SoftRateDur,
-		SanitizeFingerprints: cfg.Features.SanitizeBlacklistFingerprints,
-		RecordClientInfo:     cfg.Logging.RequestClientInfo,
-	})
-	// 用量记录器：与 state 文件同目录，随 state_file 配置一起搬移。
-	// datapath 由 state 文件路径推出，避免再加一个配置项。
-	usagePath := usagePathFor(cfg.StateFile)
-	rec := usage.New(usagePath)
-	rec.Start()
-	defer rec.Stop()
-	log.Printf("[usage] 逐请求用量记录已启用: %s (%s)", usagePath, rec.Describe())
-
-	// 请求指标始终启用；JSONL 归档只写脱敏元数据，写盘失败不影响聊天请求。
-	requestLog := reqlog.New(reqlog.Config{
-		Dir:           stateSibling(cfg.StateFile, "request-logs"),
-		Enabled:       cfg.Logging.RequestArchiveEnabled,
-		RetentionDays: cfg.Logging.RequestRetentionDays,
-		MaxBytes:      int64(cfg.Logging.RequestArchiveMaxMB) << 20,
-	})
-	defer requestLog.Close()
-	rs := requestLog.Snapshot().Archive
-	if rs.Enabled {
-		log.Printf("[reqlog] 请求指标已启用；JSONL 归档 %s（保留 %d 天，上限 %d MiB）",
-			rs.Dir, cfg.Logging.RequestRetentionDays, cfg.Logging.RequestArchiveMaxMB)
-	} else {
-		log.Printf("[reqlog] 请求指标已启用；JSONL 归档已关闭")
-	}
-
-	pn := panel.New(panel.Config{
-		Pool:        p,
-		Usage:       rec,
-		RequestLog:  requestLog,
-		Upstream:    up,
-		Scheduler:   sch,
-		AuthDir:     cfg.AuthDir,
-		APIKey:      cfg.APIKey,
-		RedisMode:   redisMode,
-		StickyCount: sessCount,
-		Version:     appVersion,
-		Live:        live,
-		// 模型上限探测数据（scripts/probe_max_tokens.py --panel-out 写入）：
-		// 与 state 文件同目录，缺省 data/output_probes.json。
-		ProbeFile:  stateSibling(cfg.StateFile, "output_probes.json"),
-		ConfigPath: *cfgPath,
-		LoadConfig: func() (any, error) {
-			return Load(*cfgPath)
-		},
-		SaveConfig: func(raw []byte) ([]string, error) {
-			return saveConfig(raw, *cfgPath, live, p, up, sch)
-		},
-	})
-	// 成长任务队列每日自动执行（与「执行全部待办」同管线）：Sequential 族零点解锁后
-	// 无需手动扫描；hook 返回即启动（异步执行），已在跑时内部跳过。
-	sch.SetGrowthHook(pn.RunGrowthQueueOnce)
-	log.SetOutput(io.MultiWriter(os.Stderr, pn.Logs()))
-	server.SetChatLogOutput(io.MultiWriter(os.Stdout, pn.Logs()))
-
-	h := server.NewHandler(server.Config{
-		Pool:         p,
-		Upstream:     up,
-		APIKey:       cfg.APIKey,
-		Session:      sessRouter,
-		StickyCount:  sessCount,
-		RedisMode:    redisMode,
-		SoftCooldown: cfg.SoftRateDur,
-		Panel:        pn,
-		Live:         live,
-		Usage:        rec,
-		RequestLog:   requestLog,
-		PromptMode:   cfg.Prompt.Mode,
-		PromptText:   cfg.PromptText,
-		// 来源记录开关经 livecfg 热生效；此处同时填静态字段，供 Live 为 nil 的
-		// 裸用/测试路径拿到同一缺省值。
-		RecordClientInfo: cfg.Logging.RequestClientInfo,
-		// handler 侧第三道闸（global realm）：false（显式逃生门）时不列 global: 模型名。
-		GlobalEnabled: cfg.Global.Enabled,
-	})
-
-	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
-	defer stop()
-	go sch.Run(ctx)
-	sch.StartBalanceRefresh(ctx, cfg.BalanceRefreshInterval)
-
-	// 启动即预热模型积分倍率表：倍率只在 FetchModels/FetchGlobalModelInfos 成功时
-	// 填充（两者均懒触发），重启后到首次 /v1/models 或面板模型页被访问之前，
-	// ModelRate 恒返回空串——积分保底的目录兜底在这段空窗期内形同虚设，触底号
-	// 会被当成「收费未知」放行并打穿（实测：重启后 2 分钟，97 分的账号打收费
-	// 模型归零；倍率表当时尚未建立）。
-	// 异步执行：不阻塞监听启动；失败仅记日志（下一轮懒触发或本轮重试仍可补上）。
-	go warmModelRates(ctx, up, p)
-
-	srv := &http.Server{
-		Addr:              cfg.Listen,
-		Handler:           h,
-		ReadHeaderTimeout: 30 * time.Second,
-		// ReadTimeout 覆盖整个请求读取（含 body）：防慢速 body 拖死连接。
-		// 请求体已无网关侧上限（max_body_mb 移除），60s 按常规带宽的数十 MB
-		// 上传余量取值；超大 body 慢速上传若超时，由客户端重试。
-		ReadTimeout: 60 * time.Second,
-		// IdleTimeout keep-alive 空闲连接回收：配合 chat 出站 ctx 传播防连接泄漏堆积。
-		// 注意：SSE 流式响应期间连接非空闲，不受此项掐断；不设全局 WriteTimeout
-		// （长流式生成合法时长可达数分钟，全局 WriteTimeout 会误杀在途 SSE）。
-		IdleTimeout: 120 * time.Second,
-	}
-	go func() {
-		<-ctx.Done()
-		p.Flush() // 信号触发：先落盘再做优雅停机
-		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-		_ = srv.Shutdown(shutdownCtx)
-	}()
-
-	log.Printf("workbuddy2api listening on %s (api_key=%v)，管理面板 http://127.0.0.1%s/panel/", cfg.Listen, cfg.APIKey != "", panelListenPath(cfg.Listen))
-	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-		log.Fatalf("http: %v", err)
-	}
-	log.Printf("bye")
-}
-
-// warmModelRates 启动预热各域模型积分倍率表（供积分保底的目录兜底判定）。
-//
-// 为什么需要：倍率表只在 FetchModels（CN）/ FetchGlobalModelInfos（global）成功时
-// 填充，两者都是懒触发（被 /v1/models 或面板模型页访问才跑）。重启后到首次触发
-// 之间的空窗期里 ModelRate 恒返回空串，保底的目录兜底判不出收费，触底号会被
-// 当成「收费未知」放行并打穿（实测：重启后 2 分钟，97 分的账号打收费模型归零）。
-//
-// 失败处理：单域失败只记 WARN（不阻塞、不致命——后续懒触发仍会补上）；global 域
-// 仅在其路由开关开启时预热（逃生门关锁时按 CN 处理，无需探测）。
-func warmModelRates(ctx context.Context, up *upstream.Client, p *pool.Pool) {
-	// 预热不得拖住进程退出：ctx 取消（SIGINT/SIGTERM）时立刻放弃剩余域。
-	if ctx.Err() != nil {
-		return
-	}
-	// CN：有可用 CN 账号才拉（与面板 models 同口径，避免无谓上游调用）。
-	if uids := p.AvailableUIDsForRealm("cn"); len(uids) > 0 {
-		if a := p.AuthByUID(uids[0]); a != nil {
-			if _, err := up.FetchModels(a); err != nil {
-				log.Printf("WARN: [upstream] warm model rates (cn): %v", err)
-			} else {
-				log.Printf("[upstream] warm model rates: cn ok")
-			}
-		}
-	}
-	// global：独立目录端点（workbuddy.ai），倍率按 "global" 域键存储。
-	if up.GlobalEnabled && ctx.Err() == nil {
-		if uids := p.AvailableUIDsForRealm("global"); len(uids) > 0 {
-			if a := p.AuthByUID(uids[0]); a != nil {
-				// FetchGlobalModelInfos 无错误返回（内部负缓存自行节流），
-				// 仅按结果条数判断是否拿到目录。
-				if infos := up.FetchGlobalModelInfos(a); len(infos) == 0 {
-					log.Printf("WARN: [upstream] warm model rates (global): empty model list")
-				} else {
-					log.Printf("[upstream] warm model rates: global ok (%d models)", len(infos))
-				}
-			}
-		}
-	}
-}
-
-// panelListenPath 从 listen 地址提取 ":port" 形式，用于启动日志拼面板 URL
-// （":7863" 或 "0.0.0.0:7863" → ":7863"；异常输入原样返回）。
-func panelListenPath(listen string) string {
-	for i := len(listen) - 1; i >= 0; i-- {
-		if listen[i] == ':' {
-			return listen[i:]
-		}
-	}
-	return listen
-}
-
-// saveConfig 面板保存配置：校验 → 落盘 → 热应用 → 返回需重启的字段列表。
-//
-// 热生效范围（设计取舍）：
-//   - api_key / cooldown.soft_rate / features.sanitize_blacklist_fingerprints → livecfg 快照
-//   - pool.* → pool.SetBreaker/SetMaxInFlight/SetSoftRateMax/SetWeights/SetCostExploreInterval/SetPreferExpiring/SetCreditFloor
-//   - schedule.* → scheduler.Reconfigure/SetBalanceInterval/SetExpiringSoonWindow
-//
-// 需重启（涉及监听地址、HTTP client 超时、auth_dir 等装配期依赖）：
-//   - listen / auth_dir / state_file / upstream.* / upstash.* / session_sticky.*（TTL 类）
-//
-// 落盘用"先写 tmp 再 rename"原子替换，且优先保留磁盘上的原始 JSON 结构（只改
-// 面板表单覆盖到的键），避免把用户手写的注释性字段/未知键洗掉——这里直接整体
-// 序列化校验后的配置，未知键在 json.Unmarshal 时已丢失，故先合并原始 map。
-func saveConfig(raw []byte, path string, live *livecfg.Holder, p *pool.Pool, up *upstream.Client, sch *scheduler.Scheduler) ([]string, error) {
-	// 1) 解析原始 JSON 为 map（保留用户手写的未知键），再叠加面板提交的键。
-	oldRaw, err := os.ReadFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("read current config: %w", err)
-	}
-	var cur, incoming map[string]any
-	if err := json.Unmarshal(oldRaw, &cur); err != nil {
-		cur = map[string]any{}
-	}
-	if err := json.Unmarshal(raw, &incoming); err != nil {
-		return nil, fmt.Errorf("parse submitted config: %w", err)
-	}
-	merged := mergeConfigMaps(cur, incoming)
-
-	// 2) 校验（与启动同一套 Default+normalize），失败直接返回、不落盘。
-	newCfg, err := ParseConfig(mergedJSON(merged))
-	if err != nil {
-		return nil, err
-	}
-
-	// 3) 落盘（原子替换）。
-	out, err := json.MarshalIndent(merged, "", "  ")
-	if err != nil {
-		return nil, fmt.Errorf("marshal config: %w", err)
-	}
-	tmp := path + ".tmp"
-	if err := os.WriteFile(tmp, out, 0o600); err != nil {
-		return nil, fmt.Errorf("write config: %w", err)
-	}
-	if err := os.Rename(tmp, path); err != nil {
-		// A single-file Docker bind mount cannot be renamed over its mount
-		// target (Linux returns EBUSY / "device or resource busy"). Keep the
-		// atomic path for regular files, but update the mounted file in place
-		// for this specific deployment shape.
-		if !errors.Is(err, syscall.EBUSY) {
-			return nil, fmt.Errorf("replace config: %w", err)
-		}
-		f, openErr := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0o600)
-		if openErr != nil {
-			_ = os.Remove(tmp)
-			return nil, fmt.Errorf("replace config (bind mount fallback): %w", openErr)
-		}
-		_, writeErr := f.Write(out)
-		if writeErr == nil {
-			writeErr = f.Sync()
-		}
-		closeErr := f.Close()
-		// 写失败时保留 tmp（挂载文件已被 O_TRUNC 破坏，tmp 里是完整新内容，
-		// 可手工恢复）；写成功才清理。
-		if writeErr != nil {
-			return nil, fmt.Errorf("replace config (bind mount fallback, 完整新内容保留在 %s): %w", tmp, writeErr)
-		}
-		_ = os.Remove(tmp)
-		if closeErr != nil {
-			return nil, fmt.Errorf("replace config (bind mount fallback): %w", closeErr)
-		}
-	}
-
-	// 4) 热应用：能立即生效的字段全部应用，并列出仍需重启的字段。
-	live.Store(livecfg.Snapshot{
-		APIKey:               newCfg.APIKey,
-		SoftCooldown:         newCfg.SoftRateDur,
-		SanitizeFingerprints: newCfg.Features.SanitizeBlacklistFingerprints,
-		RecordClientInfo:     newCfg.Logging.RequestClientInfo,
-	})
-	up.SanitizeFingerprints.Store(newCfg.Features.SanitizeBlacklistFingerprints)
-	p.SetBreaker(newCfg.Pool.BreakerThreshold, newCfg.BreakerCooldownDur, newCfg.BreakerCooldownMaxD)
-	p.SetMaxInFlight(newCfg.Pool.MaxInFlight)
-	p.SetMaxInFlightGlobal(newCfg.Pool.MaxInFlightGlobal)
-	p.SetDegrade(newCfg.Pool.DegradeThreshold, newCfg.DegradeCooldownDur, newCfg.DegradeCooldownMaxD)
-	p.SetSoftRateMax(newCfg.SoftRateMaxDur)
-	p.SetCostExploreInterval(newCfg.CostExploreIntervalDur) // costTier 探索窗口热生效（0 关停）
-	p.SetCreditFloor(newCfg.Pool.CreditFloor)               // 积分保底热生效（0 = 关闭）
-	p.SetWeights(newCfg.Pool.IdleWeightPerHour, newCfg.Pool.IdleWeightMax)
-	p.SetPreferExpiring(newCfg.Pool.PreferExpiring)
-	sch.SetExpiringSoonWindow(newCfg.ExpiringSoonDur)
-	sch.Reconfigure(
-		newCfg.Schedule.CheckinHours, newCfg.Schedule.TravelHours,
-		newCfg.Schedule.ActivityHours, newCfg.Schedule.KeepaliveHours, newCfg.Schedule.BlackcatHours,
-		newCfg.Schedule.GrowthHours,
-		!newCfg.Schedule.CheckinEnabled, !newCfg.Schedule.TravelEnabled,
-		!newCfg.Schedule.ActivityEnabled, !newCfg.Schedule.KeepaliveEnabled, !newCfg.Schedule.BlackcatEnabled,
-		!newCfg.Schedule.GrowthEnabled)
-	sch.SetBalanceInterval(newCfg.BalanceRefreshInterval)
-
-	return restartRequiredFields(newCfg), nil
-}
-
-// restartRequiredFields 返回本次改动中无法热生效、需要重启进程的字段名。
-// 恒返回完整清单中的"与当前进程装配期依赖相关"的项——面板据此提示用户。
-func restartRequiredFields(c *Config) []string {
-	var out []string
-	// 这些字段在进程内被监听地址/HTTP client/目录句柄等装配期对象捕获。
-	if c.Listen != "" {
-		out = append(out, "listen")
-	}
-	if c.AuthDir != "" {
-		out = append(out, "auth_dir")
-	}
-	if c.StateFile != "" {
-		out = append(out, "state_file")
-	}
-	out = append(out, "upstream.timeout_seconds", "upstream.header_timeout_seconds", "upstream.idle_timeout_seconds")
-	if c.Upstash.URL != "" || c.Upstash.Token != "" {
-		out = append(out, "upstash")
-	}
-	out = append(out, "session_sticky.ttl", "session_sticky.gc_interval")
-	out = append(out, "logging.request_archive_enabled", "logging.request_retention_days", "logging.request_archive_max_mb")
-	return out
-}
-
-// mergeConfigMaps 把 incoming 深合并进 cur（原地），返回 cur。
-// 对嵌套对象逐键覆盖而不是整体替换：面板表单只提交它管理的键，
-// 未提交的兄弟键（含用户手写的未知键）保持原样。
-func mergeConfigMaps(cur, incoming map[string]any) map[string]any {
-	for k, v := range incoming {
-		if inMap, ok := v.(map[string]any); ok {
-			if curMap, ok := cur[k].(map[string]any); ok {
-				cur[k] = mergeConfigMaps(curMap, inMap)
-				continue
-			}
-		}
-		cur[k] = v
-	}
-	return cur
-}
-
-// mergedJSON 把合并后的 map 序列化回 JSON（供 ParseConfig 校验）。
-func mergedJSON(m map[string]any) []byte {
-	b, err := json.Marshal(m)
-	if err != nil {
-		return []byte("{}")
-	}
-	return b
-}
+// main.go workbuddy2api 入口：加载配置、构建 pool、起调度器与 HTTP 服务。
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"io/fs"
+	"log"
+	"net/http"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"syscall"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/livecfg"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/panel"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/pool"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/redisstore"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/reqlog"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/scheduler"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/server"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/session"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/usage"
+)
+
+// appVersion 网关版本（fork 版：面板 + 任务体系），透出到 /panel/api/overview。
+const appVersion = "1.12.0-panel"
+
+// usagePathFor 由 state 文件路径推出用量文件路径：同目录、文件名 usage.json。
+// 这样 config 里改 state_file 时用量数据跟着走，不需要额外配置项。
+func usagePathFor(stateFile string) string { return stateSibling(stateFile, "usage.json") }
+
+// stateSibling 返回与 state 文件同目录的指定文件名路径（相对路径场景回落当前目录）。
+// usage.json（用量记录）与 output_probes.json（模型上限探测）共用本规则。
+func stateSibling(stateFile, name string) string {
+	dir := filepath.Dir(stateFile)
+	if dir == "" || dir == "." {
+		return name
+	}
+	return filepath.Join(dir, name)
+}
+
+func main() {
+	cfgPath := flag.String("config", "config.json", "配置文件路径（默认当前目录 config.json；不存在时自动生成推荐配置）")
+	flag.Parse()
+
+	cfg, err := Load(*cfgPath)
+	if err != nil {
+		// errors.Is 才能看穿 Load 里 fmt.Errorf("%w") 的包装；os.IsNotExist 不行。
+		if errors.Is(err, fs.ErrNotExist) {
+			// 首次运行：目录下没有配置 → 自动落一份推荐配置（含随机 api_key）再加载。
+			// 双击 exe / 裸跑 docker 即开，无需先手工复制样例。
+			if key, werr := WriteDefault(*cfgPath); werr == nil {
+				log.Printf("config %s 不存在，已生成推荐配置（api_key=%s，记录在该文件里，可自行修改）", *cfgPath, key)
+				cfg, err = Load(*cfgPath)
+			}
+			if err != nil {
+				// 生成失败（目录只读等）：退回纯默认 + env（旧行为兜底），不阻塞启动。
+				log.Printf("config %s not found (auto-generate failed), using defaults+env: %v", *cfgPath, err)
+				cfg, err = Load("")
+			}
+		}
+		if err != nil {
+			log.Fatalf("load config: %v", err)
+		}
+	}
+
+	auths, err := auth.LoadDir(cfg.AuthDir)
+	if err != nil {
+		log.Fatalf("load auths: %v", err)
+	}
+	log.Printf("loaded %d account(s) from %s", len(auths), cfg.AuthDir)
+
+	// redisstore：未配置/连接失败 → Noop（纯内存模式，一切功能照常）。
+	store := redisstore.New(cfg.Upstash.URL, cfg.Upstash.Token)
+
+	p := pool.New(cfg.StateFile)
+	// 停机序：先 pool.Close()（最后一次 Flush → SaveState 已提交到 store），
+	// 再 store.Close() 排空在途异步写（最后一笔 Redis 镜像必须写完才关连接）。
+	defer func() {
+		p.Close()
+		_ = store.Close()
+	}()
+	p.SetStore(store)
+	p.RestoreFromSnapshot() // 择新恢复：Redis 快照比本地新才采用，否则本地优先
+	p.SyncToDir(auths)      // 与 auths 目录对齐：新账号加入、已删除文件账号剔除（状态保留）
+
+	// 熔断器 + 在途上限（含 global 分档）+ 连败降权 + 闲置补偿调优（从 config 注入，
+	// 非正值回退默认）。
+	p.SetBreaker(cfg.Pool.BreakerThreshold, cfg.BreakerCooldownDur, cfg.BreakerCooldownMaxD)
+	p.SetMaxInFlight(cfg.Pool.MaxInFlight)
+	p.SetMaxInFlightGlobal(cfg.Pool.MaxInFlightGlobal) // global 域 WAF 风控分档（P1-1）
+	p.SetDegrade(cfg.Pool.DegradeThreshold, cfg.DegradeCooldownDur, cfg.DegradeCooldownMaxD)
+	p.SetSoftRateMax(cfg.SoftRateMaxDur)                 // 软冷却指数退避封顶（soft_rate_max，默认 2h）
+	p.SetCostExploreInterval(cfg.CostExploreIntervalDur) // costTier 探索窗口（issue #136，默认 30m；0 关停）
+	p.SetCreditFloor(cfg.Pool.CreditFloor)               // 积分保底（默认 0 = 关闭）
+	p.SetWeights(cfg.Pool.IdleWeightPerHour, cfg.Pool.IdleWeightMax)
+	p.SetPreferExpiring(cfg.Pool.PreferExpiring)
+
+	// 会话粘性路由（可配关闭）。
+	var sessRouter *session.Router
+	redisMode := "noop"
+	if _, ok := store.(redisstore.Noop); !ok {
+		redisMode = "upstash"
+	}
+	if cfg.SessionSticky.Enabled {
+		sessRouter = session.New(session.Config{
+			TTL:        cfg.SessionTTL,
+			GCInterval: cfg.SessionGCInterval,
+			Store:      store,
+			Available:  p.AvailableUIDs,
+			// realm 感知闭包：带前缀模型名按 realm 过滤可用账号（跨 realm 不泄漏）；
+			// 裸名走 cn（现状零回归）。闭包内部 resolveModel 剥前缀，再按 realm 过滤。
+			AvailableForModel: realmAwareAvailableForModel(p),
+		})
+		sessRouter.LoadFromStore() // 启动时从 Redis 恢复粘性（读操作仅此处）
+		sessRouter.StartGC()
+		defer sessRouter.StopGC()
+	}
+	sessCount := func() int {
+		if sessRouter != nil {
+			return sessRouter.Count()
+		}
+		return 0
+	}
+
+	up := upstream.New()
+
+	// 积分保底的「收费」兜底判据：接上游模型目录的积分倍率表。本地实测台账无观测
+	// 时用它判收费——否则「没学过」恒等于「放行」，高价新模型会把触底号一笔打穿
+	// （kimi-k3-1 实案：全池无观测 → 保底全放行 → 两笔打穿并硬冷却到次日 04:00）。
+	// 位于 up 装配之后：倍率表由探测下发，闭包每次调用读实时快照。
+	p.SetModelRateOf(func(realm, model string) string { return up.ModelRate(realm, model) })
+
+	// 短 RPC 总时长上限（refresh/checkin/balance/FetchModels），语义不变。
+	up.HTTP.Timeout = time.Duration(cfg.Upstream.TimeoutSeconds) * time.Second
+	// 聊天 SSE 首字节前（响应头）上限：cfg 已 normalize（缺省回落 timeout_seconds）。
+	up.HeaderTimeout = time.Duration(cfg.Upstream.HeaderTimeoutSeconds) * time.Second
+	if tr, ok := up.ChatHTTP.Transport.(*http.Transport); ok {
+		tr.ResponseHeaderTimeout = up.HeaderTimeout
+	}
+	// 聊天 SSE 流中空闲上限（S3 空闲监控读取）。
+	up.IdleTimeout = time.Duration(cfg.Upstream.IdleTimeoutSeconds) * time.Second
+	up.SanitizeFingerprints.Store(cfg.Features.SanitizeBlacklistFingerprints)
+	// 出站 UA 与归属头（issue #42 + 上游同步）：
+	// UserAgent 非空则完全覆盖；ClientVersion/CliVersion 缺省对齐官方形态；
+	// ClientName 非空时 chat 路径注入 X-IDE-* 四头（用量归因对齐官方桌面端）。
+	up.UserAgent = cfg.Upstream.UserAgent
+	up.ClientVersion = cfg.Upstream.ClientVersion
+	up.CliVersion = cfg.Upstream.CliVersion
+	up.ClientName = cfg.Upstream.ClientName
+	up.DeviceToken = cfg.Upstream.DeviceToken
+	up.DeviceTokenFile = cfg.Upstream.DeviceTokenFile
+	up.PassthroughIP = cfg.Upstream.PassthroughIP
+	// global realm 路由（config global 段）：上游侧开关（第一道闸）+ base 覆盖；
+	// auth 侧开关（auth.SetGlobalEnabled）是第二道闸，两者同 config global.enabled。
+	up.GlobalEnabled = cfg.Global.Enabled
+	up.ChatBaseGlobal = cfg.Global.ChatBase
+	up.BillingBaseGlobal = cfg.Global.BillingBase
+	auth.SetGlobalEnabled(cfg.Global.Enabled)
+	// model.json 本地缓存接线（context_length/max_output_tokens 四级查找链第 3 级）：
+	// 数据目录与 state.json 同风格（Docker volume 持久化路径）。首次缺失/损坏自动
+	// 回落仓库内嵌种子；models.dev 按需拉取成功后原子写回。
+	upstream.SetModelCatalogPath(stateSibling(cfg.StateFile, "model.json"))
+
+	sch := scheduler.New(scheduler.Config{
+		Pool:           p,
+		Upstream:       up,
+		CheckinHours:   cfg.Schedule.CheckinHours,
+		TravelHours:    cfg.Schedule.TravelHours,
+		ActivityHours:  cfg.Schedule.ActivityHours,
+		KeepaliveHours: cfg.Schedule.KeepaliveHours,
+		BlackcatHours:  cfg.Schedule.BlackcatHours,
+		GrowthHours:    cfg.Schedule.GrowthHours,
+		// 快过期积分优先消耗：签到/余额刷新按此窗口分桶（issue:积分过期）。
+		ExpiringSoonWindow: cfg.ExpiringSoonDur,
+		CheckinDisabled:    !cfg.Schedule.CheckinEnabled,
+		TravelDisabled:     !cfg.Schedule.TravelEnabled,
+		ActivityDisabled:   !cfg.Schedule.ActivityEnabled,
+		KeepaliveDisabled:  !cfg.Schedule.KeepaliveEnabled,
+		BlackcatDisabled:   !cfg.Schedule.BlackcatEnabled,
+		GrowthDisabled:     !cfg.Schedule.GrowthEnabled,
+		// 保号类四任务是否覆盖禁用账号（缺省 false = 禁用即跳过，保持既有行为）。
+		IncludeDisabledInTasks: cfg.Schedule.IncludeDisabledInTasks,
+	})
+	switch {
+	case !cfg.Schedule.CheckinEnabled:
+		log.Printf("签到已禁用（schedule.checkin_enabled=false）")
+	default:
+		log.Printf("签到已启用：%v 点（签到 + 余额查询解冻）", cfg.Schedule.CheckinHours)
+	}
+	switch {
+	case !cfg.Schedule.TravelEnabled:
+		log.Printf("猫猫旅行已禁用（schedule.travel_enabled=false）")
+	default:
+		log.Printf("猫猫旅行已启用：%v 点（独立排程：领养 / 派出 / 领奖）", cfg.Schedule.TravelHours)
+	}
+	switch {
+	case !cfg.Schedule.ActivityEnabled:
+		log.Printf("活跃上报已禁用（schedule.activity_enabled=false）")
+	default:
+		log.Printf("活跃上报已启用：%v 点（每日 1 次，点亮连登 + 解锁 first_buddy）", cfg.Schedule.ActivityHours)
+	}
+	if !cfg.Schedule.KeepaliveEnabled {
+		log.Printf("token 保活已禁用（schedule.keepalive_enabled=false）")
+	} else {
+		log.Printf("token 保活已启用：%v 点", cfg.Schedule.KeepaliveHours)
+	}
+	switch {
+	case !cfg.Schedule.BlackcatEnabled:
+		log.Printf("夜猫子已禁用（schedule.blackcat_enabled=false）")
+	default:
+		log.Printf("夜猫子已启用：%v 点（23:00–08:00 窗口 glm-5.2 对话补足）", cfg.Schedule.BlackcatHours)
+	}
+	switch {
+	case !cfg.Schedule.BalanceRefreshEnabled:
+		log.Printf("余额后台刷��已禁用（schedule.balance_refresh_enabled=false）")
+	case cfg.BalanceRefreshInterval > 0:
+		log.Printf("余额后台刷新：每 %s（签到时点照常额外刷新）", cfg.BalanceRefreshInterval)
+	}
+	if cfg.Schedule.IncludeDisabledInTasks {
+		log.Printf("保号任务覆盖禁用账号（schedule.include_disabled_in_tasks=true）：禁用号仍签到 / 活跃 / 保活 / 刷新余额，但不参与选号")
+	}
+
+	// 管理面板日志镜像：标准 log（stderr）与 chat 表格日志（stdout）双路复制进
+	// 面板环形缓冲，供 /panel/api/logs 读取；控制台输出行为完全不变。
+	// live 承载可热改字段（api_key/soft_rate/脱敏开关），面板保存配置时在线替换。
+	live := livecfg.New(livecfg.Snapshot{
+		APIKey:               cfg.APIKey,
+		SoftCooldown:         cfg.SoftRateDur,
+		SanitizeFingerprints: cfg.Features.SanitizeBlacklistFingerprints,
+		RecordClientInfo:     cfg.Logging.RequestClientInfo,
+	})
+	// 用量记录器：与 state 文件同目录，随 state_file 配置一起搬移。
+	// datapath 由 state 文件路径推出，避免再加一个配置项。
+	usagePath := usagePathFor(cfg.StateFile)
+	rec := usage.New(usagePath)
+	rec.Start()
+	defer rec.Stop()
+	log.Printf("[usage] 逐请求用量记录已启用: %s (%s)", usagePath, rec.Describe())
+
+	// 请求指标始终启用；JSONL 归档只写脱敏元数据，写盘失败不影响聊天请求。
+	requestLog := reqlog.New(reqlog.Config{
+		Dir:           stateSibling(cfg.StateFile, "request-logs"),
+		Enabled:       cfg.Logging.RequestArchiveEnabled,
+		RetentionDays: cfg.Logging.RequestRetentionDays,
+		MaxBytes:      int64(cfg.Logging.RequestArchiveMaxMB) << 20,
+	})
+	defer requestLog.Close()
+	rs := requestLog.Snapshot().Archive
+	if rs.Enabled {
+		log.Printf("[reqlog] 请求指标已启用；JSONL 归档 %s（保留 %d 天，上限 %d MiB）",
+			rs.Dir, cfg.Logging.RequestRetentionDays, cfg.Logging.RequestArchiveMaxMB)
+	} else {
+		log.Printf("[reqlog] 请求指标已启用；JSONL 归档已关闭")
+	}
+
+	pn := panel.New(panel.Config{
+		Pool:        p,
+		Usage:       rec,
+		RequestLog:  requestLog,
+		Upstream:    up,
+		Scheduler:   sch,
+		AuthDir:     cfg.AuthDir,
+		APIKey:      cfg.APIKey,
+		RedisMode:   redisMode,
+		StickyCount: sessCount,
+		Version:     appVersion,
+		Live:        live,
+		// 模型上限探测数据（scripts/probe_max_tokens.py --panel-out 写入）：
+		// 与 state 文件同目录，缺省 data/output_probes.json。
+		ProbeFile:  stateSibling(cfg.StateFile, "output_probes.json"),
+		ConfigPath: *cfgPath,
+		LoadConfig: func() (any, error) {
+			return Load(*cfgPath)
+		},
+		SaveConfig: func(raw []byte) ([]string, error) {
+			return saveConfig(raw, *cfgPath, live, p, up, sch)
+		},
+	})
+	// 成长任务队列每日自动执行（与「执行全部待办」同管线）：Sequential 族零点解锁后
+	// 无需手动扫描；hook 返回即启动（异步执行），已在跑时内部跳过。
+	sch.SetGrowthHook(pn.RunGrowthQueueOnce)
+	log.SetOutput(io.MultiWriter(os.Stderr, pn.Logs()))
+	server.SetChatLogOutput(io.MultiWriter(os.Stdout, pn.Logs()))
+
+	h := server.NewHandler(server.Config{
+		Pool:         p,
+		Upstream:     up,
+		APIKey:       cfg.APIKey,
+		Session:      sessRouter,
+		StickyCount:  sessCount,
+		RedisMode:    redisMode,
+		SoftCooldown: cfg.SoftRateDur,
+		Panel:        pn,
+		Live:         live,
+		Usage:        rec,
+		RequestLog:   requestLog,
+		PromptMode:   cfg.Prompt.Mode,
+		PromptText:   cfg.PromptText,
+		// 来源记录开关经 livecfg 热生效；此处同时填静态字段，供 Live 为 nil 的
+		// 裸用/测试路径拿到同一缺省值。
+		RecordClientInfo: cfg.Logging.RequestClientInfo,
+		// handler 侧第三道闸（global realm）：false（显式逃生门）时不列 global: 模型名。
+		GlobalEnabled: cfg.Global.Enabled,
+	})
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+	go sch.Run(ctx)
+	sch.StartBalanceRefresh(ctx, cfg.BalanceRefreshInterval)
+
+	// 启动即预热模型积分倍率表：倍率只在 FetchModels/FetchGlobalModelInfos 成功时
+	// 填充（两者均懒触发），重启后到首次 /v1/models 或面板模型页被访问之前，
+	// ModelRate 恒返回空串——积分保底的目录兜底在这段空窗期内形同虚设，触底号
+	// 会被当成「收费未知」放行并打穿（实测：重启后 2 分钟，97 分的账号打收费
+	// 模型归零；倍率表当时尚未建立）。
+	// 异步执行：不阻塞监听启动；失败仅记日志（下一轮懒触发或本轮重试仍可补上）。
+	go warmModelRates(ctx, up, p)
+
+	srv := &http.Server{
+		Addr:              cfg.Listen,
+		Handler:           h,
+		ReadHeaderTimeout: 30 * time.Second,
+		// ReadTimeout 覆盖整个请求读取（含 body 上传）：防慢速 body 拖死连接。
+		// 请求体已无网关侧上限（max_body_mb ��除）。缺省 300s（issue #100：旧固定
+		// 60s 会掐掉大上下文/文件块经反代链的慢速上传，客户端收到
+		// 400 "read body: ... i/o timeout"）；server.read_timeout="0" 显式关闭。
+		// 改动需重启进程。
+		ReadTimeout: cfg.ServerReadTimeoutDur,
+		// IdleTimeout keep-alive 空闲连接回收：配合 chat 出站 ctx 传播防连接泄漏堆积。
+		// 注意：SSE 流式响应期间连接非空闲，不受此项掐断；不设全局 WriteTimeout
+		// （长流式生成合法时长可达数分钟，全局 WriteTimeout 会误杀在途 SSE）。
+		IdleTimeout: 120 * time.Second,
+	}
+	go func() {
+		<-ctx.Done()
+		p.Flush() // 信号触发：先落盘再做优雅停机
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		defer cancel()
+		_ = srv.Shutdown(shutdownCtx)
+	}()
+
+	log.Printf("workbuddy2api listening on %s (api_key=%v)，管理面板 http://127.0.0.1%s/panel/", cfg.Listen, cfg.APIKey != "", panelListenPath(cfg.Listen))
+	if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		log.Fatalf("http: %v", err)
+	}
+	log.Printf("bye")
+}
+
+// warmModelRates 启动预热各域模型积分倍率表（供积分保底的目录兜底判定）。
+//
+// 为什么需要：倍率表只在 FetchModels（CN）/ FetchGlobalModelInfos（global）成功时
+// 填充，两者都是懒触发（被 /v1/models 或面板模型页访问才跑）。重启后到首次触发
+// 之间的空窗期里 ModelRate 恒返回空串，保底的目录兜底判不出收费，触底号会被
+// 当成「收费未知」放行并打穿（实测：重启后 2 分钟，97 分的账号打收费模型归零）。
+//
+// 失败处理：单域失败只记 WARN（不阻塞、不致命——后续懒触发仍会补上）；global 域
+// 仅在其路由开关开启时预热（逃生门关锁时按 CN 处理，无需探测）。
+func warmModelRates(ctx context.Context, up *upstream.Client, p *pool.Pool) {
+	// 预热不得拖住进程退出：ctx 取消（SIGINT/SIGTERM）时立刻放弃剩余域。
+	if ctx.Err() != nil {
+		return
+	}
+	// CN：有可用 CN 账号才拉（与面板 models 同口径，避免无谓上游调用）。
+	if uids := p.AvailableUIDsForRealm("cn"); len(uids) > 0 {
+		if a := p.AuthByUID(uids[0]); a != nil {
+			if _, err := up.FetchModels(a); err != nil {
+				log.Printf("WARN: [upstream] warm model rates (cn): %v", err)
+			} else {
+				log.Printf("[upstream] warm model rates: cn ok")
+			}
+		}
+	}
+	// global：独立目录端点（workbuddy.ai），倍率按 "global" 域键存储。
+	if up.GlobalEnabled && ctx.Err() == nil {
+		if uids := p.AvailableUIDsForRealm("global"); len(uids) > 0 {
+			if a := p.AuthByUID(uids[0]); a != nil {
+				// FetchGlobalModelInfos 无错误返回（内部负缓存自行节流），
+				// 仅按结果条数判断是否拿到目录。
+				if infos := up.FetchGlobalModelInfos(a); len(infos) == 0 {
+					log.Printf("WARN: [upstream] warm model rates (global): empty model list")
+				} else {
+					log.Printf("[upstream] warm model rates: global ok (%d models)", len(infos))
+				}
+			}
+		}
+	}
+}
+
+// panelListenPath 从 listen 地址提取 ":port" 形式，用于启动日志拼面板 URL
+// （":7863" 或 "0.0.0.0:7863" → ":7863"；异常输入原样返回）。
+func panelListenPath(listen string) string {
+	for i := len(listen) - 1; i >= 0; i-- {
+		if listen[i] == ':' {
+			return listen[i:]
+		}
+	}
+	return listen
+}
+
+// saveConfig 面板保存配置：校验 → 落盘 → 热应用 → 返回需重启的字段列表。
+//
+// 热生效范围（设计取舍）：
+//   - api_key / cooldown.soft_rate / features.sanitize_blacklist_fingerprints → livecfg 快照
+//   - pool.* → pool.SetBreaker/SetMaxInFlight/SetSoftRateMax/SetWeights/SetCostExploreInterval/SetPreferExpiring/SetCreditFloor
+//   - schedule.* → scheduler.Reconfigure/SetBalanceInterval/SetExpiringSoonWindow
+//
+// 需重启（涉及监听地址、HTTP client 超时、auth_dir 等装配期依赖）：
+//   - listen / auth_dir / state_file / upstream.* / upstash.* / session_sticky.*（TTL 类）
+//
+// 落盘用"先写 tmp 再 rename"原子替换，且优先保留磁盘上的原始 JSON 结构（只改
+// 面板表单覆盖到的键），避免把用户手写的注释性字段/未知键洗掉——这里直接整体
+// 序列化校验后的配置，未知键在 json.Unmarshal 时已丢失，故先合并原始 map。
+func saveConfig(raw []byte, path string, live *livecfg.Holder, p *pool.Pool, up *upstream.Client, sch *scheduler.Scheduler) ([]string, error) {
+	// 1) 解析原始 JSON 为 map（保留用户手写的未知键），再叠加面板提交的键。
+	oldRaw, err := os.ReadFile(path)
+	if err != nil {
+		return nil, fmt.Errorf("read current config: %w", err)
+	}
+	var cur, incoming map[string]any
+	if err := json.Unmarshal(oldRaw, &cur); err != nil {
+		cur = map[string]any{}
+	}
+	if err := json.Unmarshal(raw, &incoming); err != nil {
+		return nil, fmt.Errorf("parse submitted config: %w", err)
+	}
+	merged := mergeConfigMaps(cur, incoming)
+
+	// 2) 校验（与启动同一套 Default+normalize），失败直接返回、不落盘。
+	newCfg, err := ParseConfig(mergedJSON(merged))
+	if err != nil {
+		return nil, err
+	}
+
+	// 3) 落盘（原子替换）。
+	out, err := json.MarshalIndent(merged, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("marshal config: %w", err)
+	}
+	tmp := path + ".tmp"
+	if err := os.WriteFile(tmp, out, 0o600); err != nil {
+		return nil, fmt.Errorf("write config: %w", err)
+	}
+	if err := os.Rename(tmp, path); err != nil {
+		// A single-file Docker bind mount cannot be renamed over its mount
+		// target (Linux returns EBUSY / "device or resource busy"). Keep the
+		// atomic path for regular files, but update the mounted file in place
+		// for this specific deployment shape.
+		if !errors.Is(err, syscall.EBUSY) {
+			return nil, fmt.Errorf("replace config: %w", err)
+		}
+		f, openErr := os.OpenFile(path, os.O_WRONLY|os.O_TRUNC, 0o600)
+		if openErr != nil {
+			_ = os.Remove(tmp)
+			return nil, fmt.Errorf("replace config (bind mount fallback): %w", openErr)
+		}
+		_, writeErr := f.Write(out)
+		if writeErr == nil {
+			writeErr = f.Sync()
+		}
+		closeErr := f.Close()
+		// 写失败时保留 tmp（挂载文件已被 O_TRUNC 破坏，tmp 里是完整新内容，
+		// 可手工恢复）；写成功才清理。
+		if writeErr != nil {
+			return nil, fmt.Errorf("replace config (bind mount fallback, 完整新内容保留在 %s): %w", tmp, writeErr)
+		}
+		_ = os.Remove(tmp)
+		if closeErr != nil {
+			return nil, fmt.Errorf("replace config (bind mount fallback): %w", closeErr)
+		}
+	}
+
+	// 4) 热应用：能立即生效的字段全部应用，并列出仍需重启的字段。
+	live.Store(livecfg.Snapshot{
+		APIKey:               newCfg.APIKey,
+		SoftCooldown:         newCfg.SoftRateDur,
+		SanitizeFingerprints: newCfg.Features.SanitizeBlacklistFingerprints,
+		RecordClientInfo:     newCfg.Logging.RequestClientInfo,
+	})
+	up.SanitizeFingerprints.Store(newCfg.Features.SanitizeBlacklistFingerprints)
+	p.SetBreaker(newCfg.Pool.BreakerThreshold, newCfg.BreakerCooldownDur, newCfg.BreakerCooldownMaxD)
+	p.SetMaxInFlight(newCfg.Pool.MaxInFlight)
+	p.SetMaxInFlightGlobal(newCfg.Pool.MaxInFlightGlobal)
+	p.SetDegrade(newCfg.Pool.DegradeThreshold, newCfg.DegradeCooldownDur, newCfg.DegradeCooldownMaxD)
+	p.SetSoftRateMax(newCfg.SoftRateMaxDur)
+	p.SetCostExploreInterval(newCfg.CostExploreIntervalDur) // costTier 探索窗口热生效（0 关停）
+	p.SetCreditFloor(newCfg.Pool.CreditFloor)               // 积分保底热生效（0 = 关闭）
+	p.SetWeights(newCfg.Pool.IdleWeightPerHour, newCfg.Pool.IdleWeightMax)
+	p.SetPreferExpiring(newCfg.Pool.PreferExpiring)
+	sch.SetExpiringSoonWindow(newCfg.ExpiringSoonDur)
+	sch.Reconfigure(
+		newCfg.Schedule.CheckinHours, newCfg.Schedule.TravelHours,
+		newCfg.Schedule.ActivityHours, newCfg.Schedule.KeepaliveHours, newCfg.Schedule.BlackcatHours,
+		newCfg.Schedule.GrowthHours,
+		!newCfg.Schedule.CheckinEnabled, !newCfg.Schedule.TravelEnabled,
+		!newCfg.Schedule.ActivityEnabled, !newCfg.Schedule.KeepaliveEnabled, !newCfg.Schedule.BlackcatEnabled,
+		!newCfg.Schedule.GrowthEnabled)
+	sch.SetBalanceInterval(newCfg.BalanceRefreshInterval)
+	sch.SetIncludeDisabledInTasks(newCfg.Schedule.IncludeDisabledInTasks)
+
+	return restartRequiredFields(newCfg), nil
+}
+
+// restartRequiredFields 返回本次改动中无法热生效、需要重启进程的字段名。
+// 恒返回完整清单中的"与当前进程装配期依赖相关"的项——面板据此提示用户。
+func restartRequiredFields(c *Config) []string {
+	var out []string
+	// 这些字段在进程内被监听地址/HTTP client/目录句柄等装配期对象捕获。
+	if c.Listen != "" {
+		out = append(out, "listen")
+	}
+	if c.AuthDir != "" {
+		out = append(out, "auth_dir")
+	}
+	if c.StateFile != "" {
+		out = append(out, "state_file")
+	}
+	out = append(out, "upstream.timeout_seconds", "upstream.header_timeout_seconds", "upstream.idle_timeout_seconds")
+	// upstream.user_agent 在装配期被写进出站 client（main.go 的 up.UserAgent = ...），
+	// 之后不再读取——不在 livecfg 热快照里，也无法热改。此前漏列，导致面板改完
+	// 显示"已保存"却不提示需要重启，用户以为没生效（issue #102 附带发现 2）。
+	out = append(out, "upstream.user_agent")
+	if c.Upstash.URL != "" || c.Upstash.Token != "" {
+		out = append(out, "upstash")
+	}
+	out = append(out, "session_sticky.ttl", "session_sticky.gc_interval")
+	out = append(out, "logging.request_archive_enabled", "logging.request_retention_days", "logging.request_archive_max_mb")
+	out = append(out, "server.read_timeout")
+	return out
+}
+
+// mergeConfigMaps 把 incoming 深合并进 cur（原地），返回 cur。
+// 对嵌套对象逐键覆盖而不是整体替���：面板表单只提交它管理的键，
+// 未提交的兄弟键（含用户手写的未知键）保持原样。
+func mergeConfigMaps(cur, incoming map[string]any) map[string]any {
+	for k, v := range incoming {
+		if inMap, ok := v.(map[string]any); ok {
+			if curMap, ok := cur[k].(map[string]any); ok {
+				cur[k] = mergeConfigMaps(curMap, inMap)
+				continue
+			}
+		}
+		cur[k] = v
+	}
+	return cur
+}
+
+// mergedJSON 把合并后的 map 序列化回 JSON（供 ParseConfig 校验）。
+func mergedJSON(m map[string]any) []byte {
+	b, err := json.Marshal(m)
+	if err != nil {
+		return []byte("{}")
+	}
+	return b
+}

cmd/server/wiring.go

@@ -1,24 +1,24 @@
-package main
-
-import (
-	"github.com/linguo2625469/workbuddy2api-panel/internal/pool"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/server"
-)
-
-// realmAwareAvailableForModel 构造会话粘性路由按模型可用口径的 realm 感知闭包。
-//
-// 粘性分配的模型名可能带 realm 前缀（"global:gpt-5.4" / "cn:glm-5.2"）：必须按前缀剥出
-// realm + bareModel，再交给分池选号域过滤——否则裸名取池子全集，global 号会被粘性分配给
-// CN 前缀请求（跨 realm 泄漏）。裸名/显式 cn → cn 集合；global: → global 集合。
-//
-// realm 为空串时 pool.WeightedAvailableUIDsForModelRealm 退化为现状
-// （AvailableUIDsForModel），老调用（无前缀模型名）语义零改动。
-//
-// 返回列表可能对快过期账号重复同一 UID，作为虚拟实例权重；会话哈希分配无需感知
-// 权重细节，已有绑定的快路径仍直接返回原账号，不做迁移。
-func realmAwareAvailableForModel(p *pool.Pool) func(model string) []string {
-	return func(model string) []string {
-		realm, bare := server.ResolveModel(model)
-		return p.WeightedAvailableUIDsForModelRealm(bare, realm)
-	}
-}
+package main
+
+import (
+	"github.com/linguo2625469/workbuddy2api-panel/internal/pool"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/server"
+)
+
+// realmAwareAvailableForModel 构造会话粘性路由按模型可用口径的 realm 感知闭包。
+//
+// 粘性分配的模型名可能带 realm 前缀（"global:gpt-5.4" / "cn:glm-5.2"）：必须按前缀剥出
+// realm + bareModel，再交给分池选号域过滤——否则裸名取池子全集，global 号会被粘性分配给
+// CN 前缀请求（跨 realm 泄漏）。裸名/显式 cn → cn 集合；global: → global 集合。
+//
+// realm 为空串时 pool.WeightedAvailableUIDsForModelRealm 退化为现状
+// （AvailableUIDsForModel），老调用（无前缀模型名）语义零改动。
+//
+// 返回列表可能对快过期账号重复同一 UID，作为虚拟实例权重；会话哈希分配无需感知
+// 权重细节，已有绑定的快路径仍直接返回原账号，不做迁移。
+func realmAwareAvailableForModel(p *pool.Pool) func(model string) []string {
+	return func(model string) []string {
+		realm, bare := server.ResolveModel(model)
+		return p.WeightedAvailableUIDsForModelRealm(bare, realm)
+	}
+}

cmd/signin/main.go

@@ -1,140 +1,140 @@
-// signin 一次性批量签到工具：遍历 ./auths/workbuddy-*.json 全部账号，
-// 自动 RefreshToken（过期时），逐个调 daily-checkin，顺手查余额。
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path/filepath"
-	"sort"
-	"strings"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
-)
-
-type row struct {
-	file     string
-	uid      string
-	nick     string
-	status   string // OK | ALREADY | FAIL | AUTH_INVALID | LOAD_ERR
-	detail   string
-	remain   int64
-	hasQuota bool
-}
-
-func main() {
-	dir := "auths"
-	if len(os.Args) > 1 {
-		dir = os.Args[1]
-	}
-	files, err := filepath.Glob(filepath.Join(dir, "workbuddy-*.json"))
-	if err != nil || len(files) == 0 {
-		fmt.Fprintf(os.Stderr, "no auth files in %s\n", dir)
-		os.Exit(1)
-	}
-	sort.Strings(files)
-	up := upstream.New()
-
-	var rows []row
-	okN, alreadyN, failN := 0, 0, 0
-	for _, f := range files {
-		r := row{file: filepath.Base(f)}
-		raw, err := os.ReadFile(f)
-		if err != nil {
-			r.status, r.detail = "LOAD_ERR", err.Error()
-			rows = append(rows, r)
-			failN++
-			continue
-		}
-		a, err := auth.Parse(raw)
-		if err != nil {
-			r.status, r.detail = "LOAD_ERR", err.Error()
-			rows = append(rows, r)
-			failN++
-			continue
-		}
-		a.FilePath = f
-		r.uid, r.nick = a.UID, a.Nickname
-
-		// refresh 过期 token
-		if a.NeedsRefresh(2 * 3600) {
-			if err := up.RefreshToken(a); err != nil {
-				if ue, ok := err.(*upstream.Error); ok && ue.Kind == upstream.ErrSessionDead {
-					r.status = "AUTH_INVALID"
-				} else {
-					r.status = "FAIL"
-				}
-				r.detail = "refresh: " + short(err.Error())
-				rows = append(rows, r)
-				failN++
-				continue
-			}
-			// refresh 后写回文件（权限问题已修复）；落盘失败必须暴露，否则重启回旧 token
-			if err := a.SaveAtomic(); err != nil {
-				log.Printf("signin %s save: %v", a.UID, err)
-			}
-		}
-
-		err = up.DailyCheckin(a)
-		switch {
-		case err == nil:
-			r.status = "OK"
-			okN++
-		default:
-			// DailyCheckin 已签到返回 code!=0 错误
-			if isAlready(err.Error()) {
-				r.status = "ALREADY"
-				r.detail = short(err.Error())
-				alreadyN++
-			} else {
-				r.status = "FAIL"
-				r.detail = short(err.Error())
-				failN++
-			}
-		}
-		// 顺手查余额
-		if remain, _, qerr := up.UserResource(a); qerr == nil {
-			r.remain, r.hasQuota = remain, true
-		}
-		rows = append(rows, r)
-	}
-
-	// 报告
-	fmt.Printf("uid                                  | nick        | status       | remain | detail\n")
-	fmt.Printf("-------------------------------------+-------------+--------------+--------+------------------------------\n")
-	for _, r := range rows {
-		remain := "-"
-		if r.hasQuota {
-			remain = fmt.Sprintf("%d", r.remain)
-		}
-		fmt.Printf("%-36s | %-11s | %-12s | %-6s | %s\n",
-			trunc(r.uid, 36), trunc(r.nick, 11), r.status, remain, r.detail)
-	}
-	fmt.Printf("\ntotal=%d ok=%d already=%d fail=%d\n", len(rows), okN, alreadyN, failN)
-}
-
-// 已签判定：code 非 0 且含 "已签到"/"already"/"checkin" 等字样
-func isAlready(msg string) bool {
-	s := strings.ToLower(msg)
-	return strings.Contains(s, "已签到") ||
-		strings.Contains(s, "already") ||
-		strings.Contains(s, "checkin") ||
-		strings.Contains(s, "code=400")
-}
-
-func trunc(s string, n int) string {
-	if len(s) > n {
-		return s[:n]
-	}
-	return s
-}
-
-func short(s string) string {
-	s = strings.ReplaceAll(s, "\n", " ")
-	if len(s) > 60 {
-		return s[:60]
-	}
-	return s
-}
+// signin 一次性批量签到工具：遍历 ./auths/workbuddy-*.json 全部账号，
+// 自动 RefreshToken（过期时），逐个调 daily-checkin，顺手查余额。
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"sort"
+	"strings"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
+)
+
+type row struct {
+	file     string
+	uid      string
+	nick     string
+	status   string // OK | ALREADY | FAIL | AUTH_INVALID | LOAD_ERR
+	detail   string
+	remain   int64
+	hasQuota bool
+}
+
+func main() {
+	dir := "auths"
+	if len(os.Args) > 1 {
+		dir = os.Args[1]
+	}
+	files, err := filepath.Glob(filepath.Join(dir, "workbuddy-*.json"))
+	if err != nil || len(files) == 0 {
+		fmt.Fprintf(os.Stderr, "no auth files in %s\n", dir)
+		os.Exit(1)
+	}
+	sort.Strings(files)
+	up := upstream.New()
+
+	var rows []row
+	okN, alreadyN, failN := 0, 0, 0
+	for _, f := range files {
+		r := row{file: filepath.Base(f)}
+		raw, err := os.ReadFile(f)
+		if err != nil {
+			r.status, r.detail = "LOAD_ERR", err.Error()
+			rows = append(rows, r)
+			failN++
+			continue
+		}
+		a, err := auth.Parse(raw)
+		if err != nil {
+			r.status, r.detail = "LOAD_ERR", err.Error()
+			rows = append(rows, r)
+			failN++
+			continue
+		}
+		a.FilePath = f
+		r.uid, r.nick = a.UID, a.Nickname
+
+		// refresh 过期 token
+		if a.NeedsRefresh(2 * 3600) {
+			if err := up.RefreshToken(a); err != nil {
+				if ue, ok := err.(*upstream.Error); ok && ue.Kind == upstream.ErrSessionDead {
+					r.status = "AUTH_INVALID"
+				} else {
+					r.status = "FAIL"
+				}
+				r.detail = "refresh: " + short(err.Error())
+				rows = append(rows, r)
+				failN++
+				continue
+			}
+			// refresh 后写回文件（权限问题已修复）；落盘失败必须暴露，否则重启回旧 token
+			if err := a.SaveAtomic(); err != nil {
+				log.Printf("signin %s save: %v", a.UID, err)
+			}
+		}
+
+		err = up.DailyCheckin(a)
+		switch {
+		case err == nil:
+			r.status = "OK"
+			okN++
+		default:
+			// DailyCheckin 已签到返回 code!=0 错误
+			if isAlready(err.Error()) {
+				r.status = "ALREADY"
+				r.detail = short(err.Error())
+				alreadyN++
+			} else {
+				r.status = "FAIL"
+				r.detail = short(err.Error())
+				failN++
+			}
+		}
+		// 顺手查余额
+		if remain, _, qerr := up.UserResource(a); qerr == nil {
+			r.remain, r.hasQuota = remain, true
+		}
+		rows = append(rows, r)
+	}
+
+	// 报告
+	fmt.Printf("uid                                  | nick        | status       | remain | detail\n")
+	fmt.Printf("-------------------------------------+-------------+--------------+--------+------------------------------\n")
+	for _, r := range rows {
+		remain := "-"
+		if r.hasQuota {
+			remain = fmt.Sprintf("%d", r.remain)
+		}
+		fmt.Printf("%-36s | %-11s | %-12s | %-6s | %s\n",
+			trunc(r.uid, 36), trunc(r.nick, 11), r.status, remain, r.detail)
+	}
+	fmt.Printf("\ntotal=%d ok=%d already=%d fail=%d\n", len(rows), okN, alreadyN, failN)
+}
+
+// 已签判定：code 非 0 且含 "已签到"/"already"/"checkin" 等字样
+func isAlready(msg string) bool {
+	s := strings.ToLower(msg)
+	return strings.Contains(s, "已签到") ||
+		strings.Contains(s, "already") ||
+		strings.Contains(s, "checkin") ||
+		strings.Contains(s, "code=400")
+}
+
+func trunc(s string, n int) string {
+	if len(s) > n {
+		return s[:n]
+	}
+	return s
+}
+
+func short(s string) string {
+	s = strings.ReplaceAll(s, "\n", " ")
+	if len(s) > 60 {
+		return s[:60]
+	}
+	return s
+}

cmd/sync/main.go

@@ -0,0 +1,438 @@
+// sync 是本地 ↔ Hugging Face 中转之间的凭证/状态同步工具。
+//
+// 用法（典型）：
+//
+//	wb2api-sync status          # 只看差异，不写任何东西（有差异时退出码 2）
+//	wb2api-sync pull            # 远端 → 本地（本地启动器在拉起网关前先跑这个）
+//	wb2api-sync push            # 本地 → 远端
+//	wb2api-sync sync            # 双向对账（缺的补上，冲突按判据取新的一方）
+//	wb2api-sync watch -interval 5m   # 常驻，周期性 sync
+//
+// 配置来源：默认读 ./config.json 的 auth_dir / state_file 与 sync 段；
+// 命令行标志可逐项覆盖（未给 config.json 时也能用标志 + 环境变量跑起来）。
+//
+// 为什么读取走桶、写入可走网关：见 internal/syncer 包注释（Xet 上传协议）。
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"os/signal"
+	"strings"
+	"syscall"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/syncer"
+)
+
+// 退出码：0 一切就绪/已对齐；1 出错；2 有差异但未应用（status 模式，供脚本判分支）。
+const (
+	exitOK      = 0
+	exitError   = 1
+	exitPending = 2
+)
+
+// fileConfig 已移到 internal/syncer.LoadConfigFile：启动器（cmd/launcher）与
+// 本工具必须用完全同一套"从 config.json 取同步配置"的规则，否则两边对
+// auth_dir 的理解一旦漂移，就会出现"同步写 A 目录、网关读 B 目录"的诡异故障。
+
+func main() {
+	if err := run(os.Args[1:]); err != nil {
+		fmt.Fprintf(os.Stderr, "[wb2api-sync] 失败: %v\n", err)
+		os.Exit(exitError)
+	}
+}
+
+// options 是解析后的运行参数。
+type options struct {
+	mode       syncer.Mode
+	config     syncer.Config
+	dryRun     bool
+	reportOnly bool // status/diff/plan：按双向算一遍但不落地
+	jsonOut    bool
+	quiet      bool
+	watch      bool
+	interval   time.Duration
+	loaded     string // 实际读到的 config.json 路径（空 = 没读）
+}
+
+func run(args []string) error {
+	// 子命令可以是第一个位置参数；也允许省略（默认 sync）。
+	cmd := "sync"
+	if len(args) > 0 && !strings.HasPrefix(args[0], "-") {
+		cmd = args[0]
+		args = args[1:]
+	}
+
+	fs := flag.NewFlagSet("wb2api-sync", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+
+	var (
+		configPath = fs.String("config", "config.json", "配置文件路径（读 auth_dir/state_file 与 sync 段）")
+		noConfig   = fs.Bool("no-config", false, "不读配置文件，只用标志/环境变量")
+
+		bucket    = fs.String("bucket", "", "HF 桶 ID，如 a3216/wb2api-storage")
+		endpoint  = fs.String("endpoint", "", "HF 端点（默认 https://huggingface.co）")
+		token     = fs.String("token", "", "HF token（建议改用 -token-file 或 HF_TOKEN 环境变量）")
+		tokenFile = fs.String("token-file", "", "存放 HF token 的文件")
+
+		authDir = fs.String("auth-dir", "", "本地凭证目录（默认取 config.json 的 auth_dir）")
+		dataDir = fs.String("data-dir", "", "本地数据目录（默认取 state_file 所在目录）")
+		include = fs.String("include-data", "", "额外同步的 data/ 文件名，逗号分隔（默认只同步凭证）")
+
+		writer   = fs.String("writer", "", "写入通道：auto（默认）/ hf / relay")
+		hfBin    = fs.String("hf-bin", "", "hf 可执行文件，默认 hf")
+		relayURL = fs.String("relay-url", "", "中转网关地址（relay 通道用）")
+		relayKey = fs.String("relay-key", "", "中转网关 api_key（留空时自动从桶的 config.json 读）")
+		restart  = fs.String("restart-space", "", "推了新凭证后重启该 Space（如 a3216/gcli2api），让它加载新账号")
+		caBundle = fs.String("ca-bundle", "", "额外 CA 证书包（PEM）；本机跑抓包代理时给 hf CLI 用")
+
+		timeout  = fs.String("timeout", "", "单次网络超时，默认 60s")
+		insecure = fs.Bool("insecure-skip-verify", false, "跳过 TLS 校验（仅供本地抓包代理排障）")
+
+		dryRun   = fs.Bool("dry-run", false, "只展示将要做什么，不写任何东西")
+		jsonOut  = fs.Bool("json", false, "以 JSON 输出结果")
+		quiet    = fs.Bool("quiet", false, "只输出汇总行")
+		watch    = fs.Bool("watch", false, "常驻循环同步")
+		interval = fs.Duration("interval", 5*time.Minute, "watch 模式的同步间隔")
+	)
+
+	if cmd == "help" || cmd == "-h" || cmd == "--help" {
+		printHelp(fs)
+		return nil
+	}
+	if err := fs.Parse(args); err != nil {
+		return err
+	}
+
+	mode, reportOnly, err := syncer.ParseCommand(cmd)
+	if err != nil {
+		return err
+	}
+
+	opt := options{
+		mode: mode, dryRun: *dryRun || reportOnly, jsonOut: *jsonOut, quiet: *quiet,
+		watch: *watch || cmd == "watch", interval: *interval, reportOnly: reportOnly,
+	}
+	if opt.watch {
+		// watch 必须是双向的：单方向常驻没有意义。
+		opt.mode = syncer.ModeSync
+		opt.reportOnly = false
+	}
+
+	// 1) 读配置文件打底
+	if !*noConfig && *configPath != "" {
+		fc, err := syncer.LoadConfigFile(*configPath)
+		switch {
+		case err == nil:
+			opt.loaded = *configPath
+			opt.config = fc
+		case os.IsNotExist(err):
+			// 没有 config.json 不是错误：可以用标志 + 环境变量把同步跑起来。
+		default:
+			return fmt.Errorf("读取 %s 失败: %w", *configPath, err)
+		}
+	}
+
+	// 2) 标志覆盖
+	if *bucket != "" {
+		opt.config.Bucket = *bucket
+	}
+	if *endpoint != "" {
+		opt.config.Endpoint = *endpoint
+	}
+	if *token != "" {
+		opt.config.Token = *token
+	}
+	if *tokenFile != "" {
+		opt.config.TokenFile = *tokenFile
+	}
+	if *authDir != "" {
+		opt.config.AuthDir = *authDir
+	}
+	if *dataDir != "" {
+		opt.config.DataDir = *dataDir
+	}
+	if *include != "" {
+		opt.config.IncludeData = splitCSV(*include)
+	}
+	if *writer != "" {
+		opt.config.Writer = *writer
+	}
+	if *hfBin != "" {
+		opt.config.HFBin = *hfBin
+	}
+	if *relayURL != "" {
+		opt.config.RelayURL = *relayURL
+	}
+	if *relayKey != "" {
+		opt.config.RelayKey = *relayKey
+	}
+	if *restart != "" {
+		opt.config.RestartSpace = *restart
+	}
+	if *caBundle != "" {
+		opt.config.CABundle = *caBundle
+	}
+	if *timeout != "" {
+		opt.config.Timeout = *timeout
+	}
+	if *insecure {
+		opt.config.InsecureSkipVerify = true
+	}
+	// 环境变量兜底（方便 CI / 临时用，不必把 token 落盘）
+	if opt.config.Token == "" && opt.config.TokenFile == "" {
+		if t := strings.TrimSpace(os.Getenv("HF_TOKEN")); t != "" {
+			opt.config.Token = t
+		}
+	}
+	opt.config.Normalize()
+
+	if opt.config.AuthDir == "" {
+		opt.config.AuthDir = "auths"
+	}
+	if opt.config.DataDir == "" {
+		opt.config.DataDir = "data"
+	}
+	if opt.config.Bucket == "" {
+		return fmt.Errorf("未配置桶：请在 config.json 的 sync.bucket 填桶 ID（形如 a3216/wb2api-storage），或用 -bucket")
+	}
+
+	ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer cancel()
+
+	eng, err := syncer.New(opt.config)
+	if err != nil {
+		return err
+	}
+	opt.config = eng.Config() // 拿回归一化后的值（含 token_file 解出来的 token）
+
+	// relay 通道缺 api_key 时，从桶里的 config.json 自动取——省掉手工抄一遍密钥。
+	if needsRelayKey(eng) {
+		if key, kerr := eng.FetchRemoteAPIKey(ctx); kerr == nil {
+			opt.config.RelayKey = key
+			if eng, err = syncer.New(opt.config); err != nil {
+				return err
+			}
+		}
+	}
+
+	if opt.watch {
+		return runWatch(ctx, eng, opt)
+	}
+	return runOnce(ctx, eng, opt)
+}
+
+// needsRelayKey 报告当前是否"选了 relay 通道但还没 key"。
+func needsRelayKey(eng *syncer.Engine) bool {
+	return eng.WriterName() == "relay" && eng.Config().RelayKey == ""
+}
+
+// runOnce 跑一轮并输出结果。
+func runOnce(ctx context.Context, eng *syncer.Engine, opt options) error {
+	plan, res, err := eng.Sync(ctx, opt.mode, opt.dryRun)
+	if err != nil {
+		return err
+	}
+	if opt.jsonOut {
+		printJSON(plan, res, opt)
+	} else {
+		printHuman(plan, res, opt, eng)
+	}
+	if res.Failed > 0 {
+		return fmt.Errorf("%d 个文件同步失败", res.Failed)
+	}
+	// 推了新账号 → 让 Space 重启一次，否则它只在启动时扫凭证目录，加载不到新号。
+	if !opt.dryRun && opt.config.RestartSpace != "" {
+		if n := uploadedAuths(res); n > 0 {
+			if err := syncer.RestartSpace(ctx, opt.config.Endpoint, opt.config.RestartSpace,
+				opt.config.Token, 90*time.Second, opt.config.InsecureSkipVerify); err != nil {
+				return fmt.Errorf("凭证已上传，但重启 Space 失败（新账号要等它下次重启才生效）: %w", err)
+			}
+			if !opt.jsonOut {
+				fmt.Printf("\n已请求重启 Space %s（推送了 %d 个凭证）——冷启动约 30~60s 后新账号生效。\n",
+					opt.config.RestartSpace, n)
+			}
+		}
+	}
+	// status 模式：有差异时用退出码 2 告诉脚本"尚未对齐"（与 git diff --exit-code 同风格）。
+	if opt.reportOnly && plan.Changes() > 0 {
+		os.Exit(exitPending)
+	}
+	return nil
+}
+
+// uploadedAuths 统计本轮真正写成功的 auths/ 文件数——只有这些才需要触发 Space 重启。
+func uploadedAuths(res *syncer.Result) int {
+	n := 0
+	for _, a := range res.Actions {
+		if a.Op == syncer.OpUpload && a.Applied && a.Err == "" && strings.HasPrefix(a.Path, "auths/") {
+			n++
+		}
+	}
+	return n
+}
+
+// runWatch 常驻循环。只有发生变化时才打印，避免刷屏。
+func runWatch(ctx context.Context, eng *syncer.Engine, opt options) error {
+	if !opt.jsonOut {
+		fmt.Printf("[wb2api-sync] watch 启动：每 %s 同步一次（Ctrl-C 退出）\n", opt.interval)
+	}
+	t := time.NewTicker(opt.interval)
+	defer t.Stop()
+	for {
+		plan, res, err := eng.Sync(ctx, syncer.ModeSync, false)
+		switch {
+		case err != nil:
+			fmt.Fprintf(os.Stderr, "[wb2api-sync] %s 同步出错: %v\n", time.Now().Format("15:04:05"), err)
+		case plan.Changes() > 0 || res.Failed > 0:
+			if opt.jsonOut {
+				printJSON(plan, res, opt)
+			} else {
+				fmt.Printf("[wb2api-sync] %s 上传 %d / 下载 %d / 失败 %d\n",
+					time.Now().Format("15:04:05"), res.Uploaded, res.Downloaded, res.Failed)
+			}
+		}
+		select {
+		case <-ctx.Done():
+			return nil
+		case <-t.C:
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------
+// 输出
+// ---------------------------------------------------------------------------
+
+func printHuman(plan *syncer.Plan, res *syncer.Result, opt options, eng *syncer.Engine) {
+	cfg := eng.Config()
+	mode := string(opt.mode)
+	if opt.dryRun {
+		mode += "（dry-run，未写入）"
+	}
+	if !opt.quiet {
+		fmt.Printf("[wb2api-sync] 桶 %s  端点 %s\n", cfg.Bucket, cfg.Endpoint)
+		fmt.Printf("  模式 %s   写入通道 %s   凭证目录 %s\n", mode, writerLabel(eng), cfg.AuthDir)
+		if len(cfg.IncludeData) > 0 {
+			fmt.Printf("  额外同步 data/: %s\n", strings.Join(cfg.IncludeData, ", "))
+		} else {
+			fmt.Printf("  额外同步 data/: 无（只同步 auths/ 凭证；需要时用 -include-data state.json 开启）\n")
+		}
+		fmt.Printf("  本地 %d 个文件 / 远端 %d 个文件\n\n", plan.LocalFiles, plan.RemoteFiles)
+	}
+
+	for _, a := range plan.Actions {
+		if a.Op == syncer.OpNoop && !a.Conflict {
+			continue // 一致的文件不刷屏
+		}
+		icon := "="
+		switch a.Op {
+		case syncer.OpUpload:
+			icon = "↑"
+		case syncer.OpDownload:
+			icon = "↓"
+		}
+		tag := ""
+		if a.Conflict {
+			tag = " [冲突]"
+		}
+		status := ""
+		if a.Err != "" {
+			status = "  ✗ " + a.Err
+		}
+		fmt.Printf("  %s %-8s %s%s\n      %s%s\n", icon, a.Op, a.Path, tag, a.Reason, status)
+	}
+
+	if n := len(plan.Conflicts()); n > 0 && !opt.quiet {
+		fmt.Printf("\n  本轮有 %d 个真冲突（两端都有且内容不同），已按「accessToken 新鲜度 → refreshToken 有无 → mtime」裁决。\n", n)
+	}
+	fmt.Printf("\n汇总: 上传 %d / 下载 %d / 跳过 %d / 失败 %d\n",
+		res.Uploaded, res.Downloaded, res.Skipped, res.Failed)
+	for _, e := range res.Errors {
+		fmt.Fprintf(os.Stderr, "  ! %s\n", e)
+	}
+}
+
+func writerLabel(eng *syncer.Engine) string {
+	if n := eng.WriterName(); n != "" {
+		return n
+	}
+	return "(只读：未配置写入通道)"
+}
+
+// jsonReport 是 -json 的输出结构。
+type jsonReport struct {
+	OK       bool            `json:"ok"`
+	Mode     string          `json:"mode"`
+	DryRun   bool            `json:"dry_run"`
+	Bucket   string          `json:"bucket"`
+	Writer   string          `json:"writer"`
+	Local    int             `json:"local_files"`
+	Remote   int             `json:"remote_files"`
+	Changes  int             `json:"changes"`
+	Uploaded int             `json:"uploaded"`
+	Downld   int             `json:"downloaded"`
+	Skipped  int             `json:"skipped"`
+	Failed   int             `json:"failed"`
+	Actions  []syncer.Action `json:"actions"`
+	Errors   []string        `json:"errors,omitempty"`
+}
+
+func printJSON(plan *syncer.Plan, res *syncer.Result, opt options) {
+	rep := jsonReport{
+		OK: res.Failed == 0, Mode: string(opt.mode), DryRun: opt.dryRun,
+		Bucket: plan.Bucket, Writer: plan.Writer,
+		Local: plan.LocalFiles, Remote: plan.RemoteFiles, Changes: plan.Changes(),
+		Uploaded: res.Uploaded, Downld: res.Downloaded, Skipped: res.Skipped, Failed: res.Failed,
+		Actions: plan.Actions, Errors: res.Errors,
+	}
+	raw, _ := json.MarshalIndent(rep, "", "  ")
+	fmt.Println(string(raw))
+}
+
+func printHelp(fs *flag.FlagSet) {
+	fmt.Print(`wb2api-sync — 本地与 Hugging Face 中转之间的凭证/状态同步
+
+用法:
+  wb2api-sync status [标志]   只看差异（有差异退出码 2），不写任何东西
+  wb2api-sync pull   [标志]   远端 → 本地
+  wb2api-sync push   [标志]   本地 → 远端
+  wb2api-sync sync   [标志]   双向对账（默认）
+  wb2api-sync watch  [标志]   常驻，周期性 sync
+
+退出码: 0 已对齐 / 1 出错 / 2 status 模式下存在差异
+
+标志:
+`)
+	fs.PrintDefaults()
+	fmt.Print(`
+示例:
+  # 本地启动前先拉一次远端凭证
+  wb2api-sync pull -config config.json
+
+  # 看两边差在哪（不写盘）
+  wb2api-sync status -bucket a3216/wb2api-storage -token-file ./data/hf_token.txt
+
+  # 常驻，每 5 分钟对账一次
+  wb2api-sync watch -interval 5m
+`)
+}
+
+// ---------------------------------------------------------------------------
+// 小工具
+// ---------------------------------------------------------------------------
+
+// splitCSV 切分逗号列表并去掉空项。
+func splitCSV(s string) []string {
+	var out []string
+	for _, part := range strings.Split(s, ",") {
+		if p := strings.TrimSpace(part); p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}

cmd/trial/main.go

@@ -1,133 +1,133 @@
-// trial 一次性批量领取 global trial 加油包：遍历 auths 下全部账号，
-// 仅对 global 账号执行 /billing/ide/trial（CN 无此端点，明确提示不适用）。
-//
-// 用法：
-//
-//	# 本地：在项目根目录（需 config.json + auths/ + data/）直接 run
-//	go run ./cmd/trial
-//
-//	# 容器内：先 cp 进去再 exec
-//	docker cp trial workbuddy2api:/tmp/trial
-//	docker exec -w /app workbuddy2api /tmp/trial
-//
-// 结果逐账号输出到 stdout：
-//
-//	uid | nick | status | detail
-//	----+------+--------+-------
-//	... | GLOBAL | OK | trial granted
-//	... | GLOBAL | ALREADY | 已领取过（幂等，不算失败）
-//	... | CN     | N/A   | not applicable
-package main
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-	"sort"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
-)
-
-// classifyTrial 归一化 ClaimTrial 结果（纯函数，供 main 循环与测试直接断言）：
-// err → FAIL；claimed → OK；否则（幂等码已领）→ ALREADY。
-func classifyTrial(claimed bool, err error) (trialStatus, string) {
-	switch {
-	case err != nil:
-		return trialFailed, err.Error()
-	case claimed:
-		return trialOK, "trial granted"
-	default:
-		return trialAlready, "already claimed (idempotent)"
-	}
-}
-
-// trialStatus 单账号 trial 领取结果状态。
-type trialStatus string
-
-const (
-	trialOK      trialStatus = "OK"
-	trialAlready trialStatus = "ALREADY"
-	trialNotApp  trialStatus = "N/A" // CN 账号不适用
-	trialFailed  trialStatus = "FAIL"
-)
-
-type trialRow struct {
-	uid    string
-	nick   string
-	status trialStatus
-	detail string
-}
-
-func main() {
-	authDir := "auths"
-	if len(os.Args) > 1 {
-		authDir = os.Args[1]
-	}
-	files, err := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json"))
-	if err != nil || len(files) == 0 {
-		fmt.Fprintf(os.Stderr, "no auth files in %s\n", authDir)
-		os.Exit(1)
-	}
-	sort.Strings(files)
-
-	up := upstream.New()
-	// trial 是 global 专属端点：必须开启 global realm 路由，否则 upstream.New() 的
-	// GlobalEnabled 零值 false 会把请求路由到 CN base（codebuddy.cn）而必然失败。
-	up.GlobalEnabled = true
-	var rows []trialRow
-	for _, f := range files {
-		r := trialRow{uid: filepath.Base(f)}
-		raw, err := os.ReadFile(f)
-		if err != nil {
-			r.status, r.detail = trialFailed, "load: "+err.Error()
-			rows = append(rows, r)
-			continue
-		}
-		a, err := auth.Parse(raw)
-		if err != nil {
-			r.status, r.detail = trialFailed, "parse: "+err.Error()
-			rows = append(rows, r)
-			continue
-		}
-		a.FilePath = f
-		r.uid, r.nick = a.UID, a.Nickname
-
-		// 仅 global 账号适用：CN 明确提示不适用，不发任何请求。
-		if !a.IsGlobal() {
-			r.status, r.detail = trialNotApp, "CN account not applicable"
-			rows = append(rows, r)
-			continue
-		}
-
-		r.status, r.detail = classifyTrial(up.ClaimTrial(a))
-		rows = append(rows, r)
-	}
-
-	var okN, alreadyN, notAppN, failN int
-	fmt.Printf("uid                                  | nick        | status  | detail\n")
-	fmt.Printf("-------------------------------------+-------------+---------+------------------------------\n")
-	for _, r := range rows {
-		fmt.Printf("%-36s | %-11s | %-7s | %s\n",
-			trunc(r.uid, 36), trunc(r.nick, 11), r.status, r.detail)
-		switch r.status {
-		case trialOK:
-			okN++
-		case trialAlready:
-			alreadyN++
-		case trialNotApp:
-			notAppN++
-		default:
-			failN++
-		}
-	}
-	fmt.Printf("\ntotal=%d ok=%d already=%d na=%d fail=%d\n",
-		len(rows), okN, alreadyN, notAppN, failN)
-}
-
-func trunc(s string, n int) string {
-	if len(s) > n {
-		return s[:n]
-	}
-	return s
-}
+// trial 一次性批量领取 global trial 加油包：遍历 auths 下全部账号，
+// 仅对 global 账号执行 /billing/ide/trial（CN 无此端点，明确提示不适用）。
+//
+// 用法：
+//
+//	# 本地：在项目根目录（需 config.json + auths/ + data/）直接 run
+//	go run ./cmd/trial
+//
+//	# 容器内：先 cp 进去再 exec
+//	docker cp trial workbuddy2api:/tmp/trial
+//	docker exec -w /app workbuddy2api /tmp/trial
+//
+// 结果逐账号输出到 stdout：
+//
+//	uid | nick | status | detail
+//	----+------+--------+-------
+//	... | GLOBAL | OK | trial granted
+//	... | GLOBAL | ALREADY | 已领取过（幂等，不算失败）
+//	... | CN     | N/A   | not applicable
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"sort"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
+)
+
+// classifyTrial 归一化 ClaimTrial 结果（纯函数，供 main 循环与测试直接断言）：
+// err → FAIL；claimed → OK；否则（幂等码已领）→ ALREADY。
+func classifyTrial(claimed bool, err error) (trialStatus, string) {
+	switch {
+	case err != nil:
+		return trialFailed, err.Error()
+	case claimed:
+		return trialOK, "trial granted"
+	default:
+		return trialAlready, "already claimed (idempotent)"
+	}
+}
+
+// trialStatus 单账号 trial 领取结果状态。
+type trialStatus string
+
+const (
+	trialOK      trialStatus = "OK"
+	trialAlready trialStatus = "ALREADY"
+	trialNotApp  trialStatus = "N/A" // CN 账号不适用
+	trialFailed  trialStatus = "FAIL"
+)
+
+type trialRow struct {
+	uid    string
+	nick   string
+	status trialStatus
+	detail string
+}
+
+func main() {
+	authDir := "auths"
+	if len(os.Args) > 1 {
+		authDir = os.Args[1]
+	}
+	files, err := filepath.Glob(filepath.Join(authDir, "workbuddy-*.json"))
+	if err != nil || len(files) == 0 {
+		fmt.Fprintf(os.Stderr, "no auth files in %s\n", authDir)
+		os.Exit(1)
+	}
+	sort.Strings(files)
+
+	up := upstream.New()
+	// trial 是 global 专属端点：必须开启 global realm 路由，否则 upstream.New() 的
+	// GlobalEnabled 零值 false 会把请求路由到 CN base（codebuddy.cn）而必然失败。
+	up.GlobalEnabled = true
+	var rows []trialRow
+	for _, f := range files {
+		r := trialRow{uid: filepath.Base(f)}
+		raw, err := os.ReadFile(f)
+		if err != nil {
+			r.status, r.detail = trialFailed, "load: "+err.Error()
+			rows = append(rows, r)
+			continue
+		}
+		a, err := auth.Parse(raw)
+		if err != nil {
+			r.status, r.detail = trialFailed, "parse: "+err.Error()
+			rows = append(rows, r)
+			continue
+		}
+		a.FilePath = f
+		r.uid, r.nick = a.UID, a.Nickname
+
+		// 仅 global 账号适用：CN 明确提示不适用，不发任何请求。
+		if !a.IsGlobal() {
+			r.status, r.detail = trialNotApp, "CN account not applicable"
+			rows = append(rows, r)
+			continue
+		}
+
+		r.status, r.detail = classifyTrial(up.ClaimTrial(a))
+		rows = append(rows, r)
+	}
+
+	var okN, alreadyN, notAppN, failN int
+	fmt.Printf("uid                                  | nick        | status  | detail\n")
+	fmt.Printf("-------------------------------------+-------------+---------+------------------------------\n")
+	for _, r := range rows {
+		fmt.Printf("%-36s | %-11s | %-7s | %s\n",
+			trunc(r.uid, 36), trunc(r.nick, 11), r.status, r.detail)
+		switch r.status {
+		case trialOK:
+			okN++
+		case trialAlready:
+			alreadyN++
+		case trialNotApp:
+			notAppN++
+		default:
+			failN++
+		}
+	}
+	fmt.Printf("\ntotal=%d ok=%d already=%d na=%d fail=%d\n",
+		len(rows), okN, alreadyN, notAppN, failN)
+}
+
+func trunc(s string, n int) string {
+	if len(s) > n {
+		return s[:n]
+	}
+	return s
+}

config.default.json

@@ -1,98 +1,102 @@
-{
-  "listen": ":7861",
-  "api_key": "",
-  "auth_dir": "/app/storage/auths",
-  "state_file": "/app/storage/data/state.json",
-  "panel": {
-    "package_detail_limit": 5
-  },
-  "logging": {
-    "request_archive_enabled": true,
-    "request_retention_days": 7,
-    "request_archive_max_mb": 100,
-    "request_client_info": true
-  },
-  "cooldown": {
-    "soft_rate": "600s",
-    "soft_rate_max": "2h"
-  },
-  "schedule": {
-    "checkin_hours": [
-      9,
-      21
-    ],
-    "travel_hours": [
-      9,
-      21
-    ],
-    "activity_hours": [
-      10
-    ],
-    "keepalive_hours": [
-      22
-    ],
-    "blackcat_hours": [
-      23
-    ],
-    "growth_hours": [
-      1
-    ],
-    "checkin_enabled": true,
-    "travel_enabled": true,
-    "activity_enabled": true,
-    "keepalive_enabled": true,
-    "blackcat_enabled": true,
-    "growth_enabled": true,
-    "balance_refresh_enabled": true,
-    "balance_refresh_minutes": 5
-  },
-  "global": {
-    "enabled": true,
-    "chat_base": "",
-    "billing_base": ""
-  },
-  "upstream": {
-    "timeout_seconds": 120,
-    "header_timeout_seconds": 120,
-    "idle_timeout_seconds": 300,
-    "user_agent": "",
-    "client_version": "",
-    "cli_version": "",
-    "client_name": "",
-    "device_token": "",
-    "device_token_file": "",
-    "passthrough_ip": false
-  },
-  "features": {
-    "sanitize_blacklist_fingerprints": true
-  },
-  "prompt": {
-    "mode": "passthrough",
-    "file": ""
-  },
-  "upstash": {
-    "url": "",
-    "token": ""
-  },
-  "pool": {
-    "max_in_flight": 3,
-    "max_in_flight_global": 2,
-    "breaker_threshold": 3,
-    "breaker_cooldown": "30m",
-    "breaker_cooldown_max": "6h",
-    "degrade_threshold": 5,
-    "degrade_cooldown": "10m",
-    "degrade_cooldown_max": "2h",
-    "idle_weight_per_hour": 0.5,
-    "idle_weight_max": 5,
-    "prefer_expiring": true,
-    "expiring_soon": "168h",
-    "cost_explore_interval": "30m",
-    "credit_floor": 0
-  },
-  "session_sticky": {
-    "enabled": true,
-    "ttl": "30m",
-    "gc_interval": "5m"
-  }
-}
+{
+  "listen": ":7861",
+  "api_key": "",
+  "auth_dir": "/app/storage/auths",
+  "state_file": "/app/storage/data/state.json",
+  "server": {
+    "read_timeout": "300s"
+  },
+  "panel": {
+    "package_detail_limit": 5
+  },
+  "logging": {
+    "request_archive_enabled": true,
+    "request_retention_days": 7,
+    "request_archive_max_mb": 100,
+    "request_client_info": true
+  },
+  "cooldown": {
+    "soft_rate": "600s",
+    "soft_rate_max": "2h"
+  },
+  "schedule": {
+    "checkin_hours": [
+      9,
+      21
+    ],
+    "travel_hours": [
+      9,
+      21
+    ],
+    "activity_hours": [
+      10
+    ],
+    "keepalive_hours": [
+      22
+    ],
+    "blackcat_hours": [
+      23
+    ],
+    "growth_hours": [
+      1
+    ],
+    "checkin_enabled": true,
+    "travel_enabled": true,
+    "activity_enabled": true,
+    "keepalive_enabled": true,
+    "blackcat_enabled": true,
+    "growth_enabled": true,
+    "balance_refresh_enabled": true,
+    "balance_refresh_minutes": 5,
+    "include_disabled_in_tasks": false
+  },
+  "global": {
+    "enabled": true,
+    "chat_base": "",
+    "billing_base": ""
+  },
+  "upstream": {
+    "timeout_seconds": 120,
+    "header_timeout_seconds": 120,
+    "idle_timeout_seconds": 300,
+    "user_agent": "",
+    "client_version": "",
+    "cli_version": "",
+    "client_name": "",
+    "device_token": "",
+    "device_token_file": "",
+    "passthrough_ip": false
+  },
+  "features": {
+    "sanitize_blacklist_fingerprints": true
+  },
+  "prompt": {
+    "mode": "passthrough",
+    "file": ""
+  },
+  "upstash": {
+    "url": "",
+    "token": ""
+  },
+  "pool": {
+    "max_in_flight": 3,
+    "max_in_flight_global": 2,
+    "breaker_threshold": 3,
+    "breaker_cooldown": "30m",
+    "breaker_cooldown_max": "6h",
+    "degrade_threshold": 5,
+    "degrade_cooldown": "10m",
+    "degrade_cooldown_max": "2h",
+    "idle_weight_per_hour": 0.5,
+    "idle_weight_max": 5,
+    "prefer_expiring": true,
+    "expiring_soon": "168h",
+    "cost_explore_interval": "30m",
+    "credit_floor": 0
+  },
+  "session_sticky": {
+    "enabled": true,
+    "ttl": "30m",
+    "gc_interval": "5m"
+  }
+}

config.example.json

@@ -1,84 +1,105 @@
-{
-  "listen": ":7863",
-  "api_key": "test_key",
-  "auth_dir": "./auths",
-  "state_file": "./data/state.json",
-  "panel": {
-    "package_detail_limit": 5
-  },
-  "logging": {
-    "request_archive_enabled": true,
-    "request_retention_days": 7,
-    "request_archive_max_mb": 100,
-    "request_client_info": true
-  },
-  "cooldown": {
-    "soft_rate": "600s",
-    "soft_rate_max": "2h"
-  },
-  "schedule": {
-    "checkin_hours": [9, 21],
-    "growth_hours": [1],
-    "travel_hours": [9, 21],
-    "activity_hours": [10],
-    "keepalive_hours": [22],
-    "blackcat_hours": [23],
-    "checkin_enabled": true,
-    "growth_enabled": true,
-    "travel_enabled": true,
-    "activity_enabled": true,
-    "keepalive_enabled": true,
-    "blackcat_enabled": true,
-    "balance_refresh_enabled": true,
-    "balance_refresh_minutes": 5
-  },
-  "global": {
-    "enabled": true,
-    "chat_base": "",
-    "billing_base": ""
-  },
-  "upstream": {
-    "timeout_seconds": 120,
-    "header_timeout_seconds": 120,
-    "idle_timeout_seconds": 300,
-    "user_agent": "",
-    "client_version": "",
-    "cli_version": "",
-    "client_name": "",
-    "device_token": "",
-    "device_token_file": "",
-    "passthrough_ip": false
-  },
-  "features": {
-    "sanitize_blacklist_fingerprints": true
-  },
-  "prompt": {
-    "mode": "passthrough",
-    "file": ""
-  },
-  "upstash": {
-    "url": "",
-    "token": ""
-  },
-  "pool": {
-    "max_in_flight": 3,
-    "max_in_flight_global": 2,
-    "breaker_threshold": 3,
-    "breaker_cooldown": "30m",
-    "breaker_cooldown_max": "6h",
-    "degrade_threshold": 5,
-    "degrade_cooldown": "10m",
-    "degrade_cooldown_max": "2h",
-    "idle_weight_per_hour": 0.5,
-    "idle_weight_max": 5.0,
-    "prefer_expiring": true,
-    "expiring_soon": "168h",
-    "cost_explore_interval": "30m",
-    "credit_floor": 100
-  },
-  "session_sticky": {
-    "enabled": true,
-    "ttl": "30m",
-    "gc_interval": "5m"
-  }
-}
+{
+  "listen": ":7863",
+  "api_key": "test_key",
+  "auth_dir": "./auths",
+  "state_file": "./data/state.json",
+  "server": {
+    "read_timeout": "300s"
+  },
+  "panel": {
+    "package_detail_limit": 5
+  },
+  "logging": {
+    "request_archive_enabled": true,
+    "request_retention_days": 7,
+    "request_archive_max_mb": 100,
+    "request_client_info": true
+  },
+  "cooldown": {
+    "soft_rate": "600s",
+    "soft_rate_max": "2h"
+  },
+  "schedule": {
+    "checkin_hours": [9, 21],
+    "growth_hours": [1],
+    "travel_hours": [9, 21],
+    "activity_hours": [10],
+    "keepalive_hours": [22],
+    "blackcat_hours": [23],
+    "checkin_enabled": true,
+    "growth_enabled": true,
+    "travel_enabled": true,
+    "activity_enabled": true,
+    "keepalive_enabled": true,
+    "blackcat_enabled": true,
+    "balance_refresh_enabled": true,
+    "balance_refresh_minutes": 5,
+    "include_disabled_in_tasks": false
+  },
+  "global": {
+    "enabled": true,
+    "chat_base": "",
+    "billing_base": ""
+  },
+  "upstream": {
+    "timeout_seconds": 120,
+    "header_timeout_seconds": 120,
+    "idle_timeout_seconds": 300,
+    "user_agent": "",
+    "client_version": "",
+    "cli_version": "",
+    "client_name": "",
+    "device_token": "",
+    "device_token_file": "",
+    "passthrough_ip": false
+  },
+  "features": {
+    "sanitize_blacklist_fingerprints": true
+  },
+  "prompt": {
+    "mode": "passthrough",
+    "file": ""
+  },
+  "upstash": {
+    "url": "",
+    "token": ""
+  },
+  "pool": {
+    "max_in_flight": 3,
+    "max_in_flight_global": 2,
+    "breaker_threshold": 3,
+    "breaker_cooldown": "30m",
+    "breaker_cooldown_max": "6h",
+    "degrade_threshold": 5,
+    "degrade_cooldown": "10m",
+    "degrade_cooldown_max": "2h",
+    "idle_weight_per_hour": 0.5,
+    "idle_weight_max": 5.0,
+    "prefer_expiring": true,
+    "expiring_soon": "168h",
+    "cost_explore_interval": "30m",
+    "credit_floor": 100
+  },
+  "session_sticky": {
+    "enabled": true,
+    "ttl": "30m",
+    "gc_interval": "5m"
+  },
+  "sync": {
+    "bucket": "",
+    "token": "",
+    "token_file": "",
+    "endpoint": "https://huggingface.co",
+    "auth_dir": "",
+    "data_dir": "",
+    "include_data": [],
+    "writer": "auto",
+    "hf_bin": "hf",
+    "relay_url": "",
+    "relay_key": "",
+    "restart_space": "",
+    "ca_bundle": "",
+    "timeout": "60s",
+    "insecure_skip_verify": false
+  }
+}

credit.sh

@@ -1,14 +1,14 @@
-#!/usr/bin/env bash
-# credit.sh — WorkBuddy 积分日报（默认美化输出）
-#
-# 用法:
-#   ./credit.sh            # 人类可读日报
-#   ./credit.sh -json      # 原始 JSON
-#
-# 二进制升级: go build -o credit ./cmd/credit
-set -euo pipefail
-cd "$(dirname "$0")"
-if [[ "${1:-}" == "-json" ]]; then
-    exec ./credit
-fi
-exec ./credit -pretty
+#!/usr/bin/env bash
+# credit.sh — WorkBuddy 积分日报（默认美化输出）
+#
+# 用法:
+#   ./credit.sh            # 人类可读日报
+#   ./credit.sh -json      # 原始 JSON
+#
+# 二进制升级: go build -o credit ./cmd/credit
+set -euo pipefail
+cd "$(dirname "$0")"
+if [[ "${1:-}" == "-json" ]]; then
+    exec ./credit
+fi
+exec ./credit -pretty

deploy/cloudflare-worker/.dev.vars.example

@@ -0,0 +1,24 @@
+# 本地开发用的变量样例 —— 复制为 .dev.vars 后填写真实值。
+#
+#   cp .dev.vars.example .dev.vars
+#
+# ⚠️ .dev.vars 里放的是真实密钥，**永远不要提交**。
+#    `.dev.vars.example`（本文件）只放占位值，可以进版本库。
+#
+# 线上环境不要用这个文件，改用：
+#   npx wrangler secret put WB2A_API_KEY
+#
+# 格式：KEY="value"，一行一个，不要加 export。
+
+# 源站（一般不用改，改 Space 时才动）
+ORIGIN="https://a3216-gcli2api.hf.space"
+
+# 保活探测路径
+HEALTH_PATH="/healthz"
+
+# 面板 / 网关的 Bearer 密钥。留空时 scheduled() 只做裸 ping，不发送鉴权请求。
+WB2A_API_KEY=""
+
+# —— 可选的带鉴权签到（默认关闭）——
+# CHECKIN_CRON="0 * * * *"
+# CHECKIN_PATH="/panel/api/keepalive"

deploy/cloudflare-worker/README.md

@@ -0,0 +1,350 @@
+# WorkBuddy2API — Cloudflare Worker：反代 + 保活
+
+把公网入口 `cli.3216gemini.dpdns.org` 反代到 Hugging Face Space
+`a3216/gcli2api`（直连域名 `https://a3216-gcli2api.hf.space`），
+并用 Cron 定时打 `/healthz`，防止 Space 被 HF 暂停。
+
+## 这个 Worker 做什么
+| 能力 | 说明 |
+|---|---|
+| 🔁 **全量反向代理** | 方法 / 路径 / query / 请求体 / 端到端请求头原样转发，源站的状态码、响应头、响应体原样回传 |
+| ⚡ **零缓冲流式** | 直接返回 `originResponse.body`，不调用 `.text()` / `.json()`。`POST /v1/chat/completions` 是 SSE 长连接，缓冲会直接毁掉流式体验 |
+| ↩️ **不吞后端 302** | `fetch(..., { redirect: 'manual' })`，所以 `GET /` → `/panel/` 的跳转是**浏览器**看到的，不会被 Worker 内部跟掉 |
+| 🌐 **CORS 全透传** | 后端已经返回宽松的 CORS 头，Worker 一律不自己造 `Access-Control-*`，避免出现重复头 |
+| 🧹 **逐跳头剥离** | 剥掉 `host` / `connection` / `keep-alive` / `transfer-encoding` / `upgrade` / `proxy-*` / `cf-*` / `x-forwarded-*`；`Host` 永远不会用公网域名转发过去 |
+| 🍪 **set-cookie 原样** | 不做 domain / path 改写，多条也完整保留 |
+| ⏰ **Cron 保活** | `scheduled()` 每 5 分钟 ping 一次源站 `/healthz`，25s 硬超时 + 失败重试 1 次 + 每次一行日志 |
+| 🛡️ **不抛异常** | Cron 处理器内部吞掉所有异常，不会污染 Cron 运行记录 |
+
+涉及的后端接口（都不需要 Worker 特殊处理，纯透传）：
+
+- `GET /healthz` → `{"healthy":2,"realm_servable":{...},"service":"workbuddy2api","total":3}`（无可服务账号时 503）
+- `GET /` → 302 → `/panel/`
+- `GET /panel/` → 单页管理面板
+- `/panel/api/*` → 面板 JSON API，需 `Authorization: Bearer <api_key>`
+- `POST /v1/chat/completions` → OpenAI 兼容，**SSE 流式**，需同一个 Bearer 密钥
+- `GET /v1/models`、`GET /status`
+
+## 为什么需要这个 Cron
+
+Hugging Face 免费 `cpu-basic` Space 有一条硬规则：**连续 48 小时没有任何 HTTP 流量就被暂停**，
+下一次访问要等 **30–60 秒**冷启动。
+
+所以「反代」和「保活」其实是同一件事的两半：反代提供入口，Cron 保证入口后面那台机器不会睡着。
+只要有任意 HTTP 请求打到 Space，HF 的闲置计时器就会归零——**响应内容是什么完全不影响判断**，
+这就是为什么一次裸的 `GET /healthz` 就够了。
+
+## ⚠️ 接管前必读：现有入口的 `/healthz` 是 Cloudflare 自己应答的
+
+同一时刻实测对比：
+
+| 目标 | `/healthz` 响应 | 判据 |
+| --- | --- | --- |
+| `https://a3216-gcli2api.hf.space/healthz` | `{"healthy":2,…,"service":"workbuddy2api"}` | 带 `x-service`、`x-proxied-replica`，以及 HF 的 `link: …/spaces/a3216/gcli2api` 头 |
+| `https://cli.3216gemini.dpdns.org/healthz` | **`ok`（2 字节）** | 只有 `cf-ray`；**没有** `x-service`、**没有** `link` |
+
+**结论：现有入口把 `/healthz` 短路了，请求根本没到 Space。** 很可能是故意的 ——
+避免探活 / 监控 / 负载均衡把 30~60s 冷启动打起来。它只短路了这一个路径：
+`/status`、`/panel/*` 等仍是透传的（两边都带 HF 的 `link` 头，可自证）。
+
+两个直接后果：
+
+1. **千万别拿 `cli.3216gemini.dpdns.org/healthz` 做保活。** 它会稳定返回 200、
+   看起来一切健康，但 Space 完全没被唤醒 —— 48 小时一到照样被暂停。
+   保活必须打 Space 的直连域名（见仓库根的 `.github/workflows/space-keepalive.yml`）。
+2. **本 Worker 接管路由后，`/healthz` 的行为会变**：它会把 `/healthz` 原样透传给 Space，
+   于是返回的是网关 JSON 而不是 `ok`。对"真探活"来说这是**更正确**的
+   （能反映账号可用性），但如果你有监控依赖那个 `ok`，请先调整它。
+   想让本 Worker 也短路 `/healthz`，在 `worker.js` 的 `fetch()` 里加一条早返回即可。
+
+## ⚠️ 免费版只有 5 个 Cron（最容易踩的坑）
+
+**Cloudflare 免费版的 cron 触发器限制是「每个账号 5 个」，不是每个 Worker 5 个。**
+如果你账号里别的 Worker 已经占了 5 个，再部署本 Worker 就会看到这种**半成功**：
+
+```text
+Uploaded workbuddy2api-hf-proxy (1.63 sec)
+Deployed workbuddy2api-hf-proxy triggers (1.62 sec)
+✘ [ERROR] Trigger configuration for "workbuddy2api-hf-proxy" was only partially updated:
+    Cron schedules: ... failed.
+    - This account has reached the Workers Free limit of 5 cron triggers per account.
+      [code: 10072]
+  Successful trigger changes were not rolled back.
+```
+
+**怎么读这段**：Worker 的**代码确实上传成功了**，但 **cron 没加上**，而且
+"Successful trigger changes were not rolled back" 只是说"已成功的部分不回滚"。
+结果是这个 Worker 处于**空转**状态——没有 cron，它不会去唤醒任何人。
+（`*  *  *  *  *` 这种多行 crons 数组里**每一行都算一个**触发器，别写成 5 行。）
+
+两条出路：
+
+### 出路 A：腾一个 CF cron 名额（保持 CF 原生方案）
+
+Dashboard → Workers & Pages → **逐个 Worker** 看 Settings → Triggers → Cron Triggers，
+找出已经不用的那个删掉，然后重新 `npx wrangler deploy`。
+
+想用 API 一次性列全账号的 cron（需要 `CLOUDFLARE_API_TOKEN`，权限含 *Workers Scripts:Read*）：
+
+```bash
+ACC=a75c5f86fdd1b75eb3e860f5436a7970        # 你的 account id
+for w in $(curl -s "https://api.cloudflare.com/client/v4/accounts/$ACC/workers/scripts" \
+            -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" | jq -r '.result[].id'); do
+  echo "== $w"
+  curl -s "https://api.cloudflare.com/client/v4/accounts/$ACC/workers/scripts/$w/schedules" \
+    -H "Authorization: Bearer $CLOUDFLARE_API_TOKEN" | jq -c '.result.schedules'
+done
+```
+
+### 出路 B：改用 GitHub Actions（**推荐，无数量限制**）
+
+本仓库自带 `.github/workflows/space-keepalive.yml`，每 6 小时 ping 一次 Space，
+零成本、不占 CF 名额。**而且 6 小时一次完全够用**——HF 的判定阈值是 48 小时，
+所以 GitHub 定时任务偶发延迟几十分钟毫无影响（反过来说，本 Worker 里 `*/5` 的
+5 分钟粒度其实是**严重过量**的，纯粹因为免费额度够用才这么写）。
+
+两条路不冲突：Worker 留着做反代，保活交给 Actions 也完全可以。
+
+## 部署
+
+> **先看上一节**：如果你账号的 5 个 cron 名额已满，`wrangler deploy` 会报 `code: 10072`，
+> 这时按「出路 A/B」处理。
+
+### 1. 前置条件
+
+```bash
+node -v            # 需要 Node 18+
+npx wrangler -v    # 首次会提示安装 wrangler
+npx wrangler login # 登录你的 Cloudflare 账号
+```
+
+### 2. 部署
+
+```bash
+cd D:\workbuddy2api-panel\deploy\cloudflare-worker
+npx wrangler deploy
+```
+
+部署成功后 Worker 名称为 `workbuddy2api-hf-proxy`（见 `wrangler.toml` 的 `name`）。
+
+### 3. 接线路由
+
+`wrangler.toml` 里的 `routes` **默认是注释掉的**，两种接法任选其一：
+
+- **A. 交给 wrangler**：取消 `routes` 注释后重新 `wrangler deploy`，路由自动创建；
+- **B. 在 Dashboard 手动加**：Workers → 你的 Worker → Settings → Domains & Routes →
+  添加 `cli.3216gemini.dpdns.org/*`（推荐，避免误删线上路由）。
+
+> ⚠️ 启用路由前确认该主机名当前没有指向别处的「已代理」DNS 记录，
+> 否则 Worker 路由和 DNS 记录会互相打架。正确做法是该主机名由 Worker 路由接管
+> （DNS 里留一条指向 `100::` 的 AAAA 占位记录）。
+
+### 4. 设置密钥（可选）
+
+只有开启「可选唤醒/签到」时才需要。**密钥永远不要写进 `wrangler.toml`，也不要提交。**
+
+```bash
+npx wrangler secret put WB2A_API_KEY
+# 粘贴网关的 api_key（与面板登录用的是同一个），回车即可
+```
+
+未设置时 `scheduled()` 只做 `/healthz` 裸 ping，不发送任何鉴权请求。
+
+## 验证
+
+> **先接路由再验**：下面这些 URL 打的是 `cli.3216gemini.dpdns.org`，只有在该主机名已经
+> 路由到本 Worker 时才是"在验 Worker"。没接路由的话，你验到的仍是原来的链路。
+>
+> **`*.workers.dev` 在部分网络下不可用**（国内常见：DNS 被污染，解析到不相干的 IP、
+> 443 不通）。所以 `wrangler deploy` 打印的 `https://<worker>.<sub>.workers.dev`
+> 在你这里可能**根本连不上**——这**不代表部署失败**，用自定义域名的路由来验即可。
+
+```bash
+# 探活：能看到网关自己的 JSON，且带 total / service 字段
+curl -i https://cli.3216gemini.dpdns.org/healthz
+
+# 后端自带的 302 应该原样到达客户端（不要出现 -L 跟随）
+curl -i https://cli.3216gemini.dpdns.org/
+
+# 面板
+curl -I https://cli.3216gemini.dpdns.org/panel/
+
+# 流式：应逐块吐出，而不是憋到最后一次性返回
+curl -N -H "Authorization: Bearer <api_key>" \
+     -H "Content-Type: application/json" \
+     -d '{"model":"deepseek-v4-flash","stream":true,"messages":[{"role":"user","content":"hi"}]}' \
+     https://cli.3216gemini.dpdns.org/v1/chat/completions
+```
+
+看到 `server: cloudflare` 与 `cf-ray` 属正常——那是 Cloudflare 边缘加的，不代表后端没响应；
+后端的响应头（如 `service`、`x-*`）应当同时原样出现。
+
+## 看日志
+
+```bash
+cd D:\workbuddy2api-panel\deploy\cloudflare-worker
+npx wrangler tail                     # 实时请求日志
+npx wrangler tail --format pretty     # 人类可读格式
+```
+
+> **`wrangler tail` 报 `Error: Unexpected server response: 400`？**
+> 它走的是 WebSocket，经过本地抓包代理（DevSidecar / Reqable 之类）时经常被挡掉。
+> 换成这几条路即可：
+>
+> - Dashboard → Workers & Pages → 你的 Worker → **Logs** → Live / Cron Events（最省事）；
+> - 关掉代理再 `npx wrangler tail`；
+> - 或者干脆不依赖 tail：Cron 有没有在跑��**看 Space 的 `last_checkin_day` 有没有变成当天**
+>   最直接（桶里的 `data/state.json`），或看 `npx wrangler deployments list` 的更新时间。
+
+Cron 每次运行会打一行：
+
+```
+[keepalive] 2025-01-01T00:05:03.412Z /healthz -> HTTP 200 (183ms)
+```
+
+失败时是 `warn` 级别，同时带上首次失败原因，便于区分「偶发抖动」和「真的没醒」：
+
+```
+[keepalive] 2025-01-01T00:05:03.412Z /healthz -> FAILED status=0 (25013ms) first=ping timeout detail=ping timeout
+```
+
+### Cron 粒度说明
+
+- `[triggers] crons = ["*/5 * * * *"]` = 每 5 分钟一次，**这是 Cloudflare Cron Triggers 的最小粒度**（不支持每分钟）；
+- 频率换算：每 5 分钟 ≈ 288 次/天，对比 48 小时暂停阈值，余量极大；
+- Cron 触发时间有**秒级抖动**（官方说明可能延迟数秒到数十秒），对保活完全无影响；
+- 如果只是防休眠，**不需要再加密**；调成 `*/30` 之类也够用，但 5 分钟最稳。
+
+## 本地调试
+
+**推荐：先用 `dev-server.mjs` 把代理逻辑验完，再考虑 deploy。** 它用 Node 起一个本地服务，
+**原样 `import` 这个 worker.js**（不做任何改写），转发到真实的 HF Space——不需要 wrangler、
+不需要登录：
+
+```bash
+cd deploy/cloudflare-worker
+node dev-server.mjs                 # 监听 127.0.0.1:8787
+# PORT=9000 node dev-server.mjs     # 换端口
+# ORIGIN=https://other.hf.space node dev-server.mjs
+```
+
+另开一个终端逐条验：
+
+```bash
+curl -i http://127.0.0.1:8787/           # 期望 302 → /panel/（不要加 -L）
+curl -i http://127.0.0.1:8787/healthz    # 期望网关自己的 JSON（带 total / service）
+curl -i http://127.0.0.1:8787/status     # 期望 401 invalid_api_key（说明真的打到了网关）
+curl -s  http://127.0.0.1:8787/__cron    # 手动跑一次保活定时器，看控制台日志
+```
+
+`/__ping` 与 `/__cron` 是**本地专用**路径，永远不会被代理到源站，部署后的 Worker 里没有它们。
+
+也可以走 wrangler（需要它自己的本地环境）：
+
+```bash
+npx wrangler dev
+curl "http://localhost:8787/__scheduled?cron=*/5+*+*+*+*"   # 临时触发 Cron 处理器
+```
+
+### `.dev.vars`
+
+本地调试需要的变量（尤其是 `WB2A_API_KEY`）放在同目录 `.dev.vars` 里，**不要提交**：
+
+```bash
+cp .dev.vars.example .dev.vars   # 然后按需填写
+```
+
+格式为 `KEY="value"`，一行一个。`wrangler dev` 会自动读取该文件中的变量与密钥。
+
+> ✅ **`.gitignore` 已经覆盖到位**（根目录规则）：`.dev.vars` / `.dev.vars.*` / `.wrangler/`
+> 全部被忽略，同时用 `!.dev.vars.example` 把**模板**放回版本库（模板里只有占位符）。
+> 四个可提交文件：`worker.js`、`wrangler.toml`、`.dev.vars.example`、本 `README.md`。
+>
+> **任何 secret 都不得提交**，线上一律走 `wrangler secret put`。
+
+## 环境变量一览
+
+| 名称 | 类型 | 默认值 | 说明 |
+|---|---|---|---|
+| `ORIGIN` | vars | `https://a3216-gcli2api.hf.space` | 源站地址。换 Space 只改这里 |
+| `ROOT_REDIRECT` | vars（注释中） | `/panel/` | `GET /` 的跳转目标；设成空串则关闭跳转、直接透传后端的 404 |
+| `HEALTH_PATH` | vars（注释中） | `/healthz` | 保活探测路径 |
+| `CHECKIN_CRON` | vars（注释中） | 空 = 关闭 | 只在此 Cron 表达式触发时做签到 |
+| `CHECKIN_PATH` | vars（注释中） | 空 = 关闭 | 带 Bearer 调用的路径，如 `/panel/api/keepalive` |
+| `WB2A_API_KEY` | **secret** | 未设置 | 面板/网关 Bearer 密钥，仅签到功能需要 |
+
+> `ORIGIN` 若填成非法 URL，Worker 会**回落到默认源站**而不是整体 500——配置拼错时仍能提供服务。
+
+## 如果你已有自己的反代 Worker
+
+**不要替换掉你现有的反代逻辑**，只把「保活」那一小块搬过去即可，改动量极小：
+
+1. **加 `scheduled()` 处理器**：从 `worker.js` 里复制 `scheduled(event, env, ctx)` 整个函数，
+   连同它依赖的 `DEFAULT_ORIGIN` / `HEALTH_PATH` / `PING_TIMEOUT_MS` / `PING_RETRY_DELAY_MS`
+   常量、`resolveOrigin()` / `normalizePath()` 两个工具函数一起拿走。
+   （可选签到那段如果不需要，连同 `CHECKIN_*` 一起删掉即可。）
+2. **确认你的默认导出里有 `scheduled`**：必须是
+   `export default { fetch(request, env, ctx) {...}, scheduled(event, env, ctx) {...} }` 这种形状。
+   如果你原来是 `export default { async fetch(...) }`，直接把 `scheduled` 加进同一个对象即可，
+   **不要**改成 `export { scheduled }` 之外的写法。
+3. **在 `wrangler.toml` 加上 trigger 块**：
+
+   ```toml
+   [triggers]
+   crons = ["*/5 * * * *"]
+   ```
+
+4. **重新部署**：`npx wrangler deploy`。改 `[triggers]` 必须重新部署才会生效，
+   只改 Dashboard 里的 Cron 是临时的、下次部署会被覆盖。
+
+反代部分如果你已经有实现，**保持原样**——本 Worker 的 `fetch()` 只是一个满足
+「不��冲 / 不跟随 302 / 剥离逐跳头 / 透传 CORS」四条硬约束的参考实现，
+你的版本只要满足同样四条，效果完全等价。
+
+## 常见问题
+
+### 代理后 `/v1/chat/completions` 变成一次性返回，没有流式效果？
+
+几乎一定是某处调用了 `await res.text()` / `res.json()` / 中间做了缓冲（包括自己包一层
+`TransformStream` 却忘了 flush）。确认直接 `return new Response(originResponse.body, ...)`。
+
+### `GET /` 返回的是 `/panel/` 的内容，看不到 302？
+
+说明 `fetch` 的 `redirect: 'manual'` 丢了。默认的 `redirect: 'follow'` 会在 Worker 内部
+把 302 跟掉，客户端就永远看不到那次跳转。
+
+### `GET /` 到底该返回 302 还是后端原始的 404？
+
+**302 → `/panel/`。** 这是实测出来的既有行为，值得记一笔：网关只注册了 `/panel/`，
+所以**直连 Space 的 `GET /` 是 404**；但公网入口 `https://cli.3216gemini.dpdns.org/`
+返回的却是 302 → `/panel/`。同一路径两种结果，说明这层跳转是 **CF 侧加的**（Worker 或
+Redirect Rule）。`worker.js` 因此也自带了这个跳转（`ROOT_REDIRECT`，默认 `/panel/`），
+换用本 Worker 后直接打开域名首页的体验不变。
+
+想对比两种行为：
+
+```bash
+curl -i https://a3216-gcli2api.hf.space/     # 404（后端真实行为）
+curl -i https://cli.3216gemini.dpdns.org/    # 302 → /panel/（入口层加的）
+```
+
+想把跳转关掉（严格透传后端）：把 `ROOT_REDIRECT` 设成空串。
+
+### 浏览器报 CORS 重复头错误？
+
+Worker 自己造了 `Access-Control-Allow-Origin`，而后端也返回了同一个头。
+删掉 Worker 里的 CORS 处理，让它纯透传。
+
+### Cron 日志里一直是 503，是不是保活失败了？
+
+**不是。** 503 是后端「当前没有可用账号可服务」的业务语义，但只要它回了 HTTP，
+Space 就是醒着的，保活目的已经达到。只有 `status=0`（超时/网络失败）才需要关注——
+那通常意味着正在冷启动，或者 Space 真的挂了。
+
+### 想确认 Cron 到底有没有在跑？
+
+```bash
+npx wrangler tail --format pretty     # 等 5 分钟就能看到 [keepalive] 行
+```
+
+或者 Dashboard → Workers → 你的 Worker → Logs → 筛选 Cron Events。

deploy/cloudflare-worker/dev-server.mjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/**
+ * worker.js 本地开发/验证服务器。
+ *
+ * 为什么需要它：Worker 只有在部署到 Cloudflare 之后才会真正接管
+ * cli.3216gemini.dpdns.org —— 万一代理逻辑写错，你的域名当场就废了。
+ * 这个脚本用 Node 起一个本地 HTTP 服务，**原样执行同一个 worker.js**
+ * （直接 import，不做任何改写），把它转发到真实的 HF Space，
+ * 于是你可以在本地先把每一条路径验完，再决定要不要 deploy。
+ *
+ * 用法：
+ *   node dev-server.mjs                 # 监听 127.0.0.1:8787
+ *   PORT=9000 node dev-server.mjs
+ *   ORIGIN=https://other-space.hf.space node dev-server.mjs
+ *
+ * 然后另开一个终端：
+ *   curl -i http://127.0.0.1:8787/healthz      # 应返回网关的 JSON
+ *   curl -i http://127.0.0.1:8787/             # 应是 302 → /panel/（不被跟随）
+ *   curl -s http://127.0.0.1:8787/__cron       # 手动跑一次保活定时器（看日志）
+ *
+ * 注意：
+ *   - 本脚本会真实请求 HF Space。若 Space 正在休眠，第一次 /healthz 会等
+ *     30~60s 冷启动，这是正常现象（也正是 cron 保活要解决的问题）。
+ *   - /__cron 是本地专用路径，永远不会被代理到源站，部署后的 Worker 里没有它。
+ *   - 绝不把 .dev.vars 提交进版本库（见同目录 README）。
+ */
+
+import http from "node:http";
+import { Readable } from "node:stream";
+import worker from "./worker.js";
+
+const PORT = Number(process.env.PORT || 8787);
+const HOST = process.env.HOST || "127.0.0.1";
+const CRON = process.env.CRON || "*/5 * * * *";
+
+/** 把 Node 的 IncomingMessage 头转成 Web Headers。 */
+function toWebHeaders(nodeHeaders) {
+  const h = new Headers();
+  for (const [name, value] of Object.entries(nodeHeaders)) {
+    if (value === undefined) continue;
+    if (Array.isArray(value)) {
+      for (const v of value) h.append(name, v);
+    } else {
+      h.set(name, value);
+    }
+  }
+  return h;
+}
+
+const server = http.createServer(async (req, res) => {
+  try {
+    exphost: {
+      // 本地专用：手动触发一次 scheduled()，用来验证保活/重试/日志逻辑。
+      if (req.url === "/__cron") {
+        console.log(`[dev] 手动触发 scheduled() cron="${CRON}"`);
+        await worker.scheduled({ cron: CRON }, process.env, {});
+        res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({ ok: true, triggered: CRON }, null, 2) + "\n");
+        break exphost;
+      }
+
+      // 本地专用：探活，不会打到源站。
+      if (req.url === "/__ping") {
+        res.writeHead(200, { "content-type": "text/plain" });
+        res.end("dev-server alive\n");
+        break exphost;
+      }
+
+      const url = new URL(req.url, `http://${HOST}:${PORT}`);
+      const hasBody = req.method !== "GET" && req.method !== "HEAD";
+
+      // Node 要求流式请求体显式声明 duplex:"half"；Cloudflare Workers 不需要，
+      // 所以这个参数只在这里出现，worker.js 本身保持平台无关。
+      const request = new Request(url, {
+        method: req.method,
+        headers: toWebHeaders(req.headers),
+        body: hasBody ? req : undefined,
+        duplex: hasBody ? "half" : undefined,
+        redirect: "manual",
+      });
+
+      const response = await worker.fetch(request, process.env, {});
+
+      const outHeaders = {};
+      for (const [k, v] of response.headers) outHeaders[k] = v;
+      res.writeHead(response.status, outHeaders);
+
+      if (response.body) {
+        // 关键：流式回传，不缓冲 —— SSE 必须这样，否则流式体验当场报废。
+        await new Promise((resolve, reject) => {
+          Readable.fromWeb(response.body).pipe(res).on("finish", resolve).on("error", reject);
+        });
+      } else {
+        res.end();
+      }
+    }
+  } catch (err) {
+    console.error("[dev] 处理请求失败:", err);
+    if (!res.headersSent) {
+      res.writeHead(502, { "content-type": "application/json; charset=utf-8" });
+    }
+    res.end(JSON.stringify({ error: "dev_server_error", detail: String(err && err.message) }) + "\n");
+  }
+});
+
+server.listen(PORT, HOST, () => {
+  console.log(`[dev] worker.js 本地验证服务: http://${HOST}:${PORT}`);
+  console.log(`[dev] 源站 ORIGIN = ${process.env.ORIGIN || "(默认 https://a3216-gcli2api.hf.space)"}`);
+  console.log("[dev] 试试:");
+  console.log(`[dev]   curl -i http://${HOST}:${PORT}/healthz`);
+  console.log(`[dev]   curl -i http://${HOST}:${PORT}/`);
+  console.log(`[dev]   curl -s http://${HOST}:${PORT}/__cron`);
+});

deploy/cloudflare-worker/worker.js

@@ -0,0 +1,347 @@
+/**
+ * WorkBuddy2API — Cloudflare Worker：Hugging Face Space 反向代理 + 定时保活
+ *
+ * 作用有两个，缺一不可：
+ *   1. 反代：把 https://cli.3216gemini.dpdns.org/* 的流量原样转发到 HF Space
+ *      （默认 https://a3216-gcli2api.hf.space，可用 ORIGIN 变量覆盖），
+ *      方法 / 路径 / query / 请求体 / 端到端请求头全部保留，
+ *      响应状态码、响应头、响应体原样回传。
+ *   2. 保活：HF 免费 cpu-basic Space 连续 48 小时没有 HTTP 流量就会被暂停，
+ *      冷启动要 30–60s。scheduled() 定时打一次 /healthz 就能避免被暂停。
+ *
+ * 关键实现约束（改动前请先读懂）：
+ *   - 响应用 `return originResponse.body` 直接流式回传，绝不对代理响应调用
+ *     .text() / .json() / .arrayBuffer()——一旦缓冲，/v1/chat/completions 的
+ *     SSE 流就会退化成"憋完再吐"，流式体验当场报废。
+ *   - fetch 必须带 `redirect: 'manual'`。后端的 `GET /` 返回 302 到 /panel/，
+ *     这是给浏览器的，不能在 Worker 内部被跟随掉。
+ *   - Host 头不能被转发（Workers 里 Host 由 URL 决定）；同时去掉逐跳头，
+ *     否则 Cloudflare 会拒绝或产生"重复头"类的诡异问题。
+ *   - CORS 全部透传后端的：后端（ASP.NET/Kestrel）已经返回宽松的 CORS 头，
+ *     Worker 一律不要自己造 Access-Control-*，否则会出现重复头把浏览器搞挂。
+ *   - set-cookie 原样透传（浏览器看的是公网域名，后端很少下发 cookie）。
+ *
+ * 部署：见同目录 README.md 与 wrangler.toml。
+ * 作者备注：本文件刻意保持零依赖、单文件，方便直接贴进已有反代 Worker。
+ */
+
+/**
+ * 默认源站：HF Space 的直连域名。
+ * 与 Space 名 a3216/gcli2api 对应（下划线在 HF 域名里写作连字符）。
+ */
+const DEFAULT_ORIGIN = "https://a3216-gcli2api.hf.space";
+
+/** 保活探测路径：/healthz 是网关自带的探活端点，无鉴权、开销最小。 */
+const HEALTH_PATH = "/healthz";
+
+/** 单次保活请求的硬超时（ms）。冷启动时 503/超时都属正常，必须能快速失败。 */
+const PING_TIMEOUT_MS = 25_000;
+
+/** 首次失败后的重试间隔（ms）。 */
+const PING_RETRY_DELAY_MS = 3_000;
+
+/**
+ * 根路径跳转目标。
+ *
+ * 为什么需要这个：网关只注册了 `/panel/`，`GET /` 在它那里是 404。而现有入口
+ * `https://cli.3216gemini.dpdns.org/` 实测返回 **302 → /panel/**（实测对比：
+ * 直连 Space 的 `/` 是 404，公网域名却是 302 —— 说明这层跳转是 CF 侧加的）。
+ * 换用本 Worker 后如果不复刻，直接打开域名首页就会从"进入面板"变成"404 页"。
+ * 设为空字符串即可关掉。
+ */
+const DEFAULT_ROOT_REDIRECT = "/panel/";
+
+/**
+ * 逐跳头 + 宿主相关头，禁止转发到源站，也禁止从源站回传给客户端。
+ * 取值范围：RFC 7230 的 hop-by-hop 头 + Workers 运行时自带的 cf-* 头 + host。
+ * 统一小写比较。
+ */
+const STRIP_HEADERS = new Set([
+  "host",
+  "connection",
+  "keep-alive",
+  "transfer-encoding",
+  "upgrade",
+  "proxy-connection",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "http2-settings",
+  "cf-connecting-ip",
+  "cf-connecting-ipv6",
+  "cf-ipcountry",
+  "cf-ray",
+  "cf-visitor",
+  "cf-worker",
+  "cf-ew-via",
+  "cf-pseudo-ipv4",
+  "cdn-loop",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-real-ip",
+]);
+
+/**
+ * 判断一个头名是否要被剥掉。
+ * 除白名单外，再兜掉所有 `proxy-` / `cf-` / `x-forwarded-` 前缀的头——逐跳语义
+ * 的扩展头基本都长这样，逐个列举容易漏。
+ */
+function shouldStripHeader(name) {
+  const lower = name.toLowerCase();
+  if (STRIP_HEADERS.has(lower)) return true;
+  if (lower.startsWith("proxy-")) return true;
+  if (lower.startsWith("cf-")) return true;
+  if (lower.startsWith("x-forwarded-")) return true;
+  return false;
+}
+
+/** 过滤一组 Headers，返回新的 Headers。 */
+function sanitizeHeaders(headers) {
+  const out = new Headers();
+  for (const [name, value] of headers) {
+    if (shouldStripHeader(name)) continue;
+    // append 而不是 set：set-cookie 可能有多条，set 会互相覆盖。
+    out.append(name, value);
+  }
+  return out;
+}
+
+/**
+ * 把入站请求的 URL 映射到源站 URL。
+ * 只保留 path + search，绝不把公网 Host 带过去——源站只认自己的域名。
+ */
+function buildOriginUrl(origin, requestUrl) {
+  const incoming = new URL(requestUrl);
+  const base = origin.endsWith("/") ? origin.slice(0, -1) : origin;
+  return base + incoming.pathname + incoming.search;
+}
+
+/** 解析 ORIGIN 变量；非法值回落到默认源站，避免整个 Worker 因配置拼错而 500。 */
+function resolveOrigin(env) {
+  const raw = env && typeof env.ORIGIN === "string" ? env.ORIGIN.trim() : "";
+  if (!raw) return DEFAULT_ORIGIN;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return DEFAULT_ORIGIN;
+    }
+    return parsed.origin;
+  } catch {
+    return DEFAULT_ORIGIN;
+  }
+}
+
+/** 归一化可选的唤醒/签到路径：允许 "healthz"、"//healthz"、"/healthz"。 */
+function normalizePath(rawPath) {
+  const trimmed = String(rawPath || "").trim();
+  if (!trimmed) return "";
+  return trimmed.startsWith("/") ? trimmed : "/" + trimmed;
+}
+
+export default {
+  /**
+   * 全量反向代理。
+   *
+   * 注意 `fetch(request, { redirect: 'manual' })`：这里直接把 Request 对象交给
+   * Cloudflare 的 fetch，但 URL 已经被改写成源站域名。因为 Request 的 URL 是
+   * 不可变的，需要先 new Request 出来再传。
+   */
+  async fetch(request, env, ctx) {
+    const origin = resolveOrigin(env);
+
+    // 根路径跳转：复刻现有入口的行为（见 DEFAULT_ROOT_REDIRECT 的说明）。
+    // env.ROOT_REDIRECT 可以改目标；显式设成空串则关闭，直接透传。
+    const rootRedirect =
+      env && typeof env.ROOT_REDIRECT === "string"
+        ? env.ROOT_REDIRECT.trim()
+        : DEFAULT_ROOT_REDIRECT;
+    if (rootRedirect) {
+      const incoming = new URL(request.url);
+      if (incoming.pathname === "/" && (request.method === "GET" || request.method === "HEAD")) {
+        const target = rootRedirect + incoming.search;
+        return new Response(null, {
+          status: 302,
+          headers: { location: target, "cache-control": "no-store" },
+        });
+      }
+    }
+
+    const targetUrl = buildOriginUrl(origin, request.url);
+
+    // 构造转发请求：保留方法、请求体（stream 形式透传，不读进内存）、
+    // 过滤后的端到端请求头。Authorization / Content-Type / Accept 等全部保留。
+    const forwardHeaders = sanitizeHeaders(request.headers);
+
+    // 把访客真实 IP 补回去。上面按逐跳规则剥掉了全部 cf-*，其中就包括
+    // CF-Connecting-IP——而网关的「运行日志 / 请求归档」是按
+    // X-Forwarded-For 首段 → X-Real-IP → TCP 对端 的顺序取来源 IP 的，
+    // 三段全被剥掉后，面板里所有调用来源都会显示成 HF 边缘节点，排障时没法看。
+    // 这里在过滤之后显式补成网关认的那两个头（不要补 CF-Connecting-IP 本身，
+    // 它会在经过 HF 边缘时被覆盖掉）。
+    const visitorIP = request.headers.get("cf-connecting-ip");
+    if (visitorIP) {
+      forwardHeaders.set("x-forwarded-for", visitorIP);
+      forwardHeaders.set("x-real-ip", visitorIP);
+    }
+
+    const outbound = new Request(targetUrl, {
+      method: request.method,
+      headers: forwardHeaders,
+      // GET / HEAD 不允许带 body，其余一律流式透传。
+      body:
+        request.method === "GET" || request.method === "HEAD"
+          ? undefined
+          : request.body,
+      redirect: "manual",
+    });
+
+    let originResponse;
+    try {
+      originResponse = await fetch(outbound);
+    } catch (err) {
+      // 源站不可达 / 握手失败。给一个明确的 502，附带便于排查的提示，
+      // 不要把它伪装成后端的错误响应。
+      const detail = err && err.message ? err.message : String(err);
+      return new Response(
+        JSON.stringify({
+          error: "bad_gateway",
+          message: "上游 Hugging Face Space 不可达（可能正在冷启动，30–60s 后重试）",
+          origin,
+          detail,
+        }) + "\n",
+        {
+          status: 502,
+          headers: { "content-type": "application/json; charset=utf-8" },
+        },
+      );
+    }
+
+    // 响应头同样过滤逐跳头；set-cookie 原样保留（可能多条，append 保证不丢）。
+    const responseHeaders = sanitizeHeaders(originResponse.headers);
+
+    // 关键：body 直接流式回传，不做任何缓冲。SSE 就必须这样。
+    return new Response(originResponse.body, {
+      status: originResponse.status,
+      statusText: originResponse.statusText,
+      headers: responseHeaders,
+    });
+  },
+
+  /**
+   * 定时保活：击败 HF 免费 Space 的 48 小时无流量暂停。
+   *
+   * 行为：
+   *   - 打 ORIGIN + /healthz（可用 env.HEALTH_PATH 覆盖）；
+   *   - 25s 硬超时（AbortController）——冷启动期间 503 或超时都算预期；
+   *   - 失败后等 3s 重试一次；
+   *   - 每次运行只打一行日志：时间 / 状态 / 耗时；
+   *   - 任何异常都在内部吞掉：绝不从 scheduled 抛出（抛了也只会污染 Cron 日志）。
+   *
+   * 可选（默认关闭）：当 WB2A_API_KEY 已设置、且本次 Cron 触发带了签到标记时，
+   * 额外对 env.CHECKIN_PATH 发一次带 Bearer 的 POST。
+   * 一般来说根本不必要——裸 ping /healthz 就足以阻止 Space 休眠，因为 HF 只看
+   * "有没有 HTTP 请求"，不关心响应内容。只有当 Space 自身存在"需要主动调用才
+   * 会真正醒来"的业务逻辑时，才需要打开它。
+   */
+  async scheduled(event, env, ctx) {
+    const origin = resolveOrigin(env);
+    const healthPath = normalizePath(env && env.HEALTH_PATH) || HEALTH_PATH;
+
+    const attempt = async () => {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort("ping timeout"), PING_TIMEOUT_MS);
+      const startedAt = Date.now();
+      try {
+        const res = await fetch(origin + healthPath, {
+          method: "GET",
+          // 不让 Cloudflare 边缘缓存探活结果，否则 Space 可能返回 200 但其实没人打到它。
+          cache: "no-store",
+          redirect: "manual",
+          signal: controller.signal,
+          headers: {
+            "user-agent": "WorkBuddy2API-KeepAlive/1.0 (+cloudflare-worker-cron)",
+            accept: "*/*",
+          },
+        });
+        return { ok: true, status: res.status, ms: Date.now() - startedAt };
+      } catch (err) {
+        const detail = err && err.message ? err.message : String(err);
+        return { ok: false, status: 0, ms: Date.now() - startedAt, detail };
+      } finally {
+        clearTimeout(timer);
+      }
+    };
+
+    let result = await attempt();
+    if (!result.ok || result.status >= 500) {
+      // 503 是网关"没有可用账号可服务"的语义，对保活而言无所谓——
+      // 只要它回了 HTTP，Space 就是醒着的。但 5xx / 网络失败仍重试一次，
+      // 用来区分"偶发抖动"和"确实没醒"。
+      await new Promise((resolve) => setTimeout(resolve, PING_RETRY_DELAY_MS));
+      const retry = await attempt();
+      result = {
+        ...retry,
+        // 首次失败原因在日志里一并带上，方便判断是不是冷启动。
+        firstAttempt: result.detail || `HTTP ${result.status}`,
+      };
+    }
+
+    const stamp = new Date().toISOString();
+    if (result.ok && result.status < 500) {
+      console.log(
+        `[keepalive] ${stamp} ${healthPath} -> HTTP ${result.status} (${result.ms}ms)`,
+      );
+    } else {
+      console.warn(
+        `[keepalive] ${stamp} ${healthPath} -> FAILED status=${result.status} ` +
+          `(${result.ms}ms) first=${result.firstAttempt || "-"} detail=${result.detail || "-"}`,
+      );
+    }
+
+    // —— 可选的带鉴权签到（默认关闭）——
+    // 开启条件三选三：设了 WB2A_API_KEY、设了 CHECKIN_PATH、且本次触发带标记。
+    // 标记来源是 wrangler.toml 里给 Cron 表达式加的注释式约定（见该文件），
+    // 这里用 event.cron 与 env.CHECKIN_CRON 匹配；不配就永远不触发。
+    const apiKey = env && env.WB2A_API_KEY;
+    const checkinPath = normalizePath(env && env.CHECKIN_PATH);
+    const cronExpr = event && typeof event.cron === "string" ? event.cron : "";
+    const checkinCron = env && env.CHECKIN_CRON ? String(env.CHECKIN_CRON) : "";
+
+    if (!apiKey || !checkinPath || !checkinCron || cronExpr !== checkinCron) {
+      return;
+    }
+
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort("checkin timeout"), PING_TIMEOUT_MS);
+    const startedAt = Date.now();
+    try {
+      const res = await fetch(origin + checkinPath, {
+        method: "POST",
+        cache: "no-store",
+        redirect: "manual",
+        signal: controller.signal,
+        headers: {
+          authorization: `Bearer ${apiKey}`,
+          "content-type": "application/json",
+          "user-agent": "WorkBuddy2API-KeepAlive/1.0 (+cloudflare-worker-cron)",
+          accept: "application/json",
+        },
+        body: "{}",
+      });
+      console.log(
+        `[checkin] ${new Date().toISOString()} ${checkinPath} -> HTTP ${res.status} ` +
+          `(${Date.now() - startedAt}ms)`,
+      );
+    } catch (err) {
+      // 同样不抛出：签到失败不该让 Cron 报错，保活本身已经完成了。
+      const detail = err && err.message ? err.message : String(err);
+      console.warn(
+        `[checkin] ${new Date().toISOString()} ${checkinPath} -> FAILED ` +
+          `(${Date.now() - startedAt}ms) detail=${detail}`,
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+  },
+};

deploy/cloudflare-worker/wrangler.toml

@@ -0,0 +1,81 @@
+# WorkBuddy2API — Cloudflare Worker 配置
+# 本地路径：D:\workbuddy2api-panel\deploy\cloudflare-worker\worker.js
+#
+# 用法：
+#   cd D:\workbuddy2api-panel\deploy\cloudflare-worker
+#   npx wrangler deploy
+#
+# 注意：任何 secret 一律用 `wrangler secret put` 写入，绝对不要落到本文件里。
+# 本目录四个文件均可提交：worker.js / wrangler.toml / .dev.vars.example / README.md。
+# `.dev.vars`、`.dev.vars.*`、`.wrangler/` 已被根目录 .gitignore 忽略
+# （同时用 `!.dev.vars.example` 把模板放回版本库）。
+
+name = "workbuddy2api-hf-proxy"
+main = "worker.js"
+
+# 兼容性日期：固定在一个已发布版本上，不要写得太新也不要写 today。
+# 2025-01-01 已支持 Request/Response 流式透传、AbortController、
+# `redirect: "manual"` 与 crypto/Headers 全套 API，本 Worker 只用这些。
+compatibility_date = "2025-01-01"
+
+# ---------------------------------------------------------------------------
+# 环境变量（非机密）
+# ---------------------------------------------------------------------------
+[vars]
+# 源站：HF Space 的直连域名。改 Space 时只改这里，不用动 worker.js。
+ORIGIN = "https://a3216-gcli2api.hf.space"
+
+# 保活探测路径，默认 /healthz（网关自带探活端点，无鉴权、开销最小）。
+# HEALTH_PATH = "/healthz"
+
+# GET / 的跳转目标，默认 /panel/。
+# 网关只注册了 /panel/，直连 Space 的 GET / 是 404；而公网入口
+# cli.3216gemini.dpdns.org/ 实测返回 302 → /panel/ —— 说明这层跳转是 CF 侧加的。
+# 本 Worker 复刻该行为，换用后首页体验不变。设成空串则关闭跳转、严格透传后端 404。
+# ROOT_REDIRECT = "/panel/"
+
+# --- 以下为「可选唤醒/签到」相关，默认全部注释掉 = 功能关闭 ---
+# 只有当你确实需要「主动调用某个接口才算真正唤醒」时才打开；
+# 单纯的防休眠只需要 /healthz 的裸 ping，不需要任何鉴权。
+#
+# CHECKIN_CRON：只在这个 Cron 表达式触发的运行里做签到。
+# CHECKIN_PATH：带 Bearer 调用的路径，例如 "/panel/api/keepalive"。
+# CHECKIN_CRON = "0 * * * *"
+# CHECKIN_PATH = "/panel/api/keepalive"
+
+# ---------------------------------------------------------------------------
+# 定时触发：Hugging Face 免费 cpu-basic Space 连续 48 小时无 HTTP 流量即暂停，
+# 冷启动 30–60 秒。每 5 分钟打一次 /healthz 即可彻底避免被暂停。
+# 5 分钟是 Cloudflare Cron Triggers 的最小粒度，取最小值最稳。
+# ---------------------------------------------------------------------------
+[triggers]
+crons = ["*/5 * * * *"]
+
+# ---------------------------------------------------------------------------
+# 路由：把公网入口 cli.3216gemini.dpdns.org 全部流量交给本 Worker。
+# 该域名必须在本 Cloudflare 账号下（zone: 3216gemini.dpdns.org）。
+#
+# 两种接法，任选其一：
+#   A) 用 wrangler 管理路由——取消下面注释后 `wrangler deploy` 会自动建路由；
+#   B) 在 Cloudflare Dashboard → Workers → 你的 Worker → Settings → Domains &
+#      Routes 里手动添加，本文件保持注释即可（推荐，避免误删线上路由）。
+#
+# ⚠️ 启用路由前请确认：该主机名当前的 DNS 记录不能同时是「已代理指向别处」的
+#    A/AAAA/CNAME，否则 Worker 路由与 DNS 记录会打架。正确做法是让该主机名
+#    由 Worker 路由接管（DNS 里通常留一条指向 100:: 的 AAAA 占位记录）。
+#
+# routes = [
+#   { pattern = "cli.3216gemini.dpdns.org/*", zone_name = "3216gemini.dpdns.org" }
+# ]
+
+# ---------------------------------------------------------------------------
+# 机密（不要写进本文件、不要提交）
+# ---------------------------------------------------------------------------
+# WB2A_API_KEY —— 面板/网关的 Bearer 密钥。仅「可选签到」功能需要它。
+#   npx wrangler secret put WB2A_API_KEY
+# 未设置时，scheduled() 只做 /healthz 裸 ping，不发送任何鉴权请求。
+#
+# 本地调试用 `.dev.vars`（同目录，格式 KEY="value"，见 .dev.vars.example）。
+# 该文件与 `.wrangler/` 都已被根目录 .gitignore 忽略，但仍请自行确认不要
+# 把真实密钥提交上去；线上请用 `wrangler secret put`。
+#   WB2A_API_KEY="你的密钥"

docker-compose.yml

@@ -1,15 +1,15 @@
-# 本地 / 自建服务器跑法（不用 HF 时）。HF Spaces 上不需要这个文件。
-services:
-  wb2api:
-    build: .
-    container_name: workbuddy2api
-    restart: unless-stopped
-    environment:
-      - TZ=Asia/Shanghai
-    ports:
-      - "7861:7861"
-    volumes:
-      # 一个目录装下全部持久化状态，和 HF 上挂桶的布局保持一致：
-      #   storage/config.json、storage/auths/、storage/data/
-      - ./storage:/app/storage
-      - ./storage/config.json:/app/config.json
+# 本地 / 自建服务器跑法（不用 HF 时）。HF Spaces 上不需要这个文件。
+services:
+  wb2api:
+    build: .
+    container_name: workbuddy2api
+    restart: unless-stopped
+    environment:
+      - TZ=Asia/Shanghai
+    ports:
+      - "7861:7861"
+    volumes:
+      # 一个目录装下全部持久化状态，和 HF 上挂桶的布局保持一致：
+      #   storage/config.json、storage/auths/、storage/data/
+      - ./storage:/app/storage
+      - ./storage/config.json:/app/config.json

docker-entrypoint.sh

@@ -1,69 +1,69 @@
-#!/bin/sh
-# WorkBuddy2API Panel — Hugging Face Spaces 入口脚本
-#
-# 持久化模型：
-#   HF Storage Bucket（私有）  ->  挂载到容器 /app/storage
-#     /app/storage/config.json        运行配置（含 api_key，私有卷上，不进公开仓库）
-#     /app/storage/auths/*.json       账号凭证
-#     /app/storage/data/*.json        水位/用量/模型探测/请求归档
-#
-# 容器根文件系统是 ephemeral 的：重启、休眠唤醒、重新构建都会重置。
-# 所以配置和账号必须待在卷上，否则每次重启都要重新登录账号。
-set -eu
-
-PERSIST="${WB2A_PERSIST_DIR:-/app/storage}"
-TEMPLATE=/app/config.json
-CFG="$TEMPLATE"
-
-echo "[entrypoint] boot at $(date -u '+%Y-%m-%dT%H:%M:%SZ')"
-
-if [ -d "$PERSIST" ]; then
-  echo "[entrypoint] persistent volume detected at $PERSIST"
-  mkdir -p "$PERSIST/auths" "$PERSIST/data"
-
-  # 落盘自检：程序全部走「写 .tmp 再 rename」，rename 不可用的话持久化是假的
-  if echo probe > "$PERSIST/.wb2a-write-probe" 2>/dev/null \
-     && mv "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null \
-     && rm -f "$PERSIST/.wb2a-rename-probe"; then
-    echo "[entrypoint] storage self-test: write+rename OK"
-  else
-    echo "[entrypoint] storage self-test: FAILED — write or rename unsupported on $PERSIST" >&2
-    rm -f "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null || true
-  fi
-
-  if [ ! -f "$PERSIST/config.json" ]; then
-    if [ -f "$TEMPLATE" ]; then
-      echo "[entrypoint] no config.json on the volume -> seeding from image template"
-      cp "$TEMPLATE" "$PERSIST/config.json"
-    else
-      echo "[entrypoint] no config.json on the volume and no image template" >&2
-    fi
-  fi
-  [ -f "$PERSIST/config.json" ] && CFG="$PERSIST/config.json"
-else
-  echo "[entrypoint] WARNING: no persistent volume at $PERSIST — everything written will be LOST on restart" >&2
-  mkdir -p /app/auths /app/data
-fi
-
-# 安全闸门：api_key 为空 == 完全不鉴权（httpauth.VerifyBearer 语义）。
-# 空间是公网可达的，绝不允许以裸奔状态启动。
-if [ -n "${WB2A_API_KEY:-}" ]; then
-  echo "[entrypoint] api_key supplied via WB2A_API_KEY env"
-else
-  KEY=$(python3 -c 'import json,sys
-try:
-    print(json.load(open(sys.argv[1])).get("api_key") or "")
-except Exception:
-    print("")' "$CFG" 2>/dev/null || true)
-  if [ -z "$KEY" ]; then
-    echo "[entrypoint] FATAL: api_key is empty in $CFG and WB2A_API_KEY is not set." >&2
-    echo "[entrypoint] Refusing to start: an empty api_key disables authentication on a public Space." >&2
-    echo "[entrypoint] Fix: write a config.json containing an api_key onto the bucket, or set the WB2A_API_KEY secret." >&2
-    exit 1
-  fi
-  echo "[entrypoint] api_key loaded from config file"
-fi
-
-echo "[entrypoint] config: $CFG"
-echo "[entrypoint] auth_dir: $(dirname "$CFG")/auths (see config)"
-exec /app/wb2api -config "$CFG"
+#!/bin/sh
+# WorkBuddy2API Panel — Hugging Face Spaces 入口脚本
+#
+# 持久化模型：
+#   HF Storage Bucket（私有）  ->  挂载到容器 /app/storage
+#     /app/storage/config.json        运行配置（含 api_key，私有卷上，不进公开仓库）
+#     /app/storage/auths/*.json       账号凭证
+#     /app/storage/data/*.json        水位/用量/模型探测/请求归档
+#
+# 容器根文件系统是 ephemeral 的：重启、休眠唤醒、重新构建都会重置。
+# 所以配置和账号必须待在卷上，否则每次重启都要重新登录账号。
+set -eu
+
+PERSIST="${WB2A_PERSIST_DIR:-/app/storage}"
+TEMPLATE=/app/config.json
+CFG="$TEMPLATE"
+
+echo "[entrypoint] boot at $(date -u '+%Y-%m-%dT%H:%M:%SZ')"
+
+if [ -d "$PERSIST" ]; then
+  echo "[entrypoint] persistent volume detected at $PERSIST"
+  mkdir -p "$PERSIST/auths" "$PERSIST/data"
+
+  # 落盘自检：程序全部走「写 .tmp 再 rename」，rename 不可用的话持久化是假的
+  if echo probe > "$PERSIST/.wb2a-write-probe" 2>/dev/null \
+     && mv "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null \
+     && rm -f "$PERSIST/.wb2a-rename-probe"; then
+    echo "[entrypoint] storage self-test: write+rename OK"
+  else
+    echo "[entrypoint] storage self-test: FAILED — write or rename unsupported on $PERSIST" >&2
+    rm -f "$PERSIST/.wb2a-write-probe" "$PERSIST/.wb2a-rename-probe" 2>/dev/null || true
+  fi
+
+  if [ ! -f "$PERSIST/config.json" ]; then
+    if [ -f "$TEMPLATE" ]; then
+      echo "[entrypoint] no config.json on the volume -> seeding from image template"
+      cp "$TEMPLATE" "$PERSIST/config.json"
+    else
+      echo "[entrypoint] no config.json on the volume and no image template" >&2
+    fi
+  fi
+  [ -f "$PERSIST/config.json" ] && CFG="$PERSIST/config.json"
+else
+  echo "[entrypoint] WARNING: no persistent volume at $PERSIST — everything written will be LOST on restart" >&2
+  mkdir -p /app/auths /app/data
+fi
+
+# 安全闸门：api_key 为空 == 完全不鉴权（httpauth.VerifyBearer 语义）。
+# 空间是公网可达的，绝不允许以裸奔状态启动。
+if [ -n "${WB2A_API_KEY:-}" ]; then
+  echo "[entrypoint] api_key supplied via WB2A_API_KEY env"
+else
+  KEY=$(python3 -c 'import json,sys
+try:
+    print(json.load(open(sys.argv[1])).get("api_key") or "")
+except Exception:
+    print("")' "$CFG" 2>/dev/null || true)
+  if [ -z "$KEY" ]; then
+    echo "[entrypoint] FATAL: api_key is empty in $CFG and WB2A_API_KEY is not set." >&2
+    echo "[entrypoint] Refusing to start: an empty api_key disables authentication on a public Space." >&2
+    echo "[entrypoint] Fix: write a config.json containing an api_key onto the bucket, or set the WB2A_API_KEY secret." >&2
+    exit 1
+  fi
+  echo "[entrypoint] api_key loaded from config file"
+fi
+
+echo "[entrypoint] config: $CFG"
+echo "[entrypoint] auth_dir: $(dirname "$CFG")/auths (see config)"
+exec /app/wb2api -config "$CFG"

go.mod

@@ -1,11 +1,11 @@
-module github.com/linguo2625469/workbuddy2api-panel
-
-go 1.22.5
-
-require (
-	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
-	github.com/redis/go-redis/v9 v9.18.0 // indirect
-	go.uber.org/atomic v1.11.0 // indirect
-	golang.org/x/sys v0.30.0 // indirect
-)
+module github.com/linguo2625469/workbuddy2api-panel
+
+go 1.22.5
+
+require (
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/redis/go-redis/v9 v9.18.0 // indirect
+	go.uber.org/atomic v1.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+)

go.sum

@@ -1,12 +1,12 @@
-github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
-github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
-github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
-github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs=
-github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0=
-github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
-github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
-go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
-go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
-golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
-golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f h1:lO4WD4F/rVNCu3HqELle0jiPLLBs70cWOduZpkS1E78=
+github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f/go.mod h1:cuUVRXasLTGF7a8hSLbxyZXjz+1KgoB3wDUb6vlszIc=
+github.com/redis/go-redis/v9 v9.18.0 h1:pMkxYPkEbMPwRdenAzUNyFNrDgHx9U+DrBabWNfSRQs=
+github.com/redis/go-redis/v9 v9.18.0/go.mod h1:k3ufPphLU5YXwNTUcCRXGxUoF1fqxnhFQmscfkCoDA0=
+github.com/redis/go-redis/v9 v9.22.0 h1:laDvpYXTJtZLloinw1fA5Kqd6HAEH2XKxOkG/PDq2F0=
+github.com/redis/go-redis/v9 v9.22.0/go.mod h1:y2g0Wj8rQvuK0ELM+oxSudcLtC09JScs98I/X9gRWY4=
+go.uber.org/atomic v1.11.0 h1:ZvwS0R+56ePWxUNi+Atn9dWONBPp/AUETXlHW0DxSjE=
+go.uber.org/atomic v1.11.0/go.mod h1:LUxbIzbOniOlMKjJjyPfpl4v+PKK2cNJn91OQbhoJI0=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

internal/auth/auth.go

@@ -1,378 +1,378 @@
-// Package auth 解析 WorkBuddy auth 文件（嵌套形/扁平形双形态），
-// 提供 refresh 后的原子写回。
-package auth
-
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"io/fs"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/logfmt"
-)
-
-// Auth 是归一化后的账号凭证（来源可以是插件 OAuth 嵌套形或手写扁平形）。
-type Auth struct {
-	// mu 串行化 RefreshToken 写与 SaveAtomic 读，防止并发写回半更新 token。
-	mu sync.Mutex
-
-	AccessToken  string
-	RefreshToken string
-	ExpiresAt    int64 // Unix 秒
-	Domain       string
-	// realm 账号域（"cn" / "global"），落盘于 auth.realm（嵌套形）或顶层 realm（扁平形）。
-	// 空 = 缺省：Realm() 按 domain 后缀回落，最终恒非空。
-	//
-	// 命名注记：Go 不允许字段与方法同名，持久化字段用未导出 realm，计算访问器用
-	// 导出的 Realm()（跨包调用全部走方法）。Parse/SaveAtomic/login 在包内读写字段。
-	realm        string
-	UID          string
-	EnterpriseID string
-	Nickname     string
-	FilePath     string // 来源文件；refresh 后原子写回此处
-
-	// DeviceToken 设备风控 Token（X-Device-Token 头），来源 auth 文件的 device_token 键。
-	// 缺省为空 = 不注入该头（容器内无桌面端 Turing SDK 的常见部署）。
-	// 手写扁平形 auth 文件可直接写 "device_token": "..."；插件 OAuth 嵌套形
-	// 顶层 device_token 也会被解析（与桌面端共用状态文件的部署方式）。
-	DeviceToken string
-}
-
-// Lock 供同进程内其他包（upstream.RefreshToken）在改写 Auth 字段期间加锁。
-func (a *Auth) Lock() { a.mu.Lock() }
-
-// Unlock 释放 a.Lock 获取的锁。
-func (a *Auth) Unlock() { a.mu.Unlock() }
-
-// AccessTokenValue 加锁读取 AccessToken（出站请求头一律经此取值，勿直读字段）。
-//
-// 为什么必须加锁：RefreshToken 在 a.mu 内改写 AccessToken/RefreshToken/Domain/ExpiresAt
-// （client.go「第 2 段（锁内）：校验快照一致后写回」），而所有出站请求头构造
-// （ChatHeaders / BillingHeaders / fetchEnterpriseModels / fetchV3Models /
-// global_models）与调度器的 token 检查都在锁外直读这些字段。生产上两侧真会并发：
-// Scheduler.RunKeepaliveNow 定时对**每个**非禁用账号刷新（与是否有在途请求无关），
-// 而 handler 正基于**同一个** *auth.Auth 指针构造请求头（Pool.AuthByUID/List 返回的
-// 就是池内同一个对象）。无同步直读构成数据竞争（go test -race 实证）。
-func (a *Auth) AccessTokenValue() string {
-	if a == nil {
-		return ""
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.AccessToken
-}
-
-// DomainValue 加锁读取 Domain（同 AccessTokenValue：RefreshToken 在锁内改写它）。
-func (a *Auth) DomainValue() string {
-	if a == nil {
-		return ""
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.Domain
-}
-
-// RefreshTokenValue 加锁读取 RefreshToken（同 AccessTokenValue：RefreshToken 在锁内
-// 改写它）。调度器的「有无凭证」前置守卫（checkin/keepalive/travel 的
-// `a.RefreshToken == ""`）必须经此取值，勿直读字段。
-func (a *Auth) RefreshTokenValue() string {
-	if a == nil {
-		return ""
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.RefreshToken
-}
-
-// globalEnabled 全局开关：global realm 是否路由（D5 双保险）。
-// 默认开启（与 config global.enabled 缺省 true 一致）：Realm() 正常按显式 realm/
-// domain 判定 global/cn。显式 SetGlobalEnabled(false)（config "enabled": false）关闭
-// → 逃生门：纯 CN 部署，即便 auth 文件写了 realm=global 或 domain 为 .workbuddy.ai
-// 也恒判 cn——「关了才锁死」的单一闸口集中收敛在 Realm()/IsGlobal() 里。
-var globalEnabled atomic.Bool
-
-func init() { globalEnabled.Store(true) }
-
-// SetGlobalEnabled 注入 global realm 路由开关（false = 锁死纯 CN，逃生门）。
-func SetGlobalEnabled(enabled bool) { globalEnabled.Store(enabled) }
-
-// GlobalEnabled 报告 global realm 路由开关当前状态（测试/运维观测）。
-func GlobalEnabled() bool { return globalEnabled.Load() }
-
-// Realm 返回账号的归一化域：显式 Realm=="global" 或 domain 后缀 .workbuddy.ai → "global"，
-// 否则 "cn"。显式 global 优先于 domain 回落（D1）。
-// 全局开关 SetGlobalEnabled(false) 时恒 "cn"（逃生门：纯 CN 锁定，不影响默认行为）。
-// 空 realm + 空 domain → "cn"（老 CN 凭证零回归）。
-func (a *Auth) Realm() string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.realmLocked()
-}
-
-// realmLocked Realm 的无锁内部实现：仅限**已持 a.mu** 的调用方使用（sync.Mutex 不可重入，
-// 锁内再调 Realm() 会自锁）。realm 由 BackfillRealm 改写、Domain 由 RefreshToken 在锁内
-// 改写，故读取必须与写方同锁（理由见 AccessTokenValue 注释）。
-func (a *Auth) realmLocked() string {
-	if !globalEnabled.Load() {
-		return "cn"
-	}
-	if strings.TrimSpace(a.realm) == "global" || isGlobalDomain(a.Domain) {
-		return "global"
-	}
-	return "cn"
-}
-
-// ResolveRealm 归一化 realm（cn/global）：显式非空优先，否则按原始 domain 推断
-// （isGlobalDomain）。不受逃生门影响（逃生门是路由锁，不应影响标识判定）；
-// domain 也为空 → "cn"（老 CN 凭证零回归）。
-func ResolveRealm(explicit, domain string) string {
-	if r := strings.TrimSpace(explicit); r != "" {
-		return r
-	}
-	if isGlobalDomain(domain) {
-		return "global"
-	}
-	return "cn"
-}
-
-// BackfillRealm 为缺省 realm 标识的账号持久化补标识：a.realm 为空时按「原始 domain 推断」
-// 写回（cn/global），返回 (是否有变更, 归一化后的 realm)。已有标识不动（幂等）。
-//
-// 注意用 isGlobalDomain(a.Domain) 直接推断，而非 Realm()——Realm() 在逃生门
-// （SetGlobalEnabled(false)）下恒降级 cn，把 global 账号写死成 cn 会永久污染凭证
-// （逃生门是纯 CN 部署的临时锁，不应改写落盘数据）。domain 也为空时写 "cn"（老 CN 凭证）。
-func (a *Auth) BackfillRealm() (bool, string) {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if strings.TrimSpace(a.realm) != "" {
-		return false, a.realm
-	}
-	r := ResolveRealm("", a.Domain)
-	a.realm = r
-	return true, r
-}
-
-// RealmStored 直读持久化的 realm 标识（可能为空 = 未 backfill 的旧文件，Realm() 会 fallback）。
-func (a *Auth) RealmStored() string {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	return a.realm
-}
-
-// BackfillRealmFor 显式写入 realm 标识（包外登录路径使用：panel login 已知用户选了
-// global，直接落盘 realm=global，不依赖 domain 后缀推断）。realm 需为 cn/global，
-// 非法值报错（防写脏）。返回是否发生变更。
-func BackfillRealmFor(a *Auth, realm string) (bool, error) {
-	if a == nil {
-		return false, fmt.Errorf("nil auth")
-	}
-	switch strings.TrimSpace(realm) {
-	case "cn", "global":
-	default:
-		return false, fmt.Errorf("realm must be cn/global, got %q", realm)
-	}
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if a.realm == realm {
-		return false, nil
-	}
-	a.realm = realm
-	return true, nil
-}
-
-// IsGlobal 报告账号是否属于 global realm（= Realm() == "global"）。
-func (a *Auth) IsGlobal() bool { return a.Realm() == "global" }
-
-// isGlobalDomain 判定 domain 是否指向 www.workbuddy.ai 家族。
-// 同时接受裸域 workbuddy.ai 与任意子域（HasSuffix("www.workbuddy.ai") 或裸域本身）。
-func isGlobalDomain(d string) bool {
-	d = strings.ToLower(strings.TrimSpace(d))
-	return d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai")
-}
-
-// NeedsRefresh 报告 token 是否将在 within 内过期（或已过期/无 expiry）。
-func (a *Auth) NeedsRefresh(within time.Duration) bool {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if a.ExpiresAt <= 0 {
-		return true
-	}
-	return time.Now().Add(within).Unix() >= a.ExpiresAt
-}
-
-// Parse 兼容两种磁盘形态：
-//
-//	嵌套形 {"auth":{...},"account":{...}}  （插件 OAuth 输出）
-//	扁平形 {"accessToken":...,"uid":...}   （手写/旧版）
-func Parse(raw []byte) (*Auth, error) {
-	if len(raw) == 0 {
-		return nil, fmt.Errorf("empty auth storage")
-	}
-	var probe map[string]json.RawMessage
-	if err := json.Unmarshal(raw, &probe); err != nil {
-		return nil, fmt.Errorf("storage_parse_error: %w", err)
-	}
-	var a Auth
-	if _, nested := probe["auth"]; nested {
-		var n struct {
-			Auth struct {
-				AccessToken  string `json:"accessToken"`
-				RefreshToken string `json:"refreshToken"`
-				ExpiresAt    int64  `json:"expiresAt"`
-				Domain       string `json:"domain"`
-				Realm        string `json:"realm"`
-			} `json:"auth"`
-			Account struct {
-				UID          string `json:"uid"`
-				EnterpriseID string `json:"enterpriseId"`
-				Nickname     string `json:"nickname"`
-			} `json:"account"`
-			// DeviceToken 顶层 device_token（嵌套形与扁平形共用；手写时无需嵌进 auth 对象）。
-			DeviceToken string `json:"device_token"`
-		}
-		if err := json.Unmarshal(raw, &n); err != nil {
-			return nil, fmt.Errorf("storage_parse_error: %w", err)
-		}
-		a = Auth{
-			AccessToken:  n.Auth.AccessToken,
-			RefreshToken: n.Auth.RefreshToken,
-			ExpiresAt:    n.Auth.ExpiresAt,
-			Domain:       n.Auth.Domain,
-			realm:        n.Auth.Realm,
-			UID:          n.Account.UID,
-			EnterpriseID: n.Account.EnterpriseID,
-			Nickname:     n.Account.Nickname,
-			DeviceToken:  n.DeviceToken,
-		}
-	} else {
-		var f struct {
-			AccessToken  string `json:"accessToken"`
-			RefreshToken string `json:"refreshToken"`
-			ExpiresAt    int64  `json:"expiresAt"`
-			Domain       string `json:"domain"`
-			Realm        string `json:"realm"`
-			UID          string `json:"uid"`
-			EnterpriseID string `json:"enterpriseId"`
-			Nickname     string `json:"nickname"`
-			DeviceToken  string `json:"device_token"`
-		}
-		if err := json.Unmarshal(raw, &f); err != nil {
-			return nil, fmt.Errorf("storage_parse_error: %w", err)
-		}
-		a = Auth{
-			AccessToken:  f.AccessToken,
-			RefreshToken: f.RefreshToken,
-			ExpiresAt:    f.ExpiresAt,
-			Domain:       f.Domain,
-			realm:        f.Realm,
-			UID:          f.UID,
-			EnterpriseID: f.EnterpriseID,
-			Nickname:     f.Nickname,
-			DeviceToken:  f.DeviceToken,
-		}
-	}
-	if strings.TrimSpace(a.AccessToken) == "" {
-		return nil, fmt.Errorf("parse_error: missing accessToken")
-	}
-	return &a, nil
-}
-
-// SaveAtomic 以嵌套形原子写回 FilePath（tmp + rename），保持嵌套形（插件可读）格式。
-// 全程持 a.mu：防止与 RefreshToken 修改 token 字段并发，杜绝写回半更新。
-// 防御：accessToken 为空时拒绝写回，避免误用空凭证覆盖有效文件。
-func (a *Auth) SaveAtomic() error {
-	a.mu.Lock()
-	defer a.mu.Unlock()
-	if strings.TrimSpace(a.AccessToken) == "" {
-		return fmt.Errorf("save refused: empty accessToken (uid=%s)", a.UID)
-	}
-	if a.FilePath == "" {
-		return fmt.Errorf("no FilePath set")
-	}
-	doc := map[string]any{
-		"auth": map[string]any{
-			"accessToken":  a.AccessToken,
-			"refreshToken": a.RefreshToken,
-			"expiresAt":    a.ExpiresAt,
-			"domain":       a.Domain,
-			"realm":        a.realm,
-		},
-		"account": map[string]any{
-			"uid":          a.UID,
-			"enterpriseId": a.EnterpriseID,
-			"nickname":     a.Nickname,
-		},
-	}
-	// DeviceToken 非空才写回顶层 device_token：避免在无该字段的旧文件里引入空键
-	// （保持与插件 OAuth 输出形状一致，插件读取忽略未知键）。
-	if a.DeviceToken != "" {
-		doc["device_token"] = a.DeviceToken
-	}
-	raw, err := json.MarshalIndent(doc, "", "  ")
-	if err != nil {
-		return err
-	}
-	tmp := a.FilePath + ".tmp"
-	if err := os.WriteFile(tmp, raw, 0o600); err != nil {
-		// Docker bind-mount 权限问题的典型现场：容器内 app 用户（uid 10001）
-		// 对宿主机挂载目录无写权限。给出可操作指引而不是裸 syscall 错误。
-		msg := fmt.Sprintf("写入 %s 失败: %v", tmp, err)
-		if errors.Is(err, fs.ErrPermission) {
-			msg += "\n（Docker 部署：容器内用户对宿主机挂载目录无写权限。解法任选：" +
-				"1) 以本机 uid 运行容器：PUID=$(id -u) PGID=$(id -g) docker compose up -d；" +
-				"2) sudo chown -R 10001:10001 ./auths ./data ./config.json；" +
-				"3) compose 设 user: \"0:0\" 以 root 运行）"
-		}
-		return errors.New(msg)
-	}
-	return os.Rename(tmp, a.FilePath)
-}
-
-// LoadDir 扫描并解析 dir 下 workbuddy*.json；解析失败的文件静默跳过（启动日志由调用方统计）。
-// 顺带做 realm 标识存量迁移：对空 realm 的 auth 自动 backfill（原始 domain 推断）并 SaveAtomic
-// 落盘，一次性把旧文件补上 realm 键。单个文件写失败不阻断启动（log WARN 继续），
-// 避免历史 auth 目录个别文件不可写时整个服务起不来。
-func LoadDir(dir string) ([]*Auth, error) {
-	files, err := filepath.Glob(filepath.Join(dir, "workbuddy*.json"))
-	if err != nil {
-		return nil, err
-	}
-	// seenUID 重复 UID 检测：同 UID 出现在多个文件时（双 realm 同名 UID 概率近零）
-	// 打 WARN 告警含两文件路径，由「后载入者胜出」保持现状行为（不改变加载结果）。
-	seenUID := make(map[string]string, len(files))
-	var out []*Auth
-	for _, f := range files {
-		raw, err := os.ReadFile(f)
-		if err != nil {
-			continue
-		}
-		a, err := Parse(raw)
-		if err != nil {
-			continue
-		}
-		a.FilePath = f
-		if prev, ok := seenUID[a.UID]; ok {
-			log.Printf("WARN: uid %s duplicated across %s and %s — 后者覆盖（不同 realm 同名 UID？）",
-				logfmt.Label(a.UID, a.Nickname), prev, f)
-		}
-		seenUID[a.UID] = f
-		if a.RealmStored() == "" {
-			if changed, r := a.BackfillRealm(); changed {
-				if err := a.SaveAtomic(); err != nil {
-					log.Printf("WARN: auth %s realm backfill save: %v", logfmt.Label(a.UID, a.Nickname), err)
-				} else if r == "global" {
-					log.Printf("auth %s 存量迁移: 补 realm=global（domain=%s）", logfmt.Label(a.UID, a.Nickname), a.Domain)
-				}
-			}
-		}
-		out = append(out, a)
-	}
-	return out, nil
-}
+// Package auth 解析 WorkBuddy auth 文件（嵌套形/扁平形双形态），
+// 提供 refresh 后的原子写回。
+package auth
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/fs"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/logfmt"
+)
+
+// Auth 是归一化后的账号凭证（来源可以是插件 OAuth 嵌套形或手写扁平形）。
+type Auth struct {
+	// mu 串行化 RefreshToken 写与 SaveAtomic 读，防止并发写回半更新 token。
+	mu sync.Mutex
+
+	AccessToken  string
+	RefreshToken string
+	ExpiresAt    int64 // Unix 秒
+	Domain       string
+	// realm 账号域（"cn" / "global"），落盘于 auth.realm（嵌套形）或顶层 realm（扁平形）。
+	// 空 = 缺省：Realm() 按 domain 后缀回落，最终恒非空。
+	//
+	// 命名注记：Go 不允许字段与方法同名，持久化字段用未导出 realm，计算访问器用
+	// 导出的 Realm()（跨包调用全部走方法）。Parse/SaveAtomic/login 在包内读写字段。
+	realm        string
+	UID          string
+	EnterpriseID string
+	Nickname     string
+	FilePath     string // 来源文件；refresh 后原子写回此处
+
+	// DeviceToken 设备风控 Token（X-Device-Token 头），来源 auth 文件的 device_token 键。
+	// 缺省为空 = 不注入该头（容器内无桌面端 Turing SDK 的常见部署）。
+	// 手写扁平形 auth 文件可直接写 "device_token": "..."；插件 OAuth 嵌套形
+	// 顶层 device_token 也会被解析（与桌面端共用状态文件的部署方式）。
+	DeviceToken string
+}
+
+// Lock 供同进程内其他包（upstream.RefreshToken）在改写 Auth 字段期间加锁。
+func (a *Auth) Lock() { a.mu.Lock() }
+
+// Unlock 释放 a.Lock 获取的锁。
+func (a *Auth) Unlock() { a.mu.Unlock() }
+
+// AccessTokenValue 加锁读取 AccessToken（出站请求头一律经此取值，勿直读字段）。
+//
+// 为什么必须加锁：RefreshToken 在 a.mu 内改写 AccessToken/RefreshToken/Domain/ExpiresAt
+// （client.go「第 2 段（锁内）：校验快照一致后写回」），而所有出站请求头构造
+// （ChatHeaders / BillingHeaders / fetchEnterpriseModels / fetchV3Models /
+// global_models）与调度器的 token 检查都在锁外直读这些字段。生产上两侧真会并发：
+// Scheduler.RunKeepaliveNow 定时对**每个**非禁用账号刷新（与是否有在途请求无关），
+// 而 handler 正基于**同一个** *auth.Auth 指针构造请求头（Pool.AuthByUID/List 返回的
+// 就是池内同一个对象）。无同步直读构成数据竞争（go test -race 实证）。
+func (a *Auth) AccessTokenValue() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.AccessToken
+}
+
+// DomainValue 加锁读取 Domain（同 AccessTokenValue：RefreshToken 在锁内改写它）。
+func (a *Auth) DomainValue() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.Domain
+}
+
+// RefreshTokenValue 加锁读取 RefreshToken（同 AccessTokenValue：RefreshToken 在锁内
+// 改写它）。调度器的「有无凭证」前置守卫（checkin/keepalive/travel 的
+// `a.RefreshToken == ""`）必须经此取值，勿直读字段。
+func (a *Auth) RefreshTokenValue() string {
+	if a == nil {
+		return ""
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.RefreshToken
+}
+
+// globalEnabled 全局开关：global realm 是否路由（D5 双保险）。
+// 默认开启（与 config global.enabled 缺省 true 一致）：Realm() 正常按显式 realm/
+// domain 判定 global/cn。显式 SetGlobalEnabled(false)（config "enabled": false）关闭
+// → 逃生门：纯 CN 部署，即便 auth 文件写了 realm=global 或 domain 为 .workbuddy.ai
+// 也恒判 cn——「关了才锁死」的单一闸口集中收敛在 Realm()/IsGlobal() 里。
+var globalEnabled atomic.Bool
+
+func init() { globalEnabled.Store(true) }
+
+// SetGlobalEnabled 注入 global realm 路由开关（false = 锁死纯 CN，逃生门）。
+func SetGlobalEnabled(enabled bool) { globalEnabled.Store(enabled) }
+
+// GlobalEnabled 报告 global realm 路由开关当前状态（测试/运维观测）。
+func GlobalEnabled() bool { return globalEnabled.Load() }
+
+// Realm 返回账号的归一化域：显式 Realm=="global" 或 domain 后缀 .workbuddy.ai → "global"，
+// 否则 "cn"。显式 global 优先于 domain 回落（D1）。
+// 全局开关 SetGlobalEnabled(false) 时恒 "cn"（逃生门：纯 CN 锁定，不影响默认行为）。
+// 空 realm + 空 domain → "cn"（老 CN 凭证零回归）。
+func (a *Auth) Realm() string {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.realmLocked()
+}
+
+// realmLocked Realm 的无锁内部实现：仅限**已持 a.mu** 的调用方使用（sync.Mutex 不可重入，
+// 锁内再调 Realm() 会自锁）。realm 由 BackfillRealm 改写、Domain 由 RefreshToken 在锁内
+// 改写，故读取必须与写方同锁（理由见 AccessTokenValue 注释）。
+func (a *Auth) realmLocked() string {
+	if !globalEnabled.Load() {
+		return "cn"
+	}
+	if strings.TrimSpace(a.realm) == "global" || isGlobalDomain(a.Domain) {
+		return "global"
+	}
+	return "cn"
+}
+
+// ResolveRealm 归一化 realm（cn/global）：显式非空优先，否则按原始 domain 推断
+// （isGlobalDomain）。不受逃生门影响（逃生门是路由锁，不应影响标识判定）；
+// domain 也为空 → "cn"（老 CN 凭证零回归）。
+func ResolveRealm(explicit, domain string) string {
+	if r := strings.TrimSpace(explicit); r != "" {
+		return r
+	}
+	if isGlobalDomain(domain) {
+		return "global"
+	}
+	return "cn"
+}
+
+// BackfillRealm 为缺省 realm 标识的账号持久化补标识：a.realm 为空时按「原始 domain 推断」
+// 写回（cn/global），返回 (是否有变更, 归一化后的 realm)。已有标识不动（幂等）。
+//
+// 注意用 isGlobalDomain(a.Domain) 直接推断，而非 Realm()——Realm() 在逃生门
+// （SetGlobalEnabled(false)）下恒降级 cn，把 global 账号写死成 cn 会永久污染凭证
+// （逃生门是纯 CN 部署的临时锁，不应改写落盘数据）。domain 也为空时写 "cn"（老 CN 凭证）。
+func (a *Auth) BackfillRealm() (bool, string) {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if strings.TrimSpace(a.realm) != "" {
+		return false, a.realm
+	}
+	r := ResolveRealm("", a.Domain)
+	a.realm = r
+	return true, r
+}
+
+// RealmStored 直读持久化的 realm 标识（可能为空 = 未 backfill 的旧文件，Realm() 会 fallback）。
+func (a *Auth) RealmStored() string {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	return a.realm
+}
+
+// BackfillRealmFor 显式写入 realm 标识（包外登录路径使用：panel login 已知用户选了
+// global，直接落盘 realm=global，不依赖 domain 后缀推断）。realm 需为 cn/global，
+// 非法值报错（防写脏）。返回是否发生变更。
+func BackfillRealmFor(a *Auth, realm string) (bool, error) {
+	if a == nil {
+		return false, fmt.Errorf("nil auth")
+	}
+	switch strings.TrimSpace(realm) {
+	case "cn", "global":
+	default:
+		return false, fmt.Errorf("realm must be cn/global, got %q", realm)
+	}
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.realm == realm {
+		return false, nil
+	}
+	a.realm = realm
+	return true, nil
+}
+
+// IsGlobal 报告账号是否属于 global realm（= Realm() == "global"）。
+func (a *Auth) IsGlobal() bool { return a.Realm() == "global" }
+
+// isGlobalDomain 判定 domain 是否指向 www.workbuddy.ai 家族。
+// 同时接受裸域 workbuddy.ai 与任意子域（HasSuffix("www.workbuddy.ai") 或裸域本身）。
+func isGlobalDomain(d string) bool {
+	d = strings.ToLower(strings.TrimSpace(d))
+	return d == "workbuddy.ai" || strings.HasSuffix(d, ".workbuddy.ai")
+}
+
+// NeedsRefresh 报告 token 是否将在 within 内过期（或已过期/无 expiry）。
+func (a *Auth) NeedsRefresh(within time.Duration) bool {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if a.ExpiresAt <= 0 {
+		return true
+	}
+	return time.Now().Add(within).Unix() >= a.ExpiresAt
+}
+
+// Parse 兼容两种磁盘形态：
+//
+//	嵌套形 {"auth":{...},"account":{...}}  （插件 OAuth 输出）
+//	扁平形 {"accessToken":...,"uid":...}   （手写/旧版）
+func Parse(raw []byte) (*Auth, error) {
+	if len(raw) == 0 {
+		return nil, fmt.Errorf("empty auth storage")
+	}
+	var probe map[string]json.RawMessage
+	if err := json.Unmarshal(raw, &probe); err != nil {
+		return nil, fmt.Errorf("storage_parse_error: %w", err)
+	}
+	var a Auth
+	if _, nested := probe["auth"]; nested {
+		var n struct {
+			Auth struct {
+				AccessToken  string `json:"accessToken"`
+				RefreshToken string `json:"refreshToken"`
+				ExpiresAt    int64  `json:"expiresAt"`
+				Domain       string `json:"domain"`
+				Realm        string `json:"realm"`
+			} `json:"auth"`
+			Account struct {
+				UID          string `json:"uid"`
+				EnterpriseID string `json:"enterpriseId"`
+				Nickname     string `json:"nickname"`
+			} `json:"account"`
+			// DeviceToken 顶层 device_token（嵌套形与扁平形共用；手写时无需嵌进 auth 对象）。
+			DeviceToken string `json:"device_token"`
+		}
+		if err := json.Unmarshal(raw, &n); err != nil {
+			return nil, fmt.Errorf("storage_parse_error: %w", err)
+		}
+		a = Auth{
+			AccessToken:  n.Auth.AccessToken,
+			RefreshToken: n.Auth.RefreshToken,
+			ExpiresAt:    n.Auth.ExpiresAt,
+			Domain:       n.Auth.Domain,
+			realm:        n.Auth.Realm,
+			UID:          n.Account.UID,
+			EnterpriseID: n.Account.EnterpriseID,
+			Nickname:     n.Account.Nickname,
+			DeviceToken:  n.DeviceToken,
+		}
+	} else {
+		var f struct {
+			AccessToken  string `json:"accessToken"`
+			RefreshToken string `json:"refreshToken"`
+			ExpiresAt    int64  `json:"expiresAt"`
+			Domain       string `json:"domain"`
+			Realm        string `json:"realm"`
+			UID          string `json:"uid"`
+			EnterpriseID string `json:"enterpriseId"`
+			Nickname     string `json:"nickname"`
+			DeviceToken  string `json:"device_token"`
+		}
+		if err := json.Unmarshal(raw, &f); err != nil {
+			return nil, fmt.Errorf("storage_parse_error: %w", err)
+		}
+		a = Auth{
+			AccessToken:  f.AccessToken,
+			RefreshToken: f.RefreshToken,
+			ExpiresAt:    f.ExpiresAt,
+			Domain:       f.Domain,
+			realm:        f.Realm,
+			UID:          f.UID,
+			EnterpriseID: f.EnterpriseID,
+			Nickname:     f.Nickname,
+			DeviceToken:  f.DeviceToken,
+		}
+	}
+	if strings.TrimSpace(a.AccessToken) == "" {
+		return nil, fmt.Errorf("parse_error: missing accessToken")
+	}
+	return &a, nil
+}
+
+// SaveAtomic 以嵌套形原子写回 FilePath（tmp + rename），保持嵌套形（插件可读）格式。
+// 全程持 a.mu：防止与 RefreshToken 修改 token 字段并发，杜绝写回半更新。
+// 防御：accessToken 为空时拒绝写回，避免误用空凭证覆盖有效文件。
+func (a *Auth) SaveAtomic() error {
+	a.mu.Lock()
+	defer a.mu.Unlock()
+	if strings.TrimSpace(a.AccessToken) == "" {
+		return fmt.Errorf("save refused: empty accessToken (uid=%s)", a.UID)
+	}
+	if a.FilePath == "" {
+		return fmt.Errorf("no FilePath set")
+	}
+	doc := map[string]any{
+		"auth": map[string]any{
+			"accessToken":  a.AccessToken,
+			"refreshToken": a.RefreshToken,
+			"expiresAt":    a.ExpiresAt,
+			"domain":       a.Domain,
+			"realm":        a.realm,
+		},
+		"account": map[string]any{
+			"uid":          a.UID,
+			"enterpriseId": a.EnterpriseID,
+			"nickname":     a.Nickname,
+		},
+	}
+	// DeviceToken 非空才写回顶层 device_token：避免在无该字段的旧文件里引入空键
+	// （保持与插件 OAuth 输出形状一致，插件读取忽略未知键）。
+	if a.DeviceToken != "" {
+		doc["device_token"] = a.DeviceToken
+	}
+	raw, err := json.MarshalIndent(doc, "", "  ")
+	if err != nil {
+		return err
+	}
+	tmp := a.FilePath + ".tmp"
+	if err := os.WriteFile(tmp, raw, 0o600); err != nil {
+		// Docker bind-mount 权限问题的典型现场：容器内 app 用户（uid 10001）
+		// 对宿主机挂载目录无写权限。给出可操作指引而不是裸 syscall 错误。
+		msg := fmt.Sprintf("写入 %s 失败: %v", tmp, err)
+		if errors.Is(err, fs.ErrPermission) {
+			msg += "\n（Docker 部署：容器内用户对宿主机挂载目录无写权限。解法任选：" +
+				"1) 以本机 uid 运行容器：PUID=$(id -u) PGID=$(id -g) docker compose up -d；" +
+				"2) sudo chown -R 10001:10001 ./auths ./data ./config.json；" +
+				"3) compose 设 user: \"0:0\" 以 root 运行）"
+		}
+		return errors.New(msg)
+	}
+	return os.Rename(tmp, a.FilePath)
+}
+
+// LoadDir 扫描并解析 dir 下 workbuddy*.json；解析失败的文件静默跳过（启动日志由调用方统计）。
+// 顺带做 realm 标识存量迁移：对空 realm 的 auth 自动 backfill（原始 domain 推断）并 SaveAtomic
+// 落盘，一次性把旧文件补上 realm 键。单个文件写失败不阻断启动（log WARN 继续），
+// 避免历史 auth 目录个别文件不可写时整个服务起不来。
+func LoadDir(dir string) ([]*Auth, error) {
+	files, err := filepath.Glob(filepath.Join(dir, "workbuddy*.json"))
+	if err != nil {
+		return nil, err
+	}
+	// seenUID 重复 UID 检测：同 UID 出现在多个文件时（双 realm 同名 UID 概率近零）
+	// 打 WARN 告警含两文件路径，由「后载入者胜出」保持现状行为（不改变加载结果）。
+	seenUID := make(map[string]string, len(files))
+	var out []*Auth
+	for _, f := range files {
+		raw, err := os.ReadFile(f)
+		if err != nil {
+			continue
+		}
+		a, err := Parse(raw)
+		if err != nil {
+			continue
+		}
+		a.FilePath = f
+		if prev, ok := seenUID[a.UID]; ok {
+			log.Printf("WARN: uid %s duplicated across %s and %s — 后者覆盖（不同 realm 同名 UID？）",
+				logfmt.Label(a.UID, a.Nickname), prev, f)
+		}
+		seenUID[a.UID] = f
+		if a.RealmStored() == "" {
+			if changed, r := a.BackfillRealm(); changed {
+				if err := a.SaveAtomic(); err != nil {
+					log.Printf("WARN: auth %s realm backfill save: %v", logfmt.Label(a.UID, a.Nickname), err)
+				} else if r == "global" {
+					log.Printf("auth %s 存量迁移: 补 realm=global（domain=%s）", logfmt.Label(a.UID, a.Nickname), a.Domain)
+				}
+			}
+		}
+		out = append(out, a)
+	}
+	return out, nil
+}

internal/auth/auth_test.go

@@ -1,266 +1,266 @@
-package auth
-
-import (
-	"io"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-)
-
-func TestParseNested(t *testing.T) {
-	raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"domain":""},"account":{"uid":"u1","enterpriseId":"e1","nickname":"n1"}}`)
-	sa, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("nested parse err: %v", err)
-	}
-	if sa.AccessToken != "at" || sa.RefreshToken != "rt" || sa.ExpiresAt != 1753600000 {
-		t.Errorf("tokens: %+v", sa)
-	}
-	if sa.UID != "u1" || sa.EnterpriseID != "e1" || sa.Nickname != "n1" {
-		t.Errorf("account: %+v", sa)
-	}
-}
-
-func TestParseFlat(t *testing.T) {
-	raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"uid":"u2","nickname":"n2"}`)
-	sa, err := Parse(raw)
-	if err != nil || sa.UID != "u2" || sa.AccessToken != "at" {
-		t.Fatalf("flat: %+v %v", sa, err)
-	}
-}
-
-func TestParseMissingToken(t *testing.T) {
-	if _, err := Parse([]byte(`{"uid":"u3"}`)); err == nil {
-		t.Fatal("want error for missing accessToken")
-	}
-}
-
-func TestSaveAtomicRoundtrip(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "workbuddy-u1.json")
-	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000,
-		UID: "u1", EnterpriseID: "e1", Nickname: "n1", FilePath: fp}
-	if err := a.SaveAtomic(); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	if _, err := os.Stat(fp + ".tmp"); !os.IsNotExist(err) {
-		t.Error("tmp file should not remain")
-	}
-	raw, err := os.ReadFile(fp)
-	if err != nil {
-		t.Fatalf("read: %v", err)
-	}
-	b, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("reparse: %v", err)
-	}
-	if b.AccessToken != "at" || b.UID != "u1" || b.EnterpriseID != "e1" {
-		t.Errorf("roundtrip: %+v", b)
-	}
-}
-
-// TestLoadDirLoadsAllValid 不再按 region 过滤：所有可解析的 auth 文件都被加载，
-// 解析失败的文件静默跳过。
-func TestLoadDirLoadsAllValid(t *testing.T) {
-	dir := t.TempDir()
-	cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"cn1"}}`
-	other := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"example.com"},"account":{"uid":"u2"}}`
-	bad := `not json`
-	os.WriteFile(filepath.Join(dir, "workbuddy-cn1.json"), []byte(cn), 0o600)
-	os.WriteFile(filepath.Join(dir, "workbuddy-u2.json"), []byte(other), 0o600)
-	os.WriteFile(filepath.Join(dir, "workbuddy-bad.json"), []byte(bad), 0o600)
-
-	list, err := LoadDir(dir)
-	if err != nil {
-		t.Fatalf("load: %v", err)
-	}
-	if len(list) != 2 {
-		t.Fatalf("want 2 valid accounts, got %+v", list)
-	}
-	for _, a := range list {
-		if a.FilePath == "" {
-			t.Error("FilePath not set")
-		}
-	}
-}
-
-func TestNeedsRefresh(t *testing.T) {
-	a := &Auth{ExpiresAt: 0}
-	if !a.NeedsRefresh(0) {
-		t.Error("zero expiry should need refresh")
-	}
-	a.ExpiresAt = 9999999999
-	if a.NeedsRefresh(0) {
-		t.Error("far future should not need refresh")
-	}
-}
-
-// TestParseDeviceToken 嵌套形与扁平形 auth 文件的顶层 device_token 键均被解析。
-func TestParseDeviceToken(t *testing.T) {
-	nested := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":""},"account":{"uid":"u1"},"device_token":"dev-tok-nested"}`)
-	sa, err := Parse(nested)
-	if err != nil {
-		t.Fatalf("nested parse: %v", err)
-	}
-	if sa.DeviceToken != "dev-tok-nested" {
-		t.Errorf("nested DeviceToken = %q want %q", sa.DeviceToken, "dev-tok-nested")
-	}
-
-	flat := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","device_token":"dev-tok-flat"}`)
-	fa, err := Parse(flat)
-	if err != nil {
-		t.Fatalf("flat parse: %v", err)
-	}
-	if fa.DeviceToken != "dev-tok-flat" {
-		t.Errorf("flat DeviceToken = %q want %q", fa.DeviceToken, "dev-tok-flat")
-	}
-}
-
-// TestSaveAtomicPreservesDeviceToken SaveAtomic 写回后顶层 device_token 被保留并重新解析回来。
-func TestSaveAtomicPreservesDeviceToken(t *testing.T) {
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "workbuddy-dt.json")
-	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
-		UID: "u1", DeviceToken: "persisted-tok", FilePath: fp}
-	if err := a.SaveAtomic(); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	raw, err := os.ReadFile(fp)
-	if err != nil {
-		t.Fatalf("read: %v", err)
-	}
-	b, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("reparse: %v", err)
-	}
-	if b.DeviceToken != "persisted-tok" {
-		t.Errorf("roundtrip DeviceToken = %q want %q", b.DeviceToken, "persisted-tok")
-	}
-}
-
-// TestLoadDirBackfillsRealm 存量迁移：LoadDir 加载目录时对空 realm 的 auth 自动
-// backfill + SaveAtomic；已有 realm 的保持原值（不被 domain 覆盖）；文件全部带标识。
-func TestLoadDirBackfillsRealm(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-	fixtures := map[string]string{
-		"workbuddy-g1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`,
-		"workbuddy-c1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"c1"}}`,
-		// 已有 realm 的不因 domain 变化被覆盖：global domain + 显式 cn → 保持 cn
-		"workbuddy-c2.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai","realm":"cn"},"account":{"uid":"c2"}}`,
-	}
-	for name, body := range fixtures {
-		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil {
-			t.Fatal(err)
-		}
-	}
-
-	list, err := LoadDir(dir)
-	if err != nil {
-		t.Fatalf("load: %v", err)
-	}
-	if len(list) != 3 {
-		t.Fatalf("want 3 accounts, got %d", len(list))
-	}
-	want := map[string]string{"g1": "global", "c1": "cn", "c2": "cn"}
-	for _, a := range list {
-		// 内存态已补标识
-		if got := a.RealmStored(); got != want[a.UID] {
-			t.Errorf("uid=%s in-memory realm=%q want %q", a.UID, got, want[a.UID])
-		}
-		// 落盘文件也带 realm 键
-		raw, err := os.ReadFile(a.FilePath)
-		if err != nil {
-			t.Fatalf("read %s: %v", a.FilePath, err)
-		}
-		b, err := Parse(raw)
-		if err != nil {
-			t.Fatalf("reparse %s: %v", a.FilePath, err)
-		}
-		if got := b.RealmStored(); got != want[a.UID] {
-			t.Errorf("uid=%s on-disk realm=%q want %q", a.UID, got, want[a.UID])
-		}
-	}
-}
-
-// TestLoadDirBackfillWriteFailureDoesNotBlock 单个文件 backfill 落盘失败（tmp 预置目录
-// 使 WriteFile 失败）不阻断启动：其他文件照常迁移，LoadDir 不向上抛错。
-// （历史纯 CN auth 目录一次性迁移时，个别文件不可写不应让整个服务起不来。）
-func TestLoadDirBackfillWriteFailureDoesNotBlock(t *testing.T) {
-	t.Parallel()
-	dir := t.TempDir()
-	good := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`
-	if err := os.WriteFile(filepath.Join(dir, "workbuddy-g1.json"), []byte(good), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	// 预置同名 .tmp 目录 → SaveAtomic 的 os.WriteFile(".tmp") 报 is a directory。
-	if err := os.Mkdir(filepath.Join(dir, "workbuddy-c1.json.tmp"), 0o700); err != nil {
-		t.Fatal(err)
-	}
-	bad := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1},"account":{"uid":"c1"}}`
-	if err := os.WriteFile(filepath.Join(dir, "workbuddy-c1.json"), []byte(bad), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	list, err := LoadDir(dir)
-	if err != nil {
-		t.Fatalf("load err=%v want nil (write failure must not block startup)", err)
-	}
-	if len(list) != 2 {
-		t.Fatalf("want 2 accounts loaded, got %d", len(list))
-	}
-	// 好文件迁移成功
-	raw, _ := os.ReadFile(filepath.Join(dir, "workbuddy-g1.json"))
-	b, _ := Parse(raw)
-	if b.RealmStored() != "global" {
-		t.Errorf("good file realm=%q want global (migration should succeed)", b.RealmStored())
-	}
-}
-
-// TestLoadDirDuplicateUIDWarning 同 UID 双 realm auth 文件（概率近零的 EDGE）：LoadDir
-// 检测到重复 UID 时打 WARN（含两文件路径），且不改变加载行为——后载入者胜出（返回 1 个、
-// 不 panic、realm 为后载入者值）。LoadDir 现在有额外 seenUID 副作用，逐字验证 WARN。
-func TestLoadDirDuplicateUIDWarning(t *testing.T) {
-	dir := t.TempDir()
-	// 同一 UID u9 的两个文件：cn realm 文件按文件名排序在前（workbuddy-a-...），
-	// global realm 文件在后 → 后载入者（global）胜出。
-	cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":"www.codebuddy.cn"},"account":{"uid":"u9"}}`
-	gl := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"u9"}}`
-	if err := os.WriteFile(filepath.Join(dir, "workbuddy-a-cn.json"), []byte(cn), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if err := os.WriteFile(filepath.Join(dir, "workbuddy-z-global.json"), []byte(gl), 0o600); err != nil {
-		t.Fatal(err)
-	}
-
-	// 捕获 log 输出（本测试不 t.Parallel：log.SetOutput 是进程级全局，需串行）。
-	old := log.Writer()
-	r, w, err := os.Pipe()
-	if err != nil {
-		t.Fatal(err)
-	}
-	log.SetOutput(w)
-
-	list, err := LoadDir(dir)
-	_ = w.Close()
-	raw, _ := io.ReadAll(r)
-	log.SetOutput(old)
-
-	if err != nil {
-		t.Fatalf("load err=%v", err)
-	}
-	// 行为稳定（不改加载结果）：LoadDir 返回全部可解析文件（去重发生在 pool.SyncToDir
-	// 的 UID 键 upsert），不 panic。
-	if len(list) != 2 {
-		t.Fatalf("want 2 accounts loaded (dedup later in pool), got %d", len(list))
-	}
-	// WARN 已触发且含两文件路径。
-	if !strings.Contains(string(raw), "WARN: uid") ||
-		!strings.Contains(string(raw), "duplicated") ||
-		!strings.Contains(string(raw), "workbuddy-a-cn.json") ||
-		!strings.Contains(string(raw), "workbuddy-z-global.json") {
-		t.Errorf("expected WARN with both paths, got output: %s", string(raw))
-	}
-}
+package auth
+
+import (
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestParseNested(t *testing.T) {
+	raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"domain":""},"account":{"uid":"u1","enterpriseId":"e1","nickname":"n1"}}`)
+	sa, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("nested parse err: %v", err)
+	}
+	if sa.AccessToken != "at" || sa.RefreshToken != "rt" || sa.ExpiresAt != 1753600000 {
+		t.Errorf("tokens: %+v", sa)
+	}
+	if sa.UID != "u1" || sa.EnterpriseID != "e1" || sa.Nickname != "n1" {
+		t.Errorf("account: %+v", sa)
+	}
+}
+
+func TestParseFlat(t *testing.T) {
+	raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1753600000,"uid":"u2","nickname":"n2"}`)
+	sa, err := Parse(raw)
+	if err != nil || sa.UID != "u2" || sa.AccessToken != "at" {
+		t.Fatalf("flat: %+v %v", sa, err)
+	}
+}
+
+func TestParseMissingToken(t *testing.T) {
+	if _, err := Parse([]byte(`{"uid":"u3"}`)); err == nil {
+		t.Fatal("want error for missing accessToken")
+	}
+}
+
+func TestSaveAtomicRoundtrip(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "workbuddy-u1.json")
+	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1753600000,
+		UID: "u1", EnterpriseID: "e1", Nickname: "n1", FilePath: fp}
+	if err := a.SaveAtomic(); err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	if _, err := os.Stat(fp + ".tmp"); !os.IsNotExist(err) {
+		t.Error("tmp file should not remain")
+	}
+	raw, err := os.ReadFile(fp)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	b, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("reparse: %v", err)
+	}
+	if b.AccessToken != "at" || b.UID != "u1" || b.EnterpriseID != "e1" {
+		t.Errorf("roundtrip: %+v", b)
+	}
+}
+
+// TestLoadDirLoadsAllValid 不再按 region 过滤：所有可解析的 auth 文件都被加载，
+// 解析失败的文件静默跳过。
+func TestLoadDirLoadsAllValid(t *testing.T) {
+	dir := t.TempDir()
+	cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"cn1"}}`
+	other := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"example.com"},"account":{"uid":"u2"}}`
+	bad := `not json`
+	os.WriteFile(filepath.Join(dir, "workbuddy-cn1.json"), []byte(cn), 0o600)
+	os.WriteFile(filepath.Join(dir, "workbuddy-u2.json"), []byte(other), 0o600)
+	os.WriteFile(filepath.Join(dir, "workbuddy-bad.json"), []byte(bad), 0o600)
+
+	list, err := LoadDir(dir)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if len(list) != 2 {
+		t.Fatalf("want 2 valid accounts, got %+v", list)
+	}
+	for _, a := range list {
+		if a.FilePath == "" {
+			t.Error("FilePath not set")
+		}
+	}
+}
+
+func TestNeedsRefresh(t *testing.T) {
+	a := &Auth{ExpiresAt: 0}
+	if !a.NeedsRefresh(0) {
+		t.Error("zero expiry should need refresh")
+	}
+	a.ExpiresAt = 9999999999
+	if a.NeedsRefresh(0) {
+		t.Error("far future should not need refresh")
+	}
+}
+
+// TestParseDeviceToken 嵌套形与扁平形 auth 文件的顶层 device_token 键均被解析。
+func TestParseDeviceToken(t *testing.T) {
+	nested := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":""},"account":{"uid":"u1"},"device_token":"dev-tok-nested"}`)
+	sa, err := Parse(nested)
+	if err != nil {
+		t.Fatalf("nested parse: %v", err)
+	}
+	if sa.DeviceToken != "dev-tok-nested" {
+		t.Errorf("nested DeviceToken = %q want %q", sa.DeviceToken, "dev-tok-nested")
+	}
+
+	flat := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","device_token":"dev-tok-flat"}`)
+	fa, err := Parse(flat)
+	if err != nil {
+		t.Fatalf("flat parse: %v", err)
+	}
+	if fa.DeviceToken != "dev-tok-flat" {
+		t.Errorf("flat DeviceToken = %q want %q", fa.DeviceToken, "dev-tok-flat")
+	}
+}
+
+// TestSaveAtomicPreservesDeviceToken SaveAtomic 写回后顶层 device_token 被保留并重新解析回来。
+func TestSaveAtomicPreservesDeviceToken(t *testing.T) {
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "workbuddy-dt.json")
+	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
+		UID: "u1", DeviceToken: "persisted-tok", FilePath: fp}
+	if err := a.SaveAtomic(); err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	raw, err := os.ReadFile(fp)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	b, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("reparse: %v", err)
+	}
+	if b.DeviceToken != "persisted-tok" {
+		t.Errorf("roundtrip DeviceToken = %q want %q", b.DeviceToken, "persisted-tok")
+	}
+}
+
+// TestLoadDirBackfillsRealm 存量迁移：LoadDir 加载目录时对空 realm 的 auth 自动
+// backfill + SaveAtomic；已有 realm 的保持原值（不被 domain 覆盖）；文件全部带标识。
+func TestLoadDirBackfillsRealm(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	fixtures := map[string]string{
+		"workbuddy-g1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`,
+		"workbuddy-c1.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":""},"account":{"uid":"c1"}}`,
+		// 已有 realm 的不因 domain 变化被覆盖：global domain + 显式 cn → 保持 cn
+		"workbuddy-c2.json": `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai","realm":"cn"},"account":{"uid":"c2"}}`,
+	}
+	for name, body := range fixtures {
+		if err := os.WriteFile(filepath.Join(dir, name), []byte(body), 0o600); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	list, err := LoadDir(dir)
+	if err != nil {
+		t.Fatalf("load: %v", err)
+	}
+	if len(list) != 3 {
+		t.Fatalf("want 3 accounts, got %d", len(list))
+	}
+	want := map[string]string{"g1": "global", "c1": "cn", "c2": "cn"}
+	for _, a := range list {
+		// 内存态已补标识
+		if got := a.RealmStored(); got != want[a.UID] {
+			t.Errorf("uid=%s in-memory realm=%q want %q", a.UID, got, want[a.UID])
+		}
+		// 落盘文件也带 realm 键
+		raw, err := os.ReadFile(a.FilePath)
+		if err != nil {
+			t.Fatalf("read %s: %v", a.FilePath, err)
+		}
+		b, err := Parse(raw)
+		if err != nil {
+			t.Fatalf("reparse %s: %v", a.FilePath, err)
+		}
+		if got := b.RealmStored(); got != want[a.UID] {
+			t.Errorf("uid=%s on-disk realm=%q want %q", a.UID, got, want[a.UID])
+		}
+	}
+}
+
+// TestLoadDirBackfillWriteFailureDoesNotBlock 单个文件 backfill 落盘失败（tmp 预置目录
+// 使 WriteFile 失败）不阻断启动：其他文件照常迁移，LoadDir 不向上抛错。
+// （历史纯 CN auth 目录一次性迁移时，个别文件不可写不应让整个服务起不来。）
+func TestLoadDirBackfillWriteFailureDoesNotBlock(t *testing.T) {
+	t.Parallel()
+	dir := t.TempDir()
+	good := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"g1"}}`
+	if err := os.WriteFile(filepath.Join(dir, "workbuddy-g1.json"), []byte(good), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	// 预置同名 .tmp 目录 → SaveAtomic 的 os.WriteFile(".tmp") 报 is a directory。
+	if err := os.Mkdir(filepath.Join(dir, "workbuddy-c1.json.tmp"), 0o700); err != nil {
+		t.Fatal(err)
+	}
+	bad := `{"auth":{"accessToken":"at","refreshToken":"r","expiresAt":1},"account":{"uid":"c1"}}`
+	if err := os.WriteFile(filepath.Join(dir, "workbuddy-c1.json"), []byte(bad), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	list, err := LoadDir(dir)
+	if err != nil {
+		t.Fatalf("load err=%v want nil (write failure must not block startup)", err)
+	}
+	if len(list) != 2 {
+		t.Fatalf("want 2 accounts loaded, got %d", len(list))
+	}
+	// 好文件迁移成功
+	raw, _ := os.ReadFile(filepath.Join(dir, "workbuddy-g1.json"))
+	b, _ := Parse(raw)
+	if b.RealmStored() != "global" {
+		t.Errorf("good file realm=%q want global (migration should succeed)", b.RealmStored())
+	}
+}
+
+// TestLoadDirDuplicateUIDWarning 同 UID 双 realm auth 文件（概率近零的 EDGE）：LoadDir
+// 检测到重复 UID 时打 WARN（含两文件路径），且不改变加载行为——后载入者胜出（返回 1 个、
+// 不 panic、realm 为后载入者值）。LoadDir 现在有额外 seenUID 副作用，逐字验证 WARN。
+func TestLoadDirDuplicateUIDWarning(t *testing.T) {
+	dir := t.TempDir()
+	// 同一 UID u9 的两个文件：cn realm 文件按文件名排序在前（workbuddy-a-...），
+	// global realm 文件在后 → 后载入者（global）胜出。
+	cn := `{"auth":{"accessToken":"at1","refreshToken":"r","expiresAt":1,"domain":"www.codebuddy.cn"},"account":{"uid":"u9"}}`
+	gl := `{"auth":{"accessToken":"at2","refreshToken":"r","expiresAt":1,"domain":"www.workbuddy.ai"},"account":{"uid":"u9"}}`
+	if err := os.WriteFile(filepath.Join(dir, "workbuddy-a-cn.json"), []byte(cn), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, "workbuddy-z-global.json"), []byte(gl), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	// 捕获 log 输出（本测试不 t.Parallel：log.SetOutput 是进程级全局，需串行）。
+	old := log.Writer()
+	r, w, err := os.Pipe()
+	if err != nil {
+		t.Fatal(err)
+	}
+	log.SetOutput(w)
+
+	list, err := LoadDir(dir)
+	_ = w.Close()
+	raw, _ := io.ReadAll(r)
+	log.SetOutput(old)
+
+	if err != nil {
+		t.Fatalf("load err=%v", err)
+	}
+	// 行为稳定（不改加载结果）：LoadDir 返回全部可解析文件（去重发生在 pool.SyncToDir
+	// 的 UID 键 upsert），不 panic。
+	if len(list) != 2 {
+		t.Fatalf("want 2 accounts loaded (dedup later in pool), got %d", len(list))
+	}
+	// WARN 已触发且含两文件路径。
+	if !strings.Contains(string(raw), "WARN: uid") ||
+		!strings.Contains(string(raw), "duplicated") ||
+		!strings.Contains(string(raw), "workbuddy-a-cn.json") ||
+		!strings.Contains(string(raw), "workbuddy-z-global.json") {
+		t.Errorf("expected WARN with both paths, got output: %s", string(raw))
+	}
+}

internal/auth/permhint_test.go

@@ -1,29 +1,29 @@
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-)
-
-// TestSaveAtomicPermissionHint 无写权限目录下保存，错误应包含 Docker chown 指引。
-func TestSaveAtomicPermissionHint(t *testing.T) {
-	if runtime.GOOS == "windows" || os.Geteuid() == 0 {
-		t.Skip("Windows 无 POSIX 权限语义 / root 无权限限制，跳过")
-	}
-	dir := t.TempDir()
-	ro := filepath.Join(dir, "ro")
-	os.MkdirAll(ro, 0o555) // 只读目录
-	defer os.Chmod(ro, 0o755)
-	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
-		UID: "u1", FilePath: filepath.Join(ro, "workbuddy-u1.json")}
-	err := a.SaveAtomic()
-	if err == nil {
-		t.Fatal("只读目录保存应失败")
-	}
-	if !strings.Contains(err.Error(), "chown") || !strings.Contains(err.Error(), "10001") {
-		t.Errorf("权限错误应包含 Docker 指引，实际: %v", err)
-	}
-}
+package auth
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// TestSaveAtomicPermissionHint 无写权限目录下保存，错误应包含 Docker chown 指引。
+func TestSaveAtomicPermissionHint(t *testing.T) {
+	if runtime.GOOS == "windows" || os.Geteuid() == 0 {
+		t.Skip("Windows 无 POSIX 权限语义 / root 无权限限制，跳过")
+	}
+	dir := t.TempDir()
+	ro := filepath.Join(dir, "ro")
+	os.MkdirAll(ro, 0o555) // 只读目录
+	defer os.Chmod(ro, 0o755)
+	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
+		UID: "u1", FilePath: filepath.Join(ro, "workbuddy-u1.json")}
+	err := a.SaveAtomic()
+	if err == nil {
+		t.Fatal("只读目录保存应失败")
+	}
+	if !strings.Contains(err.Error(), "chown") || !strings.Contains(err.Error(), "10001") {
+		t.Errorf("权限错误应包含 Docker 指引，实际: %v", err)
+	}
+}

internal/auth/realm_test.go

@@ -1,275 +1,275 @@
-package auth
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-// withGlobalEnabled 临时打开 global realm 开关（生产缺省即开，此辅助仅显式确保），
-// 测试结束复位为开启态（缺省）。
-func withGlobalEnabled(t *testing.T) {
-	t.Helper()
-	globalEnabled.Store(true)
-	t.Cleanup(func() { globalEnabled.Store(true) })
-}
-
-// withGlobalDisabled 临时关闭 global realm 开关（逃生门），测试结束复位为开启态（缺省）。
-func withGlobalDisabled(t *testing.T) {
-	t.Helper()
-	globalEnabled.Store(false)
-	t.Cleanup(func() { globalEnabled.Store(true) })
-}
-
-func TestRealmExplicitGlobal(t *testing.T) {
-	withGlobalEnabled(t)
-	a := &Auth{realm: "global"}
-	if got := a.Realm(); got != "global" {
-		t.Errorf("Realm()=%q want global", got)
-	}
-	if !a.IsGlobal() {
-		t.Error("IsGlobal()=false want true")
-	}
-}
-
-func TestRealmExplicitCN(t *testing.T) {
-	a := &Auth{realm: "cn"}
-	if got := a.Realm(); got != "cn" {
-		t.Errorf("Realm()=%q want cn", got)
-	}
-	if a.IsGlobal() {
-		t.Error("IsGlobal()=true want false")
-	}
-}
-
-func TestRealmDomainFallback(t *testing.T) {
-	withGlobalEnabled(t)
-	cases := []struct{ domain, want string }{
-		{"www.workbuddy.ai", "global"},
-		{"workbuddy.ai", "global"},
-		{"sub.workbuddy.ai", "global"},
-		{"www.codebuddy.cn", "cn"},
-		{"", "cn"},
-	}
-	for _, c := range cases {
-		a := &Auth{Domain: c.domain}
-		if got := a.Realm(); got != c.want {
-			t.Errorf("Domain=%q Realm()=%q want %q", c.domain, got, c.want)
-		}
-	}
-}
-
-func TestRealmEmptyFallsBackToCN(t *testing.T) {
-	// 开关缺省开启（零回归前提）：空 realm + 空 domain → cn（老 CN 凭证的核心）。
-	a := &Auth{}
-	if got := a.Realm(); got != "cn" {
-		t.Errorf("Realm()=%q want cn", got)
-	}
-	// 显式 global → global（缺省开启，Realm() 不再因"未配置"而恒 cn）。
-	ag := &Auth{realm: "global"}
-	if got := ag.Realm(); got != "global" {
-		t.Errorf("Realm()=%q want global", got)
-	}
-	// domain 回落照常（缺省开启识别 workbuddy.ai）。
-	ad := &Auth{Domain: "www.workbuddy.ai"}
-	if got := ad.Realm(); got != "global" {
-		t.Errorf("Realm()=%q want global", got)
-	}
-}
-
-// TestRealmDefaultOnForCNZeroRegression 开关缺省开启时，老 CN 凭证（无 realm、无 domain）
-// Realm() 恒为 cn——「默认开启」不影响纯 CN 部署行为。
-func TestRealmDefaultOnForCNZeroRegression(t *testing.T) {
-	withGlobalEnabled(t)
-	cases := []*Auth{
-		{},
-		{Domain: "www.codebuddy.cn"},
-		{Domain: "codebuddy.cn"},
-		{realm: "cn"},
-		{realm: "cn", Domain: "www.codebuddy.cn"},
-	}
-	for _, a := range cases {
-		if got := a.Realm(); got != "cn" {
-			t.Errorf("%+v Realm()=%q want cn", a, got)
-		}
-		if a.IsGlobal() {
-			t.Errorf("%+v IsGlobal()=true want false", a)
-		}
-	}
-}
-
-// TestRealmExplicitOffEscapeHatch 逃生门：SetGlobalEnabled(false) 后恒 cn，
-// 即便 realm=global / domain=workbuddy.ai（纯 CN 锁定，与旧缺省行为等价）。
-func TestRealmExplicitOffEscapeHatch(t *testing.T) {
-	withGlobalDisabled(t)
-	cases := []struct {
-		auth *Auth
-	}{
-		{&Auth{realm: "global"}},
-		{&Auth{realm: "global", Domain: "www.workbuddy.ai"}},
-		{&Auth{Domain: "www.workbuddy.ai"}},
-	}
-	for _, tc := range cases {
-		if got := tc.auth.Realm(); got != "cn" {
-			t.Errorf("%+v Realm()=%q want cn (switch off)", tc.auth, got)
-		}
-		if tc.auth.IsGlobal() {
-			t.Errorf("%+v IsGlobal()=true want false (switch off)", tc.auth)
-		}
-	}
-}
-
-func TestParseNestedRealm(t *testing.T) {
-	raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":"www.workbuddy.ai","realm":"global"},"account":{"uid":"u1"}}`)
-	sa, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("nested parse err: %v", err)
-	}
-	if sa.realm != "global" {
-		t.Errorf("nested realm=%q want global", sa.realm)
-	}
-	// 嵌套形显式 realm 空 → 读不到，靠 domain 回落。
-	raw2 := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1},"account":{"uid":"u1"}}`)
-	sa2, err := Parse(raw2)
-	if err != nil {
-		t.Fatalf("nested no-realm parse err: %v", err)
-	}
-	if sa2.realm != "" {
-		t.Errorf("nested missing realm key should be zero, got %q", sa2.realm)
-	}
-}
-
-func TestParseFlatRealm(t *testing.T) {
-	withGlobalEnabled(t)
-	raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","realm":"global"}`)
-	fa, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("flat parse err: %v", err)
-	}
-	if fa.realm != "global" {
-		t.Errorf("flat realm=%q want global", fa.realm)
-	}
-	if !fa.IsGlobal() {
-		t.Error("flat global account IsGlobal()=false want true")
-	}
-	// 扁平形缺 realm 键 → 零值 → CN。
-	flatCN := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u3"}`)
-	fc, err := Parse(flatCN)
-	if err != nil {
-		t.Fatalf("flat cn parse err: %v", err)
-	}
-	if fc.realm != "" {
-		t.Errorf("flat missing realm should be zero, got %q", fc.realm)
-	}
-}
-
-func TestSaveAtomicWritesRealm(t *testing.T) {
-	withGlobalEnabled(t)
-	dir := t.TempDir()
-	fp := filepath.Join(dir, "workbuddy-global.json")
-	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
-		UID: "g1", realm: "global", FilePath: fp}
-	if err := a.SaveAtomic(); err != nil {
-		t.Fatalf("save: %v", err)
-	}
-	raw, err := os.ReadFile(fp)
-	if err != nil {
-		t.Fatalf("read: %v", err)
-	}
-	b, err := Parse(raw)
-	if err != nil {
-		t.Fatalf("reparse: %v", err)
-	}
-	if b.realm != "global" {
-		t.Errorf("roundtrip realm=%q want global", b.realm)
-	}
-	if !b.IsGlobal() {
-		t.Error("roundtrip global account IsGlobal()=false")
-	}
-}
-
-// TestBackfillRealmDomain CN/global 按原始 domain 推断（backfill 为导出空 realm 字段服务）。
-func TestBackfillRealmDomain(t *testing.T) {
-	t.Parallel() // 不触碰全局开关
-	cases := []struct {
-		domain string
-		want   string
-	}{
-		{"www.workbuddy.ai", "global"},
-		{"workbuddy.ai", "global"},
-		{"sub.workbuddy.ai", "global"},
-		{"www.codebuddy.cn", "cn"},
-		{"codebuddy.cn", "cn"},
-		{"", "cn"}, // 空 domain + 空 realm → cn（老 CN 凭证核心）
-	}
-	for _, c := range cases {
-		a := &Auth{Domain: c.domain}
-		changed, got := a.BackfillRealm()
-		if !changed {
-			t.Errorf("Domain=%q backfill changed=false want true", c.domain)
-		}
-		assertRealmStored(a, c.want, t)
-		if got != c.want {
-			t.Errorf("Domain=%q backfill got realm=%q want %q", c.domain, got, c.want)
-		}
-	}
-}
-
-// TestBackfillRealmEscapeHatchFree 逃生门关闭时 backfill 仍按原始 domain 推断（不受 Realm() 降级影响）。
-func TestBackfillRealmEscapeHatchFree(t *testing.T) {
-	withGlobalDisabled(t) // 逃生门关闭：Realm() 恒 cn，但 backfill 不得被污染
-	a := &Auth{Domain: "www.workbuddy.ai"}
-	if g := a.Realm(); g != "cn" {
-		t.Fatalf("precondition Realm()=%q want cn (escape hatch on)", g)
-	}
-	changed, got := a.BackfillRealm()
-	if !changed {
-		t.Fatal("backfill changed=false want true (escape hatch free)")
-	}
-	assertRealmStored(a, "global", t)
-	if got != "global" {
-		t.Errorf("backfill got=%q want global (escape hatch must not corrupt backfill)", got)
-	}
-}
-
-// TestBackfillRealmIdempotent 已有 realm 标识的文件不做修改（幂等）。
-func TestBackfillRealmIdempotent(t *testing.T) {
-	t.Parallel()
-	a := &Auth{Domain: "www.workbuddy.ai", realm: "cn"} // 已有 cn，domain 会推断 global——绝不覆盖
-	changed, got := a.BackfillRealm()
-	if changed {
-		t.Errorf("backfill changed=true want false (existing realm must win)")
-	}
-	if got != "cn" {
-		t.Errorf("backfill got=%q want cn (existing realm preserved)", got)
-	}
-	assertRealmStored(a, "cn", t)
-}
-
-func assertRealmStored(a *Auth, want string, t *testing.T) {
-	t.Helper()
-	if a.realm != want {
-		t.Errorf("stored realm field=%q want %q", a.realm, want)
-	}
-}
-
-// TestResolveRealm 纯函数归一化显式 realm，缺失时按 domain 推断（与 BackfillRealm
-// 共用同一来源；不受逃生门影响）。显式值优先于 domain 推断。
-func TestResolveRealm(t *testing.T) {
-	t.Parallel() // 纯函数：不触碰全局开关
-	cases := []struct {
-		explicit, domain, want string
-	}{
-		{"global", "www.codebuddy.cn", "global"}, // 显式优先：cn domain 也写 global
-		{"cn", "www.workbuddy.ai", "cn"},         // 显式优先：global domain 也写 cn
-		{"", "www.workbuddy.ai", "global"},       // 缺省按 domain 推断
-		{"", "workbuddy.ai", "global"},
-		{"", "codebuddy.cn", "cn"},
-		{"", "", "cn"}, // 空 domain → cn（老 CN 凭证零回归）
-	}
-	for _, c := range cases {
-		if got := ResolveRealm(c.explicit, c.domain); got != c.want {
-			t.Errorf("ResolveRealm(%q,%q)=%q want %q", c.explicit, c.domain, got, c.want)
-		}
-	}
-}
+package auth
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// withGlobalEnabled 临时打开 global realm 开关（生产缺省即开，此辅助仅显式确保），
+// 测试结束复位为开启态（缺省）。
+func withGlobalEnabled(t *testing.T) {
+	t.Helper()
+	globalEnabled.Store(true)
+	t.Cleanup(func() { globalEnabled.Store(true) })
+}
+
+// withGlobalDisabled 临时关闭 global realm 开关（逃生门），测试结束复位为开启态（缺省）。
+func withGlobalDisabled(t *testing.T) {
+	t.Helper()
+	globalEnabled.Store(false)
+	t.Cleanup(func() { globalEnabled.Store(true) })
+}
+
+func TestRealmExplicitGlobal(t *testing.T) {
+	withGlobalEnabled(t)
+	a := &Auth{realm: "global"}
+	if got := a.Realm(); got != "global" {
+		t.Errorf("Realm()=%q want global", got)
+	}
+	if !a.IsGlobal() {
+		t.Error("IsGlobal()=false want true")
+	}
+}
+
+func TestRealmExplicitCN(t *testing.T) {
+	a := &Auth{realm: "cn"}
+	if got := a.Realm(); got != "cn" {
+		t.Errorf("Realm()=%q want cn", got)
+	}
+	if a.IsGlobal() {
+		t.Error("IsGlobal()=true want false")
+	}
+}
+
+func TestRealmDomainFallback(t *testing.T) {
+	withGlobalEnabled(t)
+	cases := []struct{ domain, want string }{
+		{"www.workbuddy.ai", "global"},
+		{"workbuddy.ai", "global"},
+		{"sub.workbuddy.ai", "global"},
+		{"www.codebuddy.cn", "cn"},
+		{"", "cn"},
+	}
+	for _, c := range cases {
+		a := &Auth{Domain: c.domain}
+		if got := a.Realm(); got != c.want {
+			t.Errorf("Domain=%q Realm()=%q want %q", c.domain, got, c.want)
+		}
+	}
+}
+
+func TestRealmEmptyFallsBackToCN(t *testing.T) {
+	// 开关缺省开启（零回归前提）：空 realm + 空 domain → cn（老 CN 凭证的核心）。
+	a := &Auth{}
+	if got := a.Realm(); got != "cn" {
+		t.Errorf("Realm()=%q want cn", got)
+	}
+	// 显式 global → global（缺省开启，Realm() 不再因"未配置"而恒 cn）。
+	ag := &Auth{realm: "global"}
+	if got := ag.Realm(); got != "global" {
+		t.Errorf("Realm()=%q want global", got)
+	}
+	// domain 回落照常（缺省开启识别 workbuddy.ai）。
+	ad := &Auth{Domain: "www.workbuddy.ai"}
+	if got := ad.Realm(); got != "global" {
+		t.Errorf("Realm()=%q want global", got)
+	}
+}
+
+// TestRealmDefaultOnForCNZeroRegression 开关缺省开启时，老 CN 凭证（无 realm、无 domain）
+// Realm() 恒为 cn——「默认开启」不影响纯 CN 部署行为。
+func TestRealmDefaultOnForCNZeroRegression(t *testing.T) {
+	withGlobalEnabled(t)
+	cases := []*Auth{
+		{},
+		{Domain: "www.codebuddy.cn"},
+		{Domain: "codebuddy.cn"},
+		{realm: "cn"},
+		{realm: "cn", Domain: "www.codebuddy.cn"},
+	}
+	for _, a := range cases {
+		if got := a.Realm(); got != "cn" {
+			t.Errorf("%+v Realm()=%q want cn", a, got)
+		}
+		if a.IsGlobal() {
+			t.Errorf("%+v IsGlobal()=true want false", a)
+		}
+	}
+}
+
+// TestRealmExplicitOffEscapeHatch 逃生门：SetGlobalEnabled(false) 后恒 cn，
+// 即便 realm=global / domain=workbuddy.ai（纯 CN 锁定，与旧缺省行为等价）。
+func TestRealmExplicitOffEscapeHatch(t *testing.T) {
+	withGlobalDisabled(t)
+	cases := []struct {
+		auth *Auth
+	}{
+		{&Auth{realm: "global"}},
+		{&Auth{realm: "global", Domain: "www.workbuddy.ai"}},
+		{&Auth{Domain: "www.workbuddy.ai"}},
+	}
+	for _, tc := range cases {
+		if got := tc.auth.Realm(); got != "cn" {
+			t.Errorf("%+v Realm()=%q want cn (switch off)", tc.auth, got)
+		}
+		if tc.auth.IsGlobal() {
+			t.Errorf("%+v IsGlobal()=true want false (switch off)", tc.auth)
+		}
+	}
+}
+
+func TestParseNestedRealm(t *testing.T) {
+	raw := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1,"domain":"www.workbuddy.ai","realm":"global"},"account":{"uid":"u1"}}`)
+	sa, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("nested parse err: %v", err)
+	}
+	if sa.realm != "global" {
+		t.Errorf("nested realm=%q want global", sa.realm)
+	}
+	// 嵌套形显式 realm 空 → 读不到，靠 domain 回落。
+	raw2 := []byte(`{"auth":{"accessToken":"at","refreshToken":"rt","expiresAt":1},"account":{"uid":"u1"}}`)
+	sa2, err := Parse(raw2)
+	if err != nil {
+		t.Fatalf("nested no-realm parse err: %v", err)
+	}
+	if sa2.realm != "" {
+		t.Errorf("nested missing realm key should be zero, got %q", sa2.realm)
+	}
+}
+
+func TestParseFlatRealm(t *testing.T) {
+	withGlobalEnabled(t)
+	raw := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u2","realm":"global"}`)
+	fa, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("flat parse err: %v", err)
+	}
+	if fa.realm != "global" {
+		t.Errorf("flat realm=%q want global", fa.realm)
+	}
+	if !fa.IsGlobal() {
+		t.Error("flat global account IsGlobal()=false want true")
+	}
+	// 扁平形缺 realm 键 → 零值 → CN。
+	flatCN := []byte(`{"accessToken":"at","refreshToken":"rt","expiresAt":1,"uid":"u3"}`)
+	fc, err := Parse(flatCN)
+	if err != nil {
+		t.Fatalf("flat cn parse err: %v", err)
+	}
+	if fc.realm != "" {
+		t.Errorf("flat missing realm should be zero, got %q", fc.realm)
+	}
+}
+
+func TestSaveAtomicWritesRealm(t *testing.T) {
+	withGlobalEnabled(t)
+	dir := t.TempDir()
+	fp := filepath.Join(dir, "workbuddy-global.json")
+	a := &Auth{AccessToken: "at", RefreshToken: "rt", ExpiresAt: 1,
+		UID: "g1", realm: "global", FilePath: fp}
+	if err := a.SaveAtomic(); err != nil {
+		t.Fatalf("save: %v", err)
+	}
+	raw, err := os.ReadFile(fp)
+	if err != nil {
+		t.Fatalf("read: %v", err)
+	}
+	b, err := Parse(raw)
+	if err != nil {
+		t.Fatalf("reparse: %v", err)
+	}
+	if b.realm != "global" {
+		t.Errorf("roundtrip realm=%q want global", b.realm)
+	}
+	if !b.IsGlobal() {
+		t.Error("roundtrip global account IsGlobal()=false")
+	}
+}
+
+// TestBackfillRealmDomain CN/global 按原始 domain 推断（backfill 为导出空 realm 字段服务）。
+func TestBackfillRealmDomain(t *testing.T) {
+	t.Parallel() // 不触碰全局开关
+	cases := []struct {
+		domain string
+		want   string
+	}{
+		{"www.workbuddy.ai", "global"},
+		{"workbuddy.ai", "global"},
+		{"sub.workbuddy.ai", "global"},
+		{"www.codebuddy.cn", "cn"},
+		{"codebuddy.cn", "cn"},
+		{"", "cn"}, // 空 domain + 空 realm → cn（老 CN 凭证核心）
+	}
+	for _, c := range cases {
+		a := &Auth{Domain: c.domain}
+		changed, got := a.BackfillRealm()
+		if !changed {
+			t.Errorf("Domain=%q backfill changed=false want true", c.domain)
+		}
+		assertRealmStored(a, c.want, t)
+		if got != c.want {
+			t.Errorf("Domain=%q backfill got realm=%q want %q", c.domain, got, c.want)
+		}
+	}
+}
+
+// TestBackfillRealmEscapeHatchFree 逃生门关闭时 backfill 仍按原始 domain 推断（不受 Realm() 降级影响）。
+func TestBackfillRealmEscapeHatchFree(t *testing.T) {
+	withGlobalDisabled(t) // 逃生门关闭：Realm() 恒 cn，但 backfill 不得被污染
+	a := &Auth{Domain: "www.workbuddy.ai"}
+	if g := a.Realm(); g != "cn" {
+		t.Fatalf("precondition Realm()=%q want cn (escape hatch on)", g)
+	}
+	changed, got := a.BackfillRealm()
+	if !changed {
+		t.Fatal("backfill changed=false want true (escape hatch free)")
+	}
+	assertRealmStored(a, "global", t)
+	if got != "global" {
+		t.Errorf("backfill got=%q want global (escape hatch must not corrupt backfill)", got)
+	}
+}
+
+// TestBackfillRealmIdempotent 已有 realm 标识的文件不做修改（幂等）。
+func TestBackfillRealmIdempotent(t *testing.T) {
+	t.Parallel()
+	a := &Auth{Domain: "www.workbuddy.ai", realm: "cn"} // 已有 cn，domain 会推断 global——绝不覆盖
+	changed, got := a.BackfillRealm()
+	if changed {
+		t.Errorf("backfill changed=true want false (existing realm must win)")
+	}
+	if got != "cn" {
+		t.Errorf("backfill got=%q want cn (existing realm preserved)", got)
+	}
+	assertRealmStored(a, "cn", t)
+}
+
+func assertRealmStored(a *Auth, want string, t *testing.T) {
+	t.Helper()
+	if a.realm != want {
+		t.Errorf("stored realm field=%q want %q", a.realm, want)
+	}
+}
+
+// TestResolveRealm 纯函数归一化显式 realm，缺失时按 domain 推断（与 BackfillRealm
+// 共用同一来源；不受逃生门影响）。显式值优先于 domain 推断。
+func TestResolveRealm(t *testing.T) {
+	t.Parallel() // 纯函数：不触碰全局开关
+	cases := []struct {
+		explicit, domain, want string
+	}{
+		{"global", "www.codebuddy.cn", "global"}, // 显式优先：cn domain 也写 global
+		{"cn", "www.workbuddy.ai", "cn"},         // 显式优先：global domain 也写 cn
+		{"", "www.workbuddy.ai", "global"},       // 缺省按 domain 推断
+		{"", "workbuddy.ai", "global"},
+		{"", "codebuddy.cn", "cn"},
+		{"", "", "cn"}, // 空 domain → cn（老 CN 凭证零回归）
+	}
+	for _, c := range cases {
+		if got := ResolveRealm(c.explicit, c.domain); got != c.want {
+			t.Errorf("ResolveRealm(%q,%q)=%q want %q", c.explicit, c.domain, got, c.want)
+		}
+	}
+}

internal/httpauth/httpauth.go

@@ -1,43 +1,43 @@
-// Package httpauth 网关与面板共用的 Bearer 鉴权原语。
-//
-// 单独成包的原因：server（/v1/*、/status）与 panel（/panel/api/*）两处鉴权
-// 必须完全同口径——此前各自复制了一份"字符串直接比较"的实现，既容易漂移，
-// 又都带计时侧信道。统一到这里后，口径只有一份，且天然常量时间比较。
-package httpauth
-
-import (
-	"crypto/sha256"
-	"crypto/subtle"
-	"net/http"
-	"strings"
-)
-
-// bearerPrefix 认证方案前缀（大小写敏感，与 HTTP 规范及既有实现一致）。
-const bearerPrefix = "Bearer "
-
-// VerifyBearer 校验请求头是否携带正确的 Bearer 密钥。
-//
-// key 为空表示"未启用鉴权"，恒返回 true（调用方据此放行）。
-// 比较用 SHA-256 摘要 + subtle.ConstantTimeCompare：
-//   - 常量时间，不因前缀匹配长度而泄露信息；
-//   - 先摘要再比较，长度差异被吸收进摘要（不会因长度不同提前返回）；
-//   - 摘要本身不可逆，即便有侧信道也拿不到密钥原文。
-func VerifyBearer(r *http.Request, key string) bool {
-	if key == "" {
-		return true
-	}
-	authz := r.Header.Get("Authorization")
-	if !strings.HasPrefix(authz, bearerPrefix) {
-		// 缺头/方案不对：仍走一次摘要比较，保持耗时形状一致。
-		subtle.ConstantTimeCompare(digest(""), digest(key))
-		return false
-	}
-	tok := authz[len(bearerPrefix):]
-	return subtle.ConstantTimeCompare(digest(tok), digest(key)) == 1
-}
-
-// digest 返回 s 的 SHA-256（定长 32 字节，供常量时间比较）。
-func digest(s string) []byte {
-	sum := sha256.Sum256([]byte(s))
-	return sum[:]
-}
+// Package httpauth 网关与面板共用的 Bearer 鉴权原语。
+//
+// 单独成包的原因：server（/v1/*、/status）与 panel（/panel/api/*）两处鉴权
+// 必须完全同口径——此前各自复制了一份"字符串直接比较"的实现，既容易漂移，
+// 又都带计时侧信道。统一到这里后，口径只有一份，且天然常量时间比较。
+package httpauth
+
+import (
+	"crypto/sha256"
+	"crypto/subtle"
+	"net/http"
+	"strings"
+)
+
+// bearerPrefix 认证方案前缀（大小写敏感，与 HTTP 规范及既有实现一致）。
+const bearerPrefix = "Bearer "
+
+// VerifyBearer 校验请求头是否携带正确的 Bearer 密钥。
+//
+// key 为空表示"未启用鉴权"，恒返回 true（调用方据此放行）。
+// 比较用 SHA-256 摘要 + subtle.ConstantTimeCompare：
+//   - 常量时间，不因前缀匹配长度而泄露信息；
+//   - 先摘要再比较，长度差异被吸收进摘要（不会因长度不同提前返回）；
+//   - 摘要本身不可逆，即便有侧信道也拿不到密钥原文。
+func VerifyBearer(r *http.Request, key string) bool {
+	if key == "" {
+		return true
+	}
+	authz := r.Header.Get("Authorization")
+	if !strings.HasPrefix(authz, bearerPrefix) {
+		// 缺头/方案不对：仍走一次摘要比较，保持耗时形状一致。
+		subtle.ConstantTimeCompare(digest(""), digest(key))
+		return false
+	}
+	tok := authz[len(bearerPrefix):]
+	return subtle.ConstantTimeCompare(digest(tok), digest(key)) == 1
+}
+
+// digest 返回 s 的 SHA-256（定长 32 字节，供常量时间比较）。
+func digest(s string) []byte {
+	sum := sha256.Sum256([]byte(s))
+	return sum[:]
+}

internal/httpauth/httpauth_test.go

@@ -1,61 +1,61 @@
-package httpauth
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func req(authz string) *http.Request {
-	r := httptest.NewRequest("GET", "/", nil)
-	if authz != "" {
-		r.Header.Set("Authorization", authz)
-	}
-	return r
-}
-
-func TestVerifyBearer(t *testing.T) {
-	cases := []struct {
-		name  string
-		key   string
-		authz string
-		want  bool
-	}{
-		{"空 key 放行（未启用鉴权）", "", "", true},
-		{"空 key 也放行任意头", "", "Bearer whatever", true},
-		{"正确 key", "sk-abc123", "Bearer sk-abc123", true},
-		{"错误 key", "sk-abc123", "Bearer sk-wrong", false},
-		{"缺 Authorization 头", "sk-abc123", "", false},
-		{"缺 Bearer 前缀", "sk-abc123", "sk-abc123", false},
-		{"前缀大小写不符（规范要求精确）", "sk-abc123", "bearer sk-abc123", false},
-		{"多余空格", "sk-abc123", "Bearer  sk-abc123", false},
-		{"前缀相同但内容短", "sk-abc123", "Bearer sk-abc12", false},
-		{"前缀相同但内容长", "sk-abc123", "Bearer sk-abc1234", false},
-		{"key 恰好是前缀", "sk-abc", "Bearer sk-abcdef", false},
-	}
-	for _, c := range cases {
-		t.Run(c.name, func(t *testing.T) {
-			if got := VerifyBearer(req(c.authz), c.key); got != c.want {
-				t.Errorf("VerifyBearer(key=%q, authz=%q) = %v, want %v", c.key, c.authz, got, c.want)
-			}
-		})
-	}
-}
-
-// TestVerifyBearerWithoutHeaderStillCompares 缺头路径不应因"提前返回"而暴露形状差异：
-// 这里只验证它确实返回 false 且不 panic（常量时间的性质无法用单测断言，靠实现保证）。
-func TestVerifyBearerWithoutHeaderStillCompares(t *testing.T) {
-	if VerifyBearer(req(""), "any-key") {
-		t.Error("missing header must not pass")
-	}
-}
-
-func TestDigestIsFixedLength(t *testing.T) {
-	// 不同长度输入摘要后应等长（这是常量时间比较的前提）
-	if len(digest("")) != len(digest("a-much-longer-secret-value")) {
-		t.Error("digest length must not depend on input length")
-	}
-	if len(digest("x")) != 32 {
-		t.Errorf("sha256 digest length = %d, want 32", len(digest("x")))
-	}
-}
+package httpauth
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func req(authz string) *http.Request {
+	r := httptest.NewRequest("GET", "/", nil)
+	if authz != "" {
+		r.Header.Set("Authorization", authz)
+	}
+	return r
+}
+
+func TestVerifyBearer(t *testing.T) {
+	cases := []struct {
+		name  string
+		key   string
+		authz string
+		want  bool
+	}{
+		{"空 key 放行（未启用鉴权）", "", "", true},
+		{"空 key 也放行任意头", "", "Bearer whatever", true},
+		{"正确 key", "sk-abc123", "Bearer sk-abc123", true},
+		{"错误 key", "sk-abc123", "Bearer sk-wrong", false},
+		{"缺 Authorization 头", "sk-abc123", "", false},
+		{"缺 Bearer 前缀", "sk-abc123", "sk-abc123", false},
+		{"前缀大小写不符（规范要求精确）", "sk-abc123", "bearer sk-abc123", false},
+		{"多余空格", "sk-abc123", "Bearer  sk-abc123", false},
+		{"前缀相同但内容短", "sk-abc123", "Bearer sk-abc12", false},
+		{"前缀相同但内容长", "sk-abc123", "Bearer sk-abc1234", false},
+		{"key 恰好是前缀", "sk-abc", "Bearer sk-abcdef", false},
+	}
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			if got := VerifyBearer(req(c.authz), c.key); got != c.want {
+				t.Errorf("VerifyBearer(key=%q, authz=%q) = %v, want %v", c.key, c.authz, got, c.want)
+			}
+		})
+	}
+}
+
+// TestVerifyBearerWithoutHeaderStillCompares 缺头路径不应因"提前返回"而暴露形状差异：
+// 这里只验证它确实返回 false 且不 panic（常量时间的性质无法用单测断言，靠实现保证）。
+func TestVerifyBearerWithoutHeaderStillCompares(t *testing.T) {
+	if VerifyBearer(req(""), "any-key") {
+		t.Error("missing header must not pass")
+	}
+}
+
+func TestDigestIsFixedLength(t *testing.T) {
+	// 不同长度输入摘要后应等长（这是常量时间比较的前提）
+	if len(digest("")) != len(digest("a-much-longer-secret-value")) {
+		t.Error("digest length must not depend on input length")
+	}
+	if len(digest("x")) != 32 {
+		t.Errorf("sha256 digest length = %d, want 32", len(digest("x")))
+	}
+}

internal/livecfg/livecfg.go

@@ -1,48 +1,48 @@
-// Package livecfg 运行期可变配置的并发安全持有者。
-//
-// 背景：进程启动时读入的配置是普通字段（读多写零），但管理面板允许在线改配置，
-// 于是少量"可热生效"的字段需要有并发安全的读写点。此处用不可变快照 + atomic 指针：
-// 读方 Load 拿到一致视图，写方 Store 整体替换，无锁无数据竞争。
-//
-// 只承载**读路径深、热改需求强**的少数字段；池参数/排程参数等各有既有 setter
-// （pool.SetBreaker、scheduler.Reconfigure 等），不重复收编到这里。
-package livecfg
-
-import (
-	"sync/atomic"
-	"time"
-)
-
-// Snapshot 一次读取的不可变配置视图。
-type Snapshot struct {
-	APIKey               string        // 网关/面板共同鉴权密钥；空 = 不鉴权
-	SoftCooldown         time.Duration // 429 软冷却基数（<=0 时调用方回退内置默认）
-	SanitizeFingerprints bool          // 出站请求体指纹脱敏
-	RecordClientInfo     bool          // 请求日志是否记录调用来源（客户端 IP / UA）
-}
-
-// Holder 原子持有当前快照。
-type Holder struct {
-	p atomic.Pointer[Snapshot]
-}
-
-// New 以初始快照构建。
-func New(s Snapshot) *Holder {
-	h := &Holder{}
-	h.Store(s)
-	return h
-}
-
-// Load 返回当前快照（Holder 为 nil 或从未 Store 时返回零值快照，调用方无需判空）。
-func (h *Holder) Load() Snapshot {
-	if h == nil {
-		return Snapshot{}
-	}
-	if s := h.p.Load(); s != nil {
-		return *s
-	}
-	return Snapshot{}
-}
-
-// Store 整体替换快照。
-func (h *Holder) Store(s Snapshot) { h.p.Store(&s) }
+// Package livecfg 运行期可变配置的并发安全持有者。
+//
+// 背景：进程启动时读入的配置是普通字段（读多写零），但管理面板允许在线改配置，
+// 于是少量"可热生效"的字段需要有并发安全的读写点。此处用不可变快照 + atomic 指针：
+// 读方 Load 拿到一致视图，写方 Store 整体替换，无锁无数据竞争。
+//
+// 只承载**读路径深、热改需求强**的少数字段；池参数/排程参数等各有既有 setter
+// （pool.SetBreaker、scheduler.Reconfigure 等），不重复收编到这里。
+package livecfg
+
+import (
+	"sync/atomic"
+	"time"
+)
+
+// Snapshot 一次读取的不可变配置视图。
+type Snapshot struct {
+	APIKey               string        // 网关/面板共同鉴权密钥；空 = 不鉴权
+	SoftCooldown         time.Duration // 429 软冷却基数（<=0 时调用方回退内置默认）
+	SanitizeFingerprints bool          // 出站请求体指纹脱敏
+	RecordClientInfo     bool          // 请求日志是否记录调用来源（客户端 IP / UA）
+}
+
+// Holder 原子持有当前快照。
+type Holder struct {
+	p atomic.Pointer[Snapshot]
+}
+
+// New 以初始快照构建。
+func New(s Snapshot) *Holder {
+	h := &Holder{}
+	h.Store(s)
+	return h
+}
+
+// Load 返回当前快照（Holder 为 nil 或从未 Store 时返回零值快照，调用方无需判空）。
+func (h *Holder) Load() Snapshot {
+	if h == nil {
+		return Snapshot{}
+	}
+	if s := h.p.Load(); s != nil {
+		return *s
+	}
+	return Snapshot{}
+}
+
+// Store 整体替换快照。
+func (h *Holder) Store(s Snapshot) { h.p.Store(&s) }

internal/logfmt/logfmt.go

@@ -1,166 +1,166 @@
-// Package logfmt 统一网关日志的 uid 截断与模块前缀约定。
-//
-// 约定：
-//   - uid 统一截 8 位：与 chat 流水行（internal/server/logging.go uidPrefix）对齐，
-//     日志行只留 uid 前 8 位。全量 uid 可从 data/state.json 查（54 个号无 8 位前缀碰撞）。
-//   - 模块前缀：调度四类已有天然前缀（travel/activity/checkin/keepalive）保持；
-//     其他补 [pool]/[auth]/[server] 等 [mod] 方括号前缀，redisstore/session 已有保持。
-//   - 级别语义：正常流转不打级别字样（保持简洁）；可疑/降级/失败行加 WARN:/ERR: 前缀。
-//
-// 本包不引入日志库，只提供 UID8 截断 / Label 账号标签 / Pad 显示宽对齐三个纯字符串
-// helper，供各包替代裸写 [:8] 与手算表格列宽（防 uid 短于 8 越界、防中文昵称错位）。
-package logfmt
-
-import (
-	"strings"
-	"unicode/utf8"
-)
-
-// Truncate 截断字符串到 n 字节上限（先 TrimSpace，与旧 upstream/内部实现口径
-// 一致），切点落在多字节字符中间时回退到 UTF-8 rune 边界——错误 body 多为中文
-// （"将在 … 重置"），按字节切会出半截序列乱码。短于 n 原样返回；n<=0 返回空串。
-func Truncate(s string, n int) string {
-	if n <= 0 {
-		return ""
-	}
-	s = strings.TrimSpace(s)
-	if len(s) > n {
-		// s[n] 是切点后的首字节：是 rune 的后续字节（continuation）说明切点落在
-		// 多字节字符中间，逐字节回退到 rune 边界（该字符整个让出）。
-		for n > 0 && !utf8.RuneStart(s[n]) {
-			n--
-		}
-		return s[:n]
-	}
-	return s
-}
-
-// UID8 返回 uid 的前 8 位；空 uid 返回 "-"（与 server.uidPrefix 对齐）。
-//
-// 用于调度类与非调度类日志行，把 <task> <full-uid>: ... 改为 <task> <uid8>: ...
-// 全量 uid 留在 state.json 供排查，日志里 8 位足够唯一定位。
-func UID8(uid string) string {
-	if uid == "" {
-		return "-"
-	}
-	if len(uid) > 8 {
-		return uid[:8]
-	}
-	return uid
-}
-
-// Label 返回日志里的账号标签，形如 "示例昵称甲(a1b2c3d4)"；昵称为空时退回 "a1b2c3d4"。
-//
-// 为什么需要：uid8 是机器标识，排障时人眼无法直接判断"刚才那个 429/6004 是哪个号"，
-// 必须再拿 uid8 去 auths/ 或 data/state.json 反查昵称，一条日志要多跳一步。昵称随
-// 登录落在 auths/<uid>.json 的 account.nickname，这里把它与 uid8 拼成可直接辨认的
-// 标签——昵称认人、uid8 供 grep，两者都保留。
-//
-// uid 与 nick 同时为空时返回 "-"（与 UID8 口径一致，避免打出 "(-)"）。
-func Label(uid, nick string) string {
-	short := UID8(uid)
-	nick = strings.TrimSpace(nick)
-	if nick == "" {
-		return short
-	}
-	return nick + "(" + short + ")"
-}
-
-// DisplayWidth 返回 s 的终端显示列宽：CJK / 全角 / emoji 记 2 列，其余记 1 列。
-//
-// 存在意义：账号昵称是用户自定的中文（"猫" 是 3 字节但占 2 列，"sample" 是 6 字节占
-// 6 列），用 len()（字节数）做表格对齐会导致列宽忽宽忽窄。Go 标准库没有显示宽度函数，
-// 本仓库不引 go-runewidth（保持零第三方依赖），故内置这份覆盖常见宽字符区段的判定。
-func DisplayWidth(s string) int {
-	w := 0
-	for _, r := range s {
-		w += runeWidth(r)
-	}
-	return w
-}
-
-// Pad 把 s 右补空格到 width 显示列宽；已超宽或 width<=0 时原样返回（不截断）。
-// 只补不截：截断会丢信息，超宽时让该行自然变宽，保持内容完整。
-func Pad(s string, width int) string {
-	if width <= 0 {
-		return s
-	}
-	if d := width - DisplayWidth(s); d > 0 {
-		return s + strings.Repeat(" ", d)
-	}
-	return s
-}
-
-// maxShortUALen ShortUA 的返回上限（显示列宽足够放下 "WorkBuddy/5.5.6"、
-// "python-requests/2.31.0" 这类常见客户端标签）。
-const maxShortUALen = 40
-
-// shortUAEngines UA 里只说明渲染引擎、不说明"是什么客户端"的通用 token：浏览器 UA
-// 恒定包含它们，拿它当客户端标签等于没信息。
-var shortUAEngines = map[string]bool{
-	"mozilla": true, "applewebkit": true, "gecko": true, "khtml": true,
-	"like": true, "safari": true, "compatible": true, "msie": true, "trident": true,
-}
-
-// ShortUA 从 User-Agent 提取便于人眼识别的客户端标签（"curl/8.4.0"、
-// "WorkBuddy/5.5.6"、"Chrome/120.0.0.0"）。
-//
-// 为什么需要：面板「运行日志」与 stdout 流水行都要展示调用来源，而完整 UA 动辄
-// 120+ 字符（浏览器尤其），直接铺进表格会把其它列挤没。这里只留"是什么客户端"，
-// 完整 UA 仍存在 reqlog.Event.UserAgent 里供面板悬停查看。
-//
-// 规则：取第一个形如 name/version 且 name 不是渲染引擎的 token；没有则回落整串
-// 的前 maxShortUALen 字节（纯产品名 UA，如 "node"）。空 UA 返回空串。
-func ShortUA(ua string) string {
-	ua = strings.TrimSpace(ua)
-	if ua == "" {
-		return ""
-	}
-	for _, tok := range strings.Fields(ua) {
-		tok = strings.Trim(tok, "(),;")
-		name, _, ok := strings.Cut(tok, "/")
-		if !ok || name == "" {
-			continue
-		}
-		if shortUAEngines[strings.ToLower(name)] {
-			continue
-		}
-		return Truncate(tok, maxShortUALen)
-	}
-	return Truncate(ua, maxShortUALen)
-}
-
-// runeWidth 单个 rune 的显示列宽。区段判定取自 Unicode East Asian Width 的
-// Wide/Fullwidth 集合（与 go-runewidth 的默认表口径一致），只保留实际会用到的段。
-func runeWidth(r rune) int {
-	switch {
-	case r == 0:
-		return 0
-	case r < 0x20 || (r >= 0x7f && r < 0xa0):
-		// 控制字符（含 DEL/C1）不占位：日志里若混入 \t \r 不破坏列宽计算。
-		return 0
-	case r < 0x1100:
-		return 1
-	case r <= 0x115f: // Hangul Jamo 初声
-		return 2
-	case r == 0x2329 || r == 0x232a:
-		return 2
-	case r >= 0x2e80 && r <= 0xa4cf && r != 0x303f: // CJK 部首…Yi（303f 是窄字符）
-		return 2
-	case r >= 0xac00 && r <= 0xd7a3: // Hangul 音节
-		return 2
-	case r >= 0xf900 && r <= 0xfaff: // CJK 兼容表意
-		return 2
-	case r >= 0xfe30 && r <= 0xfe6f: // CJK 兼容形式
-		return 2
-	case r >= 0xff00 && r <= 0xff60: // 全角 ASCII
-		return 2
-	case r >= 0xffe0 && r <= 0xffe6: // 全角符号
-		return 2
-	case r >= 0x1f300 && r <= 0x1f9ff: // emoji
-		return 2
-	case r >= 0x20000 && r <= 0x3fffd: // CJK 扩展 B 及以后
-		return 2
-	}
-	return 1
-}
+// Package logfmt 统一网关日志的 uid 截断与模块前缀约定。
+//
+// 约定：
+//   - uid 统一截 8 位：与 chat 流水行（internal/server/logging.go uidPrefix）对齐，
+//     日志行只留 uid 前 8 位。全量 uid 可从 data/state.json 查（54 个号无 8 位前缀碰撞）。
+//   - 模块前缀：调度四类已有天然前缀（travel/activity/checkin/keepalive）保持；
+//     其他补 [pool]/[auth]/[server] 等 [mod] 方括号前缀，redisstore/session 已有保持。
+//   - 级别语义：正常流转不打级别字样（保持简洁）；可疑/降级/失败行加 WARN:/ERR: 前缀。
+//
+// 本包不引入日志库，只提供 UID8 截断 / Label 账号标签 / Pad 显示宽对齐三个纯字符串
+// helper，供各包替代裸写 [:8] 与手算表格列宽（防 uid 短于 8 越界、防中文昵称错位）。
+package logfmt
+
+import (
+	"strings"
+	"unicode/utf8"
+)
+
+// Truncate 截断字符串到 n 字节上限（先 TrimSpace，与旧 upstream/内部实现口径
+// 一致），切点落在多字节字符中间时回退到 UTF-8 rune 边界——错误 body 多为中文
+// （"将在 … 重置"），按字节切会出半截序列乱码。短于 n 原样返回；n<=0 返回空串。
+func Truncate(s string, n int) string {
+	if n <= 0 {
+		return ""
+	}
+	s = strings.TrimSpace(s)
+	if len(s) > n {
+		// s[n] 是切点后的首字节：是 rune 的后续字节（continuation）说明切点落在
+		// 多字节字符中间，逐字节回退到 rune 边界（该字符整个让出）。
+		for n > 0 && !utf8.RuneStart(s[n]) {
+			n--
+		}
+		return s[:n]
+	}
+	return s
+}
+
+// UID8 返回 uid 的前 8 位；空 uid 返回 "-"（与 server.uidPrefix 对齐）。
+//
+// 用于调度类与非调度类日志行，把 <task> <full-uid>: ... 改为 <task> <uid8>: ...
+// 全量 uid 留在 state.json 供排查，日志里 8 位足够唯一定位。
+func UID8(uid string) string {
+	if uid == "" {
+		return "-"
+	}
+	if len(uid) > 8 {
+		return uid[:8]
+	}
+	return uid
+}
+
+// Label 返回日志里的账号标签，形如 "示例昵称甲(a1b2c3d4)"；昵称为空时退回 "a1b2c3d4"。
+//
+// 为什么需要：uid8 是机器标识，排障时人眼无法直接判断"刚才那个 429/6004 是哪个号"，
+// 必须再拿 uid8 去 auths/ 或 data/state.json 反查昵称，一条日志要多跳一步。昵称随
+// 登录落在 auths/<uid>.json 的 account.nickname，这里把它与 uid8 拼成可直接辨认的
+// 标签——昵称认人、uid8 供 grep，两者都保留。
+//
+// uid 与 nick 同时为空时返回 "-"（与 UID8 口径一致，避免打出 "(-)"）。
+func Label(uid, nick string) string {
+	short := UID8(uid)
+	nick = strings.TrimSpace(nick)
+	if nick == "" {
+		return short
+	}
+	return nick + "(" + short + ")"
+}
+
+// DisplayWidth 返回 s 的终端显示列宽：CJK / 全角 / emoji 记 2 列，其余记 1 列。
+//
+// 存在意义：账号昵称是用户自定的中文（"猫" 是 3 字节但占 2 列，"sample" 是 6 字节占
+// 6 列），用 len()（字节数）做表格对齐会导致列宽忽宽忽窄。Go 标准库没有显示宽度函数，
+// 本仓库不引 go-runewidth（保持零第三方依赖），故内置这份覆盖常见宽字符区段的判定。
+func DisplayWidth(s string) int {
+	w := 0
+	for _, r := range s {
+		w += runeWidth(r)
+	}
+	return w
+}
+
+// Pad 把 s 右补空格到 width 显示列宽；已超宽或 width<=0 时原样返回（不截断）。
+// 只补不截：截断会丢信息，超宽时让该行自然变宽，保持内容完整。
+func Pad(s string, width int) string {
+	if width <= 0 {
+		return s
+	}
+	if d := width - DisplayWidth(s); d > 0 {
+		return s + strings.Repeat(" ", d)
+	}
+	return s
+}
+
+// maxShortUALen ShortUA 的返回上限（显示列宽足够放下 "WorkBuddy/5.5.6"、
+// "python-requests/2.31.0" 这类常见客户端标签）。
+const maxShortUALen = 40
+
+// shortUAEngines UA 里只说明渲染引擎、不说明"是什么客户端"的通用 token：浏览器 UA
+// 恒定包含它们，拿它当客户端标签等于没信息。
+var shortUAEngines = map[string]bool{
+	"mozilla": true, "applewebkit": true, "gecko": true, "khtml": true,
+	"like": true, "safari": true, "compatible": true, "msie": true, "trident": true,
+}
+
+// ShortUA 从 User-Agent 提取便于人眼识别的客户端标签（"curl/8.4.0"、
+// "WorkBuddy/5.5.6"、"Chrome/120.0.0.0"）。
+//
+// 为什么需要：面板「运行日志」与 stdout 流水行都要展示调用来源，而完整 UA 动辄
+// 120+ 字符（浏览器尤其），直接铺进表格会把其它列挤没。这里只留"是什么客户端"，
+// 完整 UA 仍存在 reqlog.Event.UserAgent 里供面板悬停查看。
+//
+// 规则：取第一个形如 name/version 且 name 不是渲染引擎的 token；没有则回落整串
+// 的前 maxShortUALen 字节（纯产品名 UA，如 "node"）。空 UA 返回空串。
+func ShortUA(ua string) string {
+	ua = strings.TrimSpace(ua)
+	if ua == "" {
+		return ""
+	}
+	for _, tok := range strings.Fields(ua) {
+		tok = strings.Trim(tok, "(),;")
+		name, _, ok := strings.Cut(tok, "/")
+		if !ok || name == "" {
+			continue
+		}
+		if shortUAEngines[strings.ToLower(name)] {
+			continue
+		}
+		return Truncate(tok, maxShortUALen)
+	}
+	return Truncate(ua, maxShortUALen)
+}
+
+// runeWidth 单个 rune 的显示列宽。区段判定取自 Unicode East Asian Width 的
+// Wide/Fullwidth 集合（与 go-runewidth 的默认表口径一致），只保留实际会用到的段。
+func runeWidth(r rune) int {
+	switch {
+	case r == 0:
+		return 0
+	case r < 0x20 || (r >= 0x7f && r < 0xa0):
+		// 控制字符（含 DEL/C1）不占位：日志里若混入 \t \r 不破坏列宽计算。
+		return 0
+	case r < 0x1100:
+		return 1
+	case r <= 0x115f: // Hangul Jamo 初声
+		return 2
+	case r == 0x2329 || r == 0x232a:
+		return 2
+	case r >= 0x2e80 && r <= 0xa4cf && r != 0x303f: // CJK 部首…Yi（303f 是窄字符）
+		return 2
+	case r >= 0xac00 && r <= 0xd7a3: // Hangul 音节
+		return 2
+	case r >= 0xf900 && r <= 0xfaff: // CJK 兼容表意
+		return 2
+	case r >= 0xfe30 && r <= 0xfe6f: // CJK 兼容形式
+		return 2
+	case r >= 0xff00 && r <= 0xff60: // 全角 ASCII
+		return 2
+	case r >= 0xffe0 && r <= 0xffe6: // 全角符号
+		return 2
+	case r >= 0x1f300 && r <= 0x1f9ff: // emoji
+		return 2
+	case r >= 0x20000 && r <= 0x3fffd: // CJK 扩展 B 及以后
+		return 2
+	}
+	return 1
+}

internal/logfmt/shortua_test.go

@@ -1,50 +1,50 @@
-package logfmt
-
-import "testing"
-
-func TestShortUA(t *testing.T) {
-	cases := []struct {
-		name string
-		ua   string
-		want string
-	}{
-		{"empty", "", ""},
-		{"blank", "   ", ""},
-		{"curl", "curl/8.4.0", "curl/8.4.0"},
-		{"python", "python-requests/2.31.0", "python-requests/2.31.0"},
-		{"openai", "OpenAI/Python 1.30.0", "OpenAI/Python"},
-		{"workbuddy", "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1", "WorkBuddy/5.5.6"},
-		{
-			"chrome skips engine tokens",
-			"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-			"Chrome/120.0.0.0",
-		},
-		{
-			"firefox",
-			"Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0",
-			"Firefox/121.0",
-		},
-		{"no version token", "node", "node"},
-		{"only engine tokens falls back to whole", "Mozilla/5.0 AppleWebKit/537.36", "Mozilla/5.0 AppleWebKit/537.36"},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			if got := ShortUA(tc.ua); got != tc.want {
-				t.Fatalf("ShortUA(%q) = %q want %q", tc.ua, got, tc.want)
-			}
-		})
-	}
-}
-
-// ShortUA 的返回值必须有界：UA 是客户端可控自由文本，超长值不能原样带进日志列。
-func TestShortUABounded(t *testing.T) {
-	long := "VeryLongClientNameThatKeepsGoingAndGoing/1.2.3"
-	if got := ShortUA(long); len(got) > maxShortUALen {
-		t.Fatalf("len(ShortUA) = %d want <= %d (%q)", len(got), maxShortUALen, got)
-	}
-	// 没有 name/version token 时回落整串，同样受上限约束。
-	got := ShortUA("x" + string(make([]byte, 0)) + "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy")
-	if len(got) > maxShortUALen {
-		t.Fatalf("fallback not truncated: %d", len(got))
-	}
-}
+package logfmt
+
+import "testing"
+
+func TestShortUA(t *testing.T) {
+	cases := []struct {
+		name string
+		ua   string
+		want string
+	}{
+		{"empty", "", ""},
+		{"blank", "   ", ""},
+		{"curl", "curl/8.4.0", "curl/8.4.0"},
+		{"python", "python-requests/2.31.0", "python-requests/2.31.0"},
+		{"openai", "OpenAI/Python 1.30.0", "OpenAI/Python"},
+		{"workbuddy", "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1", "WorkBuddy/5.5.6"},
+		{
+			"chrome skips engine tokens",
+			"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+			"Chrome/120.0.0.0",
+		},
+		{
+			"firefox",
+			"Mozilla/5.0 (X11; Linux x86_64; rv:121.0) Gecko/20100101 Firefox/121.0",
+			"Firefox/121.0",
+		},
+		{"no version token", "node", "node"},
+		{"only engine tokens falls back to whole", "Mozilla/5.0 AppleWebKit/537.36", "Mozilla/5.0 AppleWebKit/537.36"},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			if got := ShortUA(tc.ua); got != tc.want {
+				t.Fatalf("ShortUA(%q) = %q want %q", tc.ua, got, tc.want)
+			}
+		})
+	}
+}
+
+// ShortUA 的返回值必须有界：UA 是客户端可控自由文本，超长值不能原样带进日志列。
+func TestShortUABounded(t *testing.T) {
+	long := "VeryLongClientNameThatKeepsGoingAndGoing/1.2.3"
+	if got := ShortUA(long); len(got) > maxShortUALen {
+		t.Fatalf("len(ShortUA) = %d want <= %d (%q)", len(got), maxShortUALen, got)
+	}
+	// 没有 name/version token 时回落整串，同样受上限约束。
+	got := ShortUA("x" + string(make([]byte, 0)) + "yyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyy")
+	if len(got) > maxShortUALen {
+		t.Fatalf("fallback not truncated: %d", len(got))
+	}
+}

internal/panel/autotask_lock_test.go

@@ -1,52 +1,52 @@
-package panel
-
-import (
-	"testing"
-)
-
-// TestTaskAccountLockSameAccountExclusive 同一账号的任务锁互斥：第二次 tryLock 必须失败，
-// 解锁后可再次获取。这是「重复点一键完成不并发重跑」的核心保障。
-func TestTaskAccountLockSameAccountExclusive(t *testing.T) {
-	p := &Panel{}
-	uid := "u1"
-
-	if !p.tryLockAccount(uid) {
-		t.Fatal("首次加锁应成功")
-	}
-	if p.tryLockAccount(uid) {
-		t.Fatal("同账号第二次加锁应失败（互斥）")
-	}
-	p.unlockAccount(uid)
-
-	if !p.tryLockAccount(uid) {
-		t.Fatal("解锁后应可再次加锁")
-	}
-	p.unlockAccount(uid)
-}
-
-// TestTaskAccountLockDifferentAccountsIndependent 不同账号的锁互不影响（并行照旧）。
-func TestTaskAccountLockDifferentAccountsIndependent(t *testing.T) {
-	p := &Panel{}
-	if !p.tryLockAccount("u1") {
-		t.Fatal("u1 加锁应成功")
-	}
-	if !p.tryLockAccount("u2") {
-		t.Fatal("u2 加锁应成功（不同账号不互斥）")
-	}
-	p.unlockAccount("u2")
-	p.unlockAccount("u1")
-}
-
-// TestTaskAccountLockCrossEntryShared 单任务 auto 与全量 auto_all 共用同一把账号锁
-// （在 handler 层都走 tryLockAccount，这里验证锁命名空间一致）。
-func TestTaskAccountLockCrossEntryShared(t *testing.T) {
-	p := &Panel{}
-	if !p.tryLockAccount("u1") {
-		t.Fatal("u1 加锁应成功")
-	}
-	// 模拟全量入口对同一 uid 加锁——必须被挡（否则两入口可并发）。
-	if p.tryLockAccount("u1") {
-		t.Fatal("同 uid 跨入口加锁应失败（共用锁）")
-	}
-	p.unlockAccount("u1")
-}
+package panel
+
+import (
+	"testing"
+)
+
+// TestTaskAccountLockSameAccountExclusive 同一账号的任务锁互斥：第二次 tryLock 必须失败，
+// 解锁后可再次获取。这是「重复点一键完成不并发重跑」的核心保障。
+func TestTaskAccountLockSameAccountExclusive(t *testing.T) {
+	p := &Panel{}
+	uid := "u1"
+
+	if !p.tryLockAccount(uid) {
+		t.Fatal("首次加锁应成功")
+	}
+	if p.tryLockAccount(uid) {
+		t.Fatal("同账号第二次加锁应失败（互斥）")
+	}
+	p.unlockAccount(uid)
+
+	if !p.tryLockAccount(uid) {
+		t.Fatal("解锁后应可再次加锁")
+	}
+	p.unlockAccount(uid)
+}
+
+// TestTaskAccountLockDifferentAccountsIndependent 不同账号的锁互不影响（并行照旧）。
+func TestTaskAccountLockDifferentAccountsIndependent(t *testing.T) {
+	p := &Panel{}
+	if !p.tryLockAccount("u1") {
+		t.Fatal("u1 加锁应成功")
+	}
+	if !p.tryLockAccount("u2") {
+		t.Fatal("u2 加锁应成功（不同账号不互斥）")
+	}
+	p.unlockAccount("u2")
+	p.unlockAccount("u1")
+}
+
+// TestTaskAccountLockCrossEntryShared 单任务 auto 与全量 auto_all 共用同一把账号锁
+// （在 handler 层都走 tryLockAccount，这里验证锁命名空间一致）。
+func TestTaskAccountLockCrossEntryShared(t *testing.T) {
+	p := &Panel{}
+	if !p.tryLockAccount("u1") {
+		t.Fatal("u1 加锁应成功")
+	}
+	// 模拟全量入口对同一 uid 加锁——必须被挡（否则两入口可并发）。
+	if p.tryLockAccount("u1") {
+		t.Fatal("同 uid 跨入口加锁应失败（共用锁）")
+	}
+	p.unlockAccount("u1")
+}

internal/panel/config.go

@@ -1,57 +1,57 @@
-// config.go 面板配置页接口：读取当前配置、校验并保存（热生效 + 重启项标注）。
-//
-// 分工：cmd/server 持有 Config 类型与校验逻辑（Load/normalize），此处只做
-// HTTP 编排——GET 回显、POST 透传给注入的 SaveConfig 闭包（由 main 完成
-// "校验 → 落盘 → 热应用 → 返回需重启字段列表"）。
-package panel
-
-import (
-	"io"
-	"log"
-	"net/http"
-)
-
-// getConfig 返回当前配置文件内容与路径（前端按 schema 渲染表单）。
-func (p *Panel) getConfig(w http.ResponseWriter, r *http.Request) {
-	if p.cfg.LoadConfig == nil {
-		writeErr(w, http.StatusNotImplemented, "config api not available")
-		return
-	}
-	cfg, err := p.cfg.LoadConfig()
-	if err != nil {
-		writeErr(w, http.StatusInternalServerError, "load config: "+err.Error())
-		return
-	}
-	writeJSON(w, http.StatusOK, map[string]any{
-		"ok":     true,
-		"path":   p.cfg.ConfigPath,
-		"config": cfg,
-	})
-}
-
-// saveConfig 保存配置：body 直接是配置 JSON（前端按 schema 组装完整对象）。
-// SaveConfig 闭包内部完成校验+落盘+热应用；校验失败返回 400 且不写盘。
-func (p *Panel) saveConfig(w http.ResponseWriter, r *http.Request) {
-	if p.cfg.SaveConfig == nil {
-		writeErr(w, http.StatusNotImplemented, "config api not available")
-		return
-	}
-	raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
-	if err != nil {
-		writeErr(w, http.StatusBadRequest, "read body: "+err.Error())
-		return
-	}
-	restartRequired, err := p.cfg.SaveConfig(raw)
-	if err != nil {
-		writeErr(w, http.StatusBadRequest, err.Error())
-		return
-	}
-	if restartRequired == nil {
-		restartRequired = []string{}
-	}
-	log.Printf("panel: 配置已保存（热生效完成；需重启字段 %d 个）", len(restartRequired))
-	writeJSON(w, http.StatusOK, map[string]any{
-		"ok":               true,
-		"restart_required": restartRequired,
-	})
-}
+// config.go 面板配置页接口：读取当前配置、校验并保存（热生效 + 重启项标注）。
+//
+// 分工：cmd/server 持有 Config 类型与校验逻辑（Load/normalize），此处只做
+// HTTP 编排——GET 回显、POST 透传给注入的 SaveConfig 闭包（由 main 完成
+// "校验 → 落盘 → 热应用 → 返回需重启字段列表"）。
+package panel
+
+import (
+	"io"
+	"log"
+	"net/http"
+)
+
+// getConfig 返回当前配置文件内容与路径（前端按 schema 渲染表单）。
+func (p *Panel) getConfig(w http.ResponseWriter, r *http.Request) {
+	if p.cfg.LoadConfig == nil {
+		writeErr(w, http.StatusNotImplemented, "config api not available")
+		return
+	}
+	cfg, err := p.cfg.LoadConfig()
+	if err != nil {
+		writeErr(w, http.StatusInternalServerError, "load config: "+err.Error())
+		return
+	}
+	writeJSON(w, http.StatusOK, map[string]any{
+		"ok":     true,
+		"path":   p.cfg.ConfigPath,
+		"config": cfg,
+	})
+}
+
+// saveConfig 保存配置：body 直接是配置 JSON（前端按 schema 组装完整对象）。
+// SaveConfig 闭包内部完成校验+落盘+热应用；校验失败返回 400 且不写盘。
+func (p *Panel) saveConfig(w http.ResponseWriter, r *http.Request) {
+	if p.cfg.SaveConfig == nil {
+		writeErr(w, http.StatusNotImplemented, "config api not available")
+		return
+	}
+	raw, err := io.ReadAll(io.LimitReader(r.Body, 1<<20))
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "read body: "+err.Error())
+		return
+	}
+	restartRequired, err := p.cfg.SaveConfig(raw)
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	if restartRequired == nil {
+		restartRequired = []string{}
+	}
+	log.Printf("panel: 配置已保存（热生效完成；需重启字段 %d 个）", len(restartRequired))
+	writeJSON(w, http.StatusOK, map[string]any{
+		"ok":               true,
+		"restart_required": restartRequired,
+	})
+}

internal/panel/frontend_test.go

@@ -1,647 +1,769 @@
-package panel
-
-import (
-	"bytes"
-	"net/http/httptest"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-// TestAppJSSyntax app.js 必须能通过 JS 解析器语法校验。
-//
-// 为什么需要：app.js 是 go:embed 进二进制的静态资源，Go 编译器不检查其内容——
-// 一次对象字面量键名未加引号（Model_chat_GLM5.2 被解析成属性访问 + 数字字面量）
-// 就让整个面板白屏，而所有 Go 测试依然全绿。此测试把语法校验前移到 CI。
-// 无 node 环境时跳过（不阻塞无 Node 的构建机）。
-func TestAppJSSyntax(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not available; skipping JS syntax check")
-	}
-	path, err := filepath.Abs("app.js")
-	if err != nil {
-		t.Fatal(err)
-	}
-	out, err := exec.Command(node, "--check", path).CombinedOutput()
-	if err != nil {
-		t.Fatalf("app.js syntax error:\n%s", out)
-	}
-}
-
-// TestIndexHTMLNoInlineScript index.html 不得含内联 <script> 块：
-// 严格 CSP（script-src 'self'）会拦截内联脚本，页面将完全不可用。
-// 外链形式 <script src="..."> 允许。
-func TestIndexHTMLNoInlineScript(t *testing.T) {
-	p := newTestPanel()
-	rec := httptest.NewRecorder()
-	p.ServeHTTP(rec, httptest.NewRequest("GET", "/panel/", nil))
-	body := rec.Body.String()
-
-	rest := body
-	for {
-		idx := strings.Index(rest, "<script")
-		if idx < 0 {
-			break
-		}
-		rest = rest[idx:]
-		end := strings.Index(rest, ">")
-		if end < 0 {
-			break
-		}
-		tag := rest[:end+1]
-		if !strings.Contains(tag, "src=") {
-			t.Fatalf("index.html contains inline <script> (blocked by CSP): %s", tag)
-		}
-		rest = rest[end:]
-	}
-}
-
-// TestAppJSTopLevelSmoke app.js 顶层求值冒烟（v1.11.3/1.11.4 两连炸后补的运行时闸门）：
-// node + DOM 桩执行 app.js（含按 hash 落到各视图的 go() 顶层调用），抓 TDZ/
-// ReferenceError 类运行时错误——Go 侧 frontend_test 不执行 JS，语法层检查对此全盲。
-// 无 node 的环境跳过（CI/精简机不受影响）；harness 与 app.js 同判（app.js 顶层
-// start() 的 setInterval 会让 node 事件循环不退出，故成功路径显式 exit(0)）。
-func TestAppJSTopLevelSmoke(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; JS smoke skipped")
-	}
-	harness := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const inert = new Proxy(function () {}, {
-  get(t, k) { if (k === Symbol.toPrimitive) return () => ''; return inert; },
-  set() { return true; },
-  apply() { return inert; },
-  construct() { return inert; },
-  has() { return true; },
-});
-const sandbox = new Proxy({
-  location: { hash: process.env.SMOKE_HASH || '#taskscenter' },
-  history: { replaceState() {} },
-  localStorage: { getItem: () => null, setItem() {} },
-  navigator: { clipboard: { writeText: () => Promise.resolve() } },
-  document: { querySelectorAll: () => [], querySelector: () => inert, getElementById: () => inert, addEventListener() {}, documentElement: inert, head: inert, body: inert, createElement: () => inert, cookie: '' },
-  fetch: () => new Promise(() => {}),
-  addEventListener() {}, removeEventListener() {},
-  matchMedia: () => ({ matches: false, addEventListener() {} }),
-  setInterval, clearInterval, setTimeout, clearTimeout,
-  console, JSON, Math, Date, Number, String, Boolean, Object, Array, Promise, Map, Set, RegExp, Error, TypeError, isNaN, parseInt, parseFloat, encodeURIComponent, decodeURIComponent, URL, Symbol, Proxy, Reflect,
-}, { get(t, k) { return t[k]; }, has() { return true; } });
-sandbox.window = sandbox; sandbox.globalThis = sandbox;
-vm.createContext(sandbox);
-try {
-  vm.runInContext(src, sandbox, { filename: 'app.js' });
-  console.log('SMOKE OK');
-  process.exit(0);
-} catch (e) {
-  console.log('SMOKE FAIL:', (e && e.stack ? e.stack : e).toString().split('\n').slice(0, 5).join('\n'));
-  process.exit(1);
-}
-`
-	hf, err := os.CreateTemp(t.TempDir(), "smoke-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := hf.WriteString(harness); err != nil {
-		t.Fatal(err)
-	}
-	hf.Close()
-	for _, hash := range []string{"#taskscenter", "#accounts", "#usage", "#models", "#config", "#logs", "#packages"} {
-		cmd := exec.Command(node, hf.Name(), "app.js")
-		cmd.Dir = "." // 测试工作目录 = internal/panel
-		cmd.Env = append(os.Environ(), "SMOKE_HASH="+hash)
-		out, err := cmd.CombinedOutput()
-		if err != nil {
-			t.Fatalf("app.js 顶层求值 %s 崩溃: %v\n%s", hash, err, out)
-		}
-		if !bytes.Contains(out, []byte("SMOKE OK")) {
-			t.Fatalf("app.js smoke %s 未通过:\n%s", hash, out)
-		}
-	}
-}
-
-// 积分扣除维度的格式必须稳定，且缺样本/缺匹配 Token 时不能伪造比例。
-func TestAppJSCreditDimensionFormatting(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; credit formatting test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-	const start = src.indexOf('function trimFixed');
-const end = src.indexOf('function usStat');
-if (start < 0 || end < 0) throw new Error('credit helpers not found');
-const ctx = { Number, String, RegExp };
-vm.createContext(ctx);
-vm.runInContext(
-  src.slice(start, end) +
-  '\nthis.fmtCredit=fmtCredit; this.fmtCreditRatio=fmtCreditRatio; this.fmtModelRate=fmtModelRate;',
-  ctx
-);
-process.stdout.write(JSON.stringify({
-  credit: ctx.fmtCredit(1.25),
-  zero: ctx.fmtCredit(0),
-  hundred: ctx.fmtCredit(100),
-  ratio: ctx.fmtCreditRatio(12.5, 2, 400),
-  noSamples: ctx.fmtCreditRatio(12.5, 0, 400),
-  noTokens: ctx.fmtCreditRatio(12.5, 2, 0),
-  rate: ctx.fmtModelRate('0.5'),
-  noRate: ctx.fmtModelRate(''),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "credit-format-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("credit formatting node test failed: %v\n%s", err, out)
-	}
-	const want = `{"credit":"1.25","zero":"0","hundred":"100","ratio":"12.5 / 1M","noSamples":"—","noTokens":"—","rate":"x0.5","noRate":"—"}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("credit formatting=%s want %s", out, want)
-	}
-}
-
-// 模型限流时间必须同时支持上游 reset_at、网关 until 和无重置时间三种形态。
-func TestAppJSRateLimitMeta(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; rate limit formatting test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('function dur(');
-const end = src.indexOf('function rateLimitRowsHtml');
-if (start < 0 || end < 0) throw new Error('rate limit helpers not found');
-const ctx = { Date, Number, String, Math };
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) + '\nthis.rateLimitMeta=rateLimitMeta;', ctx);
-const now = new Date(2026, 8, 28, 14, 0, 0).getTime();
-const reset = new Date(2026, 8, 28, 16, 0, 0).getTime();
-const until = new Date(2026, 8, 28, 15, 0, 0).getTime();
-const rate = ctx.rateLimitMeta({ model: 'glm-5.3', kind: 'rate_limit', reset_at: new Date(reset).toISOString(), until: new Date(until).toISOString() }, now);
-const unavailable = ctx.rateLimitMeta({ model: 'missing', kind: 'model_unavailable', until: new Date(until).toISOString() }, now);
-const unknown = ctx.rateLimitMeta({ model: 'glm-5.3', kind: 'rate_limit' }, now);
-process.stdout.write(JSON.stringify({
-  rate: rate.detail,
-  unavailable: unavailable.detail,
-  unknown: unknown.detail,
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "rate-limit-format-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("rate-limit formatting node test failed: %v\n%s", err, out)
-	}
-	const want = `{"rate":"预计 2026-09-28 16:00 解封（剩余 2时00分） · 网关最快 1时00分 后重试","unavailable":"预计 1时00分 后重试","unknown":"预计解封时间未知"}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("rate-limit formatting=%s want %s", out, want)
-	}
-}
-
-// 请求记录行必须紧凑、可读，并带上调用来源（IP / UA）；来源缺失时以 — 兜底。
-func TestAppJSRequestLogFormatting(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; request log formatting test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const escStart = src.indexOf('function esc(');
-const escEnd = src.indexOf('function ago(');
-const fmtStart = src.indexOf('function fmtTok(');
-const fmtEnd = src.indexOf('function usStat(');
-const reqStart = src.indexOf('function requestLogText');
-const reqEnd = src.indexOf('function fmtBytes');
-if ([escStart, escEnd, fmtStart, fmtEnd, reqStart, reqEnd].some(v => v < 0)) throw new Error('request log helpers not found');
-const ctx = { Date, Number, String, Math, RegExp, isNaN };
-vm.createContext(ctx);
-vm.runInContext(
-  src.slice(escStart, escEnd) + src.slice(fmtStart, fmtEnd) + src.slice(reqStart, reqEnd) +
-  '\nthis.requestLogText=requestLogText;',
-  ctx
-);
-const time = new Date(2026, 8, 28, 14, 5, 6).toISOString();
-const good = { time, status: 200, outcome: 'success', model: 'glm-5.3', account: '账号(uid8)', duration_ms: 1250, total_tokens: 2300, credit_known: true, credit: 0.12, request_id: 'req-1', client_ip: '203.0.113.7', user_agent: 'python-requests/2.31.0' };
-const noSource = { ...good, request_id: 'req-3', client_ip: '', user_agent: '' };
-const cached = { ...good, request_id: 'req-2', cache_hit_tokens: 2257, cache_miss_tokens: 43 };
-process.stdout.write(JSON.stringify({
-  good: ctx.requestLogText(good),
-  noSource: ctx.requestLogText(noSource),
-  cached: ctx.requestLogText(cached),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "request-log-format-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("request log formatting node test failed: %v\n%s", err, out)
-	}
-	text := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | 203.0.113.7 | python-requests/2.31.0 | 1.25s | 2.3k tok | 0.12 credit | req-1"
-	noSource := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | — | — | 1.25s | 2.3k tok | 0.12 credit | req-3"
-	cached := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | 203.0.113.7 | python-requests/2.31.0 | 1.25s | 2.3k tok | 0.12 credit | 命中 98.1% | req-2"
-	want := `{"good":` + strconv.Quote(text) + `,"noSource":` + strconv.Quote(noSource) + `,"cached":` + strconv.Quote(cached) + `}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("request log formatting=%s want %s", out, want)
-	}
-}
-
-// 请求记录筛选：IP / UA / 模型 / 账号 / 请求 ID 的包含匹配（空格分词 AND）+ 结果精确匹配。
-func TestAppJSRequestMatch(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; request filter test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('function reqMatch');
-const end = src.indexOf('function reqOutcomeTag');
-if (start < 0 || end < 0) throw new Error('reqMatch not found');
-const ctx = {};
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) + '\nthis.reqMatch=reqMatch;', ctx);
-const base = { outcome: 'success', client_ip: '203.0.113.7', user_agent: 'python-requests/2.31.0', model: 'cn:glm-5.3', account: '示例(uid8)', request_id: 'req-1' };
-const other = { outcome: 'http_error', client_ip: '198.51.100.4', user_agent: 'Mozilla/5.0 Chrome/120', model: 'global:hy3', account: '甲(uid9)', request_id: 'req-2' };
-const rows = [base, other];
-const pick = f => rows.filter(e => ctx.reqMatch(e, f)).map(e => e.request_id);
-process.stdout.write(JSON.stringify({
-  all: pick({ q: '', outcome: '' }),
-  byIP: pick({ q: '203.0.113', outcome: '' }),
-  byUA: pick({ q: 'chrome/120', outcome: '' }),
-  byModel: pick({ q: 'glm', outcome: '' }),
-  multiKw: pick({ q: 'glm success', outcome: '' }),
-  multiMiss: pick({ q: 'glm chrome', outcome: '' }),
-  byOutcome: pick({ q: '', outcome: 'http_error' }),
-  combined: pick({ q: '198.51', outcome: 'http_error' }),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "request-filter-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("request filter node test failed: %v\n%s", err, out)
-	}
-	// q 对 outcome 不参与匹配（outcome 有独立下拉），multiKw 里的 success 命中不了任何字段。
-	const want = `{"all":["req-1","req-2"],"byIP":["req-1"],"byUA":["req-2"],"byModel":["req-1"],"multiKw":[],"multiMiss":[],"byOutcome":["req-2"],"combined":["req-2"]}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("request filter=%s want %s", out, want)
-	}
-}
-
-// 模型按条件查询：域 / 能力 / 档位 / 价格 / 关键词，以及倍率、上下文、输出排序。
-func TestAppJSModelFilter(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; model filter test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('function mdRateValue');
-const end = src.indexOf('function mdRowHtml');
-if (start < 0 || end < 0) throw new Error('model filter helpers not found');
-const ctx = { Number, String, Array, Object, isFinite, parseFloat };
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) + '\nthis.mdMatch=mdMatch; this.mdSortList=mdSortList; this.mdRateValue=mdRateValue;', ctx);
-const models = [
-  { id: 'cn:glm-5.2', name: 'GLM-5.2', vendor: 'Zhipu', tags: ['视觉'], supports_tool_call: true, supports_images: true, supports_reasoning: true, can_disable_thinking: true, supported_efforts: ['high', 'xhigh'], default_effort: 'high', is_default: false, credits: '0.79', promo_factor: 0.5, promo_credits: '0.40', promo_label: '夜间折扣', context_length: 1000000, max_output_tokens: 131000 },
-  { id: 'cn:hy3', name: 'Hy3', supports_tool_call: true, supports_images: true, supports_reasoning: true, can_disable_thinking: false, supported_efforts: ['low', 'high'], default_effort: 'high', is_default: false, credits: '0', promo_factor: 0, promo_credits: '0', promo_label: '限时免费', context_length: 192000, max_output_tokens: 64000 },
-  { id: 'global:hy3', name: 'Hy3 Global', supports_tool_call: false, supports_images: false, supports_reasoning: false, supported_efforts: [], is_default: false, credits: '0.11', context_length: 1000000, max_output_tokens: 393000 },
-  { id: 'cn:auto', name: 'Auto', supports_tool_call: true, supports_images: true, supports_reasoning: true, is_default: true, credits: null, context_length: 256000, max_output_tokens: 32000 },
-];
-const ids = list => list.map(m => m.id);
-const filter = f => ids(ctx.mdSortList(models.filter(m => ctx.mdMatch(m, f)), f));
-process.stdout.write(JSON.stringify({
-  all: ids(models),
-  realm: filter({ realm: 'cn' }),
-  tool: filter({ cap: 'tool' }),
-  vision: filter({ cap: 'vision' }),
-  reasoning: filter({ cap: 'reasoning' }),
-  isDefault: filter({ cap: 'default' }),
-  effortOff: filter({ effort: 'off' }),
-  effortLow: filter({ effort: 'low' }),
-  free: filter({ promo: 'free' }),
-  promo: filter({ promo: 'promo' }),
-  discount: filter({ promo: 'discount' }),
-  q: filter({ q: 'glm zhipu' }),
-  qMiss: filter({ q: 'glm nosuch' }),
-  sortRate: filter({ sort: 'rate' }),
-  sortContext: filter({ sort: 'context' }),
-  sortOutput: filter({ sort: 'output' }),
-  sortName: filter({ sort: 'name' }),
-  rateFree: ctx.mdRateValue(models[1]),
-  rateMissing: ctx.mdRateValue(models[3]),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "model-filter-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("model filter node test failed: %v\n%s", err, out)
-	}
-	const want = `{"all":["cn:glm-5.2","cn:hy3","global:hy3","cn:auto"],` +
-		`"realm":["cn:glm-5.2","cn:hy3","cn:auto"],` +
-		`"tool":["cn:glm-5.2","cn:hy3","cn:auto"],` +
-		`"vision":["cn:glm-5.2","cn:hy3","cn:auto"],` +
-		`"reasoning":["cn:glm-5.2","cn:hy3","cn:auto"],` +
-		`"isDefault":["cn:auto"],` +
-		`"effortOff":["cn:glm-5.2"],` +
-		`"effortLow":["cn:hy3"],` +
-		`"free":["cn:hy3"],` +
-		`"promo":["cn:glm-5.2","cn:hy3"],` +
-		`"discount":["cn:glm-5.2"],` +
-		`"q":["cn:glm-5.2"],` +
-		`"qMiss":[],` +
-		`"sortRate":["cn:hy3","global:hy3","cn:glm-5.2","cn:auto"],` +
-		`"sortContext":["cn:glm-5.2","global:hy3","cn:auto","cn:hy3"],` +
-		`"sortOutput":["global:hy3","cn:glm-5.2","cn:hy3","cn:auto"],` +
-		`"sortName":["cn:auto","cn:glm-5.2","cn:hy3","global:hy3"],` +
-		`"rateFree":0,"rateMissing":null}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("model filter=%s\nwant %s", out, want)
-	}
-}
-
-// 用量时序图的柱体类名不得叫 bar：账号池的积分条是 .bar{height:3px}，而 SVG2 里
-// height 是 rect 的 CSS 几何属性——同名类会把每根柱子压成 3px 高，图看起来"没数据"。
-// 这个坑只能在浏览器里看出来，所以在这里钉住类名。
-func TestAppJSUsageChartBarClass(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; usage chart test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('function parsePointTime');
-const end = src.indexOf('function fmtTokTip');
-const escStart = src.indexOf('function esc(');
-const escEnd = src.indexOf('function ago(');
-const fmtStart = src.indexOf('function fmtTok(');
-const fmtEnd = src.indexOf('function usStat(');
-if ([start, end, escStart, escEnd, fmtStart, fmtEnd].some(v => v < 0)) throw new Error('usage chart helpers not found');
-const host = { innerHTML: '', textContent: '' };
-const ctx = {
-  Date, Number, String, Math, RegExp, isNaN, Set, Array, Object, Infinity,
-  document: { getElementById: () => host },
-  $: () => host,
-};
-vm.createContext(ctx);
-vm.runInContext(src.slice(escStart, escEnd) + src.slice(fmtStart, fmtEnd) + src.slice(start, end) +
-  '\nthis.renderUsageChart=renderUsageChart;', ctx);
-const series = [
-  { t: '2026-09-30T09', scope: 'hour', prompt_tokens: 35, completion_tokens: 16, total_tokens: 51, requests: 1 },
-  { t: '2026-09-30T11', scope: 'hour', prompt_tokens: 978324, completion_tokens: 20621, total_tokens: 998945, requests: 39 },
-  { t: '2026-09-30T13', scope: 'hour', prompt_tokens: 27400952, completion_tokens: 104913, total_tokens: 27505865, requests: 200 },
-];
-ctx.renderUsageChart(series);
-const svg = host.innerHTML;
-process.stdout.write(JSON.stringify({
-  hasUsbar: svg.includes('class="usbar"'),
-  hasBareBar: /class="bar"/.test(svg),
-  hasGradient: svg.includes('usGradP') && svg.includes('usGradC'),
-  barCount: (svg.match(/class="usbar"/g) || []).length,
-  hasPeak: svg.includes('峰值'),
-  hasAvg: svg.includes('均值'),
-  emptyState: (function () { ctx.renderUsageChart([]); return host.innerHTML.includes('us-empty'); })(),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "usage-chart-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("usage chart node test failed: %v\n%s", err, out)
-	}
-	const want = `{"hasUsbar":true,"hasBareBar":false,"hasGradient":true,"barCount":6,"hasPeak":true,"hasAvg":true,"emptyState":true}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("usage chart=%s\nwant %s", out, want)
-	}
-}
-
-// 时间范围控件：预设 → 查询参数的映射。要点：
-//   - 「今天」必须发浏览器本地时区的 00:00（服务端时区未必一致），且不带 to；
-//   - 滚动预设 rolling=true 发 hours（服务端整点对齐），rolling=false 折算成 from；
-//   - 「全部历史」两者都不发；「自定义」发用户挑的 from/to。
-func TestAppJSTimeRangeQuery(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; time range test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('const TRANGE_PRESETS');
-const end = src.indexOf('function rateLimitMeta');
-if (start < 0 || end < 0 || end < start) throw new Error('trange helpers not found');
-const host = { innerHTML: '' };
-const ctx = {
-  Date, Number, String, Math, Map, Array, Object, isNaN, URLSearchParams,
-  document: { getElementById: () => host },
-  $: () => host,
-  esc: s => String(s == null ? '' : s),
-};
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) +
-  '\nthis.trangeState=trangeState; this.trangeQuery=trangeQuery; this.trangeLabel=trangeLabel; this.trangeMidnight=trangeMidnight;', ctx);
-const q = (preset, rolling) => {
-  ctx.trangeState('t').preset = preset;
-  return ctx.trangeQuery('t', rolling).toString();
-};
-const secOf = d => String(Math.floor(d.getTime() / 1000));
-const approx = (qs, wantSec) => {
-  const m = /(?:^|&)from=(\d+)/.exec(qs);
-  return m && Math.abs(Number(m[1]) - wantSec) < 120;
-};
-const now = Date.now();
-const todayQ = q('today', true);
-process.stdout.write(JSON.stringify({
-  todayIsMidnight: todayQ === 'from=' + secOf(ctx.trangeMidnight()),
-  todayNoTo: !/to=/.test(todayQ),
-  rolling24: q('24', true),
-  rolling72: q('72', true),
-  rolling0: q('0', true),
-  log24From: approx(q('24', false), Math.floor((now - 24 * 3600e3) / 1000)),
-  log24HasHours: /hours=/.test(q('24', false)),
-  log7dFrom: approx(q('168', false), Math.floor((now - 168 * 3600e3) / 1000)),
-  custom: (function () {
-    const st = ctx.trangeState('t');
-    st.preset = 'custom';
-    st.from = new Date(2026, 8, 30, 9, 0, 0);
-    st.to = new Date(2026, 8, 30, 18, 30, 0);
-    return ctx.trangeQuery('t', true).toString();
-  })(),
-  labelCustom: ctx.trangeLabel('t'),
-  labelToday: (function () { ctx.trangeState('t').preset = 'today'; return ctx.trangeLabel('t'); })(),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "trange-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("time range node test failed: %v\n%s", err, out)
-	}
-	local := func(h, m int) string {
-		return strconv.FormatInt(time.Date(2026, 9, 30, h, m, 0, 0, time.Local).Unix(), 10)
-	}
-	want := `{"todayIsMidnight":true,"todayNoTo":true,` +
-		`"rolling24":"hours=24","rolling72":"hours=72","rolling0":"",` +
-		`"log24From":true,"log24HasHours":false,"log7dFrom":true,` +
-		`"custom":"from=` + local(9, 0) + `&to=` + local(18, 30) + `",` +
-		`"labelCustom":"9-30 09:00 → 9-30 18:30","labelToday":"今天"}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("time range=%s\nwant %s", out, want)
-	}
-}
-
-// 同到期时间按面额降序；其余未用完包与零/负余额包分别聚合。
-func TestAppJSDetailGroups(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; detail groups test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('const PK_DEFAULT_DETAIL_LIMIT');
-const end = src.indexOf('function renderPackages');
-if (start < 0 || end < 0) throw new Error('detail group functions not found');
-const ctx = { Date, Math, Number, String, Map, Array, Object, isFinite };
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) + '\nthis.pkDetailGroups = pkDetailGroups; this.pkDetailLimit = pkDetailLimit;', ctx);
-const input = [
-  { id: 'small-late', size: 100, remain: 1, expires_at: 400 },
-  { id: 'zero-early-b', size: 200, remain: 0, expires_at: 200 },
-  { id: 'small-early', size: 100, remain: 2, expires_at: 200 },
-  { id: 'large-unknown', size: 300, remain: 3, end_time: '' },
-  { id: 'zero-early-a', size: 200, remain: -1, expires_at: 200 },
-  { id: 'small-unknown', size: 100, remain: 1, end_time: '' },
-  { id: 'large-early', size: 300, remain: 4, expires_at: 200 },
-  { id: 'zero-late', size: 300, remain: 0, expires_at: 300 },
-];
-const before = input.map(p => p.id).join(',');
-const out = ctx.pkDetailGroups(input, 2);
-process.stdout.write(JSON.stringify({
-  visible: out.visible.map(p => p.id),
-  rest: out.rest.map(p => p.id),
-  used: out.used.map(p => p.id),
-  restSize: out.restSize,
-  restRemain: out.restRemain,
-  usedSize: out.usedSize,
-  defaultLimit: ctx.pkDetailLimit({}),
-  configuredLimit: ctx.pkDetailLimit({ panel: { package_detail_limit: 7 } }),
-  unchanged: input.map(p => p.id).join(',') === before,
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "detail-groups-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("detail groups node test failed: %v\n%s", err, out)
-	}
-	const want = `{"visible":["large-early","small-early"],"rest":["small-late","large-unknown","small-unknown"],"used":["zero-early-b","zero-early-a","zero-late"],"restSize":500,"restRemain":5,"usedSize":700,"defaultLimit":5,"configuredLimit":7,"unchanged":true}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("detail groups=%s want %s", out, want)
-	}
-}
-
-// 精确剩余天数聚合、账号内按总余额钳制、无到期批次不进入图表。
-func TestAppJSExpirySummary(t *testing.T) {
-	node, err := exec.LookPath("node")
-	if err != nil {
-		t.Skip("node not installed; expiry summary test skipped")
-	}
-	script := `const fs = require('fs');
-const vm = require('vm');
-const src = fs.readFileSync(process.argv[2], 'utf8');
-const start = src.indexOf('const PK_ACCOUNT_COLORS');
-const end = src.indexOf('function renderExpiryDistribution');
-if (start < 0 || end < 0) throw new Error('expiry summary functions not found');
-const ctx = { Date, Math, Number, String, Map, Array, Object, isFinite };
-vm.createContext(ctx);
-vm.runInContext(src.slice(start, end) + '\nthis.summarizeCreditDays = summarizeCreditDays; this.pkAccountColorMap = pkAccountColorMap;', ctx);
-const day = 86400000, now = 100000;
-const out = ctx.summarizeCreditDays([
-  { uid: 'a', remain: 100, packages: [
-    { name: 'soon-a', remain: 30, expires_at: now + day },
-    { name: 'later', remain: 70, expires_at: now + 7 * day },
-  ] },
-  { uid: 'b', remain: 55, packages: [
-    { name: 'soon-b', remain: 20, expires_at: now + day },
-    { name: 'unknown', remain: 5, end_time: '' },
-  ] },
-  { uid: 'err', error: 'offline' },
-], now);
-process.stdout.write(JSON.stringify({
-  rows: out.rows.map(row => ({ days: row.days, credits: row.credits })),
-  accountCount: out.accountCount,
-  unavailable: out.unavailable,
-  colorA: ctx.pkAccountColorMap([{ uid: 'b' }, { uid: 'a' }]).get('a'),
-  colorB: ctx.pkAccountColorMap([{ uid: 'a' }, { uid: 'b' }]).get('b'),
-}));`
-	f, err := os.CreateTemp(t.TempDir(), "expiry-*.cjs")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := f.WriteString(script); err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
-	if err != nil {
-		t.Fatalf("expiry summary node test failed: %v\n%s", err, out)
-	}
-	const want = `{"rows":[{"days":1,"credits":50},{"days":7,"credits":70}],"accountCount":3,"unavailable":1,"colorA":"#4f8cff","colorB":"#25b08b"}`
-	if strings.TrimSpace(string(out)) != want {
-		t.Fatalf("expiry summary=%s want %s", out, want)
-	}
-}
+package panel
+
+import (
+	"bytes"
+	"net/http/httptest"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+	"time"
+)
+
+// TestAppJSSyntax app.js 必须能通过 JS 解析器语法校验。
+//
+// 为什么需要：app.js 是 go:embed 进二进制的静态资源，Go 编译器不检查其内容——
+// 一次对象字面量键名未加引号（Model_chat_GLM5.2 被解析成属性访问 + 数字字面量）
+// 就让整个面板白屏，而所有 Go 测试依然全绿。此测试把语法校验前移到 CI。
+// 无 node 环境时跳过（不阻塞无 Node 的构建机）。
+func TestAppJSSyntax(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not available; skipping JS syntax check")
+	}
+	path, err := filepath.Abs("app.js")
+	if err != nil {
+		t.Fatal(err)
+	}
+	out, err := exec.Command(node, "--check", path).CombinedOutput()
+	if err != nil {
+		t.Fatalf("app.js syntax error:\n%s", out)
+	}
+}
+
+// TestIndexHTMLNoInlineScript index.html 不得含内联 <script> 块：
+// 严格 CSP（script-src 'self'）会拦截内联脚本，页面将完全不可用。
+// 外链形式 <script src="..."> 允许。
+func TestIndexHTMLNoInlineScript(t *testing.T) {
+	p := newTestPanel()
+	rec := httptest.NewRecorder()
+	p.ServeHTTP(rec, httptest.NewRequest("GET", "/panel/", nil))
+	body := rec.Body.String()
+
+	rest := body
+	for {
+		idx := strings.Index(rest, "<script")
+		if idx < 0 {
+			break
+		}
+		rest = rest[idx:]
+		end := strings.Index(rest, ">")
+		if end < 0 {
+			break
+		}
+		tag := rest[:end+1]
+		if !strings.Contains(tag, "src=") {
+			t.Fatalf("index.html contains inline <script> (blocked by CSP): %s", tag)
+		}
+		rest = rest[end:]
+	}
+}
+
+// TestAppJSTopLevelSmoke app.js 顶层求值冒烟（v1.11.3/1.11.4 两连炸后补的运行时闸门）：
+// node + DOM 桩执行 app.js（含按 hash 落到各视图的 go() 顶层调用），抓 TDZ/
+// ReferenceError 类运行时错误——Go 侧 frontend_test 不执行 JS，语法层检查对此全盲。
+// 无 node 的环境跳过（CI/精简机不受影响）；harness 与 app.js 同判（app.js 顶层
+// start() 的 setInterval 会让 node 事件循环不退出，故成功路径显式 exit(0)）。
+func TestAppJSTopLevelSmoke(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; JS smoke skipped")
+	}
+	harness := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const inert = new Proxy(function () {}, {
+  get(t, k) { if (k === Symbol.toPrimitive) return () => ''; return inert; },
+  set() { return true; },
+  apply() { return inert; },
+  construct() { return inert; },
+  has() { return true; },
+});
+const sandbox = new Proxy({
+  location: { hash: process.env.SMOKE_HASH || '#taskscenter' },
+  history: { replaceState() {} },
+  localStorage: { getItem: () => null, setItem() {} },
+  navigator: { clipboard: { writeText: () => Promise.resolve() } },
+  document: { querySelectorAll: () => [], querySelector: () => inert, getElementById: () => inert, addEventListener() {}, documentElement: inert, head: inert, body: inert, createElement: () => inert, cookie: '' },
+  fetch: () => new Promise(() => {}),
+  addEventListener() {}, removeEventListener() {},
+  matchMedia: () => ({ matches: false, addEventListener() {} }),
+  setInterval, clearInterval, setTimeout, clearTimeout,
+  console, JSON, Math, Date, Number, String, Boolean, Object, Array, Promise, Map, Set, RegExp, Error, TypeError, isNaN, parseInt, parseFloat, encodeURIComponent, decodeURIComponent, URL, Symbol, Proxy, Reflect,
+}, { get(t, k) { return t[k]; }, has() { return true; } });
+sandbox.window = sandbox; sandbox.globalThis = sandbox;
+vm.createContext(sandbox);
+try {
+  vm.runInContext(src, sandbox, { filename: 'app.js' });
+  console.log('SMOKE OK');
+  process.exit(0);
+} catch (e) {
+  console.log('SMOKE FAIL:', (e && e.stack ? e.stack : e).toString().split('\n').slice(0, 5).join('\n'));
+  process.exit(1);
+}
+`
+	hf, err := os.CreateTemp(t.TempDir(), "smoke-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := hf.WriteString(harness); err != nil {
+		t.Fatal(err)
+	}
+	hf.Close()
+	for _, hash := range []string{"#taskscenter", "#accounts", "#usage", "#models", "#config", "#logs", "#packages"} {
+		cmd := exec.Command(node, hf.Name(), "app.js")
+		cmd.Dir = "." // 测试工作目录 = internal/panel
+		cmd.Env = append(os.Environ(), "SMOKE_HASH="+hash)
+		out, err := cmd.CombinedOutput()
+		if err != nil {
+			t.Fatalf("app.js 顶层求值 %s 崩溃: %v\n%s", hash, err, out)
+		}
+		if !bytes.Contains(out, []byte("SMOKE OK")) {
+			t.Fatalf("app.js smoke %s 未通过:\n%s", hash, out)
+		}
+	}
+}
+
+// 积分扣除维度的格式必须稳定，且缺样本/缺匹配 Token 时不能伪造比例。
+func TestAppJSCreditDimensionFormatting(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; credit formatting test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+	const start = src.indexOf('function trimFixed');
+const end = src.indexOf('function usStat');
+if (start < 0 || end < 0) throw new Error('credit helpers not found');
+const ctx = { Number, String, RegExp };
+vm.createContext(ctx);
+vm.runInContext(
+  src.slice(start, end) +
+  '\nthis.fmtCredit=fmtCredit; this.fmtCreditRatio=fmtCreditRatio; this.fmtModelRate=fmtModelRate;',
+  ctx
+);
+process.stdout.write(JSON.stringify({
+  credit: ctx.fmtCredit(1.25),
+  zero: ctx.fmtCredit(0),
+  hundred: ctx.fmtCredit(100),
+  ratio: ctx.fmtCreditRatio(12.5, 2, 400),
+  noSamples: ctx.fmtCreditRatio(12.5, 0, 400),
+  noTokens: ctx.fmtCreditRatio(12.5, 2, 0),
+  rate: ctx.fmtModelRate('0.5'),
+  noRate: ctx.fmtModelRate(''),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "credit-format-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("credit formatting node test failed: %v\n%s", err, out)
+	}
+	const want = `{"credit":"1.25","zero":"0","hundred":"100","ratio":"12.5 / 1M","noSamples":"—","noTokens":"—","rate":"x0.5","noRate":"—"}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("credit formatting=%s want %s", out, want)
+	}
+}
+
+// 模型限流时间必须同时支持上游 reset_at、网关 until 和无重置时间三种形态。
+func TestAppJSRateLimitMeta(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; rate limit formatting test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('function dur(');
+const end = src.indexOf('function rateLimitRowsHtml');
+if (start < 0 || end < 0) throw new Error('rate limit helpers not found');
+const ctx = { Date, Number, String, Math };
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.rateLimitMeta=rateLimitMeta;', ctx);
+const now = new Date(2026, 8, 28, 14, 0, 0).getTime();
+const reset = new Date(2026, 8, 28, 16, 0, 0).getTime();
+const until = new Date(2026, 8, 28, 15, 0, 0).getTime();
+const rate = ctx.rateLimitMeta({ model: 'glm-5.3', kind: 'rate_limit', reset_at: new Date(reset).toISOString(), until: new Date(until).toISOString() }, now);
+const unavailable = ctx.rateLimitMeta({ model: 'missing', kind: 'model_unavailable', until: new Date(until).toISOString() }, now);
+const unknown = ctx.rateLimitMeta({ model: 'glm-5.3', kind: 'rate_limit' }, now);
+process.stdout.write(JSON.stringify({
+  rate: rate.detail,
+  unavailable: unavailable.detail,
+  unknown: unknown.detail,
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "rate-limit-format-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("rate-limit formatting node test failed: %v\n%s", err, out)
+	}
+	const want = `{"rate":"预计 2026-09-28 16:00 解封（剩余 2时00分） · 网关最快 1时00分 后重试","unavailable":"预计 1时00分 后重试","unknown":"预计解封时间未知"}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("rate-limit formatting=%s want %s", out, want)
+	}
+}
+
+// 请求记录行必须紧凑、可读，并带上调用来源（IP / UA）；来源缺失时以 — 兜底。
+func TestAppJSRequestLogFormatting(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; request log formatting test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const escStart = src.indexOf('function esc(');
+const escEnd = src.indexOf('function ago(');
+const fmtStart = src.indexOf('function fmtTok(');
+const fmtEnd = src.indexOf('function usStat(');
+const reqStart = src.indexOf('function requestLogText');
+const reqEnd = src.indexOf('function fmtBytes');
+if ([escStart, escEnd, fmtStart, fmtEnd, reqStart, reqEnd].some(v => v < 0)) throw new Error('request log helpers not found');
+const ctx = { Date, Number, String, Math, RegExp, isNaN };
+vm.createContext(ctx);
+vm.runInContext(
+  src.slice(escStart, escEnd) + src.slice(fmtStart, fmtEnd) + src.slice(reqStart, reqEnd) +
+  '\nthis.requestLogText=requestLogText;',
+  ctx
+);
+const time = new Date(2026, 8, 28, 14, 5, 6).toISOString();
+const good = { time, status: 200, outcome: 'success', model: 'glm-5.3', account: '账号(uid8)', duration_ms: 1250, total_tokens: 2300, credit_known: true, credit: 0.12, request_id: 'req-1', client_ip: '203.0.113.7', user_agent: 'python-requests/2.31.0' };
+const noSource = { ...good, request_id: 'req-3', client_ip: '', user_agent: '' };
+const cached = { ...good, request_id: 'req-2', cache_hit_tokens: 2257, cache_miss_tokens: 43 };
+process.stdout.write(JSON.stringify({
+  good: ctx.requestLogText(good),
+  noSource: ctx.requestLogText(noSource),
+  cached: ctx.requestLogText(cached),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "request-log-format-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("request log formatting node test failed: %v\n%s", err, out)
+	}
+	text := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | 203.0.113.7 | python-requests/2.31.0 | 1.25s | 2.3k tok | 0.12 credit | req-1"
+	noSource := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | — | — | 1.25s | 2.3k tok | 0.12 credit | req-3"
+	cached := "14:05:06 | 200 成功 | glm-5.3 | 账号(uid8) | 203.0.113.7 | python-requests/2.31.0 | 1.25s | 2.3k tok | 0.12 credit | 命中 98.1% | req-2"
+	want := `{"good":` + strconv.Quote(text) + `,"noSource":` + strconv.Quote(noSource) + `,"cached":` + strconv.Quote(cached) + `}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("request log formatting=%s want %s", out, want)
+	}
+}
+
+// 请求记录筛选：IP / UA / 模型 / 账号 / 请求 ID 的包含匹配（空格分词 AND）+ 结果精确匹配。
+func TestAppJSRequestMatch(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; request filter test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('function reqMatch');
+const end = src.indexOf('function reqOutcomeTag');
+if (start < 0 || end < 0) throw new Error('reqMatch not found');
+const ctx = {};
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.reqMatch=reqMatch;', ctx);
+const base = { outcome: 'success', client_ip: '203.0.113.7', user_agent: 'python-requests/2.31.0', model: 'cn:glm-5.3', account: '示例(uid8)', request_id: 'req-1' };
+const other = { outcome: 'http_error', client_ip: '198.51.100.4', user_agent: 'Mozilla/5.0 Chrome/120', model: 'global:hy3', account: '甲(uid9)', request_id: 'req-2' };
+const rows = [base, other];
+const pick = f => rows.filter(e => ctx.reqMatch(e, f)).map(e => e.request_id);
+process.stdout.write(JSON.stringify({
+  all: pick({ q: '', outcome: '' }),
+  byIP: pick({ q: '203.0.113', outcome: '' }),
+  byUA: pick({ q: 'chrome/120', outcome: '' }),
+  byModel: pick({ q: 'glm', outcome: '' }),
+  multiKw: pick({ q: 'glm success', outcome: '' }),
+  multiMiss: pick({ q: 'glm chrome', outcome: '' }),
+  byOutcome: pick({ q: '', outcome: 'http_error' }),
+  combined: pick({ q: '198.51', outcome: 'http_error' }),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "request-filter-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("request filter node test failed: %v\n%s", err, out)
+	}
+	// q 对 outcome 不参与匹配（outcome 有独立下拉），multiKw 里的 success 命中不了任何字段。
+	const want = `{"all":["req-1","req-2"],"byIP":["req-1"],"byUA":["req-2"],"byModel":["req-1"],"multiKw":[],"multiMiss":[],"byOutcome":["req-2"],"combined":["req-2"]}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("request filter=%s want %s", out, want)
+	}
+}
+
+// 模型按条件查询：域 / 能力 / 档位 / 价格 / 关键词，以及倍率、上下文、输出排序。
+func TestAppJSModelFilter(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; model filter test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('function mdRateValue');
+const end = src.indexOf('function mdRowHtml');
+if (start < 0 || end < 0) throw new Error('model filter helpers not found');
+const ctx = { Number, String, Array, Object, isFinite, parseFloat };
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.mdMatch=mdMatch; this.mdSortList=mdSortList; this.mdRateValue=mdRateValue;', ctx);
+const models = [
+  { id: 'cn:glm-5.2', name: 'GLM-5.2', vendor: 'Zhipu', tags: ['视觉'], supports_tool_call: true, supports_images: true, supports_reasoning: true, can_disable_thinking: true, supported_efforts: ['high', 'xhigh'], default_effort: 'high', is_default: false, credits: '0.79', promo_factor: 0.5, promo_credits: '0.40', promo_label: '夜间折扣', context_length: 1000000, max_output_tokens: 131000 },
+  { id: 'cn:hy3', name: 'Hy3', supports_tool_call: true, supports_images: true, supports_reasoning: true, can_disable_thinking: false, supported_efforts: ['low', 'high'], default_effort: 'high', is_default: false, credits: '0', promo_factor: 0, promo_credits: '0', promo_label: '限时免费', context_length: 192000, max_output_tokens: 64000 },
+  { id: 'global:hy3', name: 'Hy3 Global', supports_tool_call: false, supports_images: false, supports_reasoning: false, supported_efforts: [], is_default: false, credits: '0.11', context_length: 1000000, max_output_tokens: 393000 },
+  { id: 'cn:auto', name: 'Auto', supports_tool_call: true, supports_images: true, supports_reasoning: true, is_default: true, credits: null, context_length: 256000, max_output_tokens: 32000 },
+];
+const ids = list => list.map(m => m.id);
+const filter = f => ids(ctx.mdSortList(models.filter(m => ctx.mdMatch(m, f)), f));
+process.stdout.write(JSON.stringify({
+  all: ids(models),
+  realm: filter({ realm: 'cn' }),
+  tool: filter({ cap: 'tool' }),
+  vision: filter({ cap: 'vision' }),
+  reasoning: filter({ cap: 'reasoning' }),
+  isDefault: filter({ cap: 'default' }),
+  effortOff: filter({ effort: 'off' }),
+  effortLow: filter({ effort: 'low' }),
+  free: filter({ promo: 'free' }),
+  promo: filter({ promo: 'promo' }),
+  discount: filter({ promo: 'discount' }),
+  q: filter({ q: 'glm zhipu' }),
+  qMiss: filter({ q: 'glm nosuch' }),
+  sortRate: filter({ sort: 'rate' }),
+  sortContext: filter({ sort: 'context' }),
+  sortOutput: filter({ sort: 'output' }),
+  sortName: filter({ sort: 'name' }),
+  rateFree: ctx.mdRateValue(models[1]),
+  rateMissing: ctx.mdRateValue(models[3]),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "model-filter-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("model filter node test failed: %v\n%s", err, out)
+	}
+	const want = `{"all":["cn:glm-5.2","cn:hy3","global:hy3","cn:auto"],` +
+		`"realm":["cn:glm-5.2","cn:hy3","cn:auto"],` +
+		`"tool":["cn:glm-5.2","cn:hy3","cn:auto"],` +
+		`"vision":["cn:glm-5.2","cn:hy3","cn:auto"],` +
+		`"reasoning":["cn:glm-5.2","cn:hy3","cn:auto"],` +
+		`"isDefault":["cn:auto"],` +
+		`"effortOff":["cn:glm-5.2"],` +
+		`"effortLow":["cn:hy3"],` +
+		`"free":["cn:hy3"],` +
+		`"promo":["cn:glm-5.2","cn:hy3"],` +
+		`"discount":["cn:glm-5.2"],` +
+		`"q":["cn:glm-5.2"],` +
+		`"qMiss":[],` +
+		`"sortRate":["cn:hy3","global:hy3","cn:glm-5.2","cn:auto"],` +
+		`"sortContext":["cn:glm-5.2","global:hy3","cn:auto","cn:hy3"],` +
+		`"sortOutput":["global:hy3","cn:glm-5.2","cn:hy3","cn:auto"],` +
+		`"sortName":["cn:auto","cn:glm-5.2","cn:hy3","global:hy3"],` +
+		`"rateFree":0,"rateMissing":null}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("model filter=%s\nwant %s", out, want)
+	}
+}
+
+// 用量时序图的柱体类名不得叫 bar：账号池的积分条是 .bar{height:3px}，而 SVG2 里
+// height 是 rect 的 CSS 几何属性——同名类会把每根柱子压成 3px 高，图看起来"没数据"。
+// 这个坑只能在浏览器里看出来，所以在这里钉住类名。
+func TestAppJSUsageChartBarClass(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; usage chart test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('function parsePointTime');
+const end = src.indexOf('function fmtTokTip');
+const escStart = src.indexOf('function esc(');
+const escEnd = src.indexOf('function ago(');
+const fmtStart = src.indexOf('function fmtTok(');
+const fmtEnd = src.indexOf('function usStat(');
+if ([start, end, escStart, escEnd, fmtStart, fmtEnd].some(v => v < 0)) throw new Error('usage chart helpers not found');
+const host = { innerHTML: '', textContent: '' };
+const ctx = {
+  Date, Number, String, Math, RegExp, isNaN, Set, Array, Object, Infinity,
+  document: { getElementById: () => host },
+  $: () => host,
+};
+vm.createContext(ctx);
+vm.runInContext(src.slice(escStart, escEnd) + src.slice(fmtStart, fmtEnd) + src.slice(start, end) +
+  '\nthis.renderUsageChart=renderUsageChart;', ctx);
+const series = [
+  { t: '2026-09-30T09', scope: 'hour', prompt_tokens: 35, completion_tokens: 16, total_tokens: 51, requests: 1 },
+  { t: '2026-09-30T11', scope: 'hour', prompt_tokens: 978324, completion_tokens: 20621, total_tokens: 998945, requests: 39 },
+  { t: '2026-09-30T13', scope: 'hour', prompt_tokens: 27400952, completion_tokens: 104913, total_tokens: 27505865, requests: 200 },
+];
+ctx.renderUsageChart(series);
+const svg = host.innerHTML;
+process.stdout.write(JSON.stringify({
+  hasUsbar: svg.includes('class="usbar"'),
+  hasBareBar: /class="bar"/.test(svg),
+  hasGradient: svg.includes('usGradP') && svg.includes('usGradC'),
+  barCount: (svg.match(/class="usbar"/g) || []).length,
+  hasPeak: svg.includes('峰值'),
+  hasAvg: svg.includes('均值'),
+  emptyState: (function () { ctx.renderUsageChart([]); return host.innerHTML.includes('us-empty'); })(),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "usage-chart-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("usage chart node test failed: %v\n%s", err, out)
+	}
+	const want = `{"hasUsbar":true,"hasBareBar":false,"hasGradient":true,"barCount":6,"hasPeak":true,"hasAvg":true,"emptyState":true}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("usage chart=%s\nwant %s", out, want)
+	}
+}
+
+// 时间范围控件：预设 → 查询参数的映射。要点：
+//   - 「今天」必须发浏览器本地时区的 00:00（服务端时区未必一致），且不带 to；
+//   - 滚动预设 rolling=true 发 hours（服务端整点对齐），rolling=false 折算成 from；
+//   - 「全部历史」两者都不发；「自定义」发用户挑的 from/to。
+func TestAppJSTimeRangeQuery(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; time range test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('const TRANGE_PRESETS');
+const end = src.indexOf('function rateLimitMeta');
+if (start < 0 || end < 0 || end < start) throw new Error('trange helpers not found');
+const host = { innerHTML: '' };
+const ctx = {
+  Date, Number, String, Math, Map, Array, Object, isNaN, URLSearchParams,
+  document: { getElementById: () => host },
+  $: () => host,
+  esc: s => String(s == null ? '' : s),
+};
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) +
+  '\nthis.trangeState=trangeState; this.trangeQuery=trangeQuery; this.trangeLabel=trangeLabel; this.trangeMidnight=trangeMidnight;', ctx);
+const q = (preset, rolling) => {
+  ctx.trangeState('t').preset = preset;
+  return ctx.trangeQuery('t', rolling).toString();
+};
+const secOf = d => String(Math.floor(d.getTime() / 1000));
+const approx = (qs, wantSec) => {
+  const m = /(?:^|&)from=(\d+)/.exec(qs);
+  return m && Math.abs(Number(m[1]) - wantSec) < 120;
+};
+const now = Date.now();
+const todayQ = q('today', true);
+process.stdout.write(JSON.stringify({
+  todayIsMidnight: todayQ === 'from=' + secOf(ctx.trangeMidnight()),
+  todayNoTo: !/to=/.test(todayQ),
+  rolling24: q('24', true),
+  rolling72: q('72', true),
+  rolling0: q('0', true),
+  log24From: approx(q('24', false), Math.floor((now - 24 * 3600e3) / 1000)),
+  log24HasHours: /hours=/.test(q('24', false)),
+  log7dFrom: approx(q('168', false), Math.floor((now - 168 * 3600e3) / 1000)),
+  custom: (function () {
+    const st = ctx.trangeState('t');
+    st.preset = 'custom';
+    st.from = new Date(2026, 8, 30, 9, 0, 0);
+    st.to = new Date(2026, 8, 30, 18, 30, 0);
+    return ctx.trangeQuery('t', true).toString();
+  })(),
+  labelCustom: ctx.trangeLabel('t'),
+  labelToday: (function () { ctx.trangeState('t').preset = 'today'; return ctx.trangeLabel('t'); })(),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "trange-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("time range node test failed: %v\n%s", err, out)
+	}
+	local := func(h, m int) string {
+		return strconv.FormatInt(time.Date(2026, 9, 30, h, m, 0, 0, time.Local).Unix(), 10)
+	}
+	want := `{"todayIsMidnight":true,"todayNoTo":true,` +
+		`"rolling24":"hours=24","rolling72":"hours=72","rolling0":"",` +
+		`"log24From":true,"log24HasHours":false,"log7dFrom":true,` +
+		`"custom":"from=` + local(9, 0) + `&to=` + local(18, 30) + `",` +
+		`"labelCustom":"9-30 09:00 → 9-30 18:30","labelToday":"今天"}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("time range=%s\nwant %s", out, want)
+	}
+}
+
+// 配置表单与 CFG_MAP 必须一一对应，且面板声称"可在线改"的热生效键必须真的
+// 出现在表单里。
+//
+// 为什么需要：`logging.request_client_info` 曾经在表单里存在过，后来在某次改动中
+// 被连带删掉，而 Go 侧的配置键、livecfg 热生效通路、README 的描述都还在——面板
+// 少了一个开关而 Go 测试全绿，只有人肉点开配置页才会发现。这里把"表单字段 ↔
+// CFG_MAP"与"关键热改键必须在表单里"两条都钉住。
+func TestConfigFormMatchesCFGMap(t *testing.T) {
+	src, err := os.ReadFile("app.js")
+	if err != nil {
+		t.Fatal(err)
+	}
+	js := string(src)
+	htmlBytes, err := os.ReadFile("index.html")
+	if err != nil {
+		t.Fatal(err)
+	}
+	html := string(htmlBytes)
+
+	// CFG_MAP 块（下面两条检查共用）。
+	mapBlock := js[strings.Index(js, "const CFG_MAP = {"):]
+	mapBlock = mapBlock[:strings.Index(mapBlock, "\n};")]
+	// 不能按行首匹配：CFG_MAP 里多个键写在同一行（`a: [...], b: [...]`），只有行首
+	// 那个带换行缩进。按「前面是行首或分隔符」判定才不漏。
+	inMap := func(name string) bool {
+		return regexp.MustCompile(`(?:^|[\s,{])` + regexp.QuoteMeta(name) + `:\s*\[`).MatchString(mapBlock)
+	}
+
+	// 1) 表单里的每个 name 都要有 CFG_MAP 条目（否则收集/回填都拿不到它）。
+	form := html[strings.Index(html, `<form id="cfgForm">`):]
+	form = form[:strings.Index(form, "</form>")]
+	names := map[string]bool{}
+	for _, m := range regexp.MustCompile(`name="([a-z_0-9]+)"`).FindAllStringSubmatch(form, -1) {
+		names[m[1]] = true
+	}
+	if len(names) == 0 {
+		t.Fatal("未从配置表单解析出任何 name 字段")
+	}
+	for n := range names {
+		if !inMap(n) {
+			t.Errorf("表单字段 %q 在 CFG_MAP 里没有条目（保存时会被静默丢弃）", n)
+		}
+	}
+
+	// 2) CFG_MAP 里的每个键都要在表单里有控件（否则回填/保存是空转）。
+	for _, m := range regexp.MustCompile(`(?:^|[\s,{])([a-z_0-9]+):\s*\[`).FindAllStringSubmatch(mapBlock, -1) {
+		if !names[m[1]] {
+			t.Errorf("CFG_MAP 键 %q 在配置表单里没有对应控件", m[1])
+		}
+	}
+
+	// 3) 明确断言这一个键：后端有配置项、README 说面板可改，UI 不能少。
+	if !strings.Contains(js, "request_client_info: ['logging', 'request_client_info']") {
+		t.Error("CFG_MAP 缺 request_client_info 条目")
+	}
+	if !names["request_client_info"] {
+		t.Error("配置表单缺「记录调用来源」开关（logging.request_client_info）")
+	}
+}
+
+// 同到期时间按面额降序；其余未用完包与零/负余额包分别聚合。
+func TestAppJSDetailGroups(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; detail groups test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('const PK_DEFAULT_DETAIL_LIMIT');
+const end = src.indexOf('function renderPackages');
+if (start < 0 || end < 0) throw new Error('detail group functions not found');
+const ctx = { Date, Math, Number, String, Map, Array, Object, isFinite };
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.pkDetailGroups = pkDetailGroups; this.pkDetailLimit = pkDetailLimit;', ctx);
+const input = [
+  { id: 'small-late', size: 100, remain: 1, expires_at: 400 },
+  { id: 'zero-early-b', size: 200, remain: 0, expires_at: 200 },
+  { id: 'small-early', size: 100, remain: 2, expires_at: 200 },
+  { id: 'large-unknown', size: 300, remain: 3, end_time: '' },
+  { id: 'zero-early-a', size: 200, remain: -1, expires_at: 200 },
+  { id: 'small-unknown', size: 100, remain: 1, end_time: '' },
+  { id: 'large-early', size: 300, remain: 4, expires_at: 200 },
+  { id: 'zero-late', size: 300, remain: 0, expires_at: 300 },
+];
+const before = input.map(p => p.id).join(',');
+const out = ctx.pkDetailGroups(input, 2);
+process.stdout.write(JSON.stringify({
+  visible: out.visible.map(p => p.id),
+  rest: out.rest.map(p => p.id),
+  used: out.used.map(p => p.id),
+  restSize: out.restSize,
+  restRemain: out.restRemain,
+  usedSize: out.usedSize,
+  defaultLimit: ctx.pkDetailLimit({}),
+  configuredLimit: ctx.pkDetailLimit({ panel: { package_detail_limit: 7 } }),
+  unchanged: input.map(p => p.id).join(',') === before,
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "detail-groups-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("detail groups node test failed: %v\n%s", err, out)
+	}
+	const want = `{"visible":["large-early","small-early"],"rest":["small-late","large-unknown","small-unknown"],"used":["zero-early-b","zero-early-a","zero-late"],"restSize":500,"restRemain":5,"usedSize":700,"defaultLimit":5,"configuredLimit":7,"unchanged":true}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("detail groups=%s want %s", out, want)
+	}
+}
+
+// 精确剩余天数聚合、账号内按总余额钳制、无到期批次不进入图表。
+func TestAppJSExpirySummary(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; expiry summary test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('const PK_ACCOUNT_COLORS');
+const end = src.indexOf('function renderExpiryDistribution');
+if (start < 0 || end < 0) throw new Error('expiry summary functions not found');
+const ctx = { Date, Math, Number, String, Map, Array, Object, isFinite };
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.summarizeCreditDays = summarizeCreditDays; this.pkAccountColorMap = pkAccountColorMap;', ctx);
+const day = 86400000, now = 100000;
+const out = ctx.summarizeCreditDays([
+  { uid: 'a', remain: 100, packages: [
+    { name: 'soon-a', remain: 30, expires_at: now + day },
+    { name: 'later', remain: 70, expires_at: now + 7 * day },
+  ] },
+  { uid: 'b', remain: 55, packages: [
+    { name: 'soon-b', remain: 20, expires_at: now + day },
+    { name: 'unknown', remain: 5, end_time: '' },
+  ] },
+  { uid: 'err', error: 'offline' },
+], now);
+process.stdout.write(JSON.stringify({
+  rows: out.rows.map(row => ({ days: row.days, credits: row.credits })),
+  accountCount: out.accountCount,
+  unavailable: out.unavailable,
+  colorA: ctx.pkAccountColorMap([{ uid: 'b' }, { uid: 'a' }]).get('a'),
+  colorB: ctx.pkAccountColorMap([{ uid: 'a' }, { uid: 'b' }]).get('b'),
+}));`
+	f, err := os.CreateTemp(t.TempDir(), "expiry-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("expiry summary node test failed: %v\n%s", err, out)
+	}
+	const want = `{"rows":[{"days":1,"credits":50},{"days":7,"credits":70}],"accountCount":3,"unavailable":1,"colorA":"#4f8cff","colorB":"#25b08b"}`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("expiry summary=%s want %s", out, want)
+	}
+}
+
+// TestAppJSCollectConfigClearable 钉住 collectConfig 的空串语义。
+//
+// 覆盖型字段（user_agent / prompt_file）空串必须照发：漏发会让面板显示"已保存"
+// 而 config.json 里的值没变（issue #102 附带发现 2）。
+//
+// 同时钉住反面：其余文本字段空串仍然不下发。这条同样重要——若哪天为了修上面那个
+// 问题改成"所有���串都发"，表单里任何一个没填的框都会变成"请清空"，静默抹掉配置。
+func TestAppJSCollectConfigClearable(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		t.Skip("node not installed; collectConfig test skipped")
+	}
+	script := `const fs = require('fs');
+const vm = require('vm');
+const src = fs.readFileSync(process.argv[2], 'utf8');
+const start = src.indexOf('const CFG_MAP');
+const end = src.indexOf('/* Go 时长字段即时校验');
+if (start < 0 || end < 0 || end < start) throw new Error('collectConfig region not found');
+const mk = v => ({ type: 'text', value: v });
+const cfgForm = { elements: {
+  listen: mk(''),
+  api_key: mk('secret'),
+  user_agent: mk(''),
+  prompt_file: mk(''),
+  checkin_hours: mk(''),
+}};
+const ctx = {
+  Date, Number, String, Math, Map, Array, Object, isNaN, URLSearchParams, Set,
+  document: { getElementById: id => (id === 'cfgForm' ? cfgForm : null) },
+  $: id => (id === 'cfgForm' ? cfgForm : null),
+};
+vm.createContext(ctx);
+vm.runInContext(src.slice(start, end) + '\nthis.collectConfig = collectConfig;', ctx);
+const out = ctx.collectConfig();
+const has = (o, k) => Object.prototype.hasOwnProperty.call(o || {}, k);
+process.stdout.write(JSON.stringify([
+  has(out.upstream, 'user_agent'), (out.upstream || {}).user_agent,
+  has(out.prompt, 'file'), (out.prompt || {}).file,
+  has(out, 'listen'),
+  has(out.schedule, 'checkin_hours'),
+  out.api_key
+]));`
+	f, err := os.CreateTemp(t.TempDir(), "cfgc-*.cjs")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if _, err := f.WriteString(script); err != nil {
+		t.Fatal(err)
+	}
+	f.Close()
+	out, err := exec.Command(node, f.Name(), "app.js").CombinedOutput()
+	if err != nil {
+		t.Fatalf("collectConfig node test failed: %v\n%s", err, out)
+	}
+	// [user_agent 已发, 其值, prompt.file 已发, 其值, listen 未发, checkin_hours 未发, api_key]
+	const want = `[true,"",true,"",false,false,"secret"]`
+	if strings.TrimSpace(string(out)) != want {
+		t.Fatalf("collectConfig=%s want %s", strings.TrimSpace(string(out)), want)
+	}
+}

internal/panel/import.go

@@ -1,181 +1,181 @@
-package panel
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"path/filepath"
-	"strings"
-	"time"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-)
-
-// cockpitAccount 映射 cockpit tools 导出格式的单个账号。
-type cockpitAccount struct {
-	ID            string `json:"id"`
-	Email         string `json:"email"`
-	UID           string `json:"uid"`
-	Nickname      string `json:"nickname"`
-	AccessToken   string `json:"access_token"`
-	RefreshToken  string `json:"refresh_token"`
-	TokenType     string `json:"token_type"`
-	ExpiresAt     int64  `json:"expires_at"`
-	Domain        string `json:"domain"`
-	DosageNotify  string `json:"dosage_notify_code"`
-	PaymentType   string `json:"payment_type"`
-	Status        string `json:"status"`
-	UsageUpdatedAt int64 `json:"usage_updated_at"`
-	LastCheckin   int64  `json:"last_checkin_time"`
-	CheckinStreak int    `json:"checkin_streak"`
-	CreatedAt     int64  `json:"created_at"`
-	LastUsed      int64  `json:"last_used"`
-}
-
-// importCockpit 接收 cockpit tools 导出的 JSON 文件，批量导入账号到池中。
-//
-//	POST /panel/api/import/cockpit
-//	Content-Type: multipart/form-data
-//	Body: file=<json>
-//
-// 返回 {ok, total, imported, skipped, errors}。
-func (p *Panel) importCockpit(w http.ResponseWriter, r *http.Request) {
-	if err := r.ParseMultipartForm(32 << 20); err != nil {
-		writeErr(w, http.StatusBadRequest, "parse form: "+err.Error())
-		return
-	}
-	file, _, err := r.FormFile("file")
-	if err != nil {
-		writeErr(w, http.StatusBadRequest, "missing file field: "+err.Error())
-		return
-	}
-	defer file.Close()
-
-	raw, err := io.ReadAll(file)
-	if err != nil {
-		writeErr(w, http.StatusBadRequest, "read file: "+err.Error())
-		return
-	}
-
-	var accounts []cockpitAccount
-	if err := json.Unmarshal(raw, &accounts); err != nil {
-		writeErr(w, http.StatusBadRequest, "invalid json: "+err.Error())
-		return
-	}
-	if len(accounts) == 0 {
-		writeErr(w, http.StatusBadRequest, "empty accounts array")
-		return
-	}
-
-	var total, imported, skipped int
-	var errs []string
-
-	for _, acc := range accounts {
-		uid := strings.TrimSpace(acc.UID)
-		at := strings.TrimSpace(acc.AccessToken)
-		rt := strings.TrimSpace(acc.RefreshToken)
-		if uid == "" || at == "" || rt == "" {
-			skipped++
-			errs = append(errs, fmt.Sprintf("missing required fields (id=%s)", acc.ID))
-			continue
-		}
-		if !validImportUID(uid) {
-			skipped++
-			errs = append(errs, fmt.Sprintf("invalid uid (id=%s)", acc.ID))
-			continue
-		}
-
-		// 按 domain 推断 realm：workbuddy.ai 家族 → global，否则 cn。
-		realm := auth.ResolveRealm("", acc.Domain)
-
-		// cockpit tools 的 expires_at 为毫秒时间戳，转为秒。
-		expiresAt := acc.ExpiresAt / 1000
-		if expiresAt <= 0 {
-			expiresAt = time.Now().Add(365 * 24 * time.Hour).Unix()
-		}
-
-		nickname := acc.Nickname
-		if strings.TrimSpace(nickname) == "" {
-			nickname = acc.Email
-		}
-
-		a := &auth.Auth{
-			AccessToken:  at,
-			RefreshToken: rt,
-			ExpiresAt:    expiresAt,
-			Domain:       acc.Domain,
-			UID:          uid,
-			Nickname:     nickname,
-			FilePath:     filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", uid)),
-		}
-
-		if realm == "global" {
-			if _, err := auth.BackfillRealmFor(a, "global"); err != nil {
-				skipped++
-				errs = append(errs, fmt.Sprintf("uid=%s: set realm failed: %v", uid, err))
-				continue
-			}
-		} else {
-			_, _ = a.BackfillRealm()
-		}
-
-		if err := a.SaveAtomic(); err != nil {
-			skipped++
-			errs = append(errs, fmt.Sprintf("uid=%s: save auth failed: %v", uid, err))
-			continue
-		}
-
-		p.cfg.Pool.Add(a)
-		p.cfg.Pool.Revive(uid)
-
-		// 顺带签到/激活（幂等；失败仅记日志，不阻断导入）。
-		if realm == "global" {
-			if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil {
-				log.Printf("panel: import global 注册激活 uid=%s: %v", uid, err)
-			} else if activated {
-				log.Printf("panel: import global 注册激活 uid=%s 完成", uid)
-			}
-			if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil {
-				log.Printf("panel: import global trial uid=%s: %v", uid, err)
-			} else if claimed {
-				log.Printf("panel: import global trial uid=%s 已领", uid)
-			}
-		} else {
-			if err := p.cfg.Upstream.DailyCheckin(a); err != nil {
-				log.Printf("panel: import checkin uid=%s: %v", uid, err)
-			}
-		}
-		if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil {
-			p.cfg.Pool.ReenableIfCredits(uid, rm, tt)
-		}
-
-		imported++
-	}
-
-	total = len(accounts)
-	log.Printf("panel: cockpit import finished total=%d imported=%d skipped=%d", total, imported, skipped)
-	writeJSON(w, http.StatusOK, map[string]any{
-		"ok":       true,
-		"total":    total,
-		"imported": imported,
-		"skipped":  skipped,
-		"errors":   errs,
-	})
-}
-
-// validImportUID 校验导入 uid 是否可用于拼文件名（同 login.go validUID 口径）。
-func validImportUID(uid string) bool {
-	if uid == "" || len(uid) > 64 {
-		return false
-	}
-	for _, c := range uid {
-		switch {
-		case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_':
-		default:
-			return false
-		}
-	}
-	return true
-}
+package panel
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+)
+
+// cockpitAccount 映射 cockpit tools 导出格式的单个账号。
+type cockpitAccount struct {
+	ID            string `json:"id"`
+	Email         string `json:"email"`
+	UID           string `json:"uid"`
+	Nickname      string `json:"nickname"`
+	AccessToken   string `json:"access_token"`
+	RefreshToken  string `json:"refresh_token"`
+	TokenType     string `json:"token_type"`
+	ExpiresAt     int64  `json:"expires_at"`
+	Domain        string `json:"domain"`
+	DosageNotify  string `json:"dosage_notify_code"`
+	PaymentType   string `json:"payment_type"`
+	Status        string `json:"status"`
+	UsageUpdatedAt int64 `json:"usage_updated_at"`
+	LastCheckin   int64  `json:"last_checkin_time"`
+	CheckinStreak int    `json:"checkin_streak"`
+	CreatedAt     int64  `json:"created_at"`
+	LastUsed      int64  `json:"last_used"`
+}
+
+// importCockpit 接收 cockpit tools 导出的 JSON 文件，批量导入账号到池中。
+//
+//	POST /panel/api/import/cockpit
+//	Content-Type: multipart/form-data
+//	Body: file=<json>
+//
+// 返回 {ok, total, imported, skipped, errors}。
+func (p *Panel) importCockpit(w http.ResponseWriter, r *http.Request) {
+	if err := r.ParseMultipartForm(32 << 20); err != nil {
+		writeErr(w, http.StatusBadRequest, "parse form: "+err.Error())
+		return
+	}
+	file, _, err := r.FormFile("file")
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "missing file field: "+err.Error())
+		return
+	}
+	defer file.Close()
+
+	raw, err := io.ReadAll(file)
+	if err != nil {
+		writeErr(w, http.StatusBadRequest, "read file: "+err.Error())
+		return
+	}
+
+	var accounts []cockpitAccount
+	if err := json.Unmarshal(raw, &accounts); err != nil {
+		writeErr(w, http.StatusBadRequest, "invalid json: "+err.Error())
+		return
+	}
+	if len(accounts) == 0 {
+		writeErr(w, http.StatusBadRequest, "empty accounts array")
+		return
+	}
+
+	var total, imported, skipped int
+	var errs []string
+
+	for _, acc := range accounts {
+		uid := strings.TrimSpace(acc.UID)
+		at := strings.TrimSpace(acc.AccessToken)
+		rt := strings.TrimSpace(acc.RefreshToken)
+		if uid == "" || at == "" || rt == "" {
+			skipped++
+			errs = append(errs, fmt.Sprintf("missing required fields (id=%s)", acc.ID))
+			continue
+		}
+		if !validImportUID(uid) {
+			skipped++
+			errs = append(errs, fmt.Sprintf("invalid uid (id=%s)", acc.ID))
+			continue
+		}
+
+		// 按 domain 推断 realm：workbuddy.ai 家族 → global，否则 cn。
+		realm := auth.ResolveRealm("", acc.Domain)
+
+		// cockpit tools 的 expires_at 为毫秒时间戳，转为秒。
+		expiresAt := acc.ExpiresAt / 1000
+		if expiresAt <= 0 {
+			expiresAt = time.Now().Add(365 * 24 * time.Hour).Unix()
+		}
+
+		nickname := acc.Nickname
+		if strings.TrimSpace(nickname) == "" {
+			nickname = acc.Email
+		}
+
+		a := &auth.Auth{
+			AccessToken:  at,
+			RefreshToken: rt,
+			ExpiresAt:    expiresAt,
+			Domain:       acc.Domain,
+			UID:          uid,
+			Nickname:     nickname,
+			FilePath:     filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", uid)),
+		}
+
+		if realm == "global" {
+			if _, err := auth.BackfillRealmFor(a, "global"); err != nil {
+				skipped++
+				errs = append(errs, fmt.Sprintf("uid=%s: set realm failed: %v", uid, err))
+				continue
+			}
+		} else {
+			_, _ = a.BackfillRealm()
+		}
+
+		if err := a.SaveAtomic(); err != nil {
+			skipped++
+			errs = append(errs, fmt.Sprintf("uid=%s: save auth failed: %v", uid, err))
+			continue
+		}
+
+		p.cfg.Pool.Add(a)
+		p.cfg.Pool.Revive(uid)
+
+		// 顺带签到/激活（幂等；失败仅记日志，不阻断导入）。
+		if realm == "global" {
+			if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil {
+				log.Printf("panel: import global 注册激活 uid=%s: %v", uid, err)
+			} else if activated {
+				log.Printf("panel: import global 注册激活 uid=%s 完成", uid)
+			}
+			if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil {
+				log.Printf("panel: import global trial uid=%s: %v", uid, err)
+			} else if claimed {
+				log.Printf("panel: import global trial uid=%s 已领", uid)
+			}
+		} else {
+			if err := p.cfg.Upstream.DailyCheckin(a); err != nil {
+				log.Printf("panel: import checkin uid=%s: %v", uid, err)
+			}
+		}
+		if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil {
+			p.cfg.Pool.ReenableIfCredits(uid, rm, tt)
+		}
+
+		imported++
+	}
+
+	total = len(accounts)
+	log.Printf("panel: cockpit import finished total=%d imported=%d skipped=%d", total, imported, skipped)
+	writeJSON(w, http.StatusOK, map[string]any{
+		"ok":       true,
+		"total":    total,
+		"imported": imported,
+		"skipped":  skipped,
+		"errors":   errs,
+	})
+}
+
+// validImportUID 校验导入 uid 是否可用于拼文件名（同 login.go validUID 口径）。
+func validImportUID(uid string) bool {
+	if uid == "" || len(uid) > 64 {
+		return false
+	}
+	for _, c := range uid {
+		switch {
+		case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_':
+		default:
+			return false
+		}
+	}
+	return true
+}

internal/panel/index.go

@@ -1,61 +1,61 @@
-// index.go 面板静态资源与安全响应头。
-//
-// 资源经 go:embed 打进二进制（随服务部署，无外部构建步骤）：
-//   - index.html  页面骨架
-//   - app.js      全部前端逻辑（独立文件而非内联，为了启用无需 unsafe-inline 的严格 CSP）
-//
-// 安全头对"面板页面与全部 /panel/api/* 响应"统一生效：CSP 限制脚本只能来自本服务，
-// 禁止被 iframe 嵌套（防点击劫持），禁 MIME 嗅探，并声明不泄露 Referer 出去。
-package panel
-
-import (
-	_ "embed"
-	"net/http"
-)
-
-//go:embed index.html
-var indexHTML []byte
-
-//go:embed app.js
-var appJS []byte
-
-// csp 内容安全策略（严格版，无需 unsafe-inline）：
-//   - default-src 'none'        默认全禁，逐个开口
-//   - script-src 'self'         只跑同源脚本（app.js）；页面无内联事件处理器/内联脚本
-//   - style-src 'self' 'unsafe-inline'
-//     style 的内联是设计取舍：页面有少量 style="..." 属性（进度条宽度、表格列宽），
-//     允许内联样式不会导致脚本执行；仍禁止外部样式域与 @import 外链。
-//   - connect-src 'self'        前端 fetch 只能打本服务
-//   - img-src 'self' data:      图标/内联图
-//   - form-action 'none'        页面无表单提交目标（配置页是 JS 提交）
-//   - frame-ancestors 'none'    禁止被任何站点 iframe 嵌套（点击劫持）
-//   - base-uri 'none'          禁止注入 <base> 改写相对路径
-const csp = "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; " +
-	"connect-src 'self'; img-src 'self' data:; form-action 'none'; " +
-	"frame-ancestors 'none'; base-uri 'none'"
-
-// setSecurityHeaders 写入面板统一安全响应头（页面与 API 都要，API 也含 JSON 数据）。
-func setSecurityHeaders(w http.ResponseWriter) {
-	w.Header().Set("Content-Security-Policy", csp)
-	w.Header().Set("X-Content-Type-Options", "nosniff") // 禁 MIME 嗅探
-	w.Header().Set("X-Frame-Options", "DENY")           // 老浏览器兜底（CSP frame-ancestors 的等价项）
-	w.Header().Set("Referrer-Policy", "no-referrer")    // 不外泄面板地址给外部站点
-	w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
-	w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
-}
-
-// index 输出面板页面（静态无秘密；数据接口 /panel/api/* 才走鉴权）。
-func (p *Panel) index(w http.ResponseWriter, r *http.Request) {
-	setSecurityHeaders(w)
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write(indexHTML)
-}
-
-// appScript 输出前端逻辑（同源脚本，供 CSP script-src 'self' 加载）。
-func (p *Panel) appScript(w http.ResponseWriter, r *http.Request) {
-	setSecurityHeaders(w)
-	w.Header().Set("Content-Type", "text/javascript; charset=utf-8")
-	w.WriteHeader(http.StatusOK)
-	_, _ = w.Write(appJS)
-}
+// index.go 面板静态资源与安全响应头。
+//
+// 资源经 go:embed 打进二进制（随服务部署，无外部构建步骤）：
+//   - index.html  页面骨架
+//   - app.js      全部前端逻辑（独立文件而非内联，为了启用无需 unsafe-inline 的严格 CSP）
+//
+// 安全头对"面板页面与全部 /panel/api/* 响应"统一生效：CSP 限制脚本只能来自本服务，
+// 禁止被 iframe 嵌套（防点击劫持），禁 MIME 嗅探，并声明不泄露 Referer 出去。
+package panel
+
+import (
+	_ "embed"
+	"net/http"
+)
+
+//go:embed index.html
+var indexHTML []byte
+
+//go:embed app.js
+var appJS []byte
+
+// csp 内容安全策略（严格版，无需 unsafe-inline）：
+//   - default-src 'none'        默认全禁，逐个开口
+//   - script-src 'self'         只跑同源脚本（app.js）；页面无内联事件处理器/内联脚本
+//   - style-src 'self' 'unsafe-inline'
+//     style 的内联是设计取舍：页面有少量 style="..." 属性（进度条宽度、表格列宽），
+//     允许内联样式不会导致脚本执行；仍禁止外部样式域与 @import 外链。
+//   - connect-src 'self'        前端 fetch 只能打本服务
+//   - img-src 'self' data:      图标/内联图
+//   - form-action 'none'        页面无表单提交目标（配置页是 JS 提交）
+//   - frame-ancestors 'none'    禁止被任何站点 iframe 嵌套（点击劫持）
+//   - base-uri 'none'          禁止注入 <base> 改写相对路径
+const csp = "default-src 'none'; script-src 'self'; style-src 'self' 'unsafe-inline'; " +
+	"connect-src 'self'; img-src 'self' data:; form-action 'none'; " +
+	"frame-ancestors 'none'; base-uri 'none'"
+
+// setSecurityHeaders 写入面板统一安全响应头（页面与 API 都要，API 也含 JSON 数据）。
+func setSecurityHeaders(w http.ResponseWriter) {
+	w.Header().Set("Content-Security-Policy", csp)
+	w.Header().Set("X-Content-Type-Options", "nosniff") // 禁 MIME 嗅探
+	w.Header().Set("X-Frame-Options", "DENY")           // 老浏览器兜底（CSP frame-ancestors 的等价项）
+	w.Header().Set("Referrer-Policy", "no-referrer")    // 不外泄面板地址给外部站点
+	w.Header().Set("Cross-Origin-Opener-Policy", "same-origin")
+	w.Header().Set("Cross-Origin-Resource-Policy", "same-origin")
+}
+
+// index 输出面板页面（静态无秘密；数据接口 /panel/api/* 才走鉴权）。
+func (p *Panel) index(w http.ResponseWriter, r *http.Request) {
+	setSecurityHeaders(w)
+	w.Header().Set("Content-Type", "text/html; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(indexHTML)
+}
+
+// appScript 输出前端逻辑（同源脚本，供 CSP script-src 'self' 加载）。
+func (p *Panel) appScript(w http.ResponseWriter, r *http.Request) {
+	setSecurityHeaders(w)
+	w.Header().Set("Content-Type", "text/javascript; charset=utf-8")
+	w.WriteHeader(http.StatusOK)
+	_, _ = w.Write(appJS)
+}

internal/panel/login.go

@@ -1,322 +1,322 @@
-// login.go 面板内嵌的 WorkBuddy CN OAuth 设备授权流程（cmd/login 的进程内移植）。
-//
-//	POST /panel/api/login/start → 拿 state+authUrl，state 存进程内（不再落 /tmp，
-//	  原方案在 Windows 上不可用），返回授权 URL；
-//	GET  /panel/api/login/poll   → 面板前端每 3s 轮询本接口；未完成返回 done=false，
-//	  完成后取 uid/nickname、凭证落盘 auths/workbuddy-<uid>.json、热加载进池
-//	  （pool.Add + Revive），并顺带签到 + 余额刷新 —— 免重启加载新账号。
-//
-// 无 PKCE（workbuddy 设备流由服务端签发 state），请求头与上游端点与 cmd/login 保持一致。
-package panel
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"path/filepath"
-	"time"
-
-	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
-)
-
-const (
-	upstreamBaseCN      = "https://copilot.tencent.com"
-	upstreamBaseGlobal  = "https://www.workbuddy.ai"
-	clientUA            = "CLI/2.63.2 CodeBuddy/2.63.2"
-	originRefererCN     = "https://www.codebuddy.cn"
-	originRefererGlobal = "https://www.workbuddy.ai"
-)
-
-// loginEndpoints 按 realm 返回设备授权三端点（auth/state、token、account）+ Origin。
-// realm=="global" → 国际版（workbuddy.ai 同域）；cn/非法/缺省 → CN（零回归）。
-func loginEndpoints(realm string) (state, token, account, origin string) {
-	if realm == "global" {
-		base := upstreamBaseGlobal
-		return base + "/v2/plugin/auth/state?platform=CLI",
-			base + "/v2/plugin/auth/token?state=",
-			base + "/v2/plugin/login/account?state=",
-			originRefererGlobal
-	}
-	base := upstreamBaseCN
-	return base + "/v2/plugin/auth/state?platform=CLI",
-		base + "/v2/plugin/auth/token?state=",
-		base + "/v2/plugin/login/account?state=",
-		originRefererCN
-}
-
-// loginHTTP 设备授权专用 client：短超时、无 cookie（每请求携带 state，无会话态）。
-var loginHTTP = &http.Client{Timeout: 30 * time.Second}
-
-func commonHeaders(req *http.Request, origin string) {
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Accept", "application/json, text/plain, */*")
-	req.Header.Set("X-Requested-With", "XMLHttpRequest")
-	req.Header.Set("Origin", origin)
-	req.Header.Set("Referer", origin+"/")
-	req.Header.Set("User-Agent", clientUA)
-}
-
-// validUID 校验上游返回的 uid 是否可安全用于拼文件名。
-// 只放行字母、数字、下划线、连字符（腾讯侧 uid 实测为 UUID 形态），
-// 长度上限 64 兜底异常超长串；拒绝 . / \ 等路径字符与空串。
-func validUID(uid string) bool {
-	if uid == "" || len(uid) > 64 {
-		return false
-	}
-	for _, c := range uid {
-		switch {
-		case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_':
-		default:
-			return false
-		}
-	}
-	return true
-}
-
-// apiEnvelope 与 upstream 同形：{code,msg,data}，code!=0 视为业务错误。
-type apiEnvelope struct {
-	Code int             `json:"code"`
-	Msg  string          `json:"msg"`
-	Data json.RawMessage `json:"data"`
-}
-
-// doJSON 发一次 JSON 请求并解信封。origin 为 Origin/Referer 基础域（随 realm 切）。
-func doJSON(method, fullURL, bearer string, body io.Reader, origin string) (json.RawMessage, int, error) {
-	req, err := http.NewRequest(method, fullURL, body)
-	if err != nil {
-		return nil, 0, err
-	}
-	commonHeaders(req, origin)
-	if bearer != "" {
-		req.Header.Set("Authorization", "Bearer "+bearer)
-	}
-	resp, err := loginHTTP.Do(req)
-	if err != nil {
-		return nil, 0, err
-	}
-	defer resp.Body.Close()
-	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
-	if resp.StatusCode >= 300 {
-		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode)
-	}
-	var env apiEnvelope
-	if err := json.Unmarshal(raw, &env); err != nil {
-		return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err)
-	}
-	if env.Code != 0 {
-		return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg)
-	}
-	return env.Data, resp.StatusCode, nil
-}
-
-// loginStart 发起设备授权：POST auth/state 拿授权 URL。
-// body 可带 {"realm":"global"}（缺省 cn）；state 会话记 realm，poll 同 realm 落盘。
-func (p *Panel) loginStart(w http.ResponseWriter, r *http.Request) {
-	realm := "cn"
-	if r.Body != nil {
-		var reqBody struct {
-			Realm string `json:"realm"`
-		}
-		if err := json.NewDecoder(io.LimitReader(r.Body, 1<<12)).Decode(&reqBody); err == nil {
-			if reqBody.Realm == "global" {
-				realm = "global"
-			}
-		}
-	}
-	epState, _, _, origin := loginEndpoints(realm)
-	data, status, err := doJSON(http.MethodPost, epState, "", bytes.NewReader([]byte("{}")), origin)
-	if err != nil {
-		writeErr(w, http.StatusBadGateway, fmt.Sprintf("auth state (upstream %d): %v", status, err))
-		return
-	}
-	var st struct {
-		State   string `json:"state"`
-		AuthURL string `json:"authUrl"`
-	}
-	if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" {
-		writeErr(w, http.StatusBadGateway, "auth state: missing state or authUrl")
-		return
-	}
-	p.loginMu.Lock()
-	// 顺手回收过期会话，防"开弹窗走开"的 state 滞留。
-	for s, sess := range p.logins {
-		if time.Since(sess.created) > loginTTL {
-			delete(p.logins, s)
-		}
-	}
-	p.logins[st.State] = loginSession{created: time.Now(), realm: realm}
-	p.loginMu.Unlock()
-	log.Printf("panel: 发起 OAuth 添加账号 realm=%s（state=%s...）", realm, st.State[:min(8, len(st.State))])
-	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "url": st.AuthURL, "state": st.State, "realm": realm})
-}
-
-// loginPoll 轮询登录态。未完成 → {done:false}；完成 → 建凭证、落盘、热加载、签到。
-func (p *Panel) loginPoll(w http.ResponseWriter, r *http.Request) {
-	state := r.URL.Query().Get("state")
-	if state == "" {
-		writeErr(w, http.StatusBadRequest, "missing state")
-		return
-	}
-	p.loginMu.Lock()
-	sess, known := p.logins[state]
-	p.loginMu.Unlock()
-	if !known {
-		writeErr(w, http.StatusNotFound, "unknown or expired state（请重新发起添加账号）")
-		return
-	}
-	_, epToken, epAcct, origin := loginEndpoints(sess.realm)
-
-	// auth/token 是权威登录状态端点：pending 时业务 code 非 0（"login ing"）。
-	tokRaw, _, err := doJSON(http.MethodGet, epToken+state, "", nil, origin)
-	if err != nil {
-		// pending / 未完成：面板前端继续轮询。
-		writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": err.Error()})
-		return
-	}
-	var tok struct {
-		AccessToken  string `json:"accessToken"`
-		RefreshToken string `json:"refreshToken"`
-		ExpiresIn    int64  `json:"expiresIn"`
-		Domain       string `json:"domain"`
-	}
-	if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" {
-		writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": "waiting for login"})
-		return
-	}
-
-	// 完成：取 uid/nickname（失败不阻塞，仅缺展示名）。
-	var acct struct {
-		UID          string `json:"uid"`
-		EnterpriseID string `json:"enterpriseId"`
-		Nickname     string `json:"nickname"`
-	}
-	if acctRaw, _, err := doJSON(http.MethodGet, epAcct+state, tok.AccessToken, nil, origin); err == nil {
-		_ = json.Unmarshal(acctRaw, &acct)
-	}
-	if acct.UID == "" {
-		writeErr(w, http.StatusBadGateway, "login done but no uid（token 已发但账号信息获取失败，请重试）")
-		return
-	}
-	// UID 来自上游响应，未经校验就用于拼文件名会被路径穿越利用
-	// （filepath.Join("./auths", "workbuddy-../../evil.json") → auths/evil.json）。
-	// UID 是腾讯侧账号标识，实测为 UUID（十六进制与连字符），故只放行 [A-Za-z0-9_-]。
-	if !validUID(acct.UID) {
-		writeErr(w, http.StatusBadGateway, "上游返回的 uid 含非法字符，拒绝落盘（防路径穿越）")
-		return
-	}
-
-	// 凭证落盘（嵌套形，与 auths/ 目录既有格式一致）→ 热加载进池。
-	if err := os.MkdirAll(p.cfg.AuthDir, 0o755); err != nil {
-		writeErr(w, http.StatusInternalServerError, "mkdir auth dir: "+err.Error())
-		return
-	}
-	a := &auth.Auth{
-		AccessToken:  tok.AccessToken,
-		RefreshToken: tok.RefreshToken,
-		ExpiresAt:    time.Now().Add(time.Duration(tok.ExpiresIn) * time.Second).Unix(),
-		Domain:       tok.Domain,
-		UID:          acct.UID,
-		EnterpriseID: acct.EnterpriseID,
-		Nickname:     acct.Nickname,
-		FilePath:     filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", acct.UID)),
-	}
-	// global 登录：落盘 auth.realm=global（Realm() 按此判域；不写则依赖 domain 后缀回落）。
-	if sess.realm == "global" {
-		if _, err := auth.BackfillRealmFor(a, "global"); err != nil {
-			writeErr(w, http.StatusInternalServerError, "set realm: "+err.Error())
-			return
-		}
-	} else {
-		// CN 也显式补 realm 键（幂等），让 auth 文件形态统一（与 LoadDir 存量迁移对齐）。
-		_, _ = a.BackfillRealm()
-	}
-	if err := a.SaveAtomic(); err != nil {
-		writeErr(w, http.StatusInternalServerError, "save auth: "+err.Error())
-		return
-	}
-	p.cfg.Pool.Add(a)
-	p.cfg.Pool.Revive(acct.UID) // 全新登录 = 人工恢复口径：清掉旧号遗留的禁用/冷却/熔断
-
-	// 顺带签到 + 余额刷新（幂等；失败不影响登录结果，只体现在返回字段里）。
-	// realm 分支：CN 走 DailyCheckin；global 无 CN 签到体系，改为注册激活 + trial 领取
-	// （D4 门控同 scheduler：CN 任务端点对 global 不发起任何调用）。
-	checkinMsg := ""
-	remain := int64(-1)
-	total := int64(0)
-	if sess.realm == "global" {
-		// 注册激活（幂等）：region required 时自动补地区（白名单首个，HK）后重新激活。
-		// 失败不阻断登录结果（auth 已落盘），只在返回字段里体现。
-		if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil {
-			checkinMsg = "注册激活失败: " + err.Error()
-			log.Printf("panel: global 注册激活 uid=%s: %v", acct.UID, err)
-		} else if activated {
-			log.Printf("panel: global 注册激活 uid=%s 完成", acct.UID)
-		}
-		// trial 加油包（幂等 14051 = 已领过，非错误）。
-		if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil {
-			checkinMsg = joinMsg(checkinMsg, "trial 领取失败: "+err.Error())
-			log.Printf("panel: global trial uid=%s: %v", acct.UID, err)
-		} else if claimed {
-			log.Printf("panel: global trial uid=%s 已领", acct.UID)
-		}
-	} else {
-		if err := p.cfg.Upstream.DailyCheckin(a); err != nil {
-			checkinMsg = err.Error()
-		}
-	}
-	if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil {
-		remain, total = rm, tt
-		p.cfg.Pool.ReenableIfCredits(acct.UID, rm, tt)
-	}
-
-	p.loginMu.Lock()
-	delete(p.logins, state)
-	p.loginMu.Unlock()
-	log.Printf("panel: 新账号已热加载 uid=%s nickname=%q realm=%s（免重启生效）", acct.UID, acct.Nickname, sess.realm)
-	writeJSON(w, http.StatusOK, map[string]any{
-		"done":            true,
-		"uid":             acct.UID,
-		"nickname":        acct.Nickname,
-		"realm":           sess.realm,
-		"credits":         remain,
-		"credits_total":   total,
-		"checkin_message": checkinMsg,
-	})
-}
-
-// joinMsg 拼接 login 完成后的提示消息（多段用「；」连接，空段跳过）。
-func joinMsg(parts ...string) string {
-	out := ""
-	for _, s := range parts {
-		if s == "" {
-			continue
-		}
-		if out != "" {
-			out += "；"
-		}
-		out += s
-	}
-	return out
-}
-
-// loginRegions 返回 global 注册可选地区（panel 前端选地区弹窗用；CN 不调用）。
-// 未持账号时返回白名单静态兜底（前端只读展示，不依赖上游）。
-func (p *Panel) loginRegions(w http.ResponseWriter, r *http.Request) {
-	// 静态白名单（对齐国际版 web 展示集）：面板前端只读展示，无需账号态。
-	writeJSON(w, http.StatusOK, map[string]any{
-		"ok": true,
-		"regions": []map[string]string{
-			{"code": "HK", "name": "Hong Kong"},
-			{"code": "MO", "name": "Macao"},
-			{"code": "SG", "name": "Singapore"},
-			{"code": "TH", "name": "Thailand"},
-			{"code": "PH", "name": "Philippines"},
-			{"code": "MY", "name": "Malaysia"},
-			{"code": "ID", "name": "Indonesia"},
-		},
-	})
-}
+// login.go 面板内嵌的 WorkBuddy CN OAuth 设备授权流程（cmd/login 的进程内移植）。
+//
+//	POST /panel/api/login/start → 拿 state+authUrl，state 存进程内（不再落 /tmp，
+//	  原方案在 Windows 上不可用），返回授权 URL；
+//	GET  /panel/api/login/poll   → 面板前端每 3s 轮询本接口；未完成返回 done=false，
+//	  完成后取 uid/nickname、凭证落盘 auths/workbuddy-<uid>.json、热加载进池
+//	  （pool.Add + Revive），并顺带签到 + 余额刷新 —— 免重启加载新账号。
+//
+// 无 PKCE（workbuddy 设备流由服务端签发 state），请求头与上游端点与 cmd/login 保持一致。
+package panel
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+)
+
+const (
+	upstreamBaseCN      = "https://copilot.tencent.com"
+	upstreamBaseGlobal  = "https://www.workbuddy.ai"
+	clientUA            = "CLI/2.63.2 CodeBuddy/2.63.2"
+	originRefererCN     = "https://www.codebuddy.cn"
+	originRefererGlobal = "https://www.workbuddy.ai"
+)
+
+// loginEndpoints 按 realm 返回设备授权三端点（auth/state、token、account）+ Origin。
+// realm=="global" → 国际版（workbuddy.ai 同域）；cn/非法/缺省 → CN（零回归）。
+func loginEndpoints(realm string) (state, token, account, origin string) {
+	if realm == "global" {
+		base := upstreamBaseGlobal
+		return base + "/v2/plugin/auth/state?platform=CLI",
+			base + "/v2/plugin/auth/token?state=",
+			base + "/v2/plugin/login/account?state=",
+			originRefererGlobal
+	}
+	base := upstreamBaseCN
+	return base + "/v2/plugin/auth/state?platform=CLI",
+		base + "/v2/plugin/auth/token?state=",
+		base + "/v2/plugin/login/account?state=",
+		originRefererCN
+}
+
+// loginHTTP 设备授权专用 client：短超时、无 cookie（每请求携带 state，无会话态）。
+var loginHTTP = &http.Client{Timeout: 30 * time.Second}
+
+func commonHeaders(req *http.Request, origin string) {
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept", "application/json, text/plain, */*")
+	req.Header.Set("X-Requested-With", "XMLHttpRequest")
+	req.Header.Set("Origin", origin)
+	req.Header.Set("Referer", origin+"/")
+	req.Header.Set("User-Agent", clientUA)
+}
+
+// validUID 校验上游返回的 uid 是否可安全用于拼文件名。
+// 只放行字母、数字、下划线、连字符（腾讯侧 uid 实测为 UUID 形态），
+// 长度上限 64 兜底异常超长串；拒绝 . / \ 等路径字符与空串。
+func validUID(uid string) bool {
+	if uid == "" || len(uid) > 64 {
+		return false
+	}
+	for _, c := range uid {
+		switch {
+		case c >= 'a' && c <= 'z', c >= 'A' && c <= 'Z', c >= '0' && c <= '9', c == '-', c == '_':
+		default:
+			return false
+		}
+	}
+	return true
+}
+
+// apiEnvelope 与 upstream 同形：{code,msg,data}，code!=0 视为业务错误。
+type apiEnvelope struct {
+	Code int             `json:"code"`
+	Msg  string          `json:"msg"`
+	Data json.RawMessage `json:"data"`
+}
+
+// doJSON 发一次 JSON 请求并解信封。origin 为 Origin/Referer 基础域（随 realm 切）。
+func doJSON(method, fullURL, bearer string, body io.Reader, origin string) (json.RawMessage, int, error) {
+	req, err := http.NewRequest(method, fullURL, body)
+	if err != nil {
+		return nil, 0, err
+	}
+	commonHeaders(req, origin)
+	if bearer != "" {
+		req.Header.Set("Authorization", "Bearer "+bearer)
+	}
+	resp, err := loginHTTP.Do(req)
+	if err != nil {
+		return nil, 0, err
+	}
+	defer resp.Body.Close()
+	raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<20))
+	if resp.StatusCode >= 300 {
+		return nil, resp.StatusCode, fmt.Errorf("http_error: upstream %d", resp.StatusCode)
+	}
+	var env apiEnvelope
+	if err := json.Unmarshal(raw, &env); err != nil {
+		return nil, resp.StatusCode, fmt.Errorf("parse failed: %w", err)
+	}
+	if env.Code != 0 {
+		return nil, resp.StatusCode, fmt.Errorf("code=%d msg=%s", env.Code, env.Msg)
+	}
+	return env.Data, resp.StatusCode, nil
+}
+
+// loginStart 发起设备授权：POST auth/state 拿授权 URL。
+// body 可带 {"realm":"global"}（缺省 cn）；state 会话记 realm，poll 同 realm 落盘。
+func (p *Panel) loginStart(w http.ResponseWriter, r *http.Request) {
+	realm := "cn"
+	if r.Body != nil {
+		var reqBody struct {
+			Realm string `json:"realm"`
+		}
+		if err := json.NewDecoder(io.LimitReader(r.Body, 1<<12)).Decode(&reqBody); err == nil {
+			if reqBody.Realm == "global" {
+				realm = "global"
+			}
+		}
+	}
+	epState, _, _, origin := loginEndpoints(realm)
+	data, status, err := doJSON(http.MethodPost, epState, "", bytes.NewReader([]byte("{}")), origin)
+	if err != nil {
+		writeErr(w, http.StatusBadGateway, fmt.Sprintf("auth state (upstream %d): %v", status, err))
+		return
+	}
+	var st struct {
+		State   string `json:"state"`
+		AuthURL string `json:"authUrl"`
+	}
+	if err := json.Unmarshal(data, &st); err != nil || st.State == "" || st.AuthURL == "" {
+		writeErr(w, http.StatusBadGateway, "auth state: missing state or authUrl")
+		return
+	}
+	p.loginMu.Lock()
+	// 顺手回收过期会话，防"开弹窗走开"的 state 滞留。
+	for s, sess := range p.logins {
+		if time.Since(sess.created) > loginTTL {
+			delete(p.logins, s)
+		}
+	}
+	p.logins[st.State] = loginSession{created: time.Now(), realm: realm}
+	p.loginMu.Unlock()
+	log.Printf("panel: 发起 OAuth 添加账号 realm=%s（state=%s...）", realm, st.State[:min(8, len(st.State))])
+	writeJSON(w, http.StatusOK, map[string]any{"ok": true, "url": st.AuthURL, "state": st.State, "realm": realm})
+}
+
+// loginPoll 轮询登录态。未完成 → {done:false}；完成 → 建凭证、落盘、热加载、签到。
+func (p *Panel) loginPoll(w http.ResponseWriter, r *http.Request) {
+	state := r.URL.Query().Get("state")
+	if state == "" {
+		writeErr(w, http.StatusBadRequest, "missing state")
+		return
+	}
+	p.loginMu.Lock()
+	sess, known := p.logins[state]
+	p.loginMu.Unlock()
+	if !known {
+		writeErr(w, http.StatusNotFound, "unknown or expired state（请重新发起添加账号）")
+		return
+	}
+	_, epToken, epAcct, origin := loginEndpoints(sess.realm)
+
+	// auth/token 是权威登录状态端点：pending 时业务 code 非 0（"login ing"）。
+	tokRaw, _, err := doJSON(http.MethodGet, epToken+state, "", nil, origin)
+	if err != nil {
+		// pending / 未完成：面板前端继续轮询。
+		writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": err.Error()})
+		return
+	}
+	var tok struct {
+		AccessToken  string `json:"accessToken"`
+		RefreshToken string `json:"refreshToken"`
+		ExpiresIn    int64  `json:"expiresIn"`
+		Domain       string `json:"domain"`
+	}
+	if err := json.Unmarshal(tokRaw, &tok); err != nil || tok.AccessToken == "" {
+		writeJSON(w, http.StatusOK, map[string]any{"done": false, "message": "waiting for login"})
+		return
+	}
+
+	// 完成：取 uid/nickname（失败不阻塞，仅缺展示名）。
+	var acct struct {
+		UID          string `json:"uid"`
+		EnterpriseID string `json:"enterpriseId"`
+		Nickname     string `json:"nickname"`
+	}
+	if acctRaw, _, err := doJSON(http.MethodGet, epAcct+state, tok.AccessToken, nil, origin); err == nil {
+		_ = json.Unmarshal(acctRaw, &acct)
+	}
+	if acct.UID == "" {
+		writeErr(w, http.StatusBadGateway, "login done but no uid（token 已发但账号信息获取失败，请重试）")
+		return
+	}
+	// UID 来自上游响应，未经校验就用于拼文件名会被路径穿越利用
+	// （filepath.Join("./auths", "workbuddy-../../evil.json") → auths/evil.json）。
+	// UID 是腾讯侧账号标识，实测为 UUID（十六进制与连字符），故只放行 [A-Za-z0-9_-]。
+	if !validUID(acct.UID) {
+		writeErr(w, http.StatusBadGateway, "上游返回的 uid ���非法字符，拒绝落盘（防路径穿越）")
+		return
+	}
+
+	// 凭证落盘（嵌套形，与 auths/ 目录既有格式一致）→ 热加载进池。
+	if err := os.MkdirAll(p.cfg.AuthDir, 0o755); err != nil {
+		writeErr(w, http.StatusInternalServerError, "mkdir auth dir: "+err.Error())
+		return
+	}
+	a := &auth.Auth{
+		AccessToken:  tok.AccessToken,
+		RefreshToken: tok.RefreshToken,
+		ExpiresAt:    time.Now().Add(time.Duration(tok.ExpiresIn) * time.Second).Unix(),
+		Domain:       tok.Domain,
+		UID:          acct.UID,
+		EnterpriseID: acct.EnterpriseID,
+		Nickname:     acct.Nickname,
+		FilePath:     filepath.Join(p.cfg.AuthDir, fmt.Sprintf("workbuddy-%s.json", acct.UID)),
+	}
+	// global 登录：落盘 auth.realm=global（Realm() 按此判域；不写则依赖 domain 后缀回落）。
+	if sess.realm == "global" {
+		if _, err := auth.BackfillRealmFor(a, "global"); err != nil {
+			writeErr(w, http.StatusInternalServerError, "set realm: "+err.Error())
+			return
+		}
+	} else {
+		// CN 也显式补 realm 键（幂等），让 auth 文件形态统一（与 LoadDir 存量迁移对齐）。
+		_, _ = a.BackfillRealm()
+	}
+	if err := a.SaveAtomic(); err != nil {
+		writeErr(w, http.StatusInternalServerError, "save auth: "+err.Error())
+		return
+	}
+	p.cfg.Pool.Add(a)
+	p.cfg.Pool.Revive(acct.UID) // 全新登录 = 人工恢复口径：清掉旧号遗留的禁用/冷却/熔断
+
+	// 顺带签到 + 余额刷新（幂等；失败不影响登录结果，只体现在返回字段里）。
+	// realm 分支：CN 走 DailyCheckin；global 无 CN 签到体系，改为注册激活 + trial 领取
+	// （D4 门控同 scheduler：CN 任务端点对 global 不发起任何调用）。
+	checkinMsg := ""
+	remain := int64(-1)
+	total := int64(0)
+	if sess.realm == "global" {
+		// 注册激活（幂等）：region required 时自动补地区（白名单首个，HK）后重新激活。
+		// 失败不阻断登录结果（auth 已落盘），只在返回字段里体现。
+		if activated, err := p.cfg.Upstream.GlobalCompleteRegistration(a); err != nil {
+			checkinMsg = "注册激活失败: " + err.Error()
+			log.Printf("panel: global 注册激活 uid=%s: %v", acct.UID, err)
+		} else if activated {
+			log.Printf("panel: global 注册激活 uid=%s 完成", acct.UID)
+		}
+		// trial 加油包（幂等 14051 = 已领过，非错误）。
+		if claimed, err := p.cfg.Upstream.ClaimTrial(a); err != nil {
+			checkinMsg = joinMsg(checkinMsg, "trial 领取失败: "+err.Error())
+			log.Printf("panel: global trial uid=%s: %v", acct.UID, err)
+		} else if claimed {
+			log.Printf("panel: global trial uid=%s 已领", acct.UID)
+		}
+	} else {
+		if err := p.cfg.Upstream.DailyCheckin(a); err != nil {
+			checkinMsg = err.Error()
+		}
+	}
+	if rm, tt, err := p.cfg.Upstream.UserResource(a); err == nil {
+		remain, total = rm, tt
+		p.cfg.Pool.ReenableIfCredits(acct.UID, rm, tt)
+	}
+
+	p.loginMu.Lock()
+	delete(p.logins, state)
+	p.loginMu.Unlock()
+	log.Printf("panel: 新账号已热加载 uid=%s nickname=%q realm=%s（免重启生效）", acct.UID, acct.Nickname, sess.realm)
+	writeJSON(w, http.StatusOK, map[string]any{
+		"done":            true,
+		"uid":             acct.UID,
+		"nickname":        acct.Nickname,
+		"realm":           sess.realm,
+		"credits":         remain,
+		"credits_total":   total,
+		"checkin_message": checkinMsg,
+	})
+}
+
+// joinMsg 拼接 login 完成后的提示消息（多段用「；」连接，空段跳过）。
+func joinMsg(parts ...string) string {
+	out := ""
+	for _, s := range parts {
+		if s == "" {
+			continue
+		}
+		if out != "" {
+			out += "；"
+		}
+		out += s
+	}
+	return out
+}
+
+// loginRegions 返回 global 注册可选地区（panel 前端选地区弹窗用；CN 不调用）。
+// 未持账号时返回白名单静态兜底（前端只读展示，不依赖上游）。
+func (p *Panel) loginRegions(w http.ResponseWriter, r *http.Request) {
+	// 静态白名单（对齐国际版 web 展示集）：面板前端只读展示，无需账号态。
+	writeJSON(w, http.StatusOK, map[string]any{
+		"ok": true,
+		"regions": []map[string]string{
+			{"code": "HK", "name": "Hong Kong"},
+			{"code": "MO", "name": "Macao"},
+			{"code": "SG", "name": "Singapore"},
+			{"code": "TH", "name": "Thailand"},
+			{"code": "PH", "name": "Philippines"},
+			{"code": "MY", "name": "Malaysia"},
+			{"code": "ID", "name": "Indonesia"},
+		},
+	})
+}