feat(hf): 部署 WorkBuddy2API Panel 到 HF Spaces（存储桶持久化）

替换原本的 gcli2api 应用；原内容完整保留在 tag backup-gcli2api-legacy-20261003。

- Dockerfile: HF Spaces 形态（root 运行、监听 7861、入口脚本驱动）
- docker-entrypoint.sh: 卷探测 + 写/rename 自检 + api_key 为空时拒绝启动
- config.default.json: 镜像内模板（不含 api_key，公开仓库不放密钥）
- 持久化布局: /app/storage/{config.json,auths/,data/} 全部由私有 storage bucket 卷提供
- README.md: HF 卡片元数据 + 部署与运维说明

.dockerignore

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

.env.example

@@ -1,179 +0,0 @@
-# ================================================================
-# GCLI2API 环境变量配置示例文件
-# 复制此文件为 .env 并根据需要修改配置值
-# ================================================================
-
-# ================================================================
-# 服务器配置
-# ================================================================
-
-# 服务器监听地址
-# 默认: 0.0.0.0 (监听所有网络接口)
-HOST=0.0.0.0
-
-# 服务器端口
-# 默认: 7861
-PORT=7861
-
-# ================================================================
-# 密码配置 (支持分离密码)
-# ================================================================
-
-# 聊天API访问密码 (用于OpenAI和Gemini API端点认证)
-# 默认: 继承通用密码或 pwd
-API_PASSWORD=your_api_password
-
-# 控制面板访问密码 (用于Web界面登录认证)
-# 默认: 继承通用密码或 pwd
-PANEL_PASSWORD=your_panel_password
-
-# 通用访问密码 (兼容性保留)
-# 设置后会覆盖上述两个专用密码，优先级最高
-# 如果只想使用一个密码，设置此项即可
-# 默认: pwd
-PASSWORD=pwd
-
-# ================================================================
-# 存储配置
-# ================================================================
-
-# 存储后端优先级: PostgreSQL > MongoDB > 本地sqlite文件存储
-# 系统会自动选择可用的最高优先级存储后端
-
-# PostgreSQL 分布式存储模式配置 (最高优先级)
-# 设置 POSTGRESQL_URI 后自动启用 PostgreSQL 模式
-# 本地 PostgreSQL: postgresql://user:password@localhost:5432/gcli2api
-# 带 SSL: postgresql://user:password@host:5432/gcli2api?sslmode=require
-# 默认: 无 (不启用 PostgreSQL 存储)
-POSTGRESQL_URI=postgresql://user:password@localhost:5432/gcli2api
-
-# MongoDB 分布式存储模式配置 (第二优先级)
-# 设置 MONGODB_URI 后自动启用 MongoDB 模式，不再使用本地文件存储
-
-# Redis 缓存存储配置
-# 设置 REDIS_URL 后自动启用 Redis 模式，性能最佳，可大幅降低 MongoDB 的读写压力
-# 本地 Redis: redis://127.0.0.1:6379/0
-# 带密码: redis://:password@127.0.0.1:6379/0
-# 默认: 无 (不启用 Redis 缓存)
-REDIS_URL=redis://127.0.0.1:6379/0
-
-# MongoDB 连接字符串 (设置后启用 MongoDB 分布式存储模式)
-# 本地 MongoDB: mongodb://localhost:27017
-# 带认证: mongodb://admin:password@localhost:27017/admin
-# MongoDB Atlas: mongodb+srv://username:password@cluster.mongodb.net
-# 副本集: mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=rs0
-# 默认: 无 (使用本地文件存储)
-MONGODB_URI=mongodb://localhost:27017
-
-# MongoDB 数据库名称 (仅在启用 MongoDB 模式时有效)
-# 默认: gcli2api
-MONGODB_DATABASE=gcli2api
-
-# ================================================================
-# Google API 配置
-# ================================================================
-
-# 凭证文件目录 (仅在文件存储模式下使用)
-# 默认: ./creds
-CREDENTIALS_DIR=./creds
-
-
-# 代理配置 (可选)
-# 支持 http, https, socks5 代理
-# 格式: http://proxy:port, https://proxy:port, socks5://proxy:port
-PROXY=http://localhost:7890
-
-# Google API 代理 URL 配置 (可选)
-
-# Google Code Assist API 端点
-# 默认: https://cloudcode-pa.googleapis.com
-CODE_ASSIST_ENDPOINT=https://cloudcode-pa.googleapis.com
-# 用于Google OAuth2认证的代理URL
-# 默认: https://oauth2.googleapis.com
-OAUTH_PROXY_URL=https://oauth2.googleapis.com
-
-# 用于Google APIs调用的代理URL
-# 默认: https://www.googleapis.com
-GOOGLEAPIS_PROXY_URL=https://www.googleapis.com
-
-# 用于Google Cloud Resource Manager API的URL
-# 默认: https://cloudresourcemanager.googleapis.com
-RESOURCE_MANAGER_API_URL=https://cloudresourcemanager.googleapis.com
-
-# 用于Google Cloud Service Usage API的URL
-# 默认: https://serviceusage.googleapis.com
-SERVICE_USAGE_API_URL=https://serviceusage.googleapis.com
-
-# 用于Google Antigravity API的URL (反重力模式)
-# 默认: https://daily-cloudcode-pa.googleapis.com
-ANTIGRAVITY_API_URL=https://daily-cloudcode-pa.googleapis.com
-
-# ================================================================
-# 错误处理和重试配置
-# ================================================================
-
-# 是否启用自动封禁功能
-# 当凭证返回特定错误码时自动禁用该凭证
-# 默认: false
-AUTO_BAN=false
-
-# 自动封禁的错误码列表 (逗号分隔)
-# 默认: 400,403
-AUTO_BAN_ERROR_CODES=403
-
-# 是否启用 429 错误重试
-# 默认: true
-RETRY_429_ENABLED=true
-
-# 429 错误最大重试次数
-# 默认: 5
-RETRY_429_MAX_RETRIES=5
-
-# 429 错误重试间隔 (秒)
-# 默认: 1
-RETRY_429_INTERVAL=1
-
-# ================================================================
-# 日志配置
-# ================================================================
-
-# 日志级别
-# 可选值: debug, info, warning, error, critical
-# 默认: info
-LOG_LEVEL=info
-
-# 日志文件路径
-# 默认: log.txt
-LOG_FILE=log.txt
-
-# ================================================================
-# 高级功能配置
-# ================================================================
-
-# 流式抗截断最大尝试次数
-# 用于 "流式抗截断/" 前缀的模型
-# 默认: 3
-ANTI_TRUNCATION_MAX_ATTEMPTS=3
-
-# ================================================================
-# 环境变量使用说明
-# ================================================================
-
-# 1. 存储模式配置 (按优先级自动选择):
-#    - PostgreSQL 分布式模式 (最高优先级): 设置 POSTGRESQL_URI，数据存储在 PostgreSQL 数据库
-#    - Redis 缓存: 同时设置 REDIS_URI和 MONGODB_URI时，数据缓存在 Redis 数据库，持久化在MONGODB，性能最佳
-#    - MongoDB 分布式模式: 设置 MONGODB_URI，数据存储在 MongoDB 数据库
-#    - 文件存储模式 (默认): 不设置上述 URI，数据存储在本地 creds/ 目录
-#    - 自动切换: 系统根据可用的存储配置自动选择最高优先级的存储后端
-
-# 2. 密码配置优先级:
-#    a) PASSWORD 环境变量 (最高优先级，设置后覆盖其他密码)
-#    b) API_PASSWORD / PANEL_PASSWORD 环境变量 (专用密码)
-#    c) 默认值 "pwd"
-#
-# 3. 通用配置优先级:
-#    环境变量 > 默认值
-
-# 4. 布尔值环境变量:
-#    true/1/yes/on 表示启用
-#    false/0/no/off 表示禁用

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,92 +0,0 @@
-name: Bug 报告
-description: 报告项目使用中遇到的问题
-title: "[Bug]: "
-labels: ["bug", "待处理"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        ## 感谢你的反馈!
-        请填写以下信息以帮助我们更快定位问题。
-  
-  - type: checkboxes
-    id: checklist
-    attributes:
-      label: 提交前确认
-      options:
-        - label: 我已经搜索过现有的 issues,确认这不是重复问题
-          required: true
-        - label: 我已经阅读过项目文档
-          required: true
-  
-  - type: dropdown
-    id: latest-version
-    attributes:
-      label: 是否是最新版
-      description: 请确认你使用的是否是最新版本
-      options:
-        - 是,使用最新版
-        - 否,使用旧版本
-    validations:
-      required: true
-  
-  - type: input
-    id: channel
-    attributes:
-      label: 调用的是哪个渠道
-      description: 例如 geminicli 或者 antigravity
-      placeholder: "例如: geminicli"
-    validations:
-      required: true
-  
-  - type: input
-    id: model
-    attributes:
-      label: 调用的是哪个模型
-      description: 例如 gemini-2.5-flash
-      placeholder: "例如: gemini-2.5-flash"
-    validations:
-      required: true
-  
-  - type: dropdown
-    id: format
-    attributes:
-      label: 调用的是哪个格式
-      description: 选择你使用的 API 格式
-      options:
-        - gemini 格式
-        - openai 格式
-        - claude 格式
-        - 其他格式
-    validations:
-      required: true
-  
-  - type: textarea
-    id: error-content
-    attributes:
-      label: 具体报错内容
-      description: 请粘贴完整的错误信息或截图
-      placeholder: |
-        请在这里粘贴完整的错误日志或堆栈信息
-      render: shell
-    validations:
-      required: true
-  
-  - type: textarea
-    id: error-description
-    attributes:
-      label: 错误描述
-      description: 详细描述问题的发生场景、预期行为和实际行为
-      placeholder: |
-        1. 我在做什么操作时遇到了这个问题
-        2. 我期望的结果是...
-        3. 但实际上发生了...
-    validations:
-      required: true
-  
-  - type: textarea
-    id: additional-context
-    attributes:
-      label: 补充信息(可选)
-      description: 其他任何有助于解决问题的信息
-      placeholder: 例如:操作系统、Python 版本、相关配置等

.github/ISSUE_TEMPLATE/config.yml

@@ -1,8 +0,0 @@
-blank_issues_enabled: false
-contact_links:
-  - name: 使用问题讨论
-    url: https://github.com/su-kaka/gcli2api/issues
-    about: 如果是使用方面的问题,请在 issues 中提问
-  - name: 项目文档
-    url: https://github.com/su-kaka/gcli2api
-    about: 查看完整文档和使用指南

.github/workflows/docker-publish.yml

@@ -1,81 +0,0 @@
-name: Docker Build and Publish
-
-on:
-  workflow_run:
-    workflows: ["Update Version File"]
-    types:
-      - completed
-    branches:
-      - master
-      - main
-  push:
-    tags:
-      - 'v*'
-  pull_request:
-    branches:
-      - master
-      - main
-  workflow_dispatch:
-
-env:
-  REGISTRY: ghcr.io
-  IMAGE_NAME: ${{ github.repository }}
-
-jobs:
-  build-and-push:
-    runs-on: ubuntu-latest
-    # 只在 workflow_run 成功时运行，或者非 workflow_run 触发时运行
-    if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }}
-    permissions:
-      contents: read
-      packages: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          # workflow_run 触发时需要获取最新的代码（包括 version.txt 的更新）
-          ref: ${{ github.event_name == 'workflow_run' && github.event.workflow_run.head_branch || github.ref }}
-
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v3
-
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v3
-
-      - name: Log in to GitHub Container Registry
-        uses: docker/login-action@v3
-        with:
-          registry: ${{ env.REGISTRY }}
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Extract metadata
-        id: meta
-        uses: docker/metadata-action@v5
-        with:
-          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
-          tags: |
-            type=ref,event=branch
-            type=ref,event=tag
-            type=ref,event=pr
-            type=raw,value=latest,enable={{is_default_branch}}
-            type=sha,prefix={{branch}}-
-            type=semver,pattern={{version}}
-            type=semver,pattern={{major}}.{{minor}}
-            type=semver,pattern={{major}}
-
-      - name: Build and push Docker image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          platforms: linux/amd64,linux/arm64
-          push: ${{ github.event_name != 'pull_request' }}
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha
-          cache-to: type=gha,mode=max
-          build-args: |
-            BUILD_DATE=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.created'] }}
-            VERSION=${{ fromJSON(steps.meta.outputs.json).labels['org.opencontainers.image.version'] }}
-            REVISION=${{ github.sha }}

.github/workflows/update-version.yml

@@ -1,51 +0,0 @@
-name: Update Version File
-
-on:
-  push:
-    branches:
-      - master
-      - main
-
-jobs:
-  update-version:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Update version.txt
-        run: |
-          # 获取最新commit信息
-          FULL_HASH=$(git log -1 --format=%H)
-          SHORT_HASH=$(git log -1 --format=%h)
-          MESSAGE=$(git log -1 --format=%s)
-          DATE=$(git log -1 --format=%ci)
-
-          # 写入version.txt
-          echo "full_hash=$FULL_HASH" > version.txt
-          echo "short_hash=$SHORT_HASH" >> version.txt
-          echo "message=$MESSAGE" >> version.txt
-          echo "date=$DATE" >> version.txt
-
-          echo "Version file updated:"
-          cat version.txt
-
-      - name: Commit version.txt if changed
-        run: |
-          git config --local user.email "github-actions[bot]@users.noreply.github.com"
-          git config --local user.name "github-actions[bot]"
-
-          # 检查是否有变化
-          if git diff --quiet version.txt; then
-            echo "No changes to version.txt"
-          else
-            git add version.txt
-            git commit -m "chore: update version.txt [skip ci]"
-            git push
-          fi

.gitignore

@@ -1,99 +1,46 @@
-# Credential files - should never be committed
-*.json
-!package.json
-!package-lock.json
-!tsconfig.json
-*.toml
-!pyproject.toml
-creds/
-CLAUDE.md
-GEMINI.md
-.kiro
-# Environment configuration
+# Auth & secrets
+auths/
+data/
+*.key
+*.pem
+*.env
 .env
+.env.*
 
-# Python
-uv.lock
-.python-version
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-pip-wheel-metadata/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-*.manifest
-*.spec
+# Binaries (anchored to repo root only — bare "login"/"credit" would also ignore cmd/login/, cmd/credit/)
+/login
+/credit
+/wb2api
+/signin_bin
 
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
+# Config with secrets (use config.example.json)
+config.json
 
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py,cover
-.hypothesis/
-.pytest_cache/
+# Build artifacts
+*.tmp
+__pycache__/
 
-# Virtual environments
-.env
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
+# Backups (contains auth tokens)
+backups/
 
 # IDE
-.vscode/
 .idea/
-.claude/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-.DS_Store?
-._*
-.Spotlight-V100
-.Trashes
-ehthumbs.db
-Thumbs.db
-
-# Logs
-*.log
-log.txt
-
-# Temporary files
-*.tmp
-*.temp
-*.bak
-
-tools/
+.vscode/
+LOOP.md
+PLAN.md
+SPEC.md
+docs/
+
+# 设计/计划文档（但 README.md 必须进版本库）
+*.md
+!README.md
+
+# Windows binaries
+/wb2api.exe
+/login.exe
+/credit.exe
+
+# 本地验证工具（判据逆向过程脚本，结论沉淀于 data/desktop-task-protocol.md）
+/cmd/desktopverify*/
+*.zip
+server.exe

CONTRIBUTING.md

@@ -1,169 +0,0 @@
-# Contributing to gcli2api
-
-First off, thank you for considering contributing to gcli2api! It's people like you that make gcli2api such a great tool.
-
-## Code of Conduct
-
-This project is intended for personal learning and research purposes only. By participating, you are expected to uphold this code and respect the CNC-1.0 license restrictions on commercial use.
-
-## How Can I Contribute?
-
-### Reporting Bugs
-
-Before creating bug reports, please check the existing issues to avoid duplicates. When you create a bug report, include as many details as possible:
-
-* **Use a clear and descriptive title**
-* **Describe the exact steps to reproduce the problem**
-* **Provide specific examples** - Include code snippets, configuration files, or log outputs
-* **Describe the behavior you observed** and what you expected to see
-* **Include environment details**: OS, Python version, Docker version (if applicable)
-
-### Suggesting Enhancements
-
-Enhancement suggestions are tracked as GitHub issues. When creating an enhancement suggestion, include:
-
-* **Use a clear and descriptive title**
-* **Provide a detailed description** of the suggested enhancement
-* **Explain why this enhancement would be useful**
-* **List any alternative solutions** you've considered
-
-### Pull Requests
-
-1. Fork the repo and create your branch from `master`
-2. If you've added code that should be tested, add tests
-3. If you've changed APIs, update the documentation
-4. Ensure the test suite passes
-5. Make sure your code follows the existing style
-6. Write a clear commit message
-
-## Development Setup
-
-### Prerequisites
-
-* Python 3.12 or higher
-* pip or uv package manager
-
-### Setting Up Your Development Environment
-
-```bash
-# Clone your fork
-git clone https://github.com/YOUR_USERNAME/gcli2api.git
-cd gcli2api
-
-# Install development dependencies
-make install-dev
-# or
-pip install -e ".[dev]"
-
-# Copy environment example
-cp .env.example .env
-# Edit .env with your configuration
-```
-
-### Development Workflow
-
-```bash
-# Run tests
-make test
-
-# Format code
-make format
-
-# Run linters
-make lint
-
-# Run the application locally
-make run
-```
-
-### Testing
-
-We use pytest for testing. All new features should include appropriate tests.
-
-```bash
-# Run all tests
-make test
-
-# Run with coverage
-make test-cov
-
-# Run specific test file
-python -m pytest test_tool_calling.py -v
-```
-
-### Code Style
-
-* We use [Black](https://black.readthedocs.io/) for code formatting (line length: 100)
-* We use [flake8](https://flake8.pycqa.org/) for linting
-* We use [mypy](http://mypy-lang.org/) for type checking (optional, but encouraged)
-
-```bash
-# Format your code before committing
-make format
-
-# Check if code is properly formatted
-make format-check
-
-# Run linters
-make lint
-```
-
-## Project Structure
-
-```
-gcli2api/
-├── src/                    # Main source code
-│   ├── auth.py            # Authentication and OAuth
-│   ├── credential_manager.py  # Credential rotation
-│   ├── openai_router.py   # OpenAI-compatible endpoints
-│   ├── gemini_router.py   # Gemini native endpoints
-│   ├── openai_transfer.py # Format conversion
-│   ├── storage/           # Storage backends (Redis, MongoDB, Postgres, File)
-│   └── ...
-├── front/                 # Frontend static files
-├── tests/                 # Test directory (to be created)
-├── test_*.py             # Test files (root level)
-├── web.py                # Main application entry point
-├── config.py             # Configuration management
-└── requirements.txt      # Production dependencies
-```
-
-## Coding Guidelines
-
-### Python Style
-
-* Follow PEP 8 guidelines
-* Use type hints where appropriate
-* Write docstrings for classes and functions
-* Keep functions focused and concise
-
-### Commit Messages
-
-* Use the present tense ("Add feature" not "Added feature")
-* Use the imperative mood ("Move cursor to..." not "Moves cursor to...")
-* Limit the first line to 72 characters or less
-* Reference issues and pull requests liberally after the first line
-
-### Documentation
-
-* Update the README.md if you change functionality
-* Comment your code where necessary
-* Update the .env.example if you add new configuration options
-
-## License
-
-By contributing to gcli2api, you agree that your contributions will be licensed under the CNC-1.0 license. This is a strict anti-commercial license - see [LICENSE](LICENSE) for details.
-
-### Important License Restrictions
-
-* ❌ No commercial use
-* ❌ No use by companies with revenue > $1M USD
-* ❌ No use by VC-backed or publicly traded companies
-* ✅ Personal learning, research, and educational use only
-* ✅ Open source integration (must follow same license)
-
-## Questions?
-
-Feel free to open an issue with your question or reach out to the maintainers.
-
-Thank you for contributing! 🎉

Dockerfile

@@ -1,38 +1,39 @@
-# Multi-stage build for gcli2api
-FROM python:3.13-slim as base
-
-# Set environment variables
-ENV PYTHONUNBUFFERED=1 \
-    PYTHONDONTWRITEBYTECODE=1 \
-    PIP_NO_CACHE_DIR=1 \
-    PIP_DISABLE_PIP_VERSION_CHECK=1 \
-    TZ=Asia/Shanghai
-
-# Install tzdata and set timezone
-# Added: nodejs (for afp.wasm 音频指纹生成), ffmpeg (音频转码)
-RUN apt-get update && \
-    apt-get install -y --no-install-recommends \
-        tzdata \
-        nodejs \
-        ffmpeg \
-    && ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime && \
-    echo "Asia/Shanghai" > /etc/timezone && \
-    apt-get clean && \
-    rm -rf /var/lib/apt/lists/*
-
-WORKDIR /app
-
-# Copy only requirements first for better caching
-COPY requirements.txt .
-
-# Install Python dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application code
+# 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
 
-# Expose port
+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
-
-# Default command
-CMD ["python", "web.py"]
+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,83 +1,22 @@
-Cooperative Non-Commercial License (CNC-1.0)
-
-Copyright (c) 2024 gcli2api contributors
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of this software and associated documentation files (the
-"Software"), to use, copy, modify, merge, publish, distribute, and/or
-sublicense the Software, subject to the following conditions:
-
-TERMS AND CONDITIONS:
-
-1. NON-COMMERCIAL USE ONLY
-   The Software may only be used for non-commercial purposes. Commercial use
-   is strictly prohibited without explicit written permission from the 
-   copyright holders.
-
-2. DEFINITION OF COMMERCIAL USE
-   "Commercial use" includes but is not limited to:
-   a) Using the Software to provide paid services or products
-   b) Integrating the Software into commercial products or services
-   c) Using the Software in any business operation that generates revenue
-   d) Offering the Software as part of a paid subscription or service
-   e) Using the Software to compete with the original project commercially
-
-3. COPYLEFT REQUIREMENT
-   Any derivative works, modifications, or substantial portions of the Software
-   must be licensed under the same or substantially similar terms. This ensures
-   that all derivatives remain non-commercial and freely available.
-
-4. SOURCE CODE AVAILABILITY
-   If you distribute the Software or any derivative works, you must make the
-   complete source code available under the same license terms at no charge.
-
-5. ATTRIBUTION REQUIREMENT
-   You must retain all copyright notices, license notices, and attribution
-   statements in all copies or substantial portions of the Software.
-
-6. ANTI-CORPORATE CLAUSE
-   This Software may not be used by corporations with annual revenue exceeding
-   $1 million USD, venture capital backed companies, or publicly traded
-   companies without explicit written permission from the copyright holders.
-
-7. EDUCATIONAL AND RESEARCH EXEMPTION
-   Use by educational institutions, non-profit research organizations, and
-   individual researchers for educational or research purposes is explicitly
-   permitted and encouraged.
-
-8. MODIFICATION AND CONTRIBUTION
-   Modifications and contributions to the Software are welcomed and encouraged,
-   provided they comply with these license terms. Contributors grant the same
-   license to their contributions.
-
-9. PATENT GRANT
-   Each contributor grants you a non-exclusive, worldwide, royalty-free patent
-   license to make, have made, use, offer to sell, sell, import, and otherwise
-   transfer the Work for non-commercial purposes only.
-
-10. TERMINATION
-    This license automatically terminates if you violate any of its terms.
-    Upon termination, you must cease all use and distribution of the Software
-    and destroy all copies in your possession.
-
-11. LIABILITY DISCLAIMER
-    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.
-
-12. JURISDICTION
-    This license shall be governed by and construed in accordance with the laws
-    of the jurisdiction where the copyright holder resides.
-
-SUMMARY:
-This license allows free use, modification, and distribution of the Software
-for non-commercial purposes only. It explicitly prohibits commercial use and
-ensures that all derivatives remain freely available under the same terms.
-The license promotes cooperative development while preventing commercial
-exploitation of the community's work.
-
-For commercial licensing inquiries, please contact the copyright holders.
+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,891 +1,67 @@
 ---
-title: gcli2api
-colorFrom: blue
-colorTo: green
+title: WorkBuddy2API Panel
+emoji: 🧩
+colorFrom: indigo
+colorTo: blue
 sdk: docker
 app_port: 7861
 pinned: false
+short_description: WorkBuddy 账号池网关，带面板，数据落私有存储桶
 ---
-# GeminiCLI to API
 
-**将 GeminiCLI 和 Antigravity 转换为 OpenAI 、GEMINI 和 Claude API 兼容接口**
+# WorkBuddy2API Panel — Hugging Face Spaces 部署
 
-[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](LICENSE)
-[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
+把腾讯 WorkBuddy 账号变成 OpenAI 兼容 API 的多账号网关（上游：
+[linguo2625469/workbuddy2api-panel](https://github.com/linguo2625469/workbuddy2api-panel)）。
+本目录是**面向 HF Spaces 的部署分支**：唯一的改动是「持久化」。
 
-[English](docs/README_EN.md) | 中文 | [日本語](docs/README_JA.md)
+## 这个分支改了什么
 
-## 🚀 快速部署 
+Spaces 的容器根文件系统是 ephemeral 的 —— 重启、休眠唤醒、重新构建都会清空。
+原版把账号和状态放在容器内的 `./auths`、`./data`，在 Spaces 上等于每次重启都要重新登录账号。
 
-[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
-[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
----
-
-## 安装指南
-
-### Termux 环境
-
-**初始安装**
-```bash
-curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
-```
-
-**重启服务**
-```bash
-cd gcli2api
-bash termux-start.sh
-```
-
-### Windows 环境
-
-**初始安装**
-```powershell
-iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
-```
-
-**重启服务**
-双击执行 `start.bat`
-
-### Linux 环境
-
-**初始安装**
-```bash
-curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
-```
-
-**重启服务**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### macOS 环境
-
-**初始安装**
-```bash
-curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
-```
-
-**重启服务**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### Docker 环境
-
-**Docker 运行命令**
-```bash
-# 使用通用密码
-docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-
-# 使用分离密码
-docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Mac**
-```bash
-# 使用通用密码
-docker run -d \
-  --name gcli2api \
-  -p 7861:7861 \
-  -p 8080:8080 \
-  -e PASSWORD=pwd \
-  -e PORT=7861 \
-  -v "$(pwd)/data/creds":/app/creds \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-```bash
-# 使用分离密码
-docker run -d \
---name gcli2api \
--p 7861:7861 \
--p 8080:8080 \
--e API_PASSWORD=api_pwd \
--e PANEL_PASSWORD=panel_pwd \
--e PORT=7861 \
--v $(pwd)/data/creds:/app/creds \
-ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Compose 运行命令**
-1. 将以下内容保存为 `docker-compose.yml` 文件：
-    ```yaml
-    version: '3.8'
-
-    services:
-      gcli2api:
-        image: ghcr.io/su-kaka/gcli2api:latest
-        container_name: gcli2api
-        restart: unless-stopped
-        network_mode: host
-        environment:
-          # 使用通用密码（推荐用于简单部署）
-          - PASSWORD=pwd
-          - PORT=7861
-          # 或使用分离密码（推荐用于生产环境）
-          # - API_PASSWORD=your_api_password
-          # - PANEL_PASSWORD=your_panel_password
-        volumes:
-          - ./data/creds:/app/creds
-        healthcheck:
-          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
-          interval: 30s
-          timeout: 10s
-          retries: 3
-          start_period: 40s
-    ```
-2. 启动服务：
-    ```bash
-    docker-compose up -d
-    ```
-
-## 核心功能
-
-### 🔄 API 端点和格式支持
-
-**多端点多格式支持**
-- **OpenAI 兼容端点**：`/v1/chat/completions` 和 `/v1/models`
-  - 支持标准 OpenAI 格式（messages 结构）
-  - 支持 Gemini 原生格式（contents 结构）
-  - 自动格式检测和转换，无需手动切换
-  - 支持多模态输入（文本 + 图像）
-- **Gemini 原生端点**：`/v1/models/{model}:generateContent` 和 `streamGenerateContent`
-  - 支持完整的 Gemini 原生 API 规范
-  - 多种认证方式：Bearer Token、x-goog-api-key 头部、URL 参数 key
-- **Claude 格式兼容**：完整支持 Claude API 格式
-  - 端点：`/v1/messages`（遵循 Claude API 规范）
-  - 支持 Claude 标准的 messages 格式
-  - 支持 system 参数和 Claude 特有功能
-  - 自动转换为后端支持的格式
-- **Antigravity API 支持**：同时支持 OpenAI、Gemini 和 Claude 格式
-  - OpenAI 格式端点：`/antigravity/v1/chat/completions`
-  - Gemini 格式端点：`/antigravity/v1/models/{model}:generateContent` 和 `streamGenerateContent`
-  - Claude 格式端点：`/antigravity/v1/messages`
-  - 支持所有 Antigravity 模型（Claude、Gemini 等）
-  - 自动模型名称映射和思维模式检测
-
-### 🔐 认证和安全管理
-
-**灵活的密码管理**
-- **分离密码支持**：API 密码（聊天端点）和控制面板密码可独立设置
-- **多种认证方式**：支持 Authorization Bearer、x-goog-api-key 头部、URL 参数等
-- **JWT Token 认证**：控制面板支持 JWT 令牌认证
-- **用户邮箱获取**：自动获取和显示 Google 账户邮箱地址
-
-### 📊 智能凭证管理系统
-
-**高级凭证管理**
-- 多个 Google OAuth 凭证自动轮换
-- 通过冗余认证增强稳定性
-- 负载均衡与并发请求支持
-- 自动故障检测和凭证禁用
-- 凭证使用统计和配额管理
-- 支持手动启用/禁用凭证文件
-- 批量凭证文件操作（启用、禁用、删除）
-
-**凭证状态监控**
-- 实时凭证健康检查
-- 错误码追踪（429、403、500 等）
-- 自动封禁机制（可配置）
-
-### 🌊 流式传输和响应处理
-
-**多种流式支持**
-- 真正的实时流式响应
-- 假流式模式（用于兼容性）
-- 流式抗截断功能（防止回答被截断）
-- 异步任务管理和超时处理
-
-**响应优化**
-- 思维链（Thinking）内容分离
-- 推理过程（reasoning_content）处理
-- 多轮对话上下文管理
-- 兼容性模式（将 system 消息转换为 user 消息）
-
-### 🎛️ Web 管理控制台
-
-**全功能 Web 界面**
-- OAuth 认证流程管理（支持 GCLI 和 Antigravity 双模式）
-- 凭证文件上传、下载、管理
-- 实时日志查看（WebSocket）
-- 系统配置管理
-- 使用统计和监控面板
-- 移动端适配界面
-
-**批量操作支持**
-- ZIP 文件批量上传凭证（GCLI 和 Antigravity）
-- 批量启用/禁用/删除凭证
-- 批量获取用户邮箱
-- 批量配置管理
-- 统一批量上传界面管理所有凭证类型
-
-### 📈 使用监控
-
-**实时监控**
-- WebSocket 实时日志流
-- 系统状态监控
-- 凭证健康状态
-
-### 🔧 高级配置和自定义
-
-**网络和代理配置**
-- HTTP/HTTPS 代理支持
-- 代理端点配置（OAuth、Google APIs、元数据服务）
-- 超时和重试配置
-- 网络错误处理和恢复
-
-**性能和稳定性配置**
-- 429 错误自动重试（可配置间隔和次数）
-- 抗截断最大重试次数
-
-**日志和调试**
-- 多级日志系统（DEBUG、INFO、WARNING、ERROR）
-- 日志文件管理
-- 实时日志流
-- 日志下载和清空
-
-### 🔄 环境变量和配置管理
-
-**灵活的配置方式**
-- 环境变量配置
-- 热配置更新（部分配置项）
-- 配置锁定（环境变量优先级）
-
-## 支持的模型
-
-所有模型均具备 1M 上下文窗口容量。每个凭证文件提供 1000 次请求额度。
-
-### 🤖 基础模型
-- `gemini-2.5-pro`
-- `gemini-3-pro-preview`
-- `gemini-3.1-pro-preview`
-
-### 🧠 思维模型（Thinking Models）
-- `gemini-2.5-pro-high`：思考模式
-- `gemini-2.5-pro-low`：低思考模式
-- 支持自定义思考预算配置
-- 自动分离思维内容和最终回答
-
-### 🔍 搜索增强模型
-- `gemini-2.5-pro-search`：集成搜索功能的模型
-
-### 🖼️ 图像生成模型（Antigravity）
-- `gemini-3.1-flash-image`：基础图像生成模型
-- **分辨率后缀**：
-  - `-2k`：2K 分辨率
-  - `-4k`：4K 高清分辨率
-- **比例后缀**：
-  - `-1x1`：正方形（头像）
-  - `-16x9`：横屏（电脑壁纸）
-  - `-9x16`：竖屏（手机壁纸）
-  - `-21x9`：超宽屏（带鱼屏）
-  - `-4x3`：传统显示器
-  - `-3x4`：竖版海报
-- **组合使用示例**：
-  - `gemini-3.1-flash-image-4k-16x9`：4K 横屏
-  - `gemini-3.1-flash-image-2k-9x16`：2K 竖屏
-- 不指定比例时，API 自动决定横竖比例
-
-### 🌊 特殊功能变体
-- **假流式模式**：在任何模型名称后添加 `-假流式` 后缀
-  - 例：`gemini-2.5-pro-假流式`
-  - 用于需要流式响应但服务端不支持真流式的场景
-- **流式抗截断模式**：在模型名称前添加 `流式抗截断/` 前缀
-  - 例：`流式抗截断/gemini-2.5-pro`  
-  - 自动检测响应截断并重试，确保完整回答
-
-### 🔧 模型��能自动检测
-- 系统自动识别模型名称中的功能标识
-- 透明地处理功能模式转换
-- 支持功能组合使用
-
----
-
-## 配置说明
-
-1. 访问 `http://127.0.0.1:7861` （默认端口，可通过 PORT 环境变量修改）
-2. 完成 OAuth 认证流程（默认密码：`pwd`，可通过环境变量修改）
-   - **GCLI 模式**：用于获取 Google Cloud Gemini API 凭证
-   - **Antigravity 模式**：用于获取 Google Antigravity API 凭证
-3. 配置客户端：
-
-**OpenAI 兼容客户端：**
-   - **端点地址**：`http://127.0.0.1:7861/v1`
-   - **API 密钥**：`pwd`（默认值，可通过 API_PASSWORD 或 PASSWORD 环境变量修改）
-
-**Gemini 原生客户端：**
-   - **端点地址**：`http://127.0.0.1:7861`
-   - **认证方式**：
-     - `Authorization: Bearer your_api_password`
-     - `x-goog-api-key: your_api_password`
-     - URL 参数：`?key=your_api_password`
-
-### 🌟 双认证模式支持
-
-**GCLI 认证模式**
-- 标准的 Google Cloud Gemini API 认证
-- 支持 OAuth2.0 认证流程
-- 自动启用必需的 Google Cloud API
-
-**Antigravity 认证模式**
-- Google Antigravity API 专用认证
-- 独立的凭证管理系统
-- 支持批量上传和管理
-- 与 GCLI 凭证完全隔离
-
-**统一管理界面**
-- 在"批量上传"标签页中可一次性管理两种凭证
-- 上半部分：GCLI 凭证批量上传（蓝色主题）
-- 下半部分：Antigravity 凭证批量上传（绿色主题）
-- 各自独立的凭证管理标签页
-
-## 💾 数据存储模式
-
-### 🌟 存储后端支持
-
-gcli2api 支持两种存储后端：**本地 SQLite（默认）** 和 **MongoDB（云端分布式存储）**
-
-### 📁 本地 SQLite 存储（默认）
-
-**默认存储方式**
-- 无需配置，开箱即用
-- 数据存储在本地 SQLite 数据库中
-- 适合单机部署和个人使用
-- 自动创建和管理数据库文件
-
-### 🍃 MongoDB 云端存储模式
-
-**云端分布式存储方案**
-
-当需要多实例部署或云端存储时，可以启用 MongoDB 存储模式。
-
-### ⚙️ 启用 MongoDB 模式
-
-**步骤 1: 配置 MongoDB 连接**
-```bash
-# 本地 MongoDB
-export MONGODB_URI="mongodb://localhost:27017"
-
-# MongoDB Atlas 云服务
-export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
-
-# 带认证的 MongoDB
-export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
-
-# 可选：自定义数据库名称（默认: gcli2api）
-export MONGODB_DATABASE="my_gcli_db"
-```
-
-**步骤 2: 启动应用**
-```bash
-# 应用会自动检测 MongoDB 配置并使用 MongoDB 存储
-python web.py
-```
-
-**Docker 环境使用 MongoDB**
-```bash
-# 单机 MongoDB 部署
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb://mongodb:27017" \
-  -e API_PASSWORD=your_password \
-  --network your_network \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# 使用 MongoDB Atlas
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
-  -e API_PASSWORD=your_password \
-  -p 7861:7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Compose 示例**
-```yaml
-version: '3.8'
-
-services:
-  mongodb:
-    image: mongo:7
-    container_name: gcli2api-mongodb
-    restart: unless-stopped
-    environment:
-      MONGO_INITDB_ROOT_USERNAME: admin
-      MONGO_INITDB_ROOT_PASSWORD: password123
-    volumes:
-      - mongodb_data:/data/db
-    ports:
-      - "27017:27017"
-
-  gcli2api:
-    image: ghcr.io/su-kaka/gcli2api:latest
-    container_name: gcli2api
-    restart: unless-stopped
-    depends_on:
-      - mongodb
-    environment:
-      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
-      - MONGODB_DATABASE=gcli2api
-      - API_PASSWORD=your_api_password
-      - PORT=7861
-    ports:
-      - "7861:7861"
+本分支的做法：
 
-volumes:
-  mongodb_data:
-```
-
-
-### 🔧 高级配置
-
-**MongoDB 连接优化**
-```bash
-# 连接池和超时配置
-export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
-
-# 副本集配置
-export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
-
-# 读写分离配置
-export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
-```
-
-### 环境变量配置
-
-**基础配置**
-- `PORT`: 服务端口（默认：7861）
-- `HOST`: 服务器监听地址（默认：0.0.0.0）
-
-**密码配置**
-- `API_PASSWORD`: 聊天 API 访问密码（默认：继承 PASSWORD 或 pwd）
-- `PANEL_PASSWORD`: 控制面板访问密码（默认：继承 PASSWORD 或 pwd）  
-- `PASSWORD`: 通用密码，设置后覆盖上述两个（默认：pwd）
-
-**性能和稳定性配置**
-- `RETRY_429_ENABLED`: 启用 429 错误自动重试（默认：true）
-- `RETRY_429_MAX_RETRIES`: 429 错误最大重试次数（默认：3）
-- `RETRY_429_INTERVAL`: 429 错误重试间隔，秒（默认：1.0）
-- `ANTI_TRUNCATION_MAX_ATTEMPTS`: 抗截断最大重试次数（默认：3）
-
-**网络和代理配置**
-- `PROXY`: HTTP/HTTPS 代理地址（格式：`http://host:port`）
-- `OAUTH_PROXY_URL`: OAuth 认证代理端点
-- `GOOGLEAPIS_PROXY_URL`: Google APIs 代理端点
-- `METADATA_SERVICE_URL`: 元数据服务代理端点
-
-**自动化配置**
-- `AUTO_BAN`: 启用凭证自动封禁（默认：true）
-- `AUTO_LOAD_ENV_CREDS`: 启动时自动加载环境变量凭证（默认：false）
-
-**兼容性配置**
-- `COMPATIBILITY_MODE`: 启用兼容性模式，将 system 消息转为 user 消息（默认：false）
-
-**日志配置**
-- `LOG_LEVEL`: 日志级别（DEBUG/INFO/WARNING/ERROR，默认：INFO）
-- `LOG_FILE`: 日志文件路径（默认：log.txt）
-
-**存储配置**
-
-**SQLite 配置（默认）**
-- 无需配置，自动使用本地 SQLite 数据库
-- 数据库文件自动创建在项目目录
-
-**MongoDB 配置（可选云端存储）**
-- `MONGODB_URI`: MongoDB 连接字符串（设置后启用 MongoDB 模式）
-- `MONGODB_DATABASE`: MongoDB 数据库名称（默认：gcli2api）
-
-**Docker 使用示例**
-```bash
-# 使用通用密码
-docker run -d --name gcli2api \
-  -e PASSWORD=mypassword \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# 使用分离密码
-docker run -d --name gcli2api \
-  -e API_PASSWORD=my_api_password \
-  -e PANEL_PASSWORD=my_panel_password \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-注意：当设置了凭证环境变量时，系统将优先使用环境变量中的凭证，忽略 `creds` 目录中的文件。
-
-### API 使用方式
-
-本服务支持三套完整的 API 端点：
-
-#### 1. OpenAI 兼容端点（GCLI）
-
-**端点：** `/v1/chat/completions`
-**认证：** `Authorization: Bearer your_api_password`
-
-支持两种请求格式，会自动检测并处理：
-
-**OpenAI 格式：**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {"role": "system", "content": "You are a helpful assistant"},
-    {"role": "user", "content": "Hello"}
-  ],
-  "temperature": 0.7,
-  "stream": true
-}
-```
-
-**Gemini 原生格式：**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "contents": [
-    {"role": "user", "parts": [{"text": "Hello"}]}
-  ],
-  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
-  "generationConfig": {
-    "temperature": 0.7
-  }
-}
-```
-
-#### 2. Gemini 原生端点（GCLI）
-
-**非流式端点：** `/v1/models/{model}:generateContent`
-**流式端点：** `/v1/models/{model}:streamGenerateContent`
-**模型列表：** `/v1/models`
-
-**认证方式（任选一种）：**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URL 参数：`?key=your_api_password`
-
-**请求示例：**
-```bash
-# 使用 x-goog-api-key 头部
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-
-# 使用 URL 参数
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-#### 3. Claude API 格式端点
-
-**端点：** `/v1/messages`
-**认证：** `x-api-key: your_api_password` 或 `Authorization: Bearer your_api_password`
-
-**请求示例：**
-```bash
-curl -X POST "http://127.0.0.1:7861/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello, Claude!"}
-    ]
-  }'
-```
-
-**支持 system 参数：**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "max_tokens": 1024,
-  "system": "You are a helpful assistant",
-  "messages": [
-    {"role": "user", "content": "Hello"}
-  ]
-}
-```
-
-**说明：**
-- 完全兼容 Claude API 格式规范
-- 自动转换为 Gemini 格式调用后端
-- 支持 Claude 的所有标准参数
-- 响应格式符合 Claude API 规范
-
-#### 4. Antigravity API 端点
-
-**支持三种格式：OpenAI、Gemini 和 Claude**
-
-##### Antigravity OpenAI 格式端点
+- 一个**私有 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 会直接拒绝启动。
 
-**端点：** `/antigravity/v1/chat/completions`
-**认证：** `Authorization: Bearer your_api_password`
+## 一���性配置（已经做完，此处仅为记录）
 
-**请求示例：**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
-  -H "Authorization: Bearer your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "stream": true
-  }'
-```
-
-##### Antigravity Gemini 格式端点
-
-**非流式端点：** `/antigravity/v1/models/{model}:generateContent`
-**流式端点：** `/antigravity/v1/models/{model}:streamGenerateContent`
-
-**认证方式（任选一种）：**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URL 参数：`?key=your_api_password`
-
-**请求示例：**
-```bash
-# Gemini 格式非流式请求
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ],
-    "generationConfig": {
-      "temperature": 0.7
-    }
-  }'
-
-# Gemini 格式流式请求
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-##### Antigravity Claude 格式端点
-
-**端点：** `/antigravity/v1/messages`
-**认证：** `x-api-key: your_api_password`
-
-**请求示例：**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ]
-  }'
-```
-
-**支持的 Antigravity 模型：**
-- Claude 系列：`claude-sonnet-4-5`、`claude-opus-4-5` 等
-- Gemini 系列：`gemini-2.5-flash`、`gemini-2.5-pro` 等
-- 自动支持思维模型（thinking models）
-
-**Gemini 原生示例：**
 ```python
-from io import BytesIO
-from PIL import Image
-from google.genai import Client
-from google.genai.types import HttpOptions
-from google.genai import types
-# The client gets the API key from the environment variable `GEMINI_API_KEY`.
-
-client = Client(
-            api_key="pwd",
-            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
-        )
-
-prompt = (
-    """
-    画一只猫
-    """
+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")],
 )
-
-response = client.models.generate_content(
-    model="gemini-3.1-flash-image",
-    contents=[prompt],
-    config=types.GenerateContentConfig(
-        image_config=types.ImageConfig(
-            aspect_ratio="16:9",
-        )
-    )
-)
-for part in response.candidates[0].content.parts:
-    if part.text is not None:
-        print(part.text)
-    elif part.inline_data is not None:
-        image = Image.open(BytesIO(part.inline_data.data))
-        image.save("generated_image.png")
-
-```
-
-**说明：**
-- OpenAI 端点返回 OpenAI 兼容格式
-- Gemini 端点返回 Gemini 原生格式
-- 两种端点使用相同的 API 密码
-
-## 📋 完整 API 参考
-
-### Web 控制台 API
-
-**认证端点**
-- `POST /auth/login` - 用户登录
-- `POST /auth/start` - 开始 OAuth 认证（支持 GCLI 和 Antigravity 模式）
-- `POST /auth/callback` - 处理 OAuth 回调
-- `POST /auth/callback-url` - 从回调 URL 直接完成认证
-- `GET /auth/status/{project_id}` - 检查认证状态
-
-**凭证管理端点**（支持 `mode=geminicli` 或 `mode=antigravity` 参数）
-- `POST /creds/upload` - 批量上传凭证文件（支持 JSON 和 ZIP）
-- `GET /creds/status` - 获取凭证状态列表（支持分页和筛选）
-- `GET /creds/detail/{filename}` - 获取单个凭证详情
-- `POST /creds/action` - 单个凭证操作（启用/禁用/删除）
-- `POST /creds/batch-action` - 批量凭证操作
-- `GET /creds/download/{filename}` - 下载单个凭证文件
-- `GET /creds/download-all` - 打包下载所有凭证
-- `POST /creds/fetch-email/{filename}` - 获取用户邮箱
-- `POST /creds/refresh-all-emails` - 批量刷新用户邮箱
-- `POST /creds/deduplicate-by-email` - 按邮箱去重凭证
-- `POST /creds/verify-project/{filename}` - 检验凭证 Project ID
-- `GET /creds/quota/{filename}` - 获取凭证额度信息（仅 Antigravity）
-
-**配置管理端点**
-- `GET /config/get` - 获取当前配置
-- `POST /config/save` - 保存配置
-
-**日志管理端点**
-- `POST /logs/clear` - 清空日志
-- `GET /logs/download` - 下载日志文件
-- `WebSocket /logs/stream` - 实时日志流
-
-**版本信息端点**
-- `GET /version/info` - 获取版本信息（可选 `check_update=true` 参数检查更新）
-
-### 聊天 API 功能特性
-
-**多模态支持**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "描述这张图片"},
-        {
-          "type": "image_url",
-          "image_url": {
-            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
-          }
-        }
-      ]
-    }
-  ]
-}
-```
-
-**思维模式支持**
-```json
-{
-  "model": "gemini-2.5-pro-maxthinking",
-  "messages": [
-    {"role": "user", "content": "复杂数学问题"}
-  ]
-}
-```
-
-响应将包含分离的思维内容：
-```json
-{
-  "choices": [{
-    "message": {
-      "role": "assistant",
-      "content": "最终答案",
-      "reasoning_content": "详细的思考过程..."
-    }
-  }]
-}
-```
-
-**流式抗截断使用**
-```json
-{
-  "model": "流式抗截断/gemini-2.5-pro",
-  "messages": [
-    {"role": "user", "content": "写一篇长文章"}
-  ],
-  "stream": true
-}
 ```
 
-**兼容性模式**
-```bash
-# 启用兼容性模式
-export COMPATIBILITY_MODE=true
-```
-此模式下，所有 `system` 消息会转换为 `user` 消息，提高与某些客户端的兼容性。
-
----
-
-## 💬 交流群
-
-欢迎加入 QQ 群交流讨论！
-
-**QQ 群号：1083250744**
-
-<img src="docs/qq群.jpg" width="200" alt="QQ群二维码">
-
----
-
-## 许可证与免责声明
-
-本项目仅供学习和研究用途。使用本项目表示您同意：
-- 不将本项目用于任何商业用途
-- 承担使用本项目的所有风险和责任
-- 遵守相关的服务条款和法律法规
+`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 |
 
-**本项目采用 Cooperative Non-Commercial License (CNC-1.0)**
+## 运维
 
-这是一个反商业化的严格开源协议，详情请查看 [LICENSE](LICENSE) 文件。
+- **改 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 流量就被暂停，下次有人访问自动唤醒。
+  唤醒后账号和状态从桶里恢复；网关的定时任务（签到/领积分）在暂停期间不会执行。
 
-### ✅ 允许的用途：
-- 个人学习、研究、教育用途
-- 非营利组织使用
-- 开源项目集成（需遵循相同协议）
-- 学术研究和论文发表
+## 说明
 
-### ❌ 禁止的用途：
-- 任何形式的商业使用
-- 年收入超过100万美元的企业使用
-- 风投支持或公开交易的公司使用  
-- 提供付费服务或产品
-- 商业竞争用途
+上游项目与本文档的许可证见 `LICENSE`（上游为 MIT，本分支的部署脚本同样遵循）。

cmd/credit/main.go

@@ -0,0 +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)
+	}
+}

cmd/login/main.go

@@ -0,0 +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])
+	}
+}

cmd/login/realm_test.go

@@ -0,0 +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)
+			}
+		})
+	}
+}

cmd/server/config.go

@@ -0,0 +1,616 @@
+// 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
+}

cmd/server/config_test.go

@@ -0,0 +1,816 @@
+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)
+	}
+}

cmd/server/credit_floor_config_test.go

@@ -0,0 +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)
+	}
+}

cmd/server/main.go

@@ -0,0 +1,550 @@
+// 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
+}

cmd/server/wiring.go

@@ -0,0 +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)
+	}
+}

cmd/signin/main.go

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

cmd/trial/main.go

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

config.default.json

@@ -0,0 +1,98 @@
+{
+  "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"
+  }
+}

config.example.json

@@ -0,0 +1,84 @@
+{
+  "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"
+  }
+}

config.py

@@ -1,496 +0,0 @@
-"""
-Configuration constants for the Geminicli2api proxy server.
-Centralizes all configuration to avoid duplication across modules.
-
-- 启动时加载一次配置到内存
-- 修改配置时调用 reload_config() 重新从数据库加载
-"""
-
-import os
-from typing import Any, Optional
-
-# 全局配置缓存
-_config_cache: dict[str, Any] = {}
-_config_initialized = False
-
-# Client Configuration
-
-# 需要自动封禁的错误码 (默认值，可通过环境变量或配置覆盖)
-AUTO_BAN_ERROR_CODES = [403]
-
-# ====================== 环境变量映射表 ======================
-# 统一维护环境变量名和配置键名的映射关系
-# 格式: "环境变量名": "配置键名"
-ENV_MAPPINGS = {
-    "CODE_ASSIST_ENDPOINT": "code_assist_endpoint",
-    "CREDENTIALS_DIR": "credentials_dir",
-    "PROXY": "proxy",
-    "OAUTH_PROXY_URL": "oauth_proxy_url",
-    "GOOGLEAPIS_PROXY_URL": "googleapis_proxy_url",
-    "RESOURCE_MANAGER_API_URL": "resource_manager_api_url",
-    "SERVICE_USAGE_API_URL": "service_usage_api_url",
-    "ANTIGRAVITY_API_URL": "antigravity_api_url",
-    "AUTO_BAN": "auto_ban_enabled",
-    "AUTO_BAN_ERROR_CODES": "auto_ban_error_codes",
-    "RETRY_429_MAX_RETRIES": "retry_429_max_retries",
-    "RETRY_429_ENABLED": "retry_429_enabled",
-    "RETRY_429_INTERVAL": "retry_429_interval",
-    "ANTI_TRUNCATION_MAX_ATTEMPTS": "anti_truncation_max_attempts",
-    "COMPATIBILITY_MODE": "compatibility_mode_enabled",
-    "RETURN_THOUGHTS_TO_FRONTEND": "return_thoughts_to_frontend",
-    "ANTIGRAVITY_STREAM2NOSTREAM": "antigravity_stream2nostream",
-    "ANTIGRAVITY_SWITCH_CREDENTIAL": "antigravity_switch_credential_enabled",
-    "HOST": "host",
-    "PORT": "port",
-    "API_PASSWORD": "api_password",
-    "PANEL_PASSWORD": "panel_password",
-    "PASSWORD": "password",
-    "KEEPALIVE_URL": "keepalive_url",
-    "KEEPALIVE_INTERVAL": "keepalive_interval",
-}
-
-
-# ====================== 配置系统 ======================
-
-async def init_config():
-    """初始化配置缓存（启动时调用一次）"""
-    global _config_cache, _config_initialized
-
-    if _config_initialized:
-        return
-
-    try:
-        from src.storage_adapter import get_storage_adapter
-        storage_adapter = await get_storage_adapter()
-        _config_cache = await storage_adapter.get_all_config()
-        _config_initialized = True
-    except Exception:
-        # 初始化失败时使用空缓存
-        _config_cache = {}
-        _config_initialized = True
-
-
-async def reload_config():
-    """重新加载配置（修改配置后调用）"""
-    global _config_cache, _config_initialized
-
-    try:
-        from src.storage_adapter import get_storage_adapter
-        storage_adapter = await get_storage_adapter()
-
-        # 如果后端支持 reload_config_cache，调用它
-        if hasattr(storage_adapter._backend, 'reload_config_cache'):
-            await storage_adapter._backend.reload_config_cache()
-
-        # 重新加载配置缓存
-        _config_cache = await storage_adapter.get_all_config()
-        _config_initialized = True
-    except Exception:
-        pass
-
-
-def _get_cached_config(key: str, default: Any = None) -> Any:
-    """从内存缓存获取配置（同步）"""
-    return _config_cache.get(key, default)
-
-
-async def get_config_value(key: str, default: Any = None, env_var: Optional[str] = None) -> Any:
-    """Get configuration value with priority: ENV > Storage > default."""
-    # 确保配置已初始化
-    if not _config_initialized:
-        await init_config()
-
-    # Priority 1: Environment variable
-    if env_var and os.getenv(env_var):
-        return os.getenv(env_var)
-
-    # Priority 2: Memory cache
-    value = _get_cached_config(key)
-    if value is not None:
-        return value
-
-    return default
-
-
-# Configuration getters - all async
-async def get_proxy_config():
-    """Get proxy configuration."""
-    proxy_url = await get_config_value("proxy", env_var="PROXY")
-    return proxy_url if proxy_url else None
-
-
-async def get_auto_ban_enabled() -> bool:
-    """Get auto ban enabled setting."""
-    env_value = os.getenv("AUTO_BAN")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("auto_ban_enabled", False))
-
-
-async def get_auto_ban_error_codes() -> list:
-    """
-    Get auto ban error codes.
-
-    Environment variable: AUTO_BAN_ERROR_CODES (comma-separated, e.g., "400,403")
-    Database config key: auto_ban_error_codes
-    Default: [400, 403]
-    """
-    env_value = os.getenv("AUTO_BAN_ERROR_CODES")
-    if env_value:
-        try:
-            return [int(code.strip()) for code in env_value.split(",") if code.strip()]
-        except ValueError:
-            pass
-
-    codes = await get_config_value("auto_ban_error_codes")
-    if codes and isinstance(codes, list):
-        return codes
-    return AUTO_BAN_ERROR_CODES
-
-
-async def get_retry_429_max_retries() -> int:
-    """Get max retries for 429 errors."""
-    env_value = os.getenv("RETRY_429_MAX_RETRIES")
-    if env_value:
-        try:
-            return int(env_value)
-        except ValueError:
-            pass
-
-    return int(await get_config_value("retry_429_max_retries", 5))
-
-
-async def get_retry_429_enabled() -> bool:
-    """Get 429 retry enabled setting."""
-    env_value = os.getenv("RETRY_429_ENABLED")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("retry_429_enabled", True))
-
-
-async def get_retry_429_interval() -> float:
-    """Get 429 retry interval in seconds."""
-    env_value = os.getenv("RETRY_429_INTERVAL")
-    if env_value:
-        try:
-            return float(env_value)
-        except ValueError:
-            pass
-
-    return float(await get_config_value("retry_429_interval", 1))
-
-
-async def get_anti_truncation_max_attempts() -> int:
-    """
-    Get maximum attempts for anti-truncation continuation.
-
-    Environment variable: ANTI_TRUNCATION_MAX_ATTEMPTS
-    Database config key: anti_truncation_max_attempts
-    Default: 3
-    """
-    env_value = os.getenv("ANTI_TRUNCATION_MAX_ATTEMPTS")
-    if env_value:
-        try:
-            return int(env_value)
-        except ValueError:
-            pass
-
-    return int(await get_config_value("anti_truncation_max_attempts", 3))
-
-
-# Server Configuration
-async def get_server_host() -> str:
-    """
-    Get server host setting.
-
-    Environment variable: HOST
-    Database config key: host
-    Default: 0.0.0.0
-    """
-    return str(await get_config_value("host", "0.0.0.0", "HOST"))
-
-
-async def get_server_port() -> int:
-    """
-    Get server port setting.
-
-    Environment variable: PORT
-    Database config key: port
-    Default: 7861
-    """
-    env_value = os.getenv("PORT")
-    if env_value:
-        try:
-            return int(env_value)
-        except ValueError:
-            pass
-
-    return int(await get_config_value("port", 7861))
-
-
-async def get_api_password() -> str:
-    """
-    Get API password setting for chat endpoints.
-
-    Environment variable: API_PASSWORD
-    Database config key: api_password
-    Default: Uses PASSWORD env var for compatibility, otherwise 'pwd'
-    """
-    # 优先使用 API_PASSWORD，如果没有则使用通用 PASSWORD 保证兼容性
-    api_password = await get_config_value("api_password", None, "API_PASSWORD")
-    if api_password is not None:
-        return str(api_password)
-
-    # 兼容性：使用通用密码
-    return str(await get_config_value("password", "pwd", "PASSWORD"))
-
-
-async def get_panel_password() -> str:
-    """
-    Get panel password setting for web interface.
-
-    Environment variable: PANEL_PASSWORD
-    Database config key: panel_password
-    Default: Uses PASSWORD env var for compatibility, otherwise 'pwd'
-    """
-    # 优先使用 PANEL_PASSWORD，如果没有则使用通用 PASSWORD 保证兼容性
-    panel_password = await get_config_value("panel_password", None, "PANEL_PASSWORD")
-    if panel_password is not None:
-        return str(panel_password)
-
-    # 兼容性：使用通用密码
-    return str(await get_config_value("password", "pwd", "PASSWORD"))
-
-
-async def get_server_password() -> str:
-    """
-    Get server password setting (deprecated, use get_api_password or get_panel_password).
-
-    Environment variable: PASSWORD
-    Database config key: password
-    Default: pwd
-    """
-    return str(await get_config_value("password", "pwd", "PASSWORD"))
-
-
-async def get_credentials_dir() -> str:
-    """
-    Get credentials directory setting.
-
-    Environment variable: CREDENTIALS_DIR
-    Database config key: credentials_dir
-    Default: ./creds
-    """
-    return str(await get_config_value("credentials_dir", "./creds", "CREDENTIALS_DIR"))
-
-
-async def get_code_assist_endpoint() -> str:
-    """
-    Get Code Assist endpoint setting.
-
-    Environment variable: CODE_ASSIST_ENDPOINT
-    Database config key: code_assist_endpoint
-    Default: https://cloudcode-pa.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "code_assist_endpoint", "https://cloudcode-pa.googleapis.com", "CODE_ASSIST_ENDPOINT"
-        )
-    )
-
-
-async def get_compatibility_mode_enabled() -> bool:
-    """
-    Get compatibility mode setting.
-
-    兼容性模式：启用后所有system消息全部转换成user，停用system_instructions。
-    该选项可能会降低模型理解能力，但是能避免流式空回的情况。
-
-    Environment variable: COMPATIBILITY_MODE
-    Database config key: compatibility_mode_enabled
-    Default: False
-    """
-    env_value = os.getenv("COMPATIBILITY_MODE")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("compatibility_mode_enabled", False))
-
-
-async def get_return_thoughts_to_frontend() -> bool:
-    """
-    Get return thoughts to frontend setting.
-
-    控制是否将思维链返回到前端。
-    启用后，思维链会在��应中返回；禁用后，思维链会在响应中被过滤掉。
-
-    Environment variable: RETURN_THOUGHTS_TO_FRONTEND
-    Database config key: return_thoughts_to_frontend
-    Default: True
-    """
-    env_value = os.getenv("RETURN_THOUGHTS_TO_FRONTEND")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("return_thoughts_to_frontend", True))
-
-
-async def get_antigravity_stream2nostream() -> bool:
-    """
-    Get use stream for non-stream setting.
-
-    控制antigravity非流式请求是否使用流式API并收集为完整响应。
-    启用后，非流式请求将在后端使用流式API，然后收集所有块后再返回完整响应。
-
-    Environment variable: ANTIGRAVITY_STREAM2NOSTREAM
-    Database config key: antigravity_stream2nostream
-    Default: True
-    """
-    env_value = os.getenv("ANTIGRAVITY_STREAM2NOSTREAM")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("antigravity_stream2nostream", True))
-
-
-async def get_antigravity_switch_credential_enabled() -> bool:
-    """
-    Get antigravity switch credential setting.
-
-    控制antigravity在重试时是否切换凭证。
-    禁用时会持续使用当前凭证，直到该凭证对当前模型进入CD或被禁用。
-
-    Environment variable: ANTIGRAVITY_SWITCH_CREDENTIAL
-    Database config key: antigravity_switch_credential_enabled
-    Default: False
-    """
-    env_value = os.getenv("ANTIGRAVITY_SWITCH_CREDENTIAL")
-    if env_value:
-        return env_value.lower() in ("true", "1", "yes", "on")
-
-    return bool(await get_config_value("antigravity_switch_credential_enabled", False))
-
-
-async def get_oauth_proxy_url() -> str:
-    """
-    Get OAuth proxy URL setting.
-
-    用于Google OAuth2认证的代理URL。
-
-    Environment variable: OAUTH_PROXY_URL
-    Database config key: oauth_proxy_url
-    Default: https://oauth2.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "oauth_proxy_url", "https://oauth2.googleapis.com", "OAUTH_PROXY_URL"
-        )
-    )
-
-
-async def get_googleapis_proxy_url() -> str:
-    """
-    Get Google APIs proxy URL setting.
-
-    用于Google APIs调用的代理URL。
-
-    Environment variable: GOOGLEAPIS_PROXY_URL
-    Database config key: googleapis_proxy_url
-    Default: https://www.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "googleapis_proxy_url", "https://www.googleapis.com", "GOOGLEAPIS_PROXY_URL"
-        )
-    )
-
-
-async def get_resource_manager_api_url() -> str:
-    """
-    Get Google Cloud Resource Manager API URL setting.
-
-    用于Google Cloud Resource Manager API的URL。
-
-    Environment variable: RESOURCE_MANAGER_API_URL
-    Database config key: resource_manager_api_url
-    Default: https://cloudresourcemanager.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "resource_manager_api_url",
-            "https://cloudresourcemanager.googleapis.com",
-            "RESOURCE_MANAGER_API_URL",
-        )
-    )
-
-
-async def get_service_usage_api_url() -> str:
-    """
-    Get Google Cloud Service Usage API URL setting.
-
-    用于Google Cloud Service Usage API的URL。
-
-    Environment variable: SERVICE_USAGE_API_URL
-    Database config key: service_usage_api_url
-    Default: https://serviceusage.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "service_usage_api_url", "https://serviceusage.googleapis.com", "SERVICE_USAGE_API_URL"
-        )
-    )
-
-
-async def get_antigravity_api_url() -> str:
-    """
-    Get Antigravity API URL setting.
-
-    用于Google Antigravity API的URL。
-
-    Environment variable: ANTIGRAVITY_API_URL
-    Database config key: antigravity_api_url
-    Default: https://daily-cloudcode-pa.googleapis.com
-    """
-    return str(
-        await get_config_value(
-            "antigravity_api_url",
-            "https://daily-cloudcode-pa.googleapis.com",
-            "ANTIGRAVITY_API_URL",
-        )
-    )
-
-
-async def get_keepalive_url() -> str:
-    """
-    Get keep-alive URL setting.
-
-    配置后保活服务会定期向该URL发送GET请求。
-    留空表示禁用保活服务。
-
-    Environment variable: KEEPALIVE_URL
-    Database config key: keepalive_url
-    Default: "" (disabled)
-    """
-    return str(await get_config_value("keepalive_url", "", "KEEPALIVE_URL"))
-
-
-async def get_keepalive_interval() -> int:
-    """
-    Get keep-alive interval in seconds.
-
-    保活请求发送间隔（秒）。
-
-    Environment variable: KEEPALIVE_INTERVAL
-    Database config key: keepalive_interval
-    Default: 60
-    """
-    env_value = os.getenv("KEEPALIVE_INTERVAL")
-    if env_value:
-        try:
-            return int(env_value)
-        except ValueError:
-            pass
-
-    return int(await get_config_value("keepalive_interval", 60))

credit.sh

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

darwin-install.sh

@@ -1,55 +0,0 @@
-#!/bin/bash
-# macOS 安装脚本 (支持 Intel 和 Apple Silicon)
-
-# 确保 Homebrew 已安装
-if ! command -v brew &> /dev/null; then
-    echo "未检测到 Homebrew，开始安装..."
-    /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
-    
-    # 检测 Homebrew 安装路径并设置环境变量
-    if [[ -f "/opt/homebrew/bin/brew" ]]; then
-        # Apple Silicon Mac
-        eval "$(/opt/homebrew/bin/brew shellenv)"
-    elif [[ -f "/usr/local/bin/brew" ]]; then
-        # Intel Mac
-        eval "$(/usr/local/bin/brew shellenv)"
-    fi
-fi
-
-# 更新 brew 并安装 git
-brew update
-brew install git
-
-# 安装 uv (Python 环境管理工具)
-curl -Ls https://astral.sh/uv/install.sh | sh
-
-# 确保 uv 在 PATH 中
-export PATH="$HOME/.local/bin:$PATH"
-
-# 克隆或进入项目目录
-if [ -f "./web.py" ]; then
-    # 已经在目标目录
-    :
-elif [ -f "./gcli2api/web.py" ]; then
-    cd ./gcli2api
-else
-    git clone https://github.com/su-kaka/gcli2api.git
-    cd ./gcli2api
-fi
-
-# 拉取最新代码
-git pull
-
-# 创建并同步虚拟环境
-uv sync
-
-# 激活虚拟环境
-if [ -f ".venv/bin/activate" ]; then
-    source .venv/bin/activate
-else
-    echo "❌ 未找到虚拟环境，请检查 uv 是否安装成功"
-    exit 1
-fi
-
-# 启动项目
-python3 web.py

docker-compose.yml

@@ -1,79 +1,15 @@
-version: '3.8'
-
+# 本地 / 自建服务器跑法（不用 HF 时）。HF Spaces 上不需要这个文件。
 services:
-  gcli2api:
-    image: ghcr.io/su-kaka/gcli2api:latest
-    container_name: gcli2api
+  wb2api:
+    build: .
+    container_name: workbuddy2api
     restart: unless-stopped
-    network_mode: host
     environment:
-      # Password configuration (choose one)
-      # Option 1: Use common password
-      - PASSWORD=${PASSWORD:-pwd}
-      # Option 2: Use separate passwords (uncomment if needed)
-      # - API_PASSWORD=${API_PASSWORD:-your_api_password}
-      # - PANEL_PASSWORD=${PANEL_PASSWORD:-your_panel_password}
-
-      # Server configuration
-      - PORT=${PORT:-7861}
-      - HOST=${HOST:-0.0.0.0}
-
-      # Optional: Google credentials from environment
-      # - GOOGLE_CREDENTIALS=${GOOGLE_CREDENTIALS}
-
-      # Optional: Logging configuration
-      # - LOG_LEVEL=${LOG_LEVEL:-info}
-
-      # Optional: Redis configuration (for distributed storage)
-      # - REDIS_URI=${REDIS_URI}
-      # - REDIS_DATABASE=${REDIS_DATABASE:-0}
-
-      # Optional: MongoDB configuration (for distributed storage)
-      # - MONGODB_URI=${MONGODB_URI}
-      # - MONGODB_DATABASE=${MONGODB_DATABASE:-gcli2api}
-
-      # Optional: PostgreSQL configuration (for distributed storage)
-      # - POSTGRES_DSN=${POSTGRES_DSN}
-
-      # Optional: Proxy configuration
-      # - PROXY=${PROXY}
+      - TZ=Asia/Shanghai
+    ports:
+      - "7861:7861"
     volumes:
-      - ./data/creds:/app/creds
-
-# Example with Redis for distributed storage
-#  redis:
-#    image: redis:7-alpine
-#    container_name: gcli2api-redis
-#    restart: unless-stopped
-#    ports:
-#      - "6379:6379"
-#    volumes:
-#      - redis_data:/data
-#    command: redis-server --appendonly yes
-#    healthcheck:
-#      test: ["CMD", "redis-cli", "ping"]
-#      interval: 10s
-#      timeout: 3s
-#      retries: 3
-
-# Example with MongoDB for distributed storage
-#  mongodb:
-#    image: mongo:7
-#    container_name: gcli2api-mongodb
-#    restart: unless-stopped
-#    environment:
-#      MONGO_INITDB_ROOT_USERNAME: ${MONGO_USER:-admin}
-#      MONGO_INITDB_ROOT_PASSWORD: ${MONGO_PASSWORD:-password}
-#    ports:
-#      - "27017:27017"
-#    volumes:
-#      - mongodb_data:/data/db
-#    healthcheck:
-#      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
-#      interval: 10s
-#      timeout: 5s
-#      retries: 3
-
-#volumes:
-#  redis_data:
-#  mongodb_data:
+      # 一个目录装下全部持久化状态，和 HF 上挂桶的布局保持一致：
+      #   storage/config.json、storage/auths/、storage/data/
+      - ./storage:/app/storage
+      - ./storage/config.json:/app/config.json

docker-entrypoint.sh

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

docs/README_EN.md

@@ -1,883 +0,0 @@
-# GeminiCLI to API
-
-**Convert GeminiCLI and Antigravity to OpenAI, GEMINI, and Claude API Compatible Interfaces**
-
-[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](../LICENSE)
-[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
-
-[中文](../README.md) | English | [日本語](./README_JA.md)
-
-## 🚀 Quick Deploy
-
-[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
-[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
----
-
-## Installation Guide
-
-### Termux Environment
-
-**Initial Installation**
-```bash
-curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
-```
-
-**Restart Service**
-```bash
-cd gcli2api
-bash termux-start.sh
-```
-
-### Windows Environment
-
-**Initial Installation**
-```powershell
-iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
-```
-
-**Restart Service**
-Double-click to execute `start.bat`
-
-### Linux Environment
-
-**Initial Installation**
-```bash
-curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
-```
-
-**Restart Service**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### macOS Environment
-
-**Initial Installation**
-```bash
-curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
-```
-
-**Restart Service**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### Docker Environment
-
-**Docker Run Command**
-```bash
-# Using universal password
-docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-
-# Using separate passwords
-docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Mac**
-```bash
-# Using universal password
-docker run -d \
-  --name gcli2api \
-  -p 7861:7861 \
-  -p 8080:8080 \
-  -e PASSWORD=pwd \
-  -e PORT=7861 \
-  -v "$(pwd)/data/creds":/app/creds \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-```bash
-# Using separate passwords
-docker run -d \
---name gcli2api \
--p 7861:7861 \
--p 8080:8080 \
--e API_PASSWORD=api_pwd \
--e PANEL_PASSWORD=panel_pwd \
--e PORT=7861 \
--v $(pwd)/data/creds:/app/creds \
-ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Compose Run Command**
-1. Save the following content as `docker-compose.yml` file:
-    ```yaml
-    version: '3.8'
-
-    services:
-      gcli2api:
-        image: ghcr.io/su-kaka/gcli2api:latest
-        container_name: gcli2api
-        restart: unless-stopped
-        network_mode: host
-        environment:
-          # Using universal password (recommended for simple deployment)
-          - PASSWORD=pwd
-          - PORT=7861
-          # Or use separate passwords (recommended for production)
-          # - API_PASSWORD=your_api_password
-          # - PANEL_PASSWORD=your_panel_password
-        volumes:
-          - ./data/creds:/app/creds
-        healthcheck:
-          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
-          interval: 30s
-          timeout: 10s
-          retries: 3
-          start_period: 40s
-    ```
-2. Start the service:
-    ```bash
-    docker-compose up -d
-    ```
-
-## Core Features
-
-### 🔄 API Endpoints and Format Support
-
-**Multi-endpoint Multi-format Support**
-- **OpenAI Compatible Endpoints**: `/v1/chat/completions` and `/v1/models`
-  - Supports standard OpenAI format (messages structure)
-  - Supports Gemini native format (contents structure)
-  - Automatic format detection and conversion, no manual switching required
-  - Supports multimodal input (text + images)
-- **Gemini Native Endpoints**: `/v1/models/{model}:generateContent` and `streamGenerateContent`
-  - Supports complete Gemini native API specifications
-  - Multiple authentication methods: Bearer Token, x-goog-api-key header, URL parameter key
-- **Claude Format Compatibility**: Full support for Claude API format
-  - Endpoint: `/v1/messages` (follows Claude API specification)
-  - Supports Claude standard messages format
-  - Supports system parameter and Claude-specific features
-  - Automatically converts to backend-supported format
-- **Antigravity API Support**: Supports OpenAI, Gemini, and Claude formats
-  - OpenAI format endpoint: `/antigravity/v1/chat/completions`
-  - Gemini format endpoint: `/antigravity/v1/models/{model}:generateContent` and `streamGenerateContent`
-  - Claude format endpoint: `/antigravity/v1/messages`
-  - Supports all Antigravity models (Claude, Gemini, etc.)
-  - Automatic model name mapping and thinking mode detection
-
-### 🔐 Authentication and Security Management
-
-**Flexible Password Management**
-- **Separate Password Support**: API password (chat endpoints) and control panel password can be set independently
-- **Multiple Authentication Methods**: Supports Authorization Bearer, x-goog-api-key header, URL parameters, etc.
-- **JWT Token Authentication**: Control panel supports JWT token authentication
-- **User Email Retrieval**: Automatically retrieves and displays Google account email addresses
-
-### 📊 Intelligent Credential Management System
-
-**Advanced Credential Management**
-- Multiple Google OAuth credential automatic rotation
-- Enhanced stability through redundant authentication
-- Load balancing and concurrent request support
-- Automatic failure detection and credential disabling
-- Credential usage statistics and quota management
-- Support for manual enable/disable credential files
-- Batch credential file operations (enable, disable, delete)
-
-**Credential Status Monitoring**
-- Real-time credential health checks
-- Error code tracking (429, 403, 500, etc.)
-- Automatic banning mechanism (configurable)
-
-### 🌊 Streaming and Response Processing
-
-**Multiple Streaming Support**
-- True real-time streaming responses
-- Fake streaming mode (for compatibility)
-- Streaming anti-truncation feature (prevents answer truncation)
-- Asynchronous task management and timeout handling
-
-**Response Optimization**
-- Thinking chain content separation
-- Reasoning process (reasoning_content) handling
-- Multi-turn conversation context management
-- Compatibility mode (converts system messages to user messages)
-
-### 🎛️ Web Management Console
-
-**Full-featured Web Interface**
-- OAuth authentication flow management (supports GCLI and Antigravity dual modes)
-- Credential file upload, download, and management
-- Real-time log viewing (WebSocket)
-- System configuration management
-- Usage statistics and monitoring dashboard
-- Mobile-friendly interface
-
-**Batch Operation Support**
-- ZIP file batch credential upload (GCLI and Antigravity)
-- Batch enable/disable/delete credentials
-- Batch user email retrieval
-- Batch configuration management
-- Unified batch upload interface for all credential types
-
-### 📈 Usage Monitoring
-
-**Real-time Monitoring**
-- WebSocket real-time log streams
-- System status monitoring
-- Credential health status
-
-### 🔧 Advanced Configuration and Customization
-
-**Network and Proxy Configuration**
-- HTTP/HTTPS proxy support
-- Proxy endpoint configuration (OAuth, Google APIs, metadata service)
-- Timeout and retry configuration
-- Network error handling and recovery
-
-**Performance and Stability Configuration**
-- 429 error automatic retry (configurable interval and attempts)
-- Anti-truncation maximum retry attempts
-
-**Logging and Debugging**
-- Multi-level logging system (DEBUG, INFO, WARNING, ERROR)
-- Log file management
-- Real-time log streams
-- Log download and clearing
-
-### 🔄 Environment Variables and Configuration Management
-
-**Flexible Configuration Methods**
-- Environment variable configuration
-- Hot configuration updates (partial configuration items)
-- Configuration locking (environment variable priority)
-
-## Supported Models
-
-All models have 1M context window capacity. Each credential file provides 1000 request quota.
-
-### 🤖 Base Models
-- `gemini-2.5-pro`
-- `gemini-3-pro-preview`
-- `gemini-3.1-pro-preview`
-
-### 🧠 Thinking Models
-- `gemini-2.5-pro-high`: Thinking mode
-- `gemini-2.5-pro-low`: Low thinking mode
-- Supports custom thinking budget configuration
-- Automatic separation of thinking content and final answers
-
-### 🔍 Search-Enhanced Models
-- `gemini-2.5-pro-search`: Model with integrated search functionality
-
-### 🖼️ Image Generation Models (Antigravity)
-- `gemini-3.1-flash-image`: Base image generation model
-- **Resolution Suffixes**:
-  - `-2k`: 2K resolution
-  - `-4k`: 4K HD resolution
-- **Aspect Ratio Suffixes**:
-  - `-1x1`: Square (avatar)
-  - `-16x9`: Landscape (desktop wallpaper)
-  - `-9x16`: Portrait (mobile wallpaper)
-  - `-21x9`: Ultra-wide (ultrawide monitor)
-  - `-4x3`: Traditional display
-  - `-3x4`: Portrait poster
-- **Combination Examples**:
-  - `gemini-3.1-flash-image-4k-16x9`: 4K landscape
-  - `gemini-3.1-flash-image-2k-9x16`: 2K portrait
-- When no ratio is specified, the API automatically decides the aspect ratio
-
-### 🌊 Special Feature Variants
-- **Fake Streaming Mode**: Add `-假流式` suffix to any model name
-  - Example: `gemini-2.5-pro-假流式`
-  - For scenarios requiring streaming responses but server doesn't support true streaming
-- **Streaming Anti-truncation Mode**: Add `流式抗截断/` prefix to model name
-  - Example: `流式抗截断/gemini-2.5-pro`
-  - Automatically detects response truncation and retries to ensure complete answers
-
-### 🔧 Automatic Model Feature Detection
-- System automatically recognizes feature identifiers in model names
-- Transparently handles feature mode transitions
-- Supports feature combination usage
-
----
-
-## Configuration Instructions
-
-1. Visit `http://127.0.0.1:7861` (default port, modifiable via PORT environment variable)
-2. Complete OAuth authentication flow (default password: `pwd`, modifiable via environment variables)
-   - **GCLI Mode**: For obtaining Google Cloud Gemini API credentials
-   - **Antigravity Mode**: For obtaining Google Antigravity API credentials
-3. Configure client:
-
-**OpenAI Compatible Client:**
-   - **Endpoint Address**: `http://127.0.0.1:7861/v1`
-   - **API Key**: `pwd` (default value, modifiable via API_PASSWORD or PASSWORD environment variables)
-
-**Gemini Native Client:**
-   - **Endpoint Address**: `http://127.0.0.1:7861`
-   - **Authentication Methods**:
-     - `Authorization: Bearer your_api_password`
-     - `x-goog-api-key: your_api_password`
-     - URL parameter: `?key=your_api_password`
-
-### 🌟 Dual Authentication Mode Support
-
-**GCLI Authentication Mode**
-- Standard Google Cloud Gemini API authentication
-- Supports OAuth2.0 authentication flow
-- Automatically enables required Google Cloud APIs
-
-**Antigravity Authentication Mode**
-- Dedicated authentication for Google Antigravity API
-- Independent credential management system
-- Supports batch upload and management
-- Completely isolated from GCLI credentials
-
-**Unified Management Interface**
-- Manage both credential types in the "Batch Upload" tab
-- Upper section: GCLI credential batch upload (blue theme)
-- Lower section: Antigravity credential batch upload (green theme)
-- Separate credential management tabs for each type
-
-## 💾 Data Storage Mode
-
-### 🌟 Storage Backend Support
-
-gcli2api supports two storage backends: **Local SQLite (Default)** and **MongoDB (Cloud Distributed Storage)**
-
-### 📁 Local SQLite Storage (Default)
-
-**Default Storage Method**
-- No configuration required, works out of the box
-- Data is stored in a local SQLite database
-- Suitable for single-machine deployment and personal use
-- Automatically creates and manages database files
-
-### 🍃 MongoDB Cloud Storage Mode
-
-**Cloud Distributed Storage Solution**
-
-When multi-instance deployment or cloud storage is needed, MongoDB storage mode can be enabled.
-
-### ⚙️ Enable MongoDB Mode
-
-**Step 1: Configure MongoDB Connection**
-```bash
-# Local MongoDB
-export MONGODB_URI="mongodb://localhost:27017"
-
-# MongoDB Atlas cloud service
-export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
-
-# MongoDB with authentication
-export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
-
-# Optional: Custom database name (default: gcli2api)
-export MONGODB_DATABASE="my_gcli_db"
-```
-
-**Step 2: Start Application**
-```bash
-# Application will automatically detect MongoDB configuration and use MongoDB storage
-python web.py
-```
-
-**Docker Environment using MongoDB**
-```bash
-# Single MongoDB deployment
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb://mongodb:27017" \
-  -e API_PASSWORD=your_password \
-  --network your_network \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# Using MongoDB Atlas
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
-  -e API_PASSWORD=your_password \
-  -p 7861:7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Compose Example**
-```yaml
-version: '3.8'
-
-services:
-  mongodb:
-    image: mongo:7
-    container_name: gcli2api-mongodb
-    restart: unless-stopped
-    environment:
-      MONGO_INITDB_ROOT_USERNAME: admin
-      MONGO_INITDB_ROOT_PASSWORD: password123
-    volumes:
-      - mongodb_data:/data/db
-    ports:
-      - "27017:27017"
-
-  gcli2api:
-    image: ghcr.io/su-kaka/gcli2api:latest
-    container_name: gcli2api
-    restart: unless-stopped
-    depends_on:
-      - mongodb
-    environment:
-      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
-      - MONGODB_DATABASE=gcli2api
-      - API_PASSWORD=your_api_password
-      - PORT=7861
-    ports:
-      - "7861:7861"
-
-volumes:
-  mongodb_data:
-```
-
-
-### 🔧 Advanced Configuration
-
-**MongoDB Connection Optimization**
-```bash
-# Connection pool and timeout configuration
-export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
-
-# Replica set configuration
-export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
-
-# Read-write separation configuration
-export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
-```
-
-### Environment Variable Configuration
-
-**Basic Configuration**
-- `PORT`: Service port (default: 7861)
-- `HOST`: Server listen address (default: 0.0.0.0)
-
-**Password Configuration**
-- `API_PASSWORD`: Chat API access password (default: inherits PASSWORD or pwd)
-- `PANEL_PASSWORD`: Control panel access password (default: inherits PASSWORD or pwd)
-- `PASSWORD`: Universal password, overrides the above two when set (default: pwd)
-
-**Performance and Stability Configuration**
-- `RETRY_429_ENABLED`: Enable 429 error automatic retry (default: true)
-- `RETRY_429_MAX_RETRIES`: Maximum retry attempts for 429 errors (default: 3)
-- `RETRY_429_INTERVAL`: Retry interval for 429 errors, in seconds (default: 1.0)
-- `ANTI_TRUNCATION_MAX_ATTEMPTS`: Maximum retry attempts for anti-truncation (default: 3)
-
-**Network and Proxy Configuration**
-- `PROXY`: HTTP/HTTPS proxy address (format: `http://host:port`)
-- `OAUTH_PROXY_URL`: OAuth authentication proxy endpoint
-- `GOOGLEAPIS_PROXY_URL`: Google APIs proxy endpoint
-- `METADATA_SERVICE_URL`: Metadata service proxy endpoint
-
-**Automation Configuration**
-- `AUTO_BAN`: Enable automatic credential banning (default: true)
-- `AUTO_LOAD_ENV_CREDS`: Automatically load environment variable credentials at startup (default: false)
-
-**Compatibility Configuration**
-- `COMPATIBILITY_MODE`: Enable compatibility mode, converts system messages to user messages (default: false)
-
-**Logging Configuration**
-- `LOG_LEVEL`: Log level (DEBUG/INFO/WARNING/ERROR, default: INFO)
-- `LOG_FILE`: Log file path (default: log.txt)
-
-**Storage Configuration**
-
-**SQLite Configuration (Default)**
-- No configuration required, automatically uses local SQLite database
-- Database files are automatically created in the project directory
-
-**MongoDB Configuration (Optional Cloud Storage)**
-- `MONGODB_URI`: MongoDB connection string (enables MongoDB mode when set)
-- `MONGODB_DATABASE`: MongoDB database name (default: gcli2api)
-
-**Docker Usage Example**
-```bash
-# Using universal password
-docker run -d --name gcli2api \
-  -e PASSWORD=mypassword \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# Using separate passwords
-docker run -d --name gcli2api \
-  -e API_PASSWORD=my_api_password \
-  -e PANEL_PASSWORD=my_panel_password \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-Note: When credential environment variables are set, the system will prioritize using credentials from environment variables and ignore files in the `creds` directory.
-
-### API Usage Methods
-
-This service supports multiple complete sets of API endpoints:
-
-#### 1. OpenAI Compatible Endpoints (GCLI)
-
-**Endpoint:** `/v1/chat/completions`
-**Authentication:** `Authorization: Bearer your_api_password`
-
-Supports two request formats with automatic detection and processing:
-
-**OpenAI Format:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {"role": "system", "content": "You are a helpful assistant"},
-    {"role": "user", "content": "Hello"}
-  ],
-  "temperature": 0.7,
-  "stream": true
-}
-```
-
-**Gemini Native Format:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "contents": [
-    {"role": "user", "parts": [{"text": "Hello"}]}
-  ],
-  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
-  "generationConfig": {
-    "temperature": 0.7
-  }
-}
-```
-
-#### 2. Gemini Native Endpoints (GCLI)
-
-**Non-streaming Endpoint:** `/v1/models/{model}:generateContent`
-**Streaming Endpoint:** `/v1/models/{model}:streamGenerateContent`
-**Model List:** `/v1/models`
-
-**Authentication Methods (choose one):**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URL parameter: `?key=your_api_password`
-
-**Request Examples:**
-```bash
-# Using x-goog-api-key header
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-
-# Using URL parameter
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-#### 3. Claude API Format Endpoints
-
-**Endpoint:** `/v1/messages`
-**Authentication:** `x-api-key: your_api_password` or `Authorization: Bearer your_api_password`
-
-**Request Example:**
-```bash
-curl -X POST "http://127.0.0.1:7861/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello, Claude!"}
-    ]
-  }'
-```
-
-**Support for system parameter:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "max_tokens": 1024,
-  "system": "You are a helpful assistant",
-  "messages": [
-    {"role": "user", "content": "Hello"}
-  ]
-}
-```
-
-**Notes:**
-- Fully compatible with Claude API format specification
-- Automatically converts to Gemini format for backend calls
-- Supports all Claude standard parameters
-- Response format follows Claude API specification
-
-#### 4. Antigravity API Endpoints
-
-**Supports three formats: OpenAI, Gemini, and Claude**
-
-##### Antigravity OpenAI Format Endpoints
-
-**Endpoint:** `/antigravity/v1/chat/completions`
-**Authentication:** `Authorization: Bearer your_api_password`
-
-**Request Example:**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
-  -H "Authorization: Bearer your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "stream": true
-  }'
-```
-
-##### Antigravity Gemini Format Endpoints
-
-**Non-streaming Endpoint:** `/antigravity/v1/models/{model}:generateContent`
-**Streaming Endpoint:** `/antigravity/v1/models/{model}:streamGenerateContent`
-
-**Authentication Methods (choose one):**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URL parameter: `?key=your_api_password`
-
-**Request Examples:**
-```bash
-# Gemini format non-streaming request
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ],
-    "generationConfig": {
-      "temperature": 0.7
-    }
-  }'
-
-# Gemini format streaming request
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-##### Antigravity Claude Format Endpoints
-
-**Endpoint:** `/antigravity/v1/messages`
-**Authentication:** `x-api-key: your_api_password`
-
-**Request Example:**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ]
-  }'
-```
-
-**Supported Antigravity Models:**
-- Claude series: `claude-sonnet-4-5`, `claude-opus-4-5`, etc.
-- Gemini series: `gemini-2.5-flash`, `gemini-2.5-pro`, etc.
-- Automatically supports thinking models
-
-**Gemini Native Example:**
-```python
-from io import BytesIO
-from PIL import Image
-from google.genai import Client
-from google.genai.types import HttpOptions
-from google.genai import types
-# The client gets the API key from the environment variable `GEMINI_API_KEY`.
-
-client = Client(
-            api_key="pwd",
-            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
-        )
-
-prompt = (
-    """
-    Draw a cat
-    """
-)
-
-response = client.models.generate_content(
-    model="gemini-3.1-flash-image",
-    contents=[prompt],
-    config=types.GenerateContentConfig(
-        image_config=types.ImageConfig(
-            aspect_ratio="16:9",
-        )
-    )
-)
-for part in response.candidates[0].content.parts:
-    if part.text is not None:
-        print(part.text)
-    elif part.inline_data is not None:
-        image = Image.open(BytesIO(part.inline_data.data))
-        image.save("generated_image.png")
-
-```
-
-**Notes:**
-- OpenAI endpoints return OpenAI-compatible format
-- Gemini endpoints return Gemini native format
-- Both endpoints use the same API password
-
-## 📋 Complete API Reference
-
-### Web Console API
-
-**Authentication Endpoints**
-- `POST /auth/login` - User login
-- `POST /auth/start` - Start OAuth authentication (supports GCLI and Antigravity modes)
-- `POST /auth/callback` - Handle OAuth callback
-- `POST /auth/callback-url` - Complete authentication directly from callback URL
-- `GET /auth/status/{project_id}` - Check authentication status
-
-**Credential Management Endpoints** (supports `mode=geminicli` or `mode=antigravity` parameter)
-- `POST /creds/upload` - Batch upload credential files (supports JSON and ZIP)
-- `GET /creds/status` - Get credential status list (supports pagination and filtering)
-- `GET /creds/detail/{filename}` - Get single credential details
-- `POST /creds/action` - Single credential operation (enable/disable/delete)
-- `POST /creds/batch-action` - Batch credential operations
-- `GET /creds/download/{filename}` - Download single credential file
-- `GET /creds/download-all` - Package download all credentials
-- `POST /creds/fetch-email/{filename}` - Get user email
-- `POST /creds/refresh-all-emails` - Batch refresh user emails
-- `POST /creds/deduplicate-by-email` - Deduplicate credentials by email
-- `POST /creds/verify-project/{filename}` - Verify credential Project ID
-- `GET /creds/quota/{filename}` - Get credential quota information (Antigravity only)
-
-**Configuration Management Endpoints**
-- `GET /config/get` - Get current configuration
-- `POST /config/save` - Save configuration
-
-**Log Management Endpoints**
-- `POST /logs/clear` - Clear logs
-- `GET /logs/download` - Download log file
-- `WebSocket /logs/stream` - Real-time log stream
-
-**Version Information Endpoints**
-- `GET /version/info` - Get version information (optional `check_update=true` parameter to check for updates)
-
-### Chat API Features
-
-**Multimodal Support**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "Describe this image"},
-        {
-          "type": "image_url",
-          "image_url": {
-            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
-          }
-        }
-      ]
-    }
-  ]
-}
-```
-
-**Thinking Mode Support**
-```json
-{
-  "model": "gemini-2.5-pro-high",
-  "messages": [
-    {"role": "user", "content": "Complex math problem"}
-  ]
-}
-```
-
-Response will include separated thinking content:
-```json
-{
-  "choices": [{
-    "message": {
-      "role": "assistant",
-      "content": "Final answer",
-      "reasoning_content": "Detailed thought process..."
-    }
-  }]
-}
-```
-
-**Streaming Anti-truncation Usage**
-```json
-{
-  "model": "流式抗截断/gemini-2.5-pro",
-  "messages": [
-    {"role": "user", "content": "Write a long article"}
-  ],
-  "stream": true
-}
-```
-
-**Compatibility Mode**
-```bash
-# Enable compatibility mode
-export COMPATIBILITY_MODE=true
-```
-In this mode, all `system` messages are converted to `user` messages, improving compatibility with certain clients.
-
----
-
-## 💬 Community
-
-Welcome to join the QQ group for discussion!
-
-**QQ Group: 1083250744**
-
-<img src="qq群.jpg" width="200" alt="QQ Group QR Code">
-
----
-
-## License and Disclaimer
-
-This project is for learning and research purposes only. Using this project indicates that you agree to:
-- Not use this project for any commercial purposes
-- Bear all risks and responsibilities of using this project
-- Comply with relevant terms of service and legal regulations
-
-The project authors are not responsible for any direct or indirect losses arising from the use of this project.
-
-## ⚠️ License Declaration
-
-**This project is licensed under the Cooperative Non-Commercial License (CNC-1.0)**
-
-This is a strict anti-commercial open source license. Please refer to the [LICENSE](../LICENSE) file for details.
-
-### ✅ Permitted Uses:
-- Personal learning, research, and educational purposes
-- Non-profit organization use
-- Open source project integration (must comply with the same license)
-- Academic research and publication
-
-### ❌ Prohibited Uses:
-- Any form of commercial use
-- Enterprise use with annual revenue exceeding $1 million
-- Venture capital-backed or publicly traded companies
-- Providing paid services or products
-- Commercial competitive use

docs/README_JA.md

@@ -1,883 +0,0 @@
-# GeminiCLI to API
-
-**GeminiCLIおよびAntigravityをOpenAI、GEMINI、Claude API互換インターフェースに変換**
-
-[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
-[![License: CNC-1.0](https://img.shields.io/badge/License-CNC--1.0-red.svg)](../LICENSE)
-[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/su-kaka/gcli2api/pkgs/container/gcli2api)
-
-[中文](../README.md) | [English](README_EN.md) | 日本語
-
-## 🚀 クイックデプロイ
-
-[![Deploy on Zeabur](https://zeabur.com/button.svg)](https://zeabur.com/templates/97VMEF?referralCode=sukaka)
-[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/su-kaka/gcli2api)
----
-
-## インストールガイド
-
-### Termux環境
-
-**初期インストール**
-```bash
-curl -o termux-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/termux-install.sh" && chmod +x termux-install.sh && ./termux-install.sh
-```
-
-**サービス再起動**
-```bash
-cd gcli2api
-bash termux-start.sh
-```
-
-### Windows環境
-
-**初期インストール**
-```powershell
-iex (iwr "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.ps1" -UseBasicParsing).Content
-```
-
-**サービス再起動**
-`start.bat` をダブルクリックして実行
-
-### Linux環境
-
-**初期インストール**
-```bash
-curl -o install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/install.sh" && chmod +x install.sh && ./install.sh
-```
-
-**サービス再起動**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### macOS環境
-
-**初期インストール**
-```bash
-curl -o darwin-install.sh "https://raw.githubusercontent.com/su-kaka/gcli2api/refs/heads/master/darwin-install.sh" && chmod +x darwin-install.sh && ./darwin-install.sh
-```
-
-**サービス再起動**
-```bash
-cd gcli2api
-bash start.sh
-```
-
-### Docker環境
-
-**Docker Runコマンド**
-```bash
-# 共通パスワードを使用
-docker run -d --name gcli2api --network host -e PASSWORD=pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-
-# 個別パスワードを使用
-docker run -d --name gcli2api --network host -e API_PASSWORD=api_pwd -e PANEL_PASSWORD=panel_pwd -e PORT=7861 -v $(pwd)/data/creds:/app/creds ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Mac**
-```bash
-# 共通パスワードを使用
-docker run -d \
-  --name gcli2api \
-  -p 7861:7861 \
-  -p 8080:8080 \
-  -e PASSWORD=pwd \
-  -e PORT=7861 \
-  -v "$(pwd)/data/creds":/app/creds \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-```bash
-# 個別パスワードを使用
-docker run -d \
---name gcli2api \
--p 7861:7861 \
--p 8080:8080 \
--e API_PASSWORD=api_pwd \
--e PANEL_PASSWORD=panel_pwd \
--e PORT=7861 \
--v $(pwd)/data/creds:/app/creds \
-ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Compose Runコマンド**
-1. 以下の内容を `docker-compose.yml` ファイルとして保存:
-    ```yaml
-    version: '3.8'
-
-    services:
-      gcli2api:
-        image: ghcr.io/su-kaka/gcli2api:latest
-        container_name: gcli2api
-        restart: unless-stopped
-        network_mode: host
-        environment:
-          # 共通パスワードを使用（シンプルなデプロイに推奨）
-          - PASSWORD=pwd
-          - PORT=7861
-          # または個別パスワードを使用（本番環境に推奨）
-          # - API_PASSWORD=your_api_password
-          # - PANEL_PASSWORD=your_panel_password
-        volumes:
-          - ./data/creds:/app/creds
-        healthcheck:
-          test: ["CMD-SHELL", "python -c \"import sys, urllib.request, os; port = os.environ.get('PORT', '7861'); req = urllib.request.Request(f'http://localhost:{port}/v1/models', headers={'Authorization': 'Bearer ' + os.environ.get('PASSWORD', 'pwd')}); sys.exit(0 if urllib.request.urlopen(req, timeout=5).getcode() == 200 else 1)\""]
-          interval: 30s
-          timeout: 10s
-          retries: 3
-          start_period: 40s
-    ```
-2. サービスを起動:
-    ```bash
-    docker-compose up -d
-    ```
-
-## コア機能
-
-### 🔄 APIエンドポイントとフォーマット対応
-
-**マルチエンドポイント・マルチフォーマット対応**
-- **OpenAI互換エンドポイント**: `/v1/chat/completions` および `/v1/models`
-  - 標準OpenAIフォーマット（messages構造）に対応
-  - Geminiネイティブフォーマット（contents構造）に対応
-  - フォーマットの自動検出・変換、手動切替不要
-  - マルチモーダル入力に対応（テキスト＋画像）
-- **Geminiネイティブエンドポイント**: `/v1/models/{model}:generateContent` および `streamGenerateContent`
-  - Geminiネイティブ API仕様に完全対応
-  - 複数の認証方式: Bearer Token、x-goog-api-keyヘッダー、URLパラメータkey
-- **Claudeフォーマット互換**: Claude APIフォーマットに完全��応
-  - エンドポイント: `/v1/messages`（Claude API仕様に準拠）
-  - Claude標準messagesフォーマットに対応
-  - systemパラメータおよびClaude固有機能に対応
-  - バックエンド対応フォーマットへの自動変換
-- **Antigravity API対応**: OpenAI、Gemini、Claudeフォーマットに対応
-  - OpenAIフォーマットエンドポイント: `/antigravity/v1/chat/completions`
-  - Geminiフォーマットエンドポイント: `/antigravity/v1/models/{model}:generateContent` および `streamGenerateContent`
-  - Claudeフォーマットエンドポイント: `/antigravity/v1/messages`
-  - 全Antigravityモデルに対応（Claude、Geminiなど）
-  - モデル名の自動マッピングおよびThinkingモード検出
-
-### 🔐 認証とセキュリティ管理
-
-**柔軟なパスワード管理**
-- **個別パスワード対応**: APIパスワード（チャットエンドポイント）とコントロールパネルパスワードを個別に設定可能
-- **複数の認証方式**: Authorization Bearer、x-goog-api-keyヘッダー、URLパラメータなどに対応
-- **JWTトークン認証**: コントロールパネルはJWTトークン認証に対応
-- **ユーザーメール取得**: Googleアカウントのメールアドレスを自動取得・表示
-
-### 📊 インテリジェントなクレデンシャル管理システム
-
-**高度なクレデンシャル管理**
-- 複数のGoogle OAuthクレデンシャルの自動ローテーション
-- 冗長認証による安定性の向上
-- ロードバランシングと同時リクエスト対応
-- 自動障害検出とクレデンシャル無効化
-- クレデンシャル使用統計とクォータ管理
-- クレデンシャルファイルの手動有効化/無効化に対応
-- クレデンシャルファイルの一括操作（有効化、無効化、削除）
-
-**クレデンシャルステータス監視**
-- リアルタイムのクレデンシャルヘルスチェック
-- エラーコードの追跡（429、403、500など）
-- 自動BAN機能（設定可能）
-
-### 🌊 ストリーミングとレスポンス処理
-
-**複数のストリーミング対応**
-- リアルタイムストリーミングレスポンス
-- 疑似ストリーミングモード（互換性向上用）
-- ストリーミング途切れ防止機能（回答の途切れを防止）
-- 非同期タスク管理とタイムアウト処理
-
-**レスポンス最適化**
-- 思考チェーン内容の分離
-- 推論プロセス（reasoning_content）の処理
-- マルチターン会話のコンテキスト管理
-- 互換モード（systemメッセージをuserメッセージに変換）
-
-### 🎛️ Web管理コンソール
-
-**フル機能のWebインターフェース**
-- OAuth認証フロー管理（GCLIおよびAntigravityデュアルモード対応）
-- クレデンシャルファイルのアップロード、ダウンロード、管理
-- リアルタイムログ表示（WebSocket）
-- システム設定管理
-- 使用統計と監視ダッシュボード
-- モバイル対応インターフェース
-
-**一括操作対応**
-- ZIPファイルによるクレデンシャル一括アップロード（GCLIおよびAntigravity）
-- クレデンシャルの一括有効化/無効化/削除
-- ユーザーメールの一括取得
-- 設定の一括管理
-- 全クレデンシャルタイプ統合一括アップロードインターフェース
-
-### 📈 使用状況モニタリング
-
-**リアルタイム監視**
-- WebSocketリアルタイムログストリーム
-- システムステータス監視
-- クレデンシャルヘルスステータス
-
-### 🔧 高度な設定とカスタマイズ
-
-**ネットワークとプロキシ設定**
-- HTTP/HTTPSプロキシ対応
-- プロキシエンドポイント設定（OAuth、Google APIs、メタデータサービス）
-- タイムアウトとリトライ設定
-- ネットワークエラー処理とリカバリ
-
-**パフォーマンスと安定性の設定**
-- 429エラーの自動リトライ（間隔と回数を設定可能）
-- 途切れ防止の最大リトライ回数
-
-**ログとデバッグ**
-- マルチレベルログシステム（DEBUG、INFO、WARNING、ERROR）
-- ログファイル管理
-- リアルタイムログストリーム
-- ログのダウンロードとクリア
-
-### 🔄 環境変数と設定管理
-
-**柔軟な設定方法**
-- 環境変数による設定
-- ホット設定更新（一部設定項目）
-- 設定ロック（環境変数優先）
-
-## 対応モデル
-
-全モデルが100万トークンのコンテキストウィンドウに対応。各クレデンシャルファイルで1000リクエストのクォータを提供。
-
-### 🤖 基本モデル
-- `gemini-2.5-pro`
-- `gemini-3-pro-preview`
-- `gemini-3.1-pro-preview`
-
-### 🧠 Thinkingモデル
-- `gemini-2.5-pro-high`: Thinkingモード
-- `gemini-2.5-pro-low`: 低Thinkingモード
-- カスタムThinkingバジェット設定に対応
-- 思考内���と最終回答の自動分離
-
-### 🔍 検索拡張モデル
-- `gemini-2.5-pro-search`: 検索機能統合モデル
-
-### 🖼️ 画像生成モデル（Antigravity）
-- `gemini-3.1-flash-image`: 基本画像生成モデル
-- **解像度サフィックス**:
-  - `-2k`: 2K解像度
-  - `-4k`: 4K HD解像度
-- **アスペクト比サフィックス**:
-  - `-1x1`: 正方形（アバター）
-  - `-16x9`: 横長（デスクトップ壁紙）
-  - `-9x16`: 縦長（モバイル壁紙）
-  - `-21x9`: ウルトラワイド（ウルトラワイドモニター）
-  - `-4x3`: 従来のディスプレイ
-  - `-3x4`: 縦型ポスター
-- **組み合わせ例**:
-  - `gemini-3.1-flash-image-4k-16x9`: 4K横長
-  - `gemini-3.1-flash-image-2k-9x16`: 2K縦長
-- 比率未指定時はAPIが自動的にアスペクト比を決定
-
-### 🌊 特殊機能バリアント
-- **疑似ストリーミングモード**: 任意のモデル名に `-假流式` サフィックスを追加
-  - 例: `gemini-2.5-pro-假流式`
-  - ストリーミングレスポンスが必要だがサーバーが真のストリーミングに対応していない場合に使用
-- **ストリーミング途切れ防止モード**: モデル名に `流式抗截断/` プレフィックスを追加
-  - 例: `流式抗截断/gemini-2.5-pro`
-  - レスポンスの途切れを自動検出しリトライして完全な回答を保証
-
-### 🔧 モデル機能の自動検出
-- システムがモデル名内の機能識別子を自動認識
-- 機能モード切替を透過的に処理
-- 機能の組み合わせ使用に対応
-
----
-
-## 設定手順
-
-1. `http://127.0.0.1:7861` にアクセス（デフォルトポート、PORT環境変数で変更可能）
-2. OAuth認証フローを完了（デフォルトパスワード: `pwd`、環境変数で変更可能）
-   - **GCLIモード**: Google Cloud Gemini APIクレデンシャルの取得用
-   - **Antigravityモード**: Google Antigravity APIクレデンシャルの取得用
-3. クライアントを設定:
-
-**OpenAI互換クライアント:**
-   - **エンドポイントアドレス**: `http://127.0.0.1:7861/v1`
-   - **APIキー**: `pwd`（デフォルト値、API_PASSWORDまたはPASSWORD環境変数で変更可能）
-
-**Geminiネイティブクライアント:**
-   - **エンドポイントアドレス**: `http://127.0.0.1:7861`
-   - **認証方式**:
-     - `Authorization: Bearer your_api_password`
-     - `x-goog-api-key: your_api_password`
-     - URLパラメータ: `?key=your_api_password`
-
-### 🌟 デュアル認証モード対応
-
-**GCLI認証モード**
-- 標準Google Cloud Gemini API認証
-- OAuth2.0認証フローに対応
-- 必要なGoogle Cloud APIを自動的に有効化
-
-**Antigravity認証モード**
-- Google Antigravity API専用認証
-- 独立したクレデンシャル管理システム
-- 一括アップロードと管理に対応
-- GCLIクレデンシャルとは完全に分離
-
-**統合管理インターフェース**
-- 「一括アップロード」タブで両方のクレデンシャルタイプを管理
-- 上部セクション: GCLIクレデンシャル一括アップロード（青テーマ）
-- 下部セクション: Antigravityクレデンシャル一括アップロード（緑テーマ）
-- 各タイプ別のクレデンシャル管理タブ
-
-## 💾 データストレージモード
-
-### 🌟 ストレージバックエンド対応
-
-gcli2apiは2つのストレージバックエンドに対応: **ローカルSQLite（デフォルト）** と **MongoDB（クラウド分散ストレージ）**
-
-### 📁 ローカルSQLiteストレージ（デフォルト）
-
-**デフォルトストレージ方式**
-- 設定不要、すぐに利用可能
-- データはローカルSQLiteデータベースに保存
-- 単一マシンデプロイおよび個人利用に最適
-- データベースファイルの自動作成・管理
-
-### 🍃 MongoDBクラウドストレージモード
-
-**クラウド分散ストレージソリューション**
-
-マルチインスタンスデプロイやクラウドストレージが必要な場合、MongoDBストレージモードを有効にできます。
-
-### ⚙️ MongoDBモードの有効化
-
-**ステップ1: MongoDB接続の設定**
-```bash
-# ローカルMongoDB
-export MONGODB_URI="mongodb://localhost:27017"
-
-# MongoDB Atlasクラウドサービス
-export MONGODB_URI="mongodb+srv://username:password@cluster.mongodb.net"
-
-# 認証付きMongoDB
-export MONGODB_URI="mongodb://admin:password@localhost:27017/admin"
-
-# オプション: カスタムデータベース名（デフォルト: gcli2api）
-export MONGODB_DATABASE="my_gcli_db"
-```
-
-**ステップ2: アプリケーションの起動**
-```bash
-# アプリケーションがMongoDB設定を自動検出し、MongoDBストレージを使用します
-python web.py
-```
-
-**Docker環境でのMongoDB使用**
-```bash
-# 単一MongoDBデプロイ
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb://mongodb:27017" \
-  -e API_PASSWORD=your_password \
-  --network your_network \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# MongoDB Atlasの使用
-docker run -d --name gcli2api \
-  -e MONGODB_URI="mongodb+srv://user:pass@cluster.mongodb.net/gcli2api" \
-  -e API_PASSWORD=your_password \
-  -p 7861:7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-**Docker Composeの例**
-```yaml
-version: '3.8'
-
-services:
-  mongodb:
-    image: mongo:7
-    container_name: gcli2api-mongodb
-    restart: unless-stopped
-    environment:
-      MONGO_INITDB_ROOT_USERNAME: admin
-      MONGO_INITDB_ROOT_PASSWORD: password123
-    volumes:
-      - mongodb_data:/data/db
-    ports:
-      - "27017:27017"
-
-  gcli2api:
-    image: ghcr.io/su-kaka/gcli2api:latest
-    container_name: gcli2api
-    restart: unless-stopped
-    depends_on:
-      - mongodb
-    environment:
-      - MONGODB_URI=mongodb://admin:password123@mongodb:27017/admin
-      - MONGODB_DATABASE=gcli2api
-      - API_PASSWORD=your_api_password
-      - PORT=7861
-    ports:
-      - "7861:7861"
-
-volumes:
-  mongodb_data:
-```
-
-
-### 🔧 高度な設定
-
-**MongoDB接続の最適化**
-```bash
-# コネクションプールとタイムアウト設定
-export MONGODB_URI="mongodb://localhost:27017?maxPoolSize=10&serverSelectionTimeoutMS=5000"
-
-# レプリカセット設定
-export MONGODB_URI="mongodb://host1:27017,host2:27017,host3:27017/gcli2api?replicaSet=myReplicaSet"
-
-# リード・ライト分離設定
-export MONGODB_URI="mongodb://localhost:27017/gcli2api?readPreference=secondaryPreferred"
-```
-
-### 環境変数設定
-
-**基本設定**
-- `PORT`: サービスポート（デフォルト: 7861）
-- `HOST`: サーバーリッスンアドレス（デフォルト: 0.0.0.0）
-
-**パスワード設定**
-- `API_PASSWORD`: チャットAPIアクセスパスワード（デフォルト: PASSWORDまたはpwdを継承）
-- `PANEL_PASSWORD`: コントロールパネルアクセスパスワード（デフォルト: PASSWORDまたはpwdを継承）
-- `PASSWORD`: 共通パスワード、設定時に上記2つを上書き（デフォルト: pwd）
-
-**パフォーマンスと安定性の設定**
-- `RETRY_429_ENABLED`: 429エラー自動リトライの有効化（デフォルト: true）
-- `RETRY_429_MAX_RETRIES`: 429エラーの最大リトライ回数（デフォルト: 3）
-- `RETRY_429_INTERVAL`: 429エラーのリトライ間隔、秒単位（デフォルト: 1.0）
-- `ANTI_TRUNCATION_MAX_ATTEMPTS`: 途切れ防止の最大リトライ回数（デフォルト: 3）
-
-**ネットワークとプロキシ設定**
-- `PROXY`: HTTP/HTTPSプロキシアドレス（形式: `http://host:port`）
-- `OAUTH_PROXY_URL`: OAuth認証プロキシエンドポイント
-- `GOOGLEAPIS_PROXY_URL`: Google APIsプロキシエンドポイント
-- `METADATA_SERVICE_URL`: メタデータサービスプロキシエンドポイント
-
-**自動化設定**
-- `AUTO_BAN`: クレデンシャル自動BANの有効化（デフォルト: true）
-- `AUTO_LOAD_ENV_CREDS`: 起動時に環境変数クレデンシャルを自動ロード（デフォルト: false）
-
-**互換性設定**
-- `COMPATIBILITY_MODE`: 互換モードの有効化、systemメッセージをuserメッセージに変換（デフォルト: false）
-
-**ログ設定**
-- `LOG_LEVEL`: ログレベル（DEBUG/INFO/WARNING/ERROR、デフォルト: INFO）
-- `LOG_FILE`: ログファイルパス（デフォルト: log.txt）
-
-**ストレージ設定**
-
-**SQLite設定（デフォルト）**
-- 設定不要、自動的にローカルSQLiteデータベースを使用
-- データベースファイルはプロジェクトディレクトリに自動作成
-
-**MongoDB設定（オプションのクラウドストレージ）**
-- `MONGODB_URI`: MongoDB接続文字列（設定時にMongoDBモードを有効化）
-- `MONGODB_DATABASE`: MongoDBデータベース名（デフォルト: gcli2api）
-
-**Docker使用例**
-```bash
-# 共通パスワードを使用
-docker run -d --name gcli2api \
-  -e PASSWORD=mypassword \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-
-# 個別パスワードを使用
-docker run -d --name gcli2api \
-  -e API_PASSWORD=my_api_password \
-  -e PANEL_PASSWORD=my_panel_password \
-  -e PORT=7861 \
-  ghcr.io/su-kaka/gcli2api:latest
-```
-
-注意: クレデンシャル環境変数が設定されている場合、システムは環境変数のクレデンシャルを優先的に使用し、`creds` ディレクトリ内のファイルを無視します。
-
-### API使用方法
-
-本サービスは複数の完全なAPIエンドポイントセットに対応しています:
-
-#### 1. OpenAI互換エンドポイント（GCLI）
-
-**エンドポイント:** `/v1/chat/completions`
-**認証:** `Authorization: Bearer your_api_password`
-
-2つのリクエストフォーマットに対応し、自動検出・処理を行います:
-
-**OpenAIフォーマット:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {"role": "system", "content": "You are a helpful assistant"},
-    {"role": "user", "content": "Hello"}
-  ],
-  "temperature": 0.7,
-  "stream": true
-}
-```
-
-**Geminiネイティブフォーマット:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "contents": [
-    {"role": "user", "parts": [{"text": "Hello"}]}
-  ],
-  "systemInstruction": {"parts": [{"text": "You are a helpful assistant"}]},
-  "generationConfig": {
-    "temperature": 0.7
-  }
-}
-```
-
-#### 2. Geminiネイティブエンドポイント（GCLI）
-
-**非ストリーミングエンドポイント:** `/v1/models/{model}:generateContent`
-**ストリーミングエンドポイント:** `/v1/models/{model}:streamGenerateContent`
-**モデル一覧:** `/v1/models`
-
-**認証方式（いずれか1つを選択）:**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URLパラメータ: `?key=your_api_password`
-
-**リクエスト例:**
-```bash
-# x-goog-api-keyヘッダーを使用
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-
-# URLパラメータを使用
-curl -X POST "http://127.0.0.1:7861/v1/models/gemini-2.5-pro:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-#### 3. Claude APIフォーマットエンドポイント
-
-**エンドポイント:** `/v1/messages`
-**認証:** `x-api-key: your_api_password` または `Authorization: Bearer your_api_password`
-
-**リクエスト例:**
-```bash
-curl -X POST "http://127.0.0.1:7861/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "gemini-2.5-pro",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello, Claude!"}
-    ]
-  }'
-```
-
-**systemパラメータの対応:**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "max_tokens": 1024,
-  "system": "You are a helpful assistant",
-  "messages": [
-    {"role": "user", "content": "Hello"}
-  ]
-}
-```
-
-**注意事項:**
-- Claude APIフォーマット仕様に完全互換
-- バックエンド呼び出し時にGeminiフォーマットへ自動変換
-- すべてのClaude標準パラメータに対応
-- レスポンスフォーマットはClaude API仕様に準拠
-
-#### 4. Antigravity APIエンドポイント
-
-**OpenAI、Gemini、Claudeの3フォーマットに対応**
-
-##### Antigravity OpenAIフォーマットエンドポイント
-
-**エンドポイント:** `/antigravity/v1/chat/completions`
-**認証:** `Authorization: Bearer your_api_password`
-
-**リクエスト例:**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/chat/completions" \
-  -H "Authorization: Bearer your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ],
-    "stream": true
-  }'
-```
-
-##### Antigravity Geminiフォーマットエンドポイント
-
-**非ストリーミングエンドポイント:** `/antigravity/v1/models/{model}:generateContent`
-**ストリーミングエンドポイント:** `/antigravity/v1/models/{model}:streamGenerateContent`
-
-**認証方式（いずれか1つを選択）:**
-- `Authorization: Bearer your_api_password`
-- `x-goog-api-key: your_api_password`
-- URLパラメータ: `?key=your_api_password`
-
-**リクエスト例:**
-```bash
-# Geminiフォーマット非ストリーミングリクエスト
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/claude-sonnet-4-5:generateContent" \
-  -H "x-goog-api-key: your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ],
-    "generationConfig": {
-      "temperature": 0.7
-    }
-  }'
-
-# Geminiフォーマットストリーミングリクエスト
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/models/gemini-2.5-flash:streamGenerateContent?key=your_api_password" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "contents": [
-      {"role": "user", "parts": [{"text": "Hello"}]}
-    ]
-  }'
-```
-
-##### Antigravity Claudeフォーマットエンドポイント
-
-**エンドポイント:** `/antigravity/v1/messages`
-**認証:** `x-api-key: your_api_password`
-
-**リクエスト例:**
-```bash
-curl -X POST "http://127.0.0.1:7861/antigravity/v1/messages" \
-  -H "x-api-key: your_api_password" \
-  -H "anthropic-version: 2023-06-01" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "model": "claude-sonnet-4-5",
-    "max_tokens": 1024,
-    "messages": [
-      {"role": "user", "content": "Hello"}
-    ]
-  }'
-```
-
-**対応Antigravityモデル:**
-- Claudeシリーズ: `claude-sonnet-4-5`、`claude-opus-4-5` など
-- Geminiシリーズ: `gemini-2.5-flash`、`gemini-2.5-pro` など
-- Thinkingモデルに自動対��
-
-**Geminiネイティブの例:**
-```python
-from io import BytesIO
-from PIL import Image
-from google.genai import Client
-from google.genai.types import HttpOptions
-from google.genai import types
-# クライアントは環境変数 `GEMINI_API_KEY` からAPIキーを取得します。
-
-client = Client(
-            api_key="pwd",
-            http_options=HttpOptions(base_url="http://127.0.0.1:7861"),
-        )
-
-prompt = (
-    """
-    猫を描いて
-    """
-)
-
-response = client.models.generate_content(
-    model="gemini-3.1-flash-image",
-    contents=[prompt],
-    config=types.GenerateContentConfig(
-        image_config=types.ImageConfig(
-            aspect_ratio="16:9",
-        )
-    )
-)
-for part in response.candidates[0].content.parts:
-    if part.text is not None:
-        print(part.text)
-    elif part.inline_data is not None:
-        image = Image.open(BytesIO(part.inline_data.data))
-        image.save("generated_image.png")
-
-```
-
-**注意事項:**
-- OpenAIエンドポイントはOpenAI互換フォーマットを返します
-- GeminiエンドポイントはGeminiネイティブフォーマットを返します
-- 両エンドポイントとも同一のAPIパスワードを使用
-
-## 📋 完全なAPIリファレンス
-
-### Webコンソール API
-
-**認証エンドポイント**
-- `POST /auth/login` - ユーザーログイン
-- `POST /auth/start` - OAuth認証の開始（GCLIおよびAntigravityモード対応）
-- `POST /auth/callback` - OAuthコールバックの処理
-- `POST /auth/callback-url` - コールバックURLから直接認証を完了
-- `GET /auth/status/{project_id}` - 認証ステータスの確認
-
-**クレデンシャル管理エンドポイント**（`mode=geminicli` または `mode=antigravity` パラメータ対応）
-- `POST /creds/upload` - クレデンシャルファイルの一括アップロード（JSONおよびZIP対応）
-- `GET /creds/status` - クレデンシャルステータス一覧の取得（ページネーションとフィルタリング対応）
-- `GET /creds/detail/{filename}` - 単一クレデンシャルの詳細取得
-- `POST /creds/action` - 単一クレデンシャル操作（有効化/無効化/削除）
-- `POST /creds/batch-action` - クレデンシャルの一括操作
-- `GET /creds/download/{filename}` - 単一クレデンシャルファイルのダウンロード
-- `GET /creds/download-all` - 全クレデンシャルの一括ダウンロード
-- `POST /creds/fetch-email/{filename}` - ユーザーメールの取得
-- `POST /creds/refresh-all-emails` - ユーザーメールの一括更新
-- `POST /creds/deduplicate-by-email` - メールによるクレデンシャルの重複排除
-- `POST /creds/verify-project/{filename}` - クレデンシャルのProject ID検証
-- `GET /creds/quota/{filename}` - クレデンシャルのクォータ情報取得（Antigravityのみ）
-
-**設定管理エンドポイント**
-- `GET /config/get` - 現在の設定の取得
-- `POST /config/save` - 設定の保存
-
-**ログ管理エンドポイント**
-- `POST /logs/clear` - ログのクリア
-- `GET /logs/download` - ログファイルのダウンロード
-- `WebSocket /logs/stream` - リアルタイムログストリーム
-
-**バージョン情報エンドポイント**
-- `GET /version/info` - バージョン情報の取得（オプション `check_update=true` パラメータで更新確認）
-
-### チャットAPI機能
-
-**マルチモーダル対応**
-```json
-{
-  "model": "gemini-2.5-pro",
-  "messages": [
-    {
-      "role": "user",
-      "content": [
-        {"type": "text", "text": "この画像を説明してください"},
-        {
-          "type": "image_url",
-          "image_url": {
-            "url": "data:image/jpeg;base64,/9j/4AAQSkZJRgABA..."
-          }
-        }
-      ]
-    }
-  ]
-}
-```
-
-**Thinkingモード対応**
-```json
-{
-  "model": "gemini-2.5-pro-high",
-  "messages": [
-    {"role": "user", "content": "複雑な数学の問題"}
-  ]
-}
-```
-
-レスポンスには分離された思考内容が含まれます:
-```json
-{
-  "choices": [{
-    "message": {
-      "role": "assistant",
-      "content": "最終回答",
-      "reasoning_content": "詳細な思考プロセス..."
-    }
-  }]
-}
-```
-
-**ストリーミング途切れ防止の使用方法**
-```json
-{
-  "model": "流式抗截断/gemini-2.5-pro",
-  "messages": [
-    {"role": "user", "content": "長い記事を書いてください"}
-  ],
-  "stream": true
-}
-```
-
-**互換モード**
-```bash
-# 互換モードを有効化
-export COMPATIBILITY_MODE=true
-```
-このモードでは、すべての `system` メッセージが `user` メッセージに変換され、特定のクライアントとの互換性が向上します。
-
----
-
-## 💬 コミュニティ
-
-QQグループへの参加をお待ちしています！
-
-**QQグループ: 1083250744**
-
-<img src="qq群.jpg" width="200" alt="QQグループQRコード">
-
----
-
-## ライセンスと免責事項
-
-本プロジェクトは学��および研究目的のみに使用できます。本プロジェクトの使用は、以下に同意したことを意味します:
-- 本プロジェクトをいかなる商用目的にも使用しないこと
-- 本プロジェクトの使用に伴うすべてのリスクと責任を負うこと
-- 関連するサービス利用規約および法的規制を遵守すること
-
-プロジェクトの作者は、本プロジェクトの使用から生じるいかなる直接的または間接的な損害についても責任を負いません。
-
-## ⚠️ ライセンスについて
-
-**本プロジェクトはCooperative Non-Commercial License (CNC-1.0) の下でライセンスされています**
-
-これは厳格な非商用オープンソースライセンスです。詳細は [LICENSE](../LICENSE) ファイルをご参照ください。
-
-### ✅ 許可される用途:
-- 個人の学習、研究、教育目的
-- 非営利団体での利用
-- オープンソースプロジェクトへの統合（同一ライセンスの遵守が必要）
-- 学術研究および論文発表
-
-### ❌ 禁止される用途:
-- あらゆる形態の商用利用
-- 年間売上が100万ドルを超える企業での利用
-- ベンチャーキャピタルの出資を受けた企業または上場企業
-- 有料サービスまたは製品の提供
-- 商業的な競合利用

go.mod

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

go.sum

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

install.ps1

@@ -1,35 +0,0 @@
-# 检测是否为管理员
-$IsElevated = ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).
-    IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
-
-# Skip Scoop install if already present to avoid stopping the script
-if (Get-Command scoop -ErrorAction SilentlyContinue) {
-    Write-Host "Scoop is already installed. Skipping installation."
-} else {
-    Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser -Force
-    if ($IsElevated) {
-        # 管理员：使用官方一行命令并传入 -RunAsAdmin
-        Invoke-Expression "& {$(Invoke-RestMethod get.scoop.sh)} -RunAsAdmin"
-    } else {
-        # 普通用户安装
-        Invoke-WebRequest -useb get.scoop.sh | Invoke-Expression
-    }
-}
-
-scoop install git uv
-if (Test-Path -LiteralPath "./web.py") {
-    # Already in target directory; skip clone and cd
-}
-elseif (Test-Path -LiteralPath "./gcli2api/web.py") {
-    Set-Location ./gcli2api
-}
-else {
-    git clone https://github.com/su-kaka/gcli2api.git
-    Set-Location ./gcli2api
-}
-# Create relocatable virtual environment to ensure portability
-$env:UV_VENV_CLEAR = "1"
-uv venv --relocatable
-uv sync
-.venv/Scripts/activate.ps1
-python web.py

install.sh

@@ -1,302 +0,0 @@
-#!/bin/bash
-set -e  # Exit on error
-set -u  # Exit on undefined variable
-set -o pipefail  # Exit on pipe failure
-
-# Color codes for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Logging functions
-log_info() {
-    echo -e "${GREEN}[INFO]${NC} $1"
-}
-
-log_error() {
-    echo -e "${RED}[ERROR]${NC} $1" >&2
-}
-
-log_warn() {
-    echo -e "${YELLOW}[WARN]${NC} $1"
-}
-
-log_debug() {
-    echo -e "${BLUE}[DEBUG]${NC} $1"
-}
-
-# Cleanup function for error handling
-cleanup() {
-    local exit_code=$?
-    if [ $exit_code -ne 0 ]; then
-        log_error "Installation failed with exit code $exit_code"
-    fi
-    exit $exit_code
-}
-
-trap cleanup EXIT
-
-# Detect OS and distribution
-detect_os() {
-    log_info "Detecting operating system..."
-    
-    if [[ "$OSTYPE" == "linux-gnu"* ]]; then
-        if [ -f /etc/os-release ]; then
-            . /etc/os-release
-            OS_NAME=$ID
-            OS_VERSION=$VERSION_ID
-            log_info "Detected: $NAME $VERSION_ID"
-        elif [ -f /etc/lsb-release ]; then
-            . /etc/lsb-release
-            OS_NAME=$DISTRIB_ID
-            OS_VERSION=$DISTRIB_RELEASE
-            log_info "Detected: $DISTRIB_ID $DISTRIB_RELEASE"
-        else
-            OS_NAME="linux"
-            OS_VERSION="unknown"
-            log_warn "Could not determine specific Linux distribution"
-        fi
-    elif [[ "$OSTYPE" == "darwin"* ]]; then
-        OS_NAME="macos"
-        OS_VERSION=$(sw_vers -productVersion)
-        log_info "Detected: macOS $OS_VERSION"
-    elif [[ "$OSTYPE" == "freebsd"* ]]; then
-        OS_NAME="freebsd"
-        OS_VERSION=$(freebsd-version)
-        log_info "Detected: FreeBSD $OS_VERSION"
-    else
-        log_error "Unsupported operating system: $OSTYPE"
-        exit 1
-    fi
-}
-
-# Check for root privileges (only for Linux package managers that need it)
-check_root_if_needed() {
-    if [[ "$OS_NAME" == "ubuntu" ]] || [[ "$OS_NAME" == "debian" ]] || [[ "$OS_NAME" == "linuxmint" ]] || [[ "$OS_NAME" == "kali" ]]; then
-        if [ "$EUID" -ne 0 ]; then
-            log_error "This script requires root privileges for apt. Please run with sudo."
-            exit 1
-        fi
-    elif [[ "$OS_NAME" == "fedora" ]] || [[ "$OS_NAME" == "rhel" ]] || [[ "$OS_NAME" == "centos" ]] || [[ "$OS_NAME" == "rocky" ]] || [[ "$OS_NAME" == "almalinux" ]]; then
-        if [ "$EUID" -ne 0 ]; then
-            log_error "This script requires root privileges for dnf/yum. Please run with sudo."
-            exit 1
-        fi
-    elif [[ "$OS_NAME" == "arch" ]] || [[ "$OS_NAME" == "manjaro" ]]; then
-        if [ "$EUID" -ne 0 ]; then
-            log_error "This script requires root privileges for pacman. Please run with sudo."
-            exit 1
-        fi
-    fi
-}
-
-# Update package manager
-update_packages() {
-    log_info "Updating package manager..."
-    
-    case "$OS_NAME" in
-        ubuntu|debian|linuxmint|kali|pop)
-            if ! apt update; then
-                log_error "Failed to update apt package lists"
-                exit 1
-            fi
-            ;;
-        fedora|rhel|centos|rocky|almalinux)
-            if command -v dnf &> /dev/null; then
-                if ! dnf check-update; then
-                    # dnf check-update returns 100 if updates are available, which is not an error
-                    if [ $? -ne 100 ]; then
-                        log_warn "dnf check-update returned non-standard exit code"
-                    fi
-                fi
-            else
-                if ! yum check-update; then
-                    if [ $? -ne 100 ]; then
-                        log_warn "yum check-update returned non-standard exit code"
-                    fi
-                fi
-            fi
-            ;;
-        arch|manjaro)
-            if ! pacman -Syu; then
-                log_error "Failed to update pacman database"
-                exit 1
-            fi
-            ;;
-        macos)
-            if command -v brew &> /dev/null; then
-                log_info "Updating Homebrew..."
-                brew update
-            else
-                log_warn "Homebrew not installed. Skipping package manager update."
-            fi
-            ;;
-        *)
-            log_warn "Unknown package manager for $OS_NAME. Skipping update."
-            ;;
-    esac
-}
-
-# Install git based on OS
-install_git() {
-    if ! command -v git &> /dev/null; then
-        log_info "Installing git..."
-        
-        case "$OS_NAME" in
-            ubuntu|debian|linuxmint|kali|pop)
-                if ! apt install git -y; then
-                    log_error "Failed to install git"
-                    exit 1
-                fi
-                ;;
-            fedora|rhel|centos|rocky|almalinux)
-                if command -v dnf &> /dev/null; then
-                    if ! dnf install git -y; then
-                        log_error "Failed to install git"
-                        exit 1
-                    fi
-                else
-                    if ! yum install git -y; then
-                        log_error "Failed to install git"
-                        exit 1
-                    fi
-                fi
-                ;;
-            arch|manjaro)
-                if ! pacman -S git --noconfirm; then
-                    log_error "Failed to install git"
-                    exit 1
-                fi
-                ;;
-            macos)
-                if command -v brew &> /dev/null; then
-                    if ! brew install git; then
-                        log_error "Failed to install git"
-                        exit 1
-                    fi
-                else
-                    log_error "Homebrew is required for macOS. Install from https://brew.sh/"
-                    exit 1
-                fi
-                ;;
-            *)
-                log_error "Don't know how to install git on $OS_NAME"
-                exit 1
-                ;;
-        esac
-    else
-        log_info "Git is already installed ($(git --version))"
-    fi
-}
-
-# Detect OS first
-detect_os
-
-# Check root if needed
-check_root_if_needed
-
-log_info "Starting installation process..."
-
-# Update package lists
-update_packages
-
-# Install git
-install_git
-
-# Install uv if not present
-if ! command -v uv &> /dev/null; then
-    log_info "Installing uv package manager..."
-    if ! curl -Ls https://astral.sh/uv/install.sh | sh; then
-        log_error "Failed to install uv"
-        exit 1
-    fi
-    
-    # Source environment
-    if [ -f "$HOME/.local/bin/env" ]; then
-        source "$HOME/.local/bin/env"
-    elif [ -f "$HOME/.cargo/env" ]; then
-        source "$HOME/.cargo/env"
-    fi
-    
-    # Verify uv installation
-    if ! command -v uv &> /dev/null; then
-        log_error "uv installation failed - command not found after install"
-        exit 1
-    fi
-else
-    log_info "uv is already installed"
-fi
-
-# Determine working directory
-log_info "Checking project directory..."
-if [ -f "./web.py" ]; then
-    log_info "Already in target directory"
-elif [ -f "./gcli2api/web.py" ]; then
-    log_info "Changing to gcli2api directory"
-    cd ./gcli2api || exit 1
-else
-    log_info "Cloning repository..."
-    if [ -d "./gcli2api" ]; then
-        log_warn "gcli2api directory exists but web.py not found. Removing and re-cloning..."
-        rm -rf ./gcli2api
-    fi
-    
-    if ! git clone https://github.com/su-kaka/gcli2api.git; then
-        log_error "Failed to clone repository"
-        exit 1
-    fi
-    
-    cd ./gcli2api || exit 1
-fi
-
-# Update repository if it's a git repo
-if [ -d ".git" ]; then
-    log_info "Updating repository..."
-    if ! git pull; then
-        log_warn "Git pull failed, continuing anyway..."
-    fi
-else
-    log_warn "Not a git repository, skipping update"
-fi
-
-# Create relocatable virtual environment to ensure portability
-log_info "Creating relocatable virtual environment..."
-export UV_VENV_CLEAR=1
-if ! uv venv --relocatable; then
-    log_error "Failed to create virtual environment"
-    exit 1
-fi
-
-# Sync dependencies
-log_info "Syncing dependencies with uv..."
-if ! uv sync; then
-    log_error "Failed to sync dependencies"
-    exit 1
-fi
-
-# Activate virtual environment
-log_info "Activating virtual environment..."
-if [ -f ".venv/bin/activate" ]; then
-    source .venv/bin/activate
-else
-    log_error "Virtual environment not found at .venv/bin/activate"
-    exit 1
-fi
-
-# Verify Python is available
-if ! command -v python3 &> /dev/null; then
-    log_error "python3 not found in virtual environment"
-    exit 1
-fi
-
-# Check if web.py exists
-if [ ! -f "web.py" ]; then
-    log_error "web.py not found in current directory"
-    exit 1
-fi
-
-# Start the application
-log_info "Starting application..."
-python3 web.py

internal/auth/auth.go

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

internal/auth/auth_test.go

@@ -0,0 +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))
+	}
+}

internal/auth/permhint_test.go

@@ -0,0 +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)
+	}
+}

internal/auth/realm_test.go

@@ -0,0 +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)
+		}
+	}
+}

internal/httpauth/httpauth.go

@@ -0,0 +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[:]
+}

internal/httpauth/httpauth_test.go

@@ -0,0 +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")))
+	}
+}

internal/livecfg/livecfg.go

@@ -0,0 +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) }

internal/logfmt/logfmt.go

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

internal/logfmt/shortua_test.go

@@ -0,0 +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))
+	}
+}

internal/panel/autotask.go

@@ -0,0 +1,1265 @@
+// autotask.go 面板「一键完成」任务的动作实现。
+//
+// 设计依据：上游 scripts/task_*.py 实测结论 + 2026-09-12 桌面指纹协议逆向
+// （data/desktop-task-protocol.md）——
+//   - first_buddy（+300 分）：report（前置解锁）→ agreement → buddy/first
+//   - chat_5（+100 分）：累计 5 条 chat_request_send 上报
+//   - Model_chat_GLM5.2（+100 分）：accept → 用 glm-5.2 真实对话一次 → 上报（模型字段对齐）
+//   - RichMeow_Chat：桌面指纹（workbuddy-desktop）完整对话事件链，纯 API 可点亮（三账号实测）
+//   - Buddy_App / Buddy_App_QQ：buddyapp 五连事件，纯 API 可点亮（两账号实测）
+//   - automation_1：automated_task_create_suc 事件，纯 API 可点亮（两账号实测）
+//   - Library_read：web 域 web_element_click(library_doc_intro_click)（三账号实测）
+//   - template_5 / playbook_prompt / create_canvas：asar 逆向出的判据事件
+//     （template_used / playbook_prompt_send / wbx_design_canvas_*），纯 API 可点亮（三账号实测）
+//   - expert_5 / Expert_team_use_3：真实专家列表 + 召唤链 + 真实 chat（服务端 requestId）
+//   - expert_actual_use（三账号实测）
+//   - Hp_Appearance：appearance/set + appearance_skin_apply 事件（两账号实测）
+//
+// 仍未破解：skill_1（疑似要求真实 Skill 工具调用）。
+// 不做：Expert_lighthouse（需真实连接器授权）、Expert_Philanthropy（真实捐款）。
+//
+// 所有动作幂等：已 claimed/已达标的任务直接跳过，不重复消耗上游配额。
+package panel
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"math/rand/v2"
+	"net/http"
+	"strings"
+	"time"
+
+	"github.com/linguo2625469/workbuddy2api-panel/internal/auth"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/logfmt"
+	"github.com/linguo2625469/workbuddy2api-panel/internal/upstream"
+)
+
+// autoAction 一个可自动化的任务动作。
+type autoAction struct {
+	TaskCode string // 目标任务 code
+	Desc     string // 展示用说明
+	Attempt  bool   // true = 尝试型（上游未证实可脚本化，跑了可能不点亮）
+	run      func(p *Panel, a *auth.Auth) (string, error)
+}
+
+// autoActions 已实现的任务动作表（顺序即执行顺序：先解锁依赖项）。
+// first_buddy 依赖活跃上报解锁，故 chat_5/first_buddy 的执行都自带 report 步骤。
+var autoActions = []autoAction{
+	{
+		TaskCode: "chat_5",
+		Desc:     "上报 5 条对话活跃事件（自动补足差额）",
+		run:      runChat5,
+	},
+	{
+		TaskCode: "first_buddy",
+		Desc:     "上报解锁 → 同意协议 → 领取第一只 Buddy（+300 分）",
+		run:      runFirstBuddy,
+	},
+	{
+		TaskCode: "Model_chat_GLM5.2",
+		Desc:     "接受任务 → glm-5.2 真实对话一次 → 对齐模型上报",
+		run:      runModelChat,
+	},
+	{
+		TaskCode: "RichMeow_Chat",
+		Desc:     "桌面指纹事件链上报（已验证：纯 API 可点亮，三账号实测）",
+		run:      runRichMeow,
+	},
+	{
+		TaskCode: "Buddy_App",
+		Desc:     "上报「进入 Buddy 应用」事件链（已验证：纯 API 可点亮）",
+		run:      runBuddyApp,
+	},
+	{
+		TaskCode: "Buddy_App_QQ",
+		Desc:     "上报「进入企鹅教师助手」事件链（已验证：纯 API 可点亮）",
+		run:      runBuddyApp,
+	},
+	{
+		TaskCode: "automation_1",
+		Desc:     "上报「定时任务创建」事件（已验证：纯 API 可点亮）",
+		run:      runAutomationCreate,
+	},
+	{
+		TaskCode: "Library_read",
+		Desc:     "上报「读资料库介绍」事件（已验证：纯 API 可点亮）",
+		run:      runLibraryRead,
+	},
+	{
+		TaskCode: "template_5",
+		Desc:     "上报「使用模板创建任务」事件组 ×5（已验证：三账号点亮）",
+		run:      runTemplateUse,
+	},
+	{
+		TaskCode: "playbook_prompt",
+		Desc:     "上报「灵感案例做同款发送 Prompt」事件组（已验证：三账号点亮）",
+		run:      runPlaybookPrompt,
+	},
+	{
+		TaskCode: "create_canvas",
+		Desc:     "上报「设计创意画布创建」事件组（已验证：三账号点亮，+300 分）",
+		run:      runCreateCanvas,
+	},
+	{
+		TaskCode: "expert_5",
+		Desc:     "真实专家召唤+使用链 ×5（专家市场列表+真实 chat，已验证：三账号点亮）",
+		run:      runExpertUse,
+	},
+	{
+		TaskCode: "Expert_team_use_3",
+		Desc:     "真实专家团召唤+使用链 ×3（已验证：三账号点亮）",
+		run:      runExpertTeamUse,
+	},
+	{
+		TaskCode: "Hp_Appearance",
+		Desc:     "设置主题 API + 皮肤生效事件（已验证：两账号点亮）",
+		run:      runAppearance,
+	},
+	{
+		TaskCode: "skill_1",
+		Desc:     "真实对话 + skill_info 技能加载事件（已验证：人杰2 点亮）",
+		run:      runSkillFresh,
+	},
+	{
+		TaskCode: "Expert_lighthouse",
+		Desc:     "真实轻量云专家召唤+使用链（chat 链带 has_expert，已验证：两账号点亮）",
+		run:      runExpertLighthouse,
+	},
+	{
+		TaskCode: "black_cat",
+		Desc:     "夜猫子：23:00–08:00 窗口内 glm-5.2 对话补足（窗口外提示稍后再试）",
+		Attempt:  true,
+		run:      runBlackCat,
+	},
+	{
+		TaskCode: "school_season",
+		Desc:     "校园日（小程序口径）：accept → mini 对话+activityId 上报 → 领奖（+100c+5e）",
+		run:      runSchoolSeason,
+	},
+	{
+		TaskCode: "Sequential_Tasks_1",
+		Desc:     "小程序首对话（小程序口径）：accept → mini 对话上报 → 领奖（+100c+5e）",
+		run:      runSequentialChat,
+	},
+	{
+		TaskCode: "Sequential_Tasks_2",
+		Desc:     "小程序选专家对话（小程序口径）：市场专家 id → accept → expert_actual_use 上报 → 领奖（+200c+5e）",
+		run:      runMiniExpert,
+	},
+	{
+		TaskCode: "Sequential_Tasks_3",
+		Desc:     "小程序五次对话（小程序口径）：accept → mini 对话上报 ×5（自动补差额）→ 领奖（+300c+5e）",
+		run:      runSequentialChat5,
+	},
+	{
+		TaskCode: "Sequential_Tasks_4",
+		Desc:     "小程序定时任务（预留，每日零点解锁一环）：accept → 定时任务创建事件（PC 同源）→ 领奖（判据待解锁验证）",
+		run:      runSequentialAutomation,
+	},
+	{
+		TaskCode: "Sequential_Tasks_5",
+		Desc:     "小程序使用 GLM5.2（预留）：accept → 带模型字段的 mini 对话上报 → 领奖（判据待解锁验证）",
+		run:      runSequentialModelChat,
+	},
+	{
+		TaskCode: "Sequential_Tasks_6",
+		Desc:     "小程序十次对话（预留）：accept → mini 对话上报 ×target（自动补差额）→ 领奖",
+		run:      runSequentialChat10,
+	},
+	{
+		TaskCode: "Sequential_Tasks_7",
+		Desc:     "体验灵感功能（预留，疑 PC 口径 +500c+5e）：accept → 灵感事件组（PC+mp 双形态）→ 领奖（判据待解锁验证）",
+		run:      runSequentialPlaybook,
+	},
+}
+
+// autoActionFor 查任务对应的动作；无则返回 nil（不可自动化）。
+func autoActionFor(code string) *autoAction {
+	for i := range autoActions {
+		if autoActions[i].TaskCode == strings.TrimSpace(code) {
+			return &autoActions[i]
+		}
+	}
+	return nil
+}
+
+// autoActionIndex 任务在 autoActions 中的顺序（队列执行按依赖序排；未知返回大值）。
+func autoActionIndex(code string) int {
+	for i := range autoActions {
+		if autoActions[i].TaskCode == code {
+			return i
+		}
+	}
+	return 1 << 20
+}
+
+// mpTaskCodes 小程序口径专属下发的成长任务：默认（无 mp 头）列表不出现，
+// accept/claim 均要求 X-Client-Platform: miniprogram。新任务出现时在此登记。
+var mpTaskCodes = map[string]bool{
+	"school_season":      true, // 校园日（mini chat + activityId）
+	"Sequential_Tasks_1": true, // 小程序首对话（mini chat，无 activityId）
+	"Sequential_Tasks_2": true, // 小程序选中专家并完成有效对话（mp 指纹 expert_actual_use）
+	"Sequential_Tasks_3": true, // 小程序完成 5 次对话（与 Tasks_1 同形状，target=5 逐条累加）
+	// Tasks_4..7 存在性已实测（accept 返回 prerequisite not met 链式依赖；Tasks_8 not
+	// found 封顶）。链条每日零点解锁一环（task locked until 次日），判据为 issue #42
+	// 描述 + mpsrc 事件形状预置，解锁后逐个实测校正。
+	"Sequential_Tasks_4": true,
+	"Sequential_Tasks_5": true,
+	"Sequential_Tasks_6": true,
+	"Sequential_Tasks_7": true,
+}
+
+// isMPTaskCode 报告任务是否小程序口径专属（决定回读/接受/领奖走 mp 变体）。
+func isMPTaskCode(code string) bool { return mpTaskCodes[code] }
+
+// taskByCode 拉取任务列表并定位单个任务；未找到返回 nil（不视为错误）。
+// 双口径：mp 专属任务在默认列表查不到，自动回落 mp 列表（仅对已登记的 mp 码，
+// 未知码不多打一次上游）。
+func (p *Panel) taskByCode(a *auth.Auth, code string) (*upstream.Task, error) {
+	tasks, err := p.cfg.Upstream.ListTasks(a)
+	if err != nil {
+		return nil, err
+	}
+	for i := range tasks {
+		if tasks[i].TaskCode == code {
+			return &tasks[i], nil
+		}
+	}
+	if isMPTaskCode(code) {
+		return p.taskByCodeMP(a, code)
+	}
+	return nil, nil
+}
+
+// claimPollAttempts / claimPollGap 达标回读的有界轮询参数。
+// 背景：上游计分是**异步**的——行为事件上报后进度要数秒才刷新（实测 Model_chat
+// 对话完成后立即回读仍是 0/1，约 5-8 秒后才变 1/1）。一次性回读会误判"未达标"，
+// 从而跳过自动领奖。这里最多轮询 N 次、每次间隔 gap，总预算约 12 秒。
+var (
+	claimPollAttempts = 4
+	claimPollGap      = 3 * time.Second
+)
+
+// taskByCodeWaiting 回读任务，若未达标则在有界预算内轮询等待（上游异步计分）。
+// 已达标（claimable）立即返回；预算耗尽返回最后一次结果（可能仍未达标）。
+func (p *Panel) taskByCodeWaiting(a *auth.Auth, code string) (*upstream.Task, error) {
+	t, err := p.taskByCode(a, code)
+	if err != nil || t == nil {
+		return t, err
+	}
+	if t.Claimable || t.Claimed {
+		return t, nil
+	}
+	for i := 1; i < claimPollAttempts; i++ {
+		time.Sleep(claimPollGap)
+		t2, err2 := p.taskByCode(a, code)
+		if err2 != nil {
+			return t, nil // 轮询期间的查询失败不覆盖已拿到的结果
+		}
+		if t2 != nil {
+			t = t2
+			if t.Claimable || t.Claimed {
+				return t, nil
+			}
+		}
+	}
+	return t, nil
+}
+
+// taskByCodeMP 以小程序口径拉取任务列表并定位单个任务；未找到返回 nil。
+// 小程序限定任务（school_season / Sequential_Tasks_1）在默认口径列表不出现。
+func (p *Panel) taskByCodeMP(a *auth.Auth, code string) (*upstream.Task, error) {
+	tasks, err := p.cfg.Upstream.ListTasksMP(a)
+	if err != nil {
+		return nil, err
+	}
+	for i := range tasks {
+		if tasks[i].TaskCode == code {
+			return &tasks[i], nil
+		}
+	}
+	return nil, nil
+}
+
+// acceptWithVerifyMP accept 并回读验证登记生效：上游存在 200+OK 但 accept 未真正
+// 登记的形态（此时上报事件全部不归账，任务永远点不亮，上游 task_runner c793ae3
+// 实测）——判定以回读 accept_status 为准，未生效重试一次。
+func (p *Panel) acceptWithVerifyMP(a *auth.Auth, code string) bool {
+	for attempt := 1; attempt <= 2; attempt++ {
+		if err := p.cfg.Upstream.AcceptTasksMP(a, []string{code}); err != nil {
+			log.Printf("autotask %s %s: accept 尝试%d: %v", logfmt.Label(a.UID, a.Nickname), code, attempt, err)
+			continue
+		}
+		time.Sleep(mpActionGap)
+		t, err := p.taskByCodeMP(a, code)
+		if err == nil && t != nil && t.AcceptStatus != "not_accepted" && t.AcceptStatus != "" {
+			return true
+		}
+		log.Printf("autotask %s %s: accept 尝试%d 未登记生效（回读=%q）", logfmt.Label(a.UID, a.Nickname), code, attempt, acceptStatusOr(t))
+	}
+	return false
+}
+
+// acceptStatusOr 安全读取任务 accept_status（nil 任务返回 "?"）。
+func acceptStatusOr(t *upstream.Task) string {
+	if t == nil {
+		return "?"
+	}
+	if t.AcceptStatus == "" {
+		return "?"
+	}
+	return t.AcceptStatus
+}
+
+// mpActionGap mp 任务写动作间隔（accept/上报/领奖之间，防频控）。
+var mpActionGap = 2 * time.Second
+
+// mpChatEventGap mp 对话事件（chat_request_send）的真人节奏间隔。上游对
+// Sequential_Tasks_3「5 次有效对话」有反作弊校验：数秒级连发的事件会先被计入
+// 进度（回读 5/5、accept_status 甚至短暂转 completed），随后被判定无效整体回滚
+// （进度回落、claim 返回 400 "task not completed"）——2026-09-26 实测 2s 连发
+// 4 条全灭，45s 间隔逐条上报全存活且 claim +300c+5e 成功。每条上报前
+// sleep gap + 0~10s 抖动；首条也等（上一轮残留进度被回滚后立即重报同样无效）。
+var mpChatEventGap = 45 * time.Second
+
+// runMPMiniChatTask growth 域小程序限定任务通用闭环：
+// mp 查询 → accept（带登记回读验证）→ mini chat 事件上报（withActivityId 决定
+// 是否带开学季 activityId：school_season 必带，Sequential_Tasks_1 不带——服务端按
+// source=mini_program 指纹关联）→ 回读 → 达标即领奖。
+func (p *Panel) runMPMiniChatTask(a *auth.Auth, code string, withActivityId bool) (string, error) {
+	t, err := p.taskByCodeMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	if t == nil {
+		return "mp 口径未下发该任务（活动可能已结束）", nil
+	}
+	if t.Claimed {
+		return "已领取", nil
+	}
+	if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" {
+		if !p.acceptWithVerifyMP(a, code) {
+			return "accept 未登记生效（上游 200+OK 但未落账形态），待下次重试", nil
+		}
+		// accept 前的任务进度为 null（target 下发 0），兜底 target=1 会少报——
+		// Tasks_6 首轮实测：accept 后真实 target=10，只补 1 条就误判达标去领奖
+		// （claim 400 task not completed）。接受后回读一次拿真实 target/current。
+		if t2, err := p.taskByCodeMP(a, code); err == nil && t2 != nil {
+			t = t2
+		}
+	}
+	// 已达标（含 completed 未领）：直接领奖。
+	target := t.Target
+	if target <= 0 {
+		target = 1
+	}
+	if t.Current >= target || t.AcceptStatus == "completed" {
+		credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+		if err != nil {
+			return "", err
+		}
+		return fmt.Sprintf("已领取奖励（+%dc +%de）", credit, energy), nil
+	}
+	// 判据上报：按差额补 mini chat 事件。每条前 sleep mpChatEventGap+抖动——
+	// 连发会被上游反作弊判无效（见 mpChatEventGap 注释），宁可慢不可白报。
+	need := target - t.Current
+	for i := int64(0); i < need; i++ {
+		time.Sleep(mpChatEventGap + time.Duration(rand.Int64N(int64(10*time.Second))))
+		conv := fmt.Sprintf("wb2api-mp-%d-%d", time.Now().UnixMilli(), i)
+		var ev map[string]any
+		if withActivityId {
+			ev = upstream.SchoolSeasonChatEvent(conv)
+		} else {
+			ev = upstream.SchoolChatTimesEvents(conv)
+		}
+		if err := p.cfg.Upstream.ReportMPEvent(a, ev); err != nil {
+			return fmt.Sprintf("完成 %d/%d 次上报后中断: %v", i, need, err), nil
+		}
+	}
+	// 回读（��步计分，有界轮询复用 claimPoll 预算的紧凑版：两轮各隔 3s）。
+	for i := 0; i < 2; i++ {
+		time.Sleep(claimPollGap)
+		t2, err2 := p.taskByCodeMP(a, code)
+		if err2 != nil || t2 == nil {
+			continue
+		}
+		t = t2
+		if t.Claimable || t.Claimed || t.Current >= target {
+			break
+		}
+	}
+	if t.Claimed {
+		return "本轮已入账（claimed）", nil
+	}
+	if t.Current < target {
+		return fmt.Sprintf("已上报 %d 次但进度未达 %d/%d（异步计分未归账，下次重试）", need, t.Current, target), nil
+	}
+	credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("任务点亮并领取奖励（+%dc +%de）", credit, energy), nil
+}
+
+// runSchoolSeason 完成 school_season「校园日」（growth 域小程序限定）。
+// 判据 = mini chat_request_send + activityId=school_open_day_2026（无 activityId
+// 不点亮，与 school 域开学季同活动关联；上游 task_runner e2e 实测 +100c+5e）。
+func runSchoolSeason(p *Panel, a *auth.Auth) (string, error) {
+	return p.runMPMiniChatTask(a, "school_season", true)
+}
+
+// runSequentialChat 完成 Sequential_Tasks_1「小程序内完成 1 次有效对话」。
+// 判据 = mini chat_request_send（无 activityId，服务端按 source=mini_program
+// 指纹关联；上游 task_runner 实测 +100c+5e）。
+func runSequentialChat(p *Panel, a *auth.Auth) (string, error) {
+	return p.runMPMiniChatTask(a, "Sequential_Tasks_1", false)
+}
+
+// runSequentialChat5 完成 Sequential_Tasks_3「在小程序内完成 5 次有效对话」。
+// 判据与 Sequential_Tasks_1 同形状（mini 指纹 chat_request_send，无 activityId），
+// 仅 target=5——服务端按上报条数累加进度，但**要求真人节奏**：连发事件先计数
+// 后被反作弊回滚（claim 400 "task not completed"），由 mpChatEventGap 间隔保证
+// （2026-09-26 实测：45s 间隔补满 5/5 → claim +300c+5e 成功，领后 accept_status
+// =claimed 稳定不回滚）。
+func runSequentialChat5(p *Panel, a *auth.Auth) (string, error) {
+	return p.runMPMiniChatTask(a, "Sequential_Tasks_3", false)
+}
+
+// runSequentialChat10 完成 Sequential_Tasks_6「在小程序内完成 10 次有效对话」（预留）。
+// 判据假定与 Tasks_1/3 同形状（mini chat_request_send），target 由任务自带（回读），
+// runMPMiniChatTask 按差额补报——issue #42 称 target=10，以解锁后实际下发为准。
+// 真人节奏间隔同样适用（mpChatEventGap）：9 条 × ~50s ≈ 8 分钟/账号，夜间队列可接受。
+func runSequentialChat10(p *Panel, a *auth.Auth) (string, error) {
+	return p.runMPMiniChatTask(a, "Sequential_Tasks_6", false)
+}
+
+// runSequentialEventTask Sequential 链预留任务通用骨架：mp 查询 → accept（带验证）
+// → 判据事件上报（primary；未点亮且 fallback 非空时补一轮）→ 回读 → 达标领奖。
+// 每日零点解锁一环：locked 期间 accept 不落账，返回等下次调度（无需人工干预）。
+func (p *Panel) runSequentialEventTask(a *auth.Auth, code string, primary, fallback func() error) (string, error) {
+	t, err := p.taskByCodeMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	if t == nil {
+		return "mp 口径未下发该任务（前置任务未完成或活动未开始）", nil
+	}
+	if t.Claimed {
+		return "已领取", nil
+	}
+	target := t.Target
+	if target <= 0 {
+		target = 1
+	}
+	if t.Current >= target || t.AcceptStatus == "completed" {
+		credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+		if err != nil {
+			return "", err
+		}
+		return fmt.Sprintf("已领取奖励（+%dc +%de）", credit, energy), nil
+	}
+	if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" {
+		if !p.acceptWithVerifyMP(a, code) {
+			return "accept 未登记生效（任务可能处于每日锁定窗口，等解锁后自动重试）", nil
+		}
+	}
+	if err := primary(); err != nil {
+		return fmt.Sprintf("判据上报失败: %v", err), nil
+	}
+	// 回读（两轮各隔 3s）；未点亮且有 fallback 时补报一轮再读。
+	for round := 0; round < 2; round++ {
+		time.Sleep(claimPollGap)
+		t2, err2 := p.taskByCodeMP(a, code)
+		if err2 != nil || t2 == nil {
+			continue
+		}
+		t = t2
+		if t.Claimable || t.Claimed || t.Current >= target {
+			break
+		}
+		if round == 0 && fallback != nil {
+			if err := fallback(); err != nil {
+				return fmt.Sprintf("备选判据上报失败: %v", err), nil
+			}
+		}
+	}
+	if t.Claimed {
+		return "本轮已入账（claimed）", nil
+	}
+	if t.Current < target {
+		return "已上报但进度未点亮（判据形态待解锁后校正，下次重试）", nil
+	}
+	credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("任务点亮并领取奖励（+%dc +%de）", credit, energy), nil
+}
+
+// runSequentialAutomation 完成 Sequential_Tasks_4「创建定时任务」（预留）。
+// mp 源码无 automation 事件发射点 → 判据疑为 PC 口径：复用 automation_1 同源
+// 事件（DesktopAutomationCreateEvent，PC 任务三账号实测点亮）。
+func runSequentialAutomation(p *Panel, a *auth.Auth) (string, error) {
+	return p.runSequentialEventTask(a, "Sequential_Tasks_4",
+		func() error {
+			return p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopAutomationCreateEvent("wb2api 自动化"))
+		}, nil)
+}
+
+// runSequentialModelChat 完成 Sequential_Tasks_5「使用 GLM5.2」（预留）。
+// primary：mp 对话事件带 requestModelId/requestModelName=glm-5.2（mpsrc main 32904
+// 发射点实测形状）；fallback：PC 域模型活跃上报（Model_chat_GLM5.2 同源）。
+func runSequentialModelChat(p *Panel, a *auth.Auth) (string, error) {
+	return p.runSequentialEventTask(a, "Sequential_Tasks_5",
+		func() error {
+			conv := fmt.Sprintf("wb2api-mp-glm-%d", time.Now().UnixMilli())
+			return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniChatModelEvent(conv, "glm-5.2", "GLM-5.2"))
+		},
+		func() error {
+			return p.cfg.Upstream.ReportChatActivityModel(a, fmt.Sprintf("wb2api-mp-glm-%d", time.Now().UnixMilli()), "", "glm-5.2", "GLM-5.2")
+		})
+}
+
+// runSequentialPlaybook 完成 Sequential_Tasks_7「体验灵感功能」（预留，疑 PC 口径）。
+// primary：PC 灵感事件组（DesktopPlaybookPromptSequence，playbook_prompt 三账号
+// 实测点亮）；fallback：mp 指纹灵感事件组（MiniPlaybookEvents，mpsrc 形状）。
+func runSequentialPlaybook(p *Panel, a *auth.Auth) (string, error) {
+	ms := time.Now().UnixMilli()
+	return p.runSequentialEventTask(a, "Sequential_Tasks_7",
+		func() error {
+			conv := fmt.Sprintf("wb2api-pb-%d", ms)
+			req := fmt.Sprintf("wb2api-pb-req-%d", ms)
+			return p.cfg.Upstream.ReportDesktopEvent(a,
+				upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...)
+		},
+		func() error {
+			return p.cfg.Upstream.ReportMPEvent(a, upstream.MiniPlaybookEvents("pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")...)
+		})
+}
+
+// runMiniExpert 完成 Sequential_Tasks_2「在小程序内选中专家并完成有效对话」。
+// 判据 = mp 指纹 expert_actual_use（**不带** activityId/conversationId、
+// extVersion=2.2.8、type=send_message——小程序源码实测形状，与 school 域 expert
+// 事件两套口径勿混；上游 task_runner 实测上报即 completed，claim +200c+5e）。
+// 专家 id 必须是市场真实 ex_ id（空 id 服务端不入账）→ **accept 之前**先解析市场
+// 列表：拉不到就整任务不动作，避免留下「已登记未上报」的半程态（上游 9a26ae7
+// 的 ids 前置判定同款）。复用既有 MarketExpertList（expert_5 任务同源，实测可用）。
+func runMiniExpert(p *Panel, a *auth.Auth) (string, error) {
+	const code = "Sequential_Tasks_2"
+	t, err := p.taskByCodeMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	if t == nil {
+		return "mp 口径未下发该任务（活动可能已结束）", nil
+	}
+	if t.Claimed {
+		return "已领取", nil
+	}
+	target := t.Target
+	if target <= 0 {
+		target = 1 // 未 accept 的 mp 任务 progress 为 null，target 兜底（上游实测）
+	}
+	// 已达标（含 completed 未领）：直接领奖。
+	if t.Current >= target || t.AcceptStatus == "completed" {
+		credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+		if err != nil {
+			return "", err
+		}
+		return fmt.Sprintf("已领取奖励（+%dc +%de）", credit, energy), nil
+	}
+	// 判据载体前置（accept 之前）：市场真实专家 id。
+	experts, merr := p.cfg.Upstream.MarketExpertList(a, "")
+	if merr != nil || len(experts) == 0 {
+		return fmt.Sprintf("专家市场不可用（%v），跳过以防半程态", merr), nil
+	}
+	e := experts[0]
+	name := e.DisplayNameZH
+	if name == "" {
+		name = e.ProfessionZH
+	}
+	if t.AcceptStatus == "not_accepted" || t.AcceptStatus == "" {
+		if !p.acceptWithVerifyMP(a, code) {
+			return "accept 未登记生效（上游 200+OK 但未落账形态），待下次重试", nil
+		}
+	}
+	ev := upstream.MiniExpertUseEvent(e.ExpertID, name, e.ExpertType)
+	if err := p.cfg.Upstream.ReportMPEvent(a, ev); err != nil {
+		return fmt.Sprintf("上报 expert_actual_use 失败: %v", err), nil
+	}
+	// 回读（异步计分，两轮各隔 3s——与 runMPMiniChatTask 同预算）。
+	for i := 0; i < 2; i++ {
+		time.Sleep(claimPollGap)
+		t2, err2 := p.taskByCodeMP(a, code)
+		if err2 != nil || t2 == nil {
+			continue
+		}
+		t = t2
+		if t.Claimable || t.Claimed || t.Current >= target {
+			break
+		}
+	}
+	if t.Claimed {
+		return "本轮已入账（claimed）", nil
+	}
+	if t.Current < target {
+		return "已上报但进度未归账（异步计分，下次重试）", nil
+	}
+	credit, energy, err := p.cfg.Upstream.ClaimRewardMP(a, code)
+	if err != nil {
+		return "", err
+	}
+	return fmt.Sprintf("任务点亮并领取奖励（+%dc +%de）", credit, energy), nil
+}
+
+// accountTaskAuto 一键完成单个任务：执行对应动作 → 回读进度 → 汇报结果。
+func (p *Panel) accountTaskAuto(w http.ResponseWriter, r *http.Request) {
+	uid := r.PathValue("uid")
+	a := p.accountByUID(w, uid)
+	if a == nil {
+		return
+	}
+	var body struct {
+		TaskCode string `json:"task_code"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&body); err != nil || body.TaskCode == "" {
+		writeErr(w, http.StatusBadRequest, "task_code required")
+		return
+	}
+	act := autoActionFor(body.TaskCode)
+	if act == nil {
+		writeErr(w, http.StatusNotImplemented,
+			"该任务需要客户端内交互（无对应接口），无法自动完成；请按任务说明在官方客户端操作")
+		return
+	}
+	// per-account 互斥：同账号的任务动作正在跑（单任务或全量）时直接 409，
+	// 不并发重跑（动作幂等但 expert/skill 系含真实对话，重跑浪费配额）。
+	if !p.tryLockAccount(uid) {
+		writeErr(w, http.StatusConflict, "该账号有任务动作正在执行中，请等本轮结束后再试")
+		return
+	}
+	defer p.unlockAccount(uid)
+	// 前置读取：已完成的任务直接跳过（幂等，不浪费上游调用）。
+	// taskByCode 已双口径（mp 专属码自动回落 mp 列表）。
+	before, err := p.taskByCode(a, act.TaskCode)
+	if err != nil {
+		writeErr(w, http.StatusBadGateway, "list tasks: "+err.Error())
+		return
+	}
+	if before == nil {
+		writeErr(w, http.StatusNotFound, "该账号没有此任务")
+		return
+	}
+	isMP := isMPTaskCode(act.TaskCode)
+	if before.Claimed {
+		writeJSON(w, http.StatusOK, map[string]any{"ok": true, "skipped": true, "message": "该任务已领取过奖励"})
+		return
+	}
+	msg, err := act.run(p, a)
+	if err != nil {
+		writeErr(w, http.StatusBadGateway, "执行失败: "+err.Error())
+		return
+	}
+	// 回读验证：上报 200 ≠ 计分（上游可能静默丢弃 + 计分异步），
+	// 用有界轮询等异步计时落定，再决定是否自动领奖（mp 任务同口径回读）。
+	var after *upstream.Task
+	var aerr error
+	if isMP {
+		after, aerr = p.taskByCodeMP(a, act.TaskCode)
+	} else {
+		after, aerr = p.taskByCodeWaiting(a, act.TaskCode)
+	}
+	progressBefore, progressAfter := taskProgressText(before), ""
+	claimable := false
+	if aerr == nil && after != nil {
+		progressAfter = taskProgressText(after)
+		claimable = after.Claimable
+	}
+	resp := map[string]any{
+		"ok":               true,
+		"message":          msg,
+		"progress_before":  progressBefore,
+		"progress_after":   progressAfter,
+		"claimable":        claimable,
+		"attempt":          act.Attempt,
+		"verify_supported": true,
+	}
+	// 达标即自动领奖（Web 端 claim）：把"完成→领奖"收敛成一步，无需用户再点一次。
+	if claimable {
+		var credit, energy int64
+		var cerr error
+		if isMP {
+			credit, energy, cerr = p.cfg.Upstream.ClaimRewardMP(a, act.TaskCode)
+		} else {
+			credit, energy, cerr = p.cfg.Upstream.ClaimReward(a, act.TaskCode)
+		}
+		if cerr == nil {
+			resp["claimed"] = true
+			resp["credit"] = credit
+			resp["energy"] = energy
+			if credit > 0 || energy > 0 {
+				resp["message"] = msg + fmt.Sprintf("；已自动领奖 +%d 分 +%d 能", credit, energy)
+			} else {
+				resp["message"] = msg + "；奖励此前已领取"
+			}
+		} else {
+			resp["claim_error"] = cerr.Error()
+			resp["message"] = msg + "；达标但领奖失败，可在任务列表手动点「领取」重试"
+		}
+	}
+	log.Printf("panel: 任务动作 uid=%s code=%s progress %s -> %s claimable=%v claimed=%v",
+		uid, act.TaskCode, progressBefore, progressAfter, claimable, resp["claimed"])
+	writeJSON(w, http.StatusOK, resp)
+}
+
+// taskProgressText 任务进度的可读表示（回读对比用）。
+func taskProgressText(t *upstream.Task) string {
+	if t == nil {
+		return "?"
+	}
+	if t.Target > 0 {
+		return fmt.Sprintf("%d/%d", t.Current, t.Target)
+	}
+	if t.Claimed {
+		return "claimed"
+	}
+	return t.AcceptStatus
+}
+
+// truncateStr 截断错误文本（避免把上游长响应原样透给前端）。
+func truncateStr(s string, n int) string {
+	if len(s) <= n {
+		return s
+	}
+	return s[:n] + "…"
+}
+
+// ---------------------------------------------------------------------------
+// 各任务动作实现
+// ---------------------------------------------------------------------------
+
+// reportGap 连续上报之间的间隔（对齐上游脚本实测的 1.05s 口径，避免风控）。
+var reportGap = 1050 * time.Millisecond
+
+// runChat5 补足 chat_5 的进度：按差额上报 chat_request_send。
+func runChat5(p *Panel, a *auth.Auth) (string, error) {
+	t, err := p.taskByCode(a, "chat_5")
+	if err != nil {
+		return "", err
+	}
+	if t == nil {
+		return "", fmt.Errorf("任务不存在")
+	}
+	target := t.Target
+	if target <= 0 {
+		target = 5
+	}
+	need := target - t.Current
+	if need <= 0 {
+		return "进度已达标，无需上报", nil
+	}
+	for i := int64(0); i < need; i++ {
+		cid := fmt.Sprintf("wb2api-chat5-%d-%d", time.Now().UnixMilli(), i)
+		if err := p.cfg.Upstream.ReportChatActivity(a, cid, ""); err != nil {
+			return fmt.Sprintf("上报第 %d/%d 条失败: %v", i+1, need, err), nil
+		}
+		if i < need-1 {
+			time.Sleep(reportGap)
+		}
+	}
+	return fmt.Sprintf("已补报 %d 条对话事件", need), nil
+}
+
+// runFirstBuddy 领养：report（解锁前置）→ agreement → first。
+func runFirstBuddy(p *Panel, a *auth.Auth) (string, error) {
+	if err := p.cfg.Upstream.ReportChatActivity(a, fmt.Sprintf("wb2api-adopt-%d", time.Now().UnixMilli()), ""); err != nil {
+		return "", fmt.Errorf("前置上报: %w", err)
+	}
+	time.Sleep(reportGap) // 给上游事件处理留时间（脚本实测口径）
+	if err := p.cfg.Upstream.BuddyAgreement(a); err != nil {
+		return "", fmt.Errorf("同意协议: %w", err)
+	}
+	if err := p.cfg.Upstream.BuddyFirst(a); err != nil {
+		if upstream.IsBuddyTaskIncomplete(err) {
+			return "前置已上报，但领养门槛未过（上游要求当日活跃），请稍后重试", nil
+		}
+		return "", fmt.Errorf("领取 Buddy: %w", err)
+	}
+	return "已领取 Buddy（+300 分 +8 能量）", nil
+}
+
+// runModelChat 完成 Model_chat_GLM5.2：accept → 真实对话 → 对齐模型上报。
+func runModelChat(p *Panel, a *auth.Auth) (string, error) {
+	const code, modelID, modelName = "Model_chat_GLM5.2", "glm-5.2", "GLM-5.2"
+	// 1. accept（报名；失败不阻塞——行为事件才是判据）
+	if err := p.cfg.Upstream.AcceptTasks(a, []string{code}); err != nil {
+		log.Printf("panel: accept %s: %v（继续走行为链路）", code, err)
+	}
+	time.Sleep(reportGap)
+	// 2. 真实对话一次（判据的最直接证据）
+	body, _ := json.Marshal(map[string]any{
+		"model": modelID,
+		"messages": []map[string]any{
+			{"role": "user", "content": "hi，请回复一句话"},
+		},
+		"stream": true,
+	})
+	rc, status, respBody, err := p.cfg.Upstream.ChatStream(a, body, "", upstream.ChatMeta{})
+	if err != nil {
+		return "", fmt.Errorf("对话请求: %w", err)
+	}
+	if status >= 400 {
+		rc.Close()
+		return "", fmt.Errorf("对话失败 http=%d: %s", status, truncateStr(string(respBody), 160))
+	}
+	// 读干 SSE（网关对上游强制 flow：不读完会残留连接）
+	_, _ = io.Copy(io.Discard, io.LimitReader(rc, 1<<20))
+	rc.Close()
+	time.Sleep(reportGap)
+	// 3. 对齐模型的上报（触发进度）
+	if err := p.cfg.Upstream.ReportChatActivityModel(a, fmt.Sprintf("wb2api-glm52-%d", time.Now().UnixMilli()), "", modelID, modelName); err != nil {
+		return "对话已完成，但进度上报失败：" + err.Error(), nil
+	}
+	return "已完成 glm-5.2 对话并上报", nil
+}
+
+// runRichMeow 完成 RichMeow_Chat（桌面端对话1次）。
+// 2026-09-12 三账号实测验证：以桌面指纹（extName=workbuddy-desktop）向
+// copilot.tencent.com/v2/report 上报完整对话事件链（agent_task_created →
+// chat_message_response isSuccessful=true 等 6 事件），纯 API 即可点亮并领奖
+// （紫川/人杰2 两账号无桌面客户端登录状态下 3 秒内 0/1 → 1/1）。
+// Hp_Appearance 的纯 API set 不计分（需客户端在主题下活跃），区别对待。
+func runRichMeow(p *Panel, a *auth.Auth) (string, error) {
+	ms := time.Now().UnixMilli()
+	conv := fmt.Sprintf("wb2api-rm-%d", ms)
+	req := fmt.Sprintf("wb2api-rm-req-%d", ms)
+	msg := fmt.Sprintf("req-%d-user", ms)
+	events := upstream.DesktopChatSequence(conv, req, msg, "fast-model", "fast-model")
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", err
+	}
+	return "已按桌面端指纹上报完整对话事件链（agent_task_created→chat_response）", nil
+}
+
+// runBuddyApp 完成 Buddy_App / Buddy_App_QQ（进入 Buddy 应用）。
+// 2026-09-12 两账号实测：buddyapp 五连事件（discover→show→enter→auth_confirm→
+// bind_skip）以 workbuddy-desktop 指纹上报即点亮，服务端不校验真实授权。
+// 用企鹅教师助手（Buddy_App_QQ 判据应用）作载体，同一组事件同时满足
+// Buddy_App「进入任一应用」——两个表项共用本 run，幂等由任务状态跳过兜底。
+func runBuddyApp(p *Panel, a *auth.Auth) (string, error) {
+	events := upstream.DesktopBuddyAppSequence("cb_y5Dy46tPQGGWtueMxXbe", "企鹅教师助手")
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", err
+	}
+	return "已上报 buddyapp 进入五连事件（同时覆盖 Buddy_App 与 Buddy_App_QQ）", nil
+}
+
+// runAutomationCreate 完成 automation_1（设置自动化任务）。
+// 2026-09-12 两账号实测：automated_task_create_suc 事件纯 API 上报即点亮，
+// 无需真实创建定时任务。
+func runAutomationCreate(p *Panel, a *auth.Auth) (string, error) {
+	if err := p.cfg.Upstream.ReportDesktopEvent(a,
+		upstream.DesktopAutomationCreateEvent("wb2api 自动化")); err != nil {
+		return "", err
+	}
+	return "已上报定时任务创建事件", nil
+}
+
+// runLibraryRead 完成 Library_read（体验资料库）。
+// 2026-09-12 三账号实测：web 域 /v2/report 上报 web_element_click
+// (elementId=library_doc_intro_click) 即点亮（space 的 open/WS/inlong 都不是判据）。
+func runLibraryRead(p *Panel, a *auth.Auth) (string, error) {
+	const docURL = "https://www.workbuddy.cn/space/d/o0KWYeynteVv06UnAZqIFm"
+	if err := p.cfg.Upstream.ReportWebEvent(a, "web_element_click", docURL,
+		"library_doc_intro_click", "WorkBuddy资料库介绍"); err != nil {
+		return "", err
+	}
+	return "已上报资料库介绍阅读事件", nil
+}
+
+// runBlackCat 完成 black_cat（夜猫子，夜间 23:00–08:00 计数）。
+// 判据 = 夜间窗口内 glm-5.2 真实对话 + chat 事件上报（WorkBuddy-Daily 实测口径）。
+// 窗口外不做（提示等排程）；网关 blackcat_hours（默认 23 点）排程会自动补足。
+func runBlackCat(p *Panel, a *auth.Auth) (string, error) {
+	if !upstream.InNightWindow(time.Now()) {
+		return "当前不在 23:00–08:00 计数窗口，行为不计分；网关会在每日 23 点自动补足", nil
+	}
+	need, err := p.cfg.Upstream.BlackcatNeed(a)
+	if err != nil {
+		return "", err
+	}
+	if need <= 0 {
+		return "进度已达标，无需补足", nil
+	}
+	ok, err := p.cfg.Upstream.RunNightChats(a, int(need))
+	if err != nil {
+		return fmt.Sprintf("完成 %d/%d 次后中断: %v", ok, need, err), nil
+	}
+	return fmt.Sprintf("已完成 %d 次夜间对话并上报", ok), nil
+}
+
+// runSkillFresh 完成 skill_1（尝鲜热门技能）。
+// 2026-09-12 判据（紫川手动完成抓包 row 209）：`skill_info` 事件（桌面指纹）——
+// {id:<技能名>, skillId, skillVersion, toolStatus:"success", fileCount,
+// source:"workbuddy-desktop"} JOIN 真实会话（conversationId/requestId=服务端
+// id）。此前的 skill_request_send/skill_installed/skill_action 全是错误方向。
+// 人杰2 实测 0/1 → 1/1 点亮。
+func runSkillFresh(p *Panel, a *auth.Auth) (string, error) {
+	conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, "")
+	if err != nil {
+		return "", fmt.Errorf("真实对话: %w", err)
+	}
+	msgID := "msg-" + req[len(req)-8:]
+	events := upstream.DesktopChatSequence(conv, req, msgID, "fast-model", "fast-model")
+	for _, ev := range events {
+		if ev["eventCode"] == "chat_message_response" {
+			ev["finishReason"] = "tool_calls" // 模型发起工具调用（技能加载）语义
+		}
+	}
+	events = append(events, upstream.DesktopEvent{
+		"eventCode":      "skill_info",
+		"id":             "润泽小馆·日报撰写",
+		"skillId":        "skill_2097350077599879168",
+		"skillVersion":   "1.0.0",
+		"toolStatus":     "success",
+		"fileCount":      56,
+		"source":         "workbuddy-desktop",
+		"conversationId": conv, "requestId": req, "messageId": msgID,
+		"requestModelId": "fast-model", "requestModelName": "fast-model",
+		"traceId": req,
+	})
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", fmt.Errorf("skill_info 事件: %w", err)
+	}
+	return "已上报真实对话 + skill_info 技能加载事件", nil
+}
+
+// runExpertLighthouse 完成 Expert_lighthouse（体验「腾讯轻量云」专家）。
+// 2026-09-12 判据（真实样本 Sunny row 868）：与 expert_5 同构，但两处差异——
+// chat 链的 agent_task_created 需带 has_expert:true + expert_id（我们默认 false），
+// expert_actual_use 的 mode 为 "LOCAL"（非 craft）。id 固定为轻量云专家
+// ex_2cvvUZQhDyeJ；requestId 必须是真实 chat 的服务端 id。紫川/人杰2 实测点亮。
+func runExpertLighthouse(p *Panel, a *auth.Auth) (string, error) {
+	const lhID = "ex_2cvvUZQhDyeJ"
+	lh := upstream.MarketExpert{
+		ExpertID: lhID, ExpertType: "agent",
+		DisplayNameZH: "腾讯轻量云专家", ProfessionZH: "腾讯轻量云专家", Version: "1.0.2",
+	}
+	// 市场列表若命中真实条目则用其信息（version 等以服务端为准）。
+	if experts, err := p.cfg.Upstream.MarketExpertList(a, "agent"); err == nil {
+		for _, e := range experts {
+			if e.ExpertID == lhID {
+				lh = e
+				break
+			}
+		}
+	}
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopExpertSummonSequence(lh)...); err != nil {
+		return "", fmt.Errorf("召唤链: %w", err)
+	}
+	conv, req, err := p.cfg.Upstream.DesktopChatWithExpert(a, lhID)
+	if err != nil {
+		return "", fmt.Errorf("真实对话: %w", err)
+	}
+	events := upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model")
+	for _, ev := range events {
+		if ev["eventCode"] == "agent_task_created" {
+			ev["has_expert"] = true
+			ev["expert_id"] = lh.ExpertID
+			ev["expert_name"] = lh.DisplayNameZH
+			ev["expert_industry_id"] = ""
+		}
+	}
+	events = append(events, upstream.DesktopExpertActualUseLocal(lh, conv, req))
+	// 对齐真实样本细节：轻量云专家 actual_use 的 type 为空、cost=0。
+	events[len(events)-1]["type"] = ""
+	events[len(events)-1]["cost"] = 0
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", fmt.Errorf("使用事件: %w", err)
+	}
+	return "已上报轻量云专家召唤+使用链（真实对话 requestId）", nil
+}
+
+// runAppearance 完成 Hp_Appearance（换主题）。
+// 2026-09-12 紫川/人杰2 实测（desktopverify12）：判据是 appearance_skin_apply
+// 事件 {action:"apply",source:"settings_close",id:<resourceKey>,...}（客户端在
+// 主题生效状态下离开设置页时上报）——早期"纯 API set 不计分"的结论不准确，
+// 真相是当时只调了 appearance/set 没发事件。组合：set API 留痕 + 事件上报。
+func runAppearance(p *Panel, a *auth.Auth) (string, error) {
+	const themeKey = "theme-tkmw7j" // 和平精英激战金秋（Hp_Appearance 判据主题）
+	if err := p.cfg.Upstream.SetAppearanceTheme(a, themeKey); err != nil {
+		return "", fmt.Errorf("设置主题: %w", err)
+	}
+	time.Sleep(2 * time.Second)
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, upstream.DesktopEvent{
+		"eventCode": "appearance_skin_apply", "action": "apply", "source": "settings_close",
+		"id": themeKey, "vipLevel": 0, "series": "", "type": "unknown",
+	}); err != nil {
+		return "", err
+	}
+	return "已设置主题并上报皮肤生效事件", nil
+}
+
+// runTemplateUse 完成 template_5（使用 5 个模板创建任务）。
+// 2026-09-12 三账号实测：agent_task_created_with_template + template_used 事件组
+// （JOIN chat 链）一次上报 5 组即 5/5 点亮。template_id 服务端不校验真实性。
+func runTemplateUse(p *Panel, a *auth.Auth) (string, error) {
+	templates := [][2]string{{"1", "深度研究"}, {"2", "周报生成"}, {"3", "竞品分析"}, {"4", "活动策划"}, {"5", "代码评审"}}
+	for i, tp := range templates {
+		ms := time.Now().UnixMilli()
+		conv := fmt.Sprintf("wb2api-tpl-%d-%d", ms, i)
+		req := fmt.Sprintf("wb2api-tpl-req-%d-%d", ms, i)
+		events := upstream.DesktopTemplateUseSequence(conv, req, tp[0], tp[1])
+		if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+			return fmt.Sprintf("第 %d 组模板事件上报失败: %v", i+1, err), nil
+		}
+		time.Sleep(300 * time.Millisecond)
+	}
+	return "已上报 template_used ×5", nil
+}
+
+// runPlaybookPrompt 完成 playbook_prompt（灵感案例 Dialog 中发送 Prompt）。
+// 判据是 playbook_prompt_send（Dialog 发送）而非卡片曝光/点击——asar 逆向确认。
+func runPlaybookPrompt(p *Panel, a *auth.Auth) (string, error) {
+	ms := time.Now().UnixMilli()
+	conv := fmt.Sprintf("wb2api-pb-%d", ms)
+	req := fmt.Sprintf("wb2api-pb-req-%d", ms)
+	events := upstream.DesktopPlaybookPromptSequence(conv, req, "pm-gtm-launch-plan", "新产品上市 GTM 发布计划一页纸")
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", err
+	}
+	return "已上报 playbook_cta_click + playbook_prompt_send", nil
+}
+
+// runCreateCanvas 完成 create_canvas（设计创意模式创建画布，+300 分）。
+// 判据是 wbx_design_canvas_task_create/open（Ardot create_design 工具完成遥测）。
+func runCreateCanvas(p *Panel, a *auth.Auth) (string, error) {
+	ms := time.Now().UnixMilli()
+	conv := fmt.Sprintf("wb2api-canvas-%d", ms)
+	req := fmt.Sprintf("wb2api-canvas-req-%d", ms)
+	events := upstream.DesktopDesignCanvasSequence(conv, req)
+	if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+		return "", err
+	}
+	return "已上报 wbx_design_canvas_task_create/open", nil
+}
+
+// expertSummonGap 专家召唤链的间隔（真实使用节奏，v11 实测 8s 成功率 100%）。
+const expertSummonGap = 6 * time.Second
+
+// runExpertUse 完成 expert_5（使用 5 个平台专家）。
+// 2026-09-12 三账号实测公式：真实专家列表（id 必须真实存在）→ 召唤链
+// （summon_click/summoned）→ 真实 chat 拿服务端 requestId → expert_actual_use。
+// 自造专家 id 或自造 requestId 均不计数。
+func runExpertUse(p *Panel, a *auth.Auth) (string, error) {
+	return runExpertBatch(p, a, "agent", 5)
+}
+
+// runExpertTeamUse 完成 Expert_team_use_3（使用 3 个专家团，expertType=team）。
+func runExpertTeamUse(p *Panel, a *auth.Auth) (string, error) {
+	return runExpertBatch(p, a, "team", 3)
+}
+
+// runExpertBatch 专家召唤+使用的公共实现。失败逐个继续，返回汇总信息。
+func runExpertBatch(p *Panel, a *auth.Auth, expertType string, count int) (string, error) {
+	experts, err := p.cfg.Upstream.MarketExpertList(a, expertType)
+	if err != nil {
+		return "", fmt.Errorf("拉取专家列表: %w", err)
+	}
+	if len(experts) == 0 {
+		return "", fmt.Errorf("专家市场列表为空")
+	}
+	ok, fail := 0, 0
+	for i, e := range experts {
+		if ok >= count {
+			break
+		}
+		// 召唤链（web_element_click + summon_click + summoned）。
+		summonEvents := upstream.DesktopExpertSummonSequence(e)
+		if err := p.cfg.Upstream.ReportDesktopEvent(a, summonEvents...); err != nil {
+			fail++
+			continue
+		}
+		// 真实 chat（带 X-Expert-Id）→ 服务端 requestId。
+		conv, req, cerr := p.cfg.Upstream.DesktopChatWithExpert(a, e.ExpertID)
+		if cerr != nil {
+			fail++
+			continue
+		}
+		// 使用事件（JOIN 服务端 requestId）+ chat 链。
+		events := append(upstream.DesktopChatSequence(conv, req, "msg-"+req[len(req)-8:], "fast-model", "fast-model"),
+			upstream.DesktopExpertActualUseEvent(e, conv, req))
+		if err := p.cfg.Upstream.ReportDesktopEvent(a, events...); err != nil {
+			fail++
+			continue
+		}
+		ok++
+		if i < len(experts)-1 {
+			time.Sleep(expertSummonGap)
+		}
+	}
+	_ = fail
+	return fmt.Sprintf("已对 %d 位真实专家完成召唤+使用链（类型 %s）", ok, expertType), nil
+}
+
+// ---------------------------------------------------------------------------
+// 全量自动完成
+// ---------------------------------------------------------------------------
+
+// runAutoAll 对单账号依次执行所有可自动化任务，返回逐项结果。
+// 供「一键完成全部可自动任务」使用；单项失败不影响后续项。
+//
+// 流程：先把所有未接受的任务批量 accept（规范状态机；上游脚本建议"先 accept"），
+// 再逐项执行行为链路。accept 不是进度产生的必要条件，但让后续状态流转规范。
+func (p *Panel) runAutoAll(a *auth.Auth) []map[string]any {
+	var out []map[string]any
+
+	// 阶段 0：批量接受尚未接受的任务（失败不阻塞——行为事件才是进度唯一判据）。
+	if tasks, err := p.cfg.Upstream.ListTasks(a); err == nil {
+		var codes []string
+		for _, t := range tasks {
+			if !t.Claimed && !t.Locked && t.AcceptStatus != "accepted" && t.AcceptStatus != "completed" {
+				codes = append(codes, t.TaskCode)
+			}
+		}
+		if len(codes) > 0 {
+			if err := p.cfg.Upstream.AcceptTasks(a, codes); err != nil {
+				out = append(out, map[string]any{
+					"task_code": "(批量接受)", "status": "error",
+					"message": "接受任务失败（不阻塞后续）: " + err.Error(),
+				})
+			} else {
+				out = append(out, map[string]any{
+					"task_code": "(批量接受)", "status": "done",
+					"message": fmt.Sprintf("已接受 %d 个任务", len(codes)),
+				})
+				time.Sleep(reportGap)
+			}
+		}
+	}
+
+	// 阶段 0b：小程序口径任务单独接受（默认列表不含 mp 码；失败不阻塞）。
+	if mpTasks, err := p.cfg.Upstream.ListTasksMP(a); err == nil {
+		var mpCodes []string
+		for _, t := range mpTasks {
+			if !t.Claimed && !t.Locked && t.AcceptStatus != "accepted" && t.AcceptStatus != "completed" {
+				mpCodes = append(mpCodes, t.TaskCode)
+			}
+		}
+		if len(mpCodes) > 0 {
+			if err := p.cfg.Upstream.AcceptTasksMP(a, mpCodes); err != nil {
+				out = append(out, map[string]any{
+					"task_code": "(批量接受-mp)", "status": "error",
+					"message": "接受小程序任务失败（不阻塞后续）: " + err.Error(),
+				})
+			} else {
+				out = append(out, map[string]any{
+					"task_code": "(批量接受-mp)", "status": "done",
+					"message": fmt.Sprintf("已接受 %d 个小程序任务", len(mpCodes)),
+				})
+				time.Sleep(reportGap)
+			}
+		}
+	}
+
+	for _, act := range autoActions {
+		item := map[string]any{"task_code": act.TaskCode, "desc": act.Desc}
+		before, err := p.taskByCode(a, act.TaskCode)
+		if err != nil {
+			item["status"] = "error"
+			item["message"] = "查询失败: " + err.Error()
+			out = append(out, item)
+			continue
+		}
+		if before == nil {
+			item["status"] = "skipped"
+			item["message"] = "该账号无此任务"
+			out = append(out, item)
+			continue
+		}
+		if before.Claimed || before.Current >= before.Target && before.Target > 0 {
+			item["status"] = "skipped"
+			item["message"] = "已完成（" + taskProgressText(before) + "）"
+			out = append(out, item)
+			continue
+		}
+		msg, err := act.run(p, a)
+		if err != nil {
+			item["status"] = "error"
+			item["message"] = err.Error()
+			out = append(out, item)
+			continue
+		}
+		var after *upstream.Task
+		if isMPTaskCode(act.TaskCode) {
+			after, _ = p.taskByCodeMP(a, act.TaskCode)
+		} else {
+			after, _ = p.taskByCodeWaiting(a, act.TaskCode)
+		}
+		item["status"] = "done"
+		item["message"] = msg
+		item["progress_after"] = taskProgressText(after)
+		// 进度达标即自动领奖（mp 任务走 chat 域 mp 口径，其余 Web 端接口）。
+		// 领奖失败不掩盖主流程结果：status 仍为 done，附加 claim_error 供前端提示。
+		if after != nil && after.Claimable {
+			item["claimable"] = true
+			var credit, energy int64
+			var cerr error
+			if isMPTaskCode(act.TaskCode) {
+				credit, energy, cerr = p.cfg.Upstream.ClaimRewardMP(a, act.TaskCode)
+			} else {
+				credit, energy, cerr = p.cfg.Upstream.ClaimReward(a, act.TaskCode)
+			}
+			if cerr == nil {
+				item["claimed"] = true
+				item["credit"] = credit
+				item["energy"] = energy
+				if credit > 0 || energy > 0 {
+					item["message"] = msg + fmt.Sprintf("；已自动领奖 +%d 分 +%d 能", credit, energy)
+				} else {
+					item["message"] = msg + "；奖励此前已领取"
+				}
+			} else {
+				item["claim_error"] = cerr.Error()
+				item["message"] = msg + "；达标但领奖失败（可在列表手动重试）"
+			}
+		}
+		out = append(out, item)
+		time.Sleep(reportGap) // 项间节流
+	}
+	return out
+}
+
+// accountTaskAutoAll 一键完成该账号全部可自动任务。
+func (p *Panel) accountTaskAutoAll(w http.ResponseWriter, r *http.Request) {
+	uid := r.PathValue("uid")
+	a := p.accountByUID(w, uid)
+	if a == nil {
+		return
+	}
+	// per-account 互斥（与单任务动作共用一把锁）：重复点击 409。
+	if !p.tryLockAccount(uid) {
+		writeErr(w, http.StatusConflict, "该账号有任务动作正在执行中，请等本轮结束后再试")
+		return
+	}
+	// 用 context 兜底超时（多项任务串联 + 每项含真实对话，可能耗时较长）。
+	ctx, cancel := context.WithTimeout(r.Context(), 5*time.Minute)
+	defer cancel()
+	done := make(chan []map[string]any, 1)
+	go func() {
+		defer p.unlockAccount(uid) // 流水线真正结束（而非 HTTP 超时返回）才放锁
+		done <- p.runAutoAll(a)
+	}()
+	select {
+	case results := <-done:
+		log.Printf("panel: 一键完成可自动任务 uid=%s 共 %d 项", uid, len(results))
+		writeJSON(w, http.StatusOK, map[string]any{"ok": true, "results": results})
+	case <-ctx.Done():
+		// HTTP 侧超时返回，但后台流水线仍在跑——锁在流水线 goroutine 内释放，
+		// 期间重复点击会被 409 挡住，不会出现两轮并发。
+		writeErr(w, http.StatusGatewayTimeout, "执行超时（任务仍在后台继续）")
+	}
+}

internal/panel/autotask_lock_test.go

@@ -0,0 +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")
+}

internal/panel/config.go

@@ -0,0 +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,
+	})
+}