mslxdff 0.1.172 → 0.1.174

package/docs/cli_help_mini.md

@@ -59,7 +59,7 @@
 | DeepSeek 登录 | `-provider deepseek login --token <userToken>` 或 `login <email\|mobile> <password>` | DeepSeek 官网免费对话接入（ADR-0014）：userToken 在 chat.deepseek.com F12→Local Storage；无参数打印图文引导；落盘后 `allowAny on` + `-restart`；模型 `deepseek/{chat,reasoner,chat-search,reasoner-search}`；单账号 1 路并发，多号轮换 |
 | DeepSeek 探活 | `-provider deepseek health [--json]` | 逐账号体检（防禁言）：检测禁言（自动冷却 5min）/限频前兆/凭据坏；网络失败不误伤；禁言解封后再探自动恢复 |
 | 供应商改址 | `-provider <id> set-url <baseUrl>` | 改通用供应商地址 |
-| 供应商改模型路径 | `-provider <id> set-models-path <path>` | 改 `models` 路径（如 `/v1/models`、`/console/enterprises/personal/models`） |
+| 供应商改模型路径 | `-provider <id> set-models-path <path>` | 改 `models` 路径（如 `/v1/models`、`/v3/config`） |
 | 供应商改对话路径 | `-provider <id> set-chat-path <path>` | 改 `chat` 路径（如 `/v1/chat/completions`、`/v2/chat/completions`） |
 | 供应商清空 | `-provider <id> clear` | 清空该供应商 keys |
 | 供应商共享 | key 随转发自动借出（ADR-0019，无开关无白名单） | 借道时自动附带；opencode/workbuddy/cline/codearts/traework 硬排除 |
@@ -75,7 +75,7 @@
 | 千问办公接入 | `-provider qwenwork login` | 千问办公设备授权（PKCE+poll，`gateway.qwenwork.cn`）：打印兑换链接→浏览器确认→落盘 `auths/qwenwork-<uid>.json`+state；**默认 `allowAnyModels=false` + 只种 `flash/pro/qwen3.8-max-preview`**（额度是账号积分池，防 auto 烧分）；登录尾部显示套餐名+积分剩余；`qwenwork/<modelId>` 前缀路由，恒 local-only 不借出 |
 | zcode 接入 | `-provider zcode login [--bigmodel]` | ZCode（智谱官方编程工作台）免费额度授权：打印 chat.z.ai 授权链接→浏览器登录→CLI 轮询（`oauth/cli/init`→`poll`）拿 JWT，落盘 `auths/zcode-<uid>.json`+state 并把内置目录（`GLM-5.3`/`GLM-5.3-Flash`/`GLM-5.2`/`GLM-5-Turbo`）并入 allowlist；`zcode/<modelId>` 前缀路由（Anthropic 网关，恒上游 stream，**免验证码**）；`--bigmodel` 切 bigmodel.cn；恒 local-only 不借出 |
 | zcode 额度 | `-provider zcode quota [--json]` | 查 ZCode 套餐名/状态/有效期 + 各模型余量（`billing/balance` 分组表格）；空套餐给领取指引、401 给重登指引 |
-| raccoon 接入 | `-provider raccoon login` | Raccoon（商汤小浣熊）扫码登录：生成 `qrcode_code`→终端二维码 + `login/mp?code=` 链接→**用微信「扫一扫」扫**并确认（浏览器直接打开链接会 404，SPA 无该路由）→轮询拿 token，落盘 `auths/raccoon-<uid>.json`+state（`keys` 一律以文档为准，续期后自愈）并把兜底 6 模型并入 allowlist；`raccoon/<modelId>` 前缀路由（**OpenAI 兼容网关**，**免验证码**）；多号自动轮换：请求内撞积分不足/限流就当场换下一个号，**暂不支持手动指定用哪个号**；积分不足长冷 1h、限流短冷 30s；恒 local-only 不借出 |
+| raccoon 接入 | `-provider raccoon login` | Raccoon（商汤小浣熊）扫码登录：生成 `qrcode_code`→终端二维码 + `login/mp?code=` 链接→**用微信「扫一扫」扫**并确认（浏览器直接打开链接会 404，站点 SPA 无该路由）→轮询拿 token，落盘 `auths/raccoon-<uid>.json`+state（`keys` 一律以文档为准，续期后自愈）并把兜底 6 模型并入 allowlist；`raccoon/<modelId>` 前缀路由（**OpenAI 兼容网关**，**免验证码**）；多号自动轮换：请求内撞积分不足/限流就当场换下一个号，**暂不支持手动指定用哪个号**；积分不足长冷 1h、限流短冷 30s；恒 local-only 不借出 |
 | raccoon 积分 | `-provider raccoon quota [--json]` / `checkin` | 逐号查积分五分项 / 领「桌面端登录奖励」——**这家没有每日签到**：每日 300 与注册礼包 3000 由服务端自动发（无端点，每日 300 当天 23:59:59 清零），唯一要领的登录奖励 3000 是**每号一次性**且 `login` 时已自动领掉，`checkin` 只是补领兜底；判据只认账单、不认上游 `code:0`（重复领会虚回成功）；未登录给 login 指引；daemon 每日 09:00 兜底扫描未领过的号（`MSLXDFF_RACCOON_CHECKIN=0` 关，`_CHECKIN_HOUR` 改点） |
 | WorkBuddy 成长任务 | `-workbuddy growth [--json]` / `-wb growth` | 成长任务全自动（拉列表→参与→触发→领奖，串行 1.2s/1s，已领幂等跳过）；可自动 `chat_5`/`automation_1`/`skill_1`/`Model_chat_GLM5.2`，需客户端任务标 MANUAL 不发包；daemon 每日 09:30 自动（`MSLXDFF_WORKBUDDY_GROWTH=0` 关，`_GROWTH_HOUR`/`_GROWTH_MODEL` 可配） |
 | WorkBuddy 猫猫旅行 | `-workbuddy travel [--json]` / `-wb travel` | 无猫自动同意协议+领养（+300，门槛未达自动补一次对话解锁）；到站领奖 / 空闲派出（location 4）/ 旅行中跳过 |
@@ -95,7 +95,7 @@
 | 同步 opencode | `-setto opencode [modelId\|--all]` | 把本地网关注册为 opencode 供应商（`provider.mslxdff`，`http://127.0.0.1:<port>/v1`，直写裸名如 `deepseek-v4-flash-free`，`/`→`-` 如 `bai/deepseek`→`bai-deepseek` 到 8989 自动还原，`--all` 批量同步全部 picks；picks 非空时摘除失效模型；自动附模型能力：models.dev 目录 + workbuddy 走上游原生字段，opencode 原生识别；写 variants 档位供 ctrl+t 切换（effort 型按档位写，toggle 型不写，TUI 改配置后需重启）） |
 | 同步 chatgpt | `-setto chatgpt [modelId]` | 写 Codex 三端共用 `~/.codex/config.toml`（`model_providers.mslxdff` → `127.0.0.1/v1/responses`，鉴权走 `mslxdff -showtoken` 不落盘），换模型重跑 setto 或 `codex exec -m <id>` 单次覆盖，`codex exec "hi"` 验证；排障 `MSLXDFF_RESPONSES_DEBUG=1` 看 daemon.log `[responses]` |
 | 同步 Claude Code | `-setto claude [modelId] [--behaves-as <id>]` | 写 Claude Code 用户设置 `~/.claude/settings.json`（`CLAUDE_CONFIG_DIR` 可改址）：`env.ANTHROPIC_BASE_URL=http://127.0.0.1:<port>`（**不带 /v1**）+ 明文 `ANTHROPIC_AUTH_TOKEN` + `CLAUDE_CODE_ATTRIBUTION_HEADER=0`/`CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS=1`/`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1` + `model` + `modelPicker.options`；**不带 modelId = 写入 `modelPicks` 勾选集全集**（顶层 `model` 也只在勾选集内取，picks 空则报错退出，不兜底到可能已失效的 `preferredModel`；`--all` 与之同义）；`behavesAs` 只给客户端不认识的 id（缺省 `claude-sonnet-5`，`claude-*` 行不写；实测无映射的未知 id 会被本机 Claude Code 直接拒跑）（ADR-0047 `/v1/messages` 外壳）；只动这些键、其余键与键序保留，首写前一次性备份 `settings.pre-mslxdff.json`（不覆盖），JSON 解析失败拒写、写不进即报错不谎报；排障 `MSLXDFF_ANTHROPIC_DEBUG=1` 看 daemon.log `[messages]` |
-| 接 Claude Desktop（3P） | `-setto claude-desktop [modelId ...] [--max N] [--max-effort <lvl>] [--no-alias] [--check] [--official]`、`-claude-desktop status\\|slots\\|check` | 桌面端**不读** `ANTHROPIC_BASE_URL`/`settings.json`，只读自家 3P profile 且只认「三档角色 ID」→ 一次写两处：① `%LOCALAPPDATA%\Claude-3p\configLibrary\<uuid>.json` + `_meta.json`（uuid 由端口派生、只 upsert 自家条目、他人 entry 不动、损坏拒写、幂等按**原文 vs 原文**、明文 token `0600`、baseUrl **不带 /v1**、`authScheme=bearer`（本仓 `authorized()` 只认 Bearer）、`inferenceModels[{name:角色槽,labelOverride:真模型名}]`）② `model-aliases.json` 写「角色槽 → 真模型」（入站 `src/chat-pipeline/policy.js` 生效、`getModelAlias` 未命中即重读 → **不重启 daemon**）；槽位上限 12（取 App 签名 `model-catalog`，前三档 sonnet/opus/haiku，Haiku 供子 agent），缺 alias 时 App 探活 30–90 s 后 502；`--official` 摘登记不删配置；不写 `preferredModel`、不碰 `claude_desktop_config.json` 与注册表策略；⚠ **App 不热重载**，写完须完全退出重开并选 3P 入口（免 claude.ai 登录）（ADR-0048） |
+| 接 Claude Desktop（3P） | `-setto claude-desktop [modelId ...] [--max N] [--max-effort <lvl>] [--1m <off|auto|all|列表>] [--no-alias] [--check] [--official]`、`-claude-desktop status\\|slots\\|check` | 桌面端**不读** `ANTHROPIC_BASE_URL`/`settings.json`，只读自家 3P profile 且只认「三档角色 ID」→ 一次写两处：① `%LOCALAPPDATA%\Claude-3p\configLibrary\<uuid>.json` + `_meta.json`（uuid 由端口派生、只 upsert 自家条目、他人 entry 不动、损坏拒写、幂等按**原文 vs 原文**、明文 token `0600`、baseUrl **不带 /v1**、`authScheme=bearer`（本仓 `authorized()` 只认 Bearer）、`inferenceModels[{name:角色槽,labelOverride:真模型名}]`）② `model-aliases.json` 写「角色槽 → 真模型」（入站 `src/chat-pipeline/policy.js` 生效、`getModelAlias` 未命中即重读 → **不重启 daemon**）；槽位上限 12（取 App 签名 `model-catalog`，前三档 sonnet/opus/haiku，Haiku 供子 agent），缺 alias 时 App 探活 30–90 s 后 502；`--1m` 打标（ADR-0056，缺省 auto：证据=本机 `/v1/models` 已裁决窗口 ≥1M → 打官方成对键 `supports1m+prefer1m`＝菜单单条默认 1M，不打标被 App 按 200K 封顶；网关不可达 ℹ 降级不阻塞写盘；`off`=历史三键、`all`=担保全打、列表=只打命中行）；`--official` 摘登记不删配置；不写 `preferredModel`、不碰 `claude_desktop_config.json` 与注册表策略；⚠ **App 不热重载**，写完须完全退出重开并选 3P 入口（免 claude.ai 登录）（ADR-0048） |
 | 建组 | `-creategroup <name>` / `-group create <name>` | 建组，本机为 leader |
 | 加组 | `-addtogroup <host> <name> [--broadband]` | 加远端组，broadband 走中继（不占端口纯出站）；**零参数/单参数进手机宽带向导**：问组长地址+组名，自动起服务，回报出口 IP |
 | 组同步 | `-group sync` | 刷新全组成员 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.172",
+  "version": "0.1.174",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/anthropic/count-tokens.js

@@ -1,39 +1,54 @@
-// /v1/messages/count_tokens 的字符估算（从 translate.js 拆出，控单文件体积 ≤20KB 硬门）。
+// /v1/messages/count_tokens 的 token 估算（从 translate.js 拆出，控单文件体积 ≤20KB 硬门）。
 // 精度非目标：Anthropic 官方说明该端点缺失时客户端本来就退回字符估算。
+// 权重口径的单一来源在 ../text-tokens.js（ADR-0055）：旧版整段 `chars/4` 把中文低报约 4 倍，而客户端
+// 正是拿这个读数决定何时压实上下文 —— 读数偏低就一路不压实，撞上游「上下文超限」才炸。
 import { toolResultTextOf } from "./translate.js";
+import { estimateTextTokens, createTokenCounter } from "../text-tokens.js";
 
-// 图片不吃字符但占真实上下文，按固定面值计；总长设硬上限防极端请求把除法推到 Infinity
+// 图片不吃字符但占真实上下文，按固定面值计；总长设硬上限防极端请求把估算推到天文数字
 const IMAGE_TOKENS = 2000;
-const CHARS_PER_TOKEN = 4;
 const CHAR_CAP = 32_000_000;
 
+// 请求侧按「一条消息」聚成一段再套一次公式：粒度对齐参照实现 wb_proxy.py:14267-14278
+// （每条消息 content 整段一次 + 每个 tool_call 一次）。逐块各套会把「非空至少 1」下限乘上块数
+// —— 几十个 1 字符 text 块能被高报几十倍（评审 P3：方向虽偏高安全，但与生成侧口径分叉就是第二个真相源）。
+function add(acc, text) {
+  if (acc.chars > CHAR_CAP) return; // 超限后停止累计，只保留已计部分与图片面值
+  const s = text == null ? "" : String(text);
+  const c = createTokenCounter();
+  c.add(s);
+  acc.chars += s.length;
+  acc.tokens += c.tokens();
+}
+
 function countMessage(m, acc) {
   if (!m || typeof m !== "object") return;
   const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : null;
-  if (!blocks) { acc.chars += JSON.stringify(m.content ?? "").length; return; }
+  if (!blocks) { add(acc, JSON.stringify(m.content ?? "")); return; }
+  const c = createTokenCounter();
+  let chars = 0;
+  const put = (s) => { c.add(s); chars += s.length; };
   for (const b of blocks) {
     if (!b || typeof b !== "object") continue;
-    if (typeof b.text === "string") acc.chars += b.text.length;
-    else if (b.type === "tool_use") acc.chars += String(b.name || "").length + JSON.stringify(b.input ?? {}).length;
-    else if (b.type === "tool_result") acc.chars += toolResultTextOf(b.content).length; // 工具结果是大头，必须算（grill Q7）
-    else if (b.type === "thinking") acc.chars += String(b.thinking || "").length;
+    if (typeof b.text === "string") put(b.text);
+    else if (b.type === "tool_use") put(String(b.name || "") + JSON.stringify(b.input ?? {}));
+    else if (b.type === "tool_result") put(toolResultTextOf(b.content)); // 工具结果是大头，必须算
+    else if (b.type === "thinking") put(String(b.thinking || ""));
     else if (b.type === "image") acc.images += 1;
   }
+  if (acc.chars <= CHAR_CAP) acc.chars += chars;
+  acc.tokens += c.tokens();
 }
 
 /** 字符估算版 token 计数（Anthropic 官方：端点缺失时客户端本来就退回字符估算，精度非目标）。 */
 export function estimateTokens(req = {}) {
-  let chars = 0;
-  let images = 0;
-  const acc = { chars: 0, images: 0 };
+  const acc = { chars: 0, tokens: 0, images: 0 };
   const sys = typeof req.system === "string" ? [{ type: "text", text: req.system }] : Array.isArray(req.system) ? req.system : [];
-  for (const b of sys) acc.chars += b && typeof b.text === "string" ? b.text.length : 0;
+  for (const b of sys) add(acc, b && typeof b.text === "string" ? b.text : "");
   for (const m of Array.isArray(req.messages) ? req.messages : []) countMessage(m, acc);
-  if (Array.isArray(req.tools)) acc.chars += JSON.stringify(req.tools).length;
-  chars = Math.min(acc.chars, CHAR_CAP);
-  images = acc.images;
+  if (Array.isArray(req.tools)) add(acc, JSON.stringify(req.tools));
   // 字段名以 Anthropic 线上为准：`POST /v1/messages/count_tokens` 回 `{"input_tokens": N}`；
   // 额外带一份 count_tokens 仅作人读兼容（Claude Code 读的是 input_tokens）。
-  const n = Math.max(1, Math.ceil(chars / CHARS_PER_TOKEN) + images * IMAGE_TOKENS);
+  const n = Math.max(1, acc.tokens) + acc.images * IMAGE_TOKENS;
   return { input_tokens: n, count_tokens: n };
 }

package/src/anthropic/request-body.js

@@ -0,0 +1,126 @@
+// 请求侧翻译：Anthropic Messages 请求体 → OpenAI chat 请求体（/v1/messages 外壳，ADR-0047）。
+// 从 translate.js 拆出（ADR-0055）：translate.js 贴 20KB 体积硬门，且「入站请求形状」与
+// 「出站响应/usage 翻译」本就是两向关注点，拆后 translate.js 单向 import 本文件，不回环。
+// 对外接口不变：调用方与测试仍从 anthropic/translate.js import（那边 re-export）。
+//
+// 纪律（别改回去）：
+//  * 思考档位**原样透传**（thinking/effort/reasoning_effort/reasoningEffort/extra_body），语义归一交给
+//    各 provider 与 src/thinking-effort.js —— 旧版在此丢掉，下游被迫补默认值（workbuddy 恒 high，ADR-0053）；
+//  * 但**必须主动丢** output_config 原始对象 / context_management / 消息块内 thinking：Claude Code 对
+//    不认识的 model ID 照发全套字段，块内 thinking 无法签发 signature，回传必被上游拒（ADR-0047）。
+import { isServerTool } from "./web-search.js";
+import { newToolUseId } from "./shared.js";
+
+// system 允许字符串或 text 块数组；块间空行连接（缓存语义不保留，上游是 OpenAI）
+function systemTextOf(system) {
+  if (typeof system === "string") return system;
+  if (!Array.isArray(system)) return "";
+  return system.map((b) => (b && typeof b.text === "string" ? b.text : "")).filter(Boolean).join("\n\n");
+}
+
+function imagePartOf(block) {
+  const src = block?.source || {};
+  if (src.type === "base64" && src.data) {
+    return { type: "image_url", image_url: { url: `data:${src.media_type || "image/png"};base64,${src.data}` } };
+  }
+  if (src.type === "url" && src.url) return { type: "image_url", image_url: { url: String(src.url) } };
+  return null;
+}
+
+export function toolResultTextOf(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
+      .filter(Boolean)
+      .join("\n");
+  }
+  return content == null ? "" : String(content);
+}
+
+/** Anthropic Messages 请求体 → OpenAI chat 请求体（直接喂既有 ChatPipeline）。 */
+export function messagesToChatBody(req = {}) {
+  const model = String(req.model || "").trim();
+  if (!model) throw new Error("messages: 缺少 model");
+  const messages = [];
+  const sys = systemTextOf(req.system);
+  if (sys) messages.push({ role: "system", content: sys });
+
+  // 重复 tool_use_id 保首个、丢后续：客户端重试/重放历史会把同一工具结果存两份，
+  // 部分上游按 call_id 查重直接 400（同 responses/translate.js:57-59 的实测教训）。
+  const seenToolResult = new Set();
+
+  for (const m of Array.isArray(req.messages) ? req.messages : []) {
+    if (!m || typeof m !== "object") continue;
+    // role=system/developer 必须保留：Claude Code ≥2.1.286 的 mid-conversation system beta 就往 messages[] 里塞系统指令，
+    const role = m.role === "assistant" ? "assistant" : m.role === "system" || m.role === "developer" ? "system" : "user";
+    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : [];
+    let text = "";
+    const imgs = [];
+    const toolCalls = [];
+    for (const b of blocks) {
+      if (!b || typeof b !== "object") continue;
+      if (b.type === "text") text += typeof b.text === "string" ? b.text : "";
+      else if (b.type === "image") { const p = imagePartOf(b); if (p) imgs.push(p); }
+      else if (b.type === "tool_use") {
+        let args = "{}";
+        try { args = JSON.stringify(b.input ?? {}); } catch { args = "{}"; }
+        toolCalls.push({ id: String(b.id || newToolUseId()), type: "function", function: { name: String(b.name || ""), arguments: args } });
+      } else if (b.type === "tool_result") {
+        // tool 消息必须先于同轮 user 文本进数组：OpenAI 侧要求 role:tool 紧跟其 assistant
+        const key = String(b.tool_use_id || "");
+        if (key) { if (seenToolResult.has(key)) continue; seenToolResult.add(key); }
+        const body = toolResultTextOf(b.content);
+        messages.push({ role: "tool", tool_call_id: key, content: b.is_error ? `[tool_error] ${body}` : body });
+      }
+      // thinking / redacted_thinking 忽略：我们无法签发 signature，回传必被上游拒（ADR-0047）
+    }
+    if (!text && !imgs.length && !toolCalls.length) continue;
+    const msg = { role, content: imgs.length ? [...(text ? [{ type: "text", text }] : []), ...imgs] : text };
+    if (toolCalls.length) msg.tool_calls = toolCalls;
+    messages.push(msg);
+  }
+  // 空会话直接 400：绝不伪造一句 "hi" 打上游（那会把假提问写进用户上下文并白烧一发额度）
+  if (!messages.some((x) => x.role !== "system")) throw new Error("messages: 缺少用户消息");
+
+  const body = { model, messages, stream: Boolean(req.stream) };
+  // 流式必须让上游把 usage 放进收尾帧，否则 message_delta.usage 恒 0（OpenAI 规范字段）。
+  // 个别上游不认 stream_options 会 400 → `MSLXDFF_ANTHROPIC_STREAM_USAGE=0` 关掉。
+  if (body.stream && process.env.MSLXDFF_ANTHROPIC_STREAM_USAGE !== "0") body.stream_options = { include_usage: true };
+  // Anthropic 的 server tool（web_search_*/web_fetch_*/…）没有 input_schema，折成假 function 会
+  // 让上游收到「空参数空描述」的工具（严格端点直接 422），本网关不实现的发前一律剥除（ADR-0049）。
+  const fnTools = (Array.isArray(req.tools) ? req.tools : []).filter((t) => !isServerTool(t));
+  if (fnTools.length) {
+    body.tools = fnTools.map((t) => ({
+      type: "function",
+      function: { name: String(t?.name || ""), description: String(t?.description || ""), parameters: t?.input_schema || {} },
+    }));
+  }
+  const keptNames = new Set(fnTools.map((t) => String(t?.name || "")));
+  const tc = req.tool_choice;
+  if (tc === "auto" || (tc && typeof tc === "object" && tc.type === "auto")) body.tool_choice = "auto";
+  else if (tc && typeof tc === "object" && tc.type === "any") body.tool_choice = "required";
+  // 点名一个已被剥掉的工具时降为 auto：上游会按不存在的函数强制点名，那样一定拿不到有用回答
+  else if (tc && typeof tc === "object" && tc.type === "tool") body.tool_choice = keptNames.has(String(tc.name || "")) ? { type: "function", function: { name: String(tc.name || "") } } : "auto";
+  else if (tc && typeof tc === "object" && tc.type === "none") body.tool_choice = "none";
+  if (req.max_tokens != null && Number.isFinite(Number(req.max_tokens))) body.max_tokens = Number(req.max_tokens);
+  if (req.temperature != null) body.temperature = req.temperature;
+  if (req.top_p != null) body.top_p = req.top_p;
+  if (Array.isArray(req.stop_sequences) && req.stop_sequences.length) body.stop = req.stop_sequences;
+  // 思考档位原样透传（不解释语义，语义归一交给各 provider / src/thinking-effort.js）：
+  // 客户端显式声明必须一路带到上游，旧版在此丢掉 → 下游被迫补默认值（workbuddy 恒 high）。
+  if (req.thinking != null) body.thinking = req.thinking;
+  // 档位载体只收「非空 trimmed 字符串」：空串声明不算声明，不该发出去顶掉下游默认值。
+  for (const k of ["effort", "reasoning_effort", "reasoningEffort"]) {
+    const v = typeof req[k] === "string" ? req[k].trim() : "";
+    if (v) body[k] = v;
+  }
+  if (req.extra_body != null) body.extra_body = req.extra_body;
+  // output_config.effort 是 Claude Code 的另一档位载体（beta），原始对象上游不认故不外发，
+  // 但档位本身不能丢 → 归一到 reasoning_effort（客户端已显式声明时以声明为准）。
+  const ocEffort = req.output_config && typeof req.output_config === "object" ? req.output_config.effort : undefined;
+  if (ocEffort != null && body.reasoning_effort == null && body.reasoningEffort == null) {
+    body.reasoning_effort = ocEffort;
+  }
+  return body;
+}

package/src/anthropic/shared.js

@@ -0,0 +1,18 @@
+// /v1/messages 外壳的公共原语：消息/工具 id 与 Anthropic 协议错误体。
+// ADR-0055 把请求侧拆去 request-body.js 时独立成档，让 request-body.js 与 translate.js 单向依赖它，
+// 避免两文件互相 import 成环（函数提升虽能跑，顶层常量会 TDZ，属定时炸弹）。
+// 共用面：src/anthropic/request-body.js（newToolUseId）、src/anthropic/translate.js（newMessageId/
+// newToolUseId，并对外 re-export 三个符号，调用方与测试的 import 路径不变）。
+
+let seq = 0;
+export function newMessageId() {
+  return `msg_${Date.now().toString(36)}${(seq++).toString(36)}`;
+}
+export function newToolUseId() {
+  return `toolu_${Date.now().toString(36)}${(seq++).toString(36)}`;
+}
+
+/** Anthropic 协议错误体形状（非流式 JSON 与流式 in-band error 帧共用）。 */
+export function anthropicError(type, message) {
+  return { type: "error", error: { type: String(type || "api_error"), message: String(message || "error").slice(0, 500) } };
+}

package/src/anthropic/sse-aggregate.js

@@ -0,0 +1,56 @@
+// 上游只会流式、客户端要非流式时的 SSE 聚合（ADR-0055）。
+// 从 `src/routes/messages-route.js` 抽出：该文件贴着 20KB 体积硬门（20306/20480），本单要加的
+// usage 兜底接线必须先进一段，故沿用 ADR-0053 把 count_tokens 估算器拆成独立文件的同类先例。
+// 共用面：唯一调用方 `src/routes/messages-route.js`（体积门驱动的等价搬移，非新抽象）。
+//
+// 逐行吃 `data:` 帧聚成 chat.completion JSON（与 qoder/aggregate.js、zcode 非流式聚合同构），
+// 出口复用 `chatJsonToAnthropic`；一帧都没有或夹带 in-band 错误帧时返回 null，落回原有 502 + errorText
+// 路径 —— 错误绝不聚合成正文。
+
+/**
+ * @param text collector 收到的原始响应体（SSE 帧序列）
+ * @param model 回显给客户端的模型名
+ * @returns chat.completion 形状对象，或 null（无有效帧 / 夹带错误帧）
+ */
+export function sseToChatJson(text, model) {
+  let content = "";
+  let finish = "";
+  let usage = null;
+  let sawChunk = false;
+  const toolSlots = new Map();
+  for (const raw of String(text || "").split("\n")) {
+    const line = raw.trim();
+    if (!line.startsWith("data:")) continue; // 注释帧/keepalive/事件名行全跳过
+    const payload = line.slice(5).trim();
+    if (!payload || payload === "[DONE]") continue;
+    let chunk;
+    try { chunk = JSON.parse(payload); } catch { continue; }
+    if (chunk?.error) return null;
+    sawChunk = true;
+    const choice = chunk.choices?.[0] || {};
+    const delta = choice.delta || {};
+    if (choice.finish_reason) finish = choice.finish_reason;
+    if (chunk.usage) usage = chunk.usage;
+    if (typeof delta.content === "string" && delta.content) content += delta.content;
+    for (const tc of delta.tool_calls || []) {
+      const slot = Number(tc?.index ?? 0);
+      let t = toolSlots.get(slot);
+      if (!t) { t = { id: "", name: "", args: "" }; toolSlots.set(slot, t); }
+      if (tc?.id) t.id = String(tc.id);
+      if (tc?.function?.name) t.name += String(tc.function.name);
+      if (tc?.function?.arguments) t.args += String(tc.function.arguments);
+    }
+  }
+  if (!sawChunk) return null;
+  const toolCalls = [...toolSlots.values()].map((t, i) => ({ id: t.id || `call_${i}`, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
+  const message = { role: "assistant", content: content || (toolCalls.length ? null : "") };
+  if (toolCalls.length) message.tool_calls = toolCalls;
+  const out = {
+    id: "", object: "chat.completion", created: Math.floor(Date.now() / 1000), model,
+    choices: [{ index: 0, message, finish_reason: finish || (toolCalls.length ? "tool_calls" : "stop") }],
+  };
+  // 上游真报过 usage 才带这个字段：旧版合成 `{prompt_tokens:0,…}` 会把「未报」伪装成「报了 0」，
+  // 让翻译层的兜底判据永远看不到真实形状（ADR-0055 决策 3）。
+  if (usage) out.usage = usage;
+  return out;
+}

package/src/anthropic/translate.js

@@ -1,148 +1,26 @@
 /**
- * Anthropic Messages ⇄ OpenAI chat 翻译层（/v1/messages 外壳，ADR-0047）。
+ * Anthropic Messages 出站翻译层：chat → Anthropic message / SSE 具名事件（/v1/messages 外壳，ADR-0047）。
  * 纯函数，无网络、无副作用；出站形状依据 code.claude.com/docs/en/llm-gateway-protocol
  * 与参考实现 lamdt1/ms-copilot365-2api/app/formatters/anthropic_sse.py。
+ * 分档（ADR-0055，为守本文件 ≤20KB 体积硬门；对外 import 路径全走本文件、调用方零改动）：
+ *  · 请求侧 Anthropic → chat 在 ./request-body.js；
+ *  · 消息/工具 id 与协议错误体在 ./shared.js；
+ *  · token 估算的单一来源在 ../text-tokens.js（上游未报 usage 时由它兜底）。
  *
  * 与 src/responses/translate.js 的三点关键差异：
  *  1) Anthropic 的 content block **只封口不复用**（Responses 侧 ensureTextItem 会复用已开项）；
  *  2) 事件是具名的（`event: <type>` + `data:`），且**没有 `data: [DONE]`**，收场只有
  *     `message_delta`+`message_stop`（成功）或一帧 `error`（失败）——见 grill-decisions.md Q2；
- *  3) 请求侧**保留思考档位**（thinking/effort/reasoning_effort/reasoningEffort/extra_body 原样透传给
- *     pipeline，语义归一交给各 provider 与 src/thinking-effort.js），但**必须主动丢** output_config/
- *     context_management 与消息块内的 thinking：Claude Code 对不认识的 model ID 照发全套字段，而块内
- *     thinking 我们无法签发 signature，回传必被上游拒（ADR-0047）。
+ *  3) 请求侧**保留思考档位**、**必须主动丢** output_config/context_management 与消息块内 thinking
+ *     （块内 thinking 我们无法签发 signature，回传必被上游拒）——细则见 ./request-body.js 头（ADR-0047）。
  */
 import { chunkToString } from "../responses/translate.js";
-import { isServerTool } from "./web-search.js";
+import { createTokenCounter } from "../text-tokens.js";
+import { newMessageId, newToolUseId } from "./shared.js";
 
-let seq = 0;
-export function newMessageId() {
-  return `msg_${Date.now().toString(36)}${(seq++).toString(36)}`;
-}
-export function newToolUseId() {
-  return `toolu_${Date.now().toString(36)}${(seq++).toString(36)}`;
-}
-
-/** Anthropic 协议错误体形状（非流式 JSON 与流式 in-band error 帧共用）。 */
-export function anthropicError(type, message) {
-  return { type: "error", error: { type: String(type || "api_error"), message: String(message || "error").slice(0, 500) } };
-}
-
-// ---------- 请求：Anthropic → chat ----------
-
-// system 允许字符串或 text 块数组；块间空行连接（缓存语义不保留，上游是 OpenAI）
-function systemTextOf(system) {
-  if (typeof system === "string") return system;
-  if (!Array.isArray(system)) return "";
-  return system.map((b) => (b && typeof b.text === "string" ? b.text : "")).filter(Boolean).join("\n\n");
-}
-
-function imagePartOf(block) {
-  const src = block?.source || {};
-  if (src.type === "base64" && src.data) {
-    return { type: "image_url", image_url: { url: `data:${src.media_type || "image/png"};base64,${src.data}` } };
-  }
-  if (src.type === "url" && src.url) return { type: "image_url", image_url: { url: String(src.url) } };
-  return null;
-}
-
-export function toolResultTextOf(content) {
-  if (typeof content === "string") return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((p) => (typeof p === "string" ? p : p && typeof p.text === "string" ? p.text : ""))
-      .filter(Boolean)
-      .join("\n");
-  }
-  return content == null ? "" : String(content);
-}
-
-/** Anthropic Messages 请求体 → OpenAI chat 请求体（直接喂既有 ChatPipeline）。 */
-export function messagesToChatBody(req = {}) {
-  const model = String(req.model || "").trim();
-  if (!model) throw new Error("messages: 缺少 model");
-  const messages = [];
-  const sys = systemTextOf(req.system);
-  if (sys) messages.push({ role: "system", content: sys });
-
-  // 重复 tool_use_id 保首个、丢后续：客户端重试/重放历史会把同一工具结果存两份，
-  // 部分上游按 call_id 查重直接 400（同 responses/translate.js:57-59 的实测教训）。
-  const seenToolResult = new Set();
-
-  for (const m of Array.isArray(req.messages) ? req.messages : []) {
-    if (!m || typeof m !== "object") continue;
-    // role=system/developer 必须保留：Claude Code ≥2.1.286 的 mid-conversation system beta 就往 messages[] 里塞系统指令，
-    const role = m.role === "assistant" ? "assistant" : m.role === "system" || m.role === "developer" ? "system" : "user";
-    const blocks = typeof m.content === "string" ? [{ type: "text", text: m.content }] : Array.isArray(m.content) ? m.content : [];
-    let text = "";
-    const imgs = [];
-    const toolCalls = [];
-    for (const b of blocks) {
-      if (!b || typeof b !== "object") continue;
-      if (b.type === "text") text += typeof b.text === "string" ? b.text : "";
-      else if (b.type === "image") { const p = imagePartOf(b); if (p) imgs.push(p); }
-      else if (b.type === "tool_use") {
-        let args = "{}";
-        try { args = JSON.stringify(b.input ?? {}); } catch { args = "{}"; }
-        toolCalls.push({ id: String(b.id || newToolUseId()), type: "function", function: { name: String(b.name || ""), arguments: args } });
-      } else if (b.type === "tool_result") {
-        // tool 消息必须先于同轮 user 文本进数组：OpenAI 侧要求 role:tool 紧跟其 assistant
-        const key = String(b.tool_use_id || "");
-        if (key) { if (seenToolResult.has(key)) continue; seenToolResult.add(key); }
-        const body = toolResultTextOf(b.content);
-        messages.push({ role: "tool", tool_call_id: key, content: b.is_error ? `[tool_error] ${body}` : body });
-      }
-      // thinking / redacted_thinking 忽略：我们无法签发 signature，回传必被上游拒（ADR-0047）
-    }
-    if (!text && !imgs.length && !toolCalls.length) continue;
-    const msg = { role, content: imgs.length ? [...(text ? [{ type: "text", text }] : []), ...imgs] : text };
-    if (toolCalls.length) msg.tool_calls = toolCalls;
-    messages.push(msg);
-  }
-  // 空会话直接 400：绝不伪造一句 "hi" 打上游（那会把假提问写进用户上下文并白烧一发额度）
-  if (!messages.some((x) => x.role !== "system")) throw new Error("messages: 缺少用户消息");
-
-  const body = { model, messages, stream: Boolean(req.stream) };
-  // 流式必须让上游把 usage 放进收尾帧，否则 message_delta.usage 恒 0（OpenAI 规范字段）。
-  // 个别上游不认 stream_options 会 400 → `MSLXDFF_ANTHROPIC_STREAM_USAGE=0` 关掉。
-  if (body.stream && process.env.MSLXDFF_ANTHROPIC_STREAM_USAGE !== "0") body.stream_options = { include_usage: true };
-  // Anthropic 的 server tool（web_search_*/web_fetch_*/…）没有 input_schema，折成假 function 会
-  // 让上游收到「空参数空描述」的工具（严格端点直接 422），本网关不实现的发前一律剥除（ADR-0049）。
-  const fnTools = (Array.isArray(req.tools) ? req.tools : []).filter((t) => !isServerTool(t));
-  if (fnTools.length) {
-    body.tools = fnTools.map((t) => ({
-      type: "function",
-      function: { name: String(t?.name || ""), description: String(t?.description || ""), parameters: t?.input_schema || {} },
-    }));
-  }
-  const keptNames = new Set(fnTools.map((t) => String(t?.name || "")));
-  const tc = req.tool_choice;
-  if (tc === "auto" || (tc && typeof tc === "object" && tc.type === "auto")) body.tool_choice = "auto";
-  else if (tc && typeof tc === "object" && tc.type === "any") body.tool_choice = "required";
-  // 点名一个已被剥掉的工具时降为 auto：上游会按不存在的函数强制点名，那样一定拿不到有用回答
-  else if (tc && typeof tc === "object" && tc.type === "tool") body.tool_choice = keptNames.has(String(tc.name || "")) ? { type: "function", function: { name: String(tc.name || "") } } : "auto";
-  else if (tc && typeof tc === "object" && tc.type === "none") body.tool_choice = "none";
-  if (req.max_tokens != null && Number.isFinite(Number(req.max_tokens))) body.max_tokens = Number(req.max_tokens);
-  if (req.temperature != null) body.temperature = req.temperature;
-  if (req.top_p != null) body.top_p = req.top_p;
-  if (Array.isArray(req.stop_sequences) && req.stop_sequences.length) body.stop = req.stop_sequences;
-  // 思考档位原样透传（不解释语义，语义归一交给各 provider / src/thinking-effort.js）：
-  // 客户端显式声明必须一路带到上游，旧版在此丢掉 → 下游被迫补默认值（workbuddy 恒 high）。
-  if (req.thinking != null) body.thinking = req.thinking;
-  // 档位载体只收「非空 trimmed 字符串」：空串声明不算声明，不该发出去顶掉下游默认值。
-  for (const k of ["effort", "reasoning_effort", "reasoningEffort"]) {
-    const v = typeof req[k] === "string" ? req[k].trim() : "";
-    if (v) body[k] = v;
-  }
-  if (req.extra_body != null) body.extra_body = req.extra_body;
-  // output_config.effort 是 Claude Code 的另一档位载体（beta），原始对象上游不认故不外发，
-  // 但档位本身不能丢 → 归一到 reasoning_effort（客户端已显式声明时以声明为准）。
-  const ocEffort = req.output_config && typeof req.output_config === "object" ? req.output_config.effort : undefined;
-  if (ocEffort != null && body.reasoning_effort == null && body.reasoningEffort == null) {
-    body.reasoning_effort = ocEffort;
-  }
-  return body;
-}
+// re-export：拆档不改对外接口，调用方与测试仍从本文件取这些符号
+export { messagesToChatBody, toolResultTextOf } from "./request-body.js";
+export { newMessageId, newToolUseId, anthropicError } from "./shared.js";
 
 // ---------- usage / stop_reason ----------
 
@@ -151,20 +29,27 @@ export function messagesToChatBody(req = {}) {
  * Anthropic 的 `input_tokens` **不含**缓存读命中的部分（两者分开计费），而上游
  * `prompt_tokens` 是含缓存的总输入 —— 故命中数要从 input 里扣掉，否则客户端把同一段
  * 前缀算两遍（读数虚高）。
+ * `fallback()` 只在**上游整条未报**（缺字段，或 prompt/output/cache_read/cache_creation 四项全为 0）时才用：
+ * 真实模型对非空 prompt 不可能报 0，照抄 0 会让客户端的上下文计度停在原地、永不压实（ADR-0055 决策 3）。
  */
-export function toAnthropicUsage(u = {}) {
+export function toAnthropicUsage(u = {}, fallback = null) {
   const num = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0);
   const src = u && typeof u === "object" ? u : {};
   const prompt = num(src.prompt_tokens ?? src.input_tokens);
   const output = num(src.completion_tokens ?? src.output_tokens);
   const cacheRead = num(src.cache_read_input_tokens ?? src.prompt_tokens_details?.cached_tokens ?? src.input_tokens_details?.cached_tokens);
   const cacheWrite = num(src.cache_creation_input_tokens ?? src.prompt_tokens_details?.cache_creation_input_tokens);
-  return {
+  const usage = {
     input_tokens: Math.max(0, prompt - cacheRead - cacheWrite),
     output_tokens: output,
     cache_read_input_tokens: cacheRead,
     cache_creation_input_tokens: cacheWrite,
   };
+  // cache 非零也算「报了」：SDK 通道（upstream-engine/sdk/sse.js 的 usageToOpenAI）会输出
+  // `{prompt_tokens:0, …, prompt_tokens_details:{cached_tokens:N}}` 这种形状，若当未报整条覆盖，
+  // 客户端「input + cache_read」会把同一段前缀算两遍（正是上面扣减要防的事，评审 P2）。
+  if (fallback && !(prompt > 0 || output > 0 || cacheRead > 0 || cacheWrite > 0)) return { ...usage, ...(fallback() || {}) };
+  return usage;
 }
 
 function toStopReason(finish, hasToolUse) {
@@ -200,7 +85,7 @@ export function textFromChatContent(c) {
   return t;
 }
 
-export function chatJsonToAnthropic(chatJson = {}, model = "") {
+export function chatJsonToAnthropic(chatJson = {}, model = "", opts = {}) {
   const choice = chatJson.choices?.[0] || {};
   const message = choice.message || {};
   const content = [];
@@ -217,10 +102,21 @@ export function chatJsonToAnthropic(chatJson = {}, model = "") {
     content: content.length ? content : [{ type: "text", text: "" }],
     stop_reason: toStopReason(choice.finish_reason, content.some((b) => b.type === "tool_use")),
     stop_sequence: null,
-    usage: toAnthropicUsage(chatJson.usage),
+    usage: toAnthropicUsage(chatJson.usage, () => fallbackUsage(opts, content)),
   };
 }
 
+// 上游整条未报 usage 时的兜底（ADR-0055 决策 3）：请求侧用注入的 estInput，生成侧按已产出的块估。
+function fallbackUsage(opts = {}, content = []) {
+  const counter = createTokenCounter();
+  for (const b of content) {
+    if (b?.type === "text") counter.add(b.text || "");
+    else if (b?.type === "tool_use") counter.add(JSON.stringify(b.input ?? {})); // 只计参数：与流式 pushTool 同口径（name 从不进 gen）
+  }
+  const n = typeof opts.estInput === "function" ? Number(opts.estInput()) : 0;
+  return { input_tokens: Number.isFinite(n) && n > 0 ? Math.floor(n) : 0, output_tokens: counter.tokens() };
+}
+
 // ---------- 流式响应：chat SSE chunk → Anthropic 具名事件 ----------
 
 // thinking 块必须在 content_block_stop **之前**交一帧 signature_delta，缺它 Claude Code 把整块静默丢弃
@@ -240,6 +136,18 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
   const created = Math.floor(Date.now() / 1000);
   const ev = (type, extra = {}) => ({ type, ...extra });
 
+  // 请求侧 token 估算（ADR-0055 决策 3/5）：路由注入 `opts.estInput()`，memoize —— `message_start` 必须在
+  // 首块前就带 input_tokens，全文只能扫一遍；上游后报实测 usage 时估算只留在首帧，不进 message_delta。
+  let estCached = null;
+  const estInput = () => {
+    if (estCached == null) {
+      const n = typeof opts.estInput === "function" ? Number(opts.estInput()) : 0;
+      estCached = Number.isFinite(n) && n > 0 ? Math.floor(n) : 0;
+    }
+    return estCached;
+  };
+  const gen = createTokenCounter(); // 生成侧累计（text + thinking + tool 参数增量）
+
   let buf = "";
   let nextIndex = 0;
   let open = null; // 当前未封口块：{ index, kind: "text"|"thinking"|"tool_use", text? }
@@ -266,6 +174,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     const out = [];
     if (!open || open.kind !== "text") openBlock("text", { type: "text", text: "" }, out);
     open.text += delta;
+    gen.add(delta); // 生成侧只累计字数、末帧一次套公式：逐帧套会把参照实现的 +1 下限乘上帧数
     out.push(ev("content_block_delta", { index: open.index, delta: { type: "text_delta", text: delta } }));
     return out;
   }
@@ -273,6 +182,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     const out = [];
     if (!open || open.kind !== "thinking") openBlock("thinking", { type: "thinking", thinking: "", signature: "" }, out);
     open.text += delta;
+    gen.add(delta); // thinking 也按 output 计费（ADR-0055 grill Q6）
     out.push(ev("content_block_delta", { index: open.index, delta: { type: "thinking_delta", thinking: delta } }));
     return out;
   }
@@ -293,15 +203,15 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
     if (tc?.id) t.id = String(tc.id);
     if (tc?.function?.name) t.name += String(tc.function.name);
     const frag = tc?.function?.arguments ? String(tc.function.arguments) : "";
-    if (frag) { dbg.toolDeltas++; t.args += frag; }
+    if (frag) { dbg.toolDeltas++; t.args += frag; gen.add(frag); }
     if (!t.announced && t.id && t.name) announceTool(t, out);
     else if (t.announced && frag && open && open.index === t.index) out.push(ev("content_block_delta", { index: t.index, delta: { type: "input_json_delta", partial_json: frag } }));
-    else if (t.announced && frag) dbg.lateToolDeltas++; // 块已封口后才来的参数增量：发出即违规帧，丢弃并留读数
+    else if (t.announced && frag) dbg.lateToolDeltas++; // 块已封口后才来的参数增量：发出即违规帧，丢弃但上面已计入 gen（output_tokens 取计费口径：模型确实生成了这些字节）
     return out;
   }
 
   function begin() {
-    return [ev("message_start", { message: { id, type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } })];
+    return [ev("message_start", { message: { id, type: "message", role: "assistant", model, content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: estInput(), output_tokens: 0, cache_read_input_tokens: 0, cache_creation_input_tokens: 0 } } })];
   }
 
   function push(data) {
@@ -329,6 +239,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
       if (rc) {
         dbg.thinkingChars += rc.length;
         if (emitThinking) out.push(...pushThinking(rc)); // 只发 thinking_delta，无 signature 可发
+        else gen.add(rc); // `MSLXDFF_ANTHROPIC_THINKING=0` 时思考字节仍是真实生成，兜底 output 照计（在此加、不在 pushThinking 内加，避免双计）
       }
     }
     return out;
@@ -341,7 +252,7 @@ export function createAnthropicChunkTranslator(model = "", opts = {}) {
       if (!t.announced && (t.id || t.name || t.args)) announceTool(t, out); // 只有 arguments 无 name 的退化收尾
     }
     closeOpen(out);
-    out.push(ev("message_delta", { delta: { stop_reason: toStopReason(fr, sawToolUse), stop_sequence: null }, usage: toAnthropicUsage(usage || lastUsage) }));
+    out.push(ev("message_delta", { delta: { stop_reason: toStopReason(fr, sawToolUse), stop_sequence: null }, usage: toAnthropicUsage(usage || lastUsage, () => ({ input_tokens: estInput(), output_tokens: gen.tokens() })) }));
     out.push(ev("message_stop"));
     return out;
   }

package/src/chat-pipeline/policy.js

@@ -18,7 +18,15 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
   const rawModel = body.model || "";
 
   let normalizedRequested = normalizeModel(lockModel || rawModel || "");
-  const aliasResolved = getModelAlias(normalizedRequested);
+  // [1m] 后缀回退（Claude Desktop 1M 条目 / Claude Code 1M 记法，ADR-0056）：alias 直查未命中时
+  // 剥去尾部 [1m] 再查一次。仅用于本次查找——不回写、不注册 alias，未命中路径逐字不变（design D2）。
+  // 两个 alias 查找点（首轮 + mslxdff/ 前缀二段）共用同一回退，否则 `mslxdff/<槽位>[1m]` 不等价（评审 1 P1）。
+  const resolveAlias = (id) => {
+    const hit = getModelAlias(id);
+    if (hit) return hit;
+    return /\[1m\]$/i.test(id) ? getModelAlias(id.replace(/\[1m\]$/i, "")) : null;
+  };
+  let aliasResolved = resolveAlias(normalizedRequested);
   if (aliasResolved) {
     normalizedRequested = aliasResolved;
   }
@@ -29,7 +37,7 @@ export function analyzePolicy({ headers = {}, body = {} } = {}) {
     const rawPart = requested.slice("mslxdff/".length);
     aliasInfo = `${requested} -> ${rawPart} (mslxdff provider stripped)`;
     requested = rawPart;
-    const alias2 = getModelAlias(requested);
+    const alias2 = resolveAlias(requested);
     if (alias2) {
       aliasInfo = `${rawModel} -> ${alias2} (mslxdff + alias)`;
       requested = alias2;

package/src/claude-desktop/apply.js

@@ -1,7 +1,8 @@
 import { normalizeModel } from "../reasoning.js";
 import { registerModelAlias, persistModelAliases, loadModelAliases, modelAliasFile } from "../providers/model-id.js";
-import { planSlots, aliasPairs, ROLE_SLOTS } from "./slots.js";
-import { syncToClaudeDesktop, retireClaudeDesktopProfile, claudeDesktopConfigDir } from "../sync-claude-desktop.js";
+import { planSlots, aliasPairs, ROLE_SLOTS, parseOneMMode, decideRows1m } from "./slots.js";
+import { oneMContexts } from "./context1m.js";
+import { syncToClaudeDesktop, retireClaudeDesktopProfile, claudeDesktopConfigDir, readClaudeDesktopProfile } from "../sync-claude-desktop.js";
 import { detectManagedPolicy, currentAliases, probeMessages } from "./doctor.js";
 
 /**
@@ -10,11 +11,37 @@ import { detectManagedPolicy, currentAliases, probeMessages } from "./doctor.js"
  *  ① 写 Claude Desktop 的 3P profile（`inferenceModels` 用**角色槽 id**，`labelOverride` 标真模型名）；
  *  ② 写网关自己的 alias（角色槽 → 真模型），让桌面端发来的槽位请求在入站就被翻译成能跑的真模型。
  * 少了 ②，桌面端每次请求都会被当未知模型丢组员转发 → 30~90 s 后 502（App 里就表现为 Test connection 红点）。
+ *  ③ `--1m` 上下文打标（ADR-0056，Claude Desktop 专用）：auto 问本机 /v1/models 拿已裁决窗口，
+ *    证据缺位时**保留盘上既有标**（无证据≠负面证据）、**绝不阻塞写盘**；all/列表为用户担保；
+ *    打标行经 toInferenceModels 写成对官方键 `supports1m+prefer1m`。evidence 参数是测试接缝。
  */
-export async function applyClaudeDesktop({ picks = [], preferred = "", port = 8989, token = "", max, maxEffort, noAlias = false, dir, probe = false, probeTimeoutMs = 90000 } = {}) {
+export async function applyClaudeDesktop({ picks = [], preferred = "", port = 8989, token = "", max, maxEffort, oneM = "auto", evidence, noAlias = false, dir, probe = false, probeTimeoutMs = 90000 } = {}) {
   const planned = planSlots({ picks, preferred, max });
-  const rows = planned.rows.map((r) => ({ ...r, model: normalizeModel(r.model) || r.model }));
-  const written = syncToClaudeDesktop({ port, token, rows, maxEffort, dir: dir || claudeDesktopConfigDir() });
+  let rows = planned.rows.map((r) => ({ ...r, model: normalizeModel(r.model) || r.model }));
+
+  const oneMMode = oneM && typeof oneM === "object" ? oneM : parseOneMMode(oneM);
+  if (oneMMode.mode === "invalid") throw new Error("--1m 取值非法：只接受 off | auto | all | <逗号分隔槽位/模型id>");
+  const desktopDir = dir || claudeDesktopConfigDir();
+  let ev = evidence;
+  let evidenceQueried = false;
+  if (oneMMode.mode === "auto" && ev === undefined) {
+    evidenceQueried = true;
+    ev = await oneMContexts({ port, token });
+  }
+  // auto 的保留集：证据缺位（整体失败或该行不在目录）时沿用盘上既有 1M 标——网关停机的一轮
+  // 不得把上次写好的标静默抹掉（评审 1 P1-2；读盘失败自然降级为空表=与旧行为一致，不新增失败模式）
+  let preserve = null;
+  if (oneMMode.mode === "auto") {
+    preserve = new Map();
+    const existing = readClaudeDesktopProfile({ dir: desktopDir });
+    for (const m of Array.isArray(existing.profile?.inferenceModels) ? existing.profile.inferenceModels : []) {
+      if (m && typeof m === "object" && m.supports1m === true && m.name) preserve.set(String(m.name).toLowerCase(), true);
+    }
+  }
+  const decided = decideRows1m({ rows, oneM: oneMMode, contexts: ev && ev.ok ? ev.contexts : null, preserve });
+  rows = decided.rows;
+
+  const written = syncToClaudeDesktop({ port, token, rows, maxEffort, dir: desktopDir });
 
   const out = {
     dir: written.dir,
@@ -35,6 +62,16 @@ export async function applyClaudeDesktop({ picks = [], preferred = "", port = 89
     aliasSkipped: noAlias,
     managed: detectManagedPolicy(),
     probes: [],
+    oneM: {
+      mode: oneMMode.mode,
+      list: oneMMode.list || [],
+      evidenceQueried,
+      evidenceOk: oneMMode.mode === "auto" ? Boolean(ev && ev.ok) : null,
+      evidenceReason: oneMMode.mode === "auto" && ev && !ev.ok ? String(ev.reason || "") : "",
+      markedCount: rows.filter((r) => r.supports1m).length,
+      preserved: decided.preserved,
+      unmatched: decided.unmatched,
+    },
   };
 
   if (!noAlias) {

package/src/claude-desktop/context1m.js

@@ -0,0 +1,38 @@
+// -setto claude-desktop 的 1M 证据 Adapter（design D1/D3、ADR-0056）：一次 GET 本机网关 /v1/models。
+// 真相源唯一 = ADR-0054 四级解析后的已裁决值（双层同源同值；顶层 context_length 缺/非正才回落
+// capabilities.context 作保险，CLI 进程不复刻聚合、不另起第二证据链）。
+// 失败一律 {ok:false,reason} 不抛：写盘职责与网关可达性解耦（spec《证据获取失败不阻塞写盘》）。
+import { compatFetch, timeoutSignal } from "../compat.js";
+
+function positiveInt(v) {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null;
+}
+
+/**
+ * @param {{port:number|string, token?:string, fetchImpl?:Function, timeoutMs?:number}} p
+ * @returns {Promise<{ok:true, contexts:Map<string,number>} | {ok:false, reason:string}>}
+ */
+export async function oneMContexts({ port, token = "", fetchImpl = compatFetch, timeoutMs = 3000 } = {}) {
+  const url = `http://127.0.0.1:${Number(port) || 8989}/v1/models`;
+  try {
+    const res = await fetchImpl(url, {
+      headers: { Accept: "application/json", Authorization: `Bearer ${token}` },
+      signal: timeoutSignal(timeoutMs),
+    });
+    if (!res?.ok) return { ok: false, reason: `HTTP ${res?.status ?? "?"}` };
+    const data = await res.json();
+    const list = Array.isArray(data?.data) ? data.data : null;
+    if (!list) return { ok: false, reason: "响应形状异常：缺 data[]" };
+    const contexts = new Map();
+    for (const e of list) {
+      const id = String(e?.id || "").trim().toLowerCase();
+      if (!id) continue;
+      const n = positiveInt(e.context_length) ?? positiveInt(e?.capabilities?.context);
+      if (n) contexts.set(id, n);
+    }
+    return { ok: true, contexts };
+  } catch (err) {
+    return { ok: false, reason: String(err?.message || err) };
+  }
+}

package/src/claude-desktop/slots.js

@@ -76,11 +76,77 @@ export function aliasPairs(rows = []) {
  * 桌面端 profile 的 `inferenceModels` 形状（官方 models 页：条目可为 id 字符串或对象，
  * 对象里 `name` 是发给 provider 的真 id、`labelOverride` 是菜单显示名）。
  * 显示名带上真模型名，用户在 App 下拉里能认出「这条其实是 qwenwork/pro」。
+ * `supports1m===true` 的行（--1m 裁决产物，decideRows1m 打标）追加官方成对键
+ * `supports1m+prefer1m`（= 菜单单条、新会话直接 1M 窗口，ADR-0056）；
+ * 键序恒为 name→labelOverride→supports1m→prefer1m→maxEffort —— 幂等按原文比对，键序必须稳定。
  */
 export function toInferenceModels(rows = [], { maxEffort } = {}) {
   return (Array.isArray(rows) ? rows : []).map((r) => {
     const e = { name: String(r.slot), labelOverride: String(r.label || r.model) };
+    if (r.supports1m === true) { e.supports1m = true; e.prefer1m = true; }
     if (maxEffort) e.maxEffort = String(maxEffort);
     return e;
   });
 }
+
+/** `--1m` auto 模式阈值：/v1/models 已裁决窗口 ≥ 此值才打标（ADR-0056）。 */
+export const ONE_M_THRESHOLD = 1_000_000;
+
+/**
+ * `-setto claude-desktop --1m <值>` 的纯函数解析：
+ * `off|auto|all` 保留字（大小写不敏感）、空值缺省 auto；其余非空值一律按列表处理（单条即长度 1）——
+ * 列表值不与行集做存在性预校验，未命中经 decideRows1m 的 unmatched 以 ⚠ 呈现而非硬拒（spec《--1m 参数解析》）。
+ * 仅 trim 后为空/纯分隔符（`,,`）判 invalid，CLI 须在写盘前拒绝。
+ */
+export function parseOneMMode(raw) {
+  const s = String(raw ?? "").trim();
+  const low = s.toLowerCase();
+  if (s === "" || low === "auto") return { mode: "auto", list: [] };
+  if (low === "off") return { mode: "off", list: [] };
+  if (low === "all") return { mode: "all", list: [] };
+  const list = s.split(",").map((x) => x.trim().toLowerCase()).filter(Boolean);
+  if (!list.length) return { mode: "invalid" };
+  return { mode: "list", list };
+}
+
+/**
+ * --1m 裁决（纯函数，不改入参）：rows → { rows, unmatched, preserved }。
+ * `oneM` 为 parseOneMMode 产物；`contexts` 为证据 Adapter 的 Map<小写 id, 窗口数>；
+ * `preserve` 为盘上既有 1M 标 Map<小写槽位, true>。auto 语义：有证据且 ≥1M 才新增标、
+ * 有证据且 <1M 才清标；**无证据（整体失败或该行不在目录）≠ 负面证据 —— 保留既有标**，
+ * 网关停机的一轮不得静默抹掉上次写好的（评审 1 P1-2）。
+ */
+export function decideRows1m({ rows = [], oneM = { mode: "off", list: [] }, contexts = null, preserve = null } = {}) {
+  const mode = oneM && oneM.mode ? oneM.mode : "off";
+  const list = (Array.isArray(oneM && oneM.list) ? oneM.list : []).map((x) => String(x).toLowerCase());
+  const matched = new Set();
+  const preserved = [];
+  const out = (Array.isArray(rows) ? rows : []).map((r) => {
+    let mark = false;
+    if (mode === "all") {
+      mark = true;
+    } else if (mode === "list") {
+      const slot = String(r?.slot || "").toLowerCase();
+      const model = String(r?.model || "").toLowerCase();
+      const hitSlot = slot && list.includes(slot);
+      const hitModel = model && list.includes(model);
+      if (hitSlot || hitModel) {
+        mark = true;
+        if (hitSlot) matched.add(slot);
+        if (hitModel) matched.add(model);
+      }
+    } else if (mode === "auto") {
+      const key = String(r?.model || "").toLowerCase();
+      const n = contexts ? contexts.get(key) : undefined; // 短路写 `&&` 会把整体失败喂成 null → 误走「清标」分支（全量测试抓到）
+      if (n === undefined) {
+        mark = Boolean(preserve && preserve.get(String(r?.slot || "").toLowerCase()));
+        if (mark) preserved.push(String(r?.slot || "").toLowerCase());
+      } else {
+        mark = n >= ONE_M_THRESHOLD;
+      }
+    }
+    return mark ? { ...r, supports1m: true } : { ...r };
+  });
+  const unmatched = mode === "list" ? list.filter((v) => !matched.has(v)) : [];
+  return { rows: out, unmatched, preserved };
+}

package/src/cli/commands/claude-desktop.js

@@ -2,7 +2,7 @@ import { loadToken, loadModelPicks, loadPreferredModel } from "../../state.js";
 import { getPreferredModel } from "../../auto.js";
 import { effectivePort } from "../policy.js";
 import { claudeDesktopConfigDir, readClaudeDesktopProfile } from "../../sync-claude-desktop.js";
-import { ROLE_SLOTS, planSlots, slotRole } from "../../claude-desktop/slots.js";
+import { ROLE_SLOTS, planSlots, slotRole, parseOneMMode } from "../../claude-desktop/slots.js";
 import { detectManagedPolicy, readAppCatalogIds, appDataDirOf, currentAliases, probeMessages } from "../../claude-desktop/doctor.js";
 import { normalizeModel } from "../../reasoning.js";
 import { applyClaudeDesktop, retireClaudeDesktop } from "../../claude-desktop/apply.js";
@@ -57,7 +57,7 @@ export async function handleClaudeDesktop(args = [], flag = "-claude-desktop") {
         const name = typeof m === "string" ? m : String(m?.name || "");
         const label = typeof m === "string" ? "" : String(m?.labelOverride || "");
         const target = aliases[name];
-        const mark = !isSlot(name) ? "⚠ 非角色槽（App 可能拒）" : target ? `→ ${target}` : "⚠ 无 alias（请求会被当未知模型丢组员转发→超时 502）";
+        const mark = (!isSlot(name) ? "⚠ 非角色槽（App 可能拒）" : target ? `→ ${target}` : "⚠ 无 alias（请求会被当未知模型丢组员转发→超时 502）") + (typeof m !== "string" && m?.supports1m === true ? "  1M" : "");
         console.log(`    ${name.padEnd(28)} ${slotRole(name).padEnd(7)} ${label ? `[${label}]`.padEnd(30) : ""}${mark}`);
       }
       const missing = models.map((m) => (typeof m === "string" ? m : String(m?.name || ""))).filter((n) => n && !aliases[n]);
@@ -151,7 +151,7 @@ function printUsage() {
   mslxdff -claude-desktop status        看 profile / 托管策略 / 槽位 alias 是否齐（只读盘）
   mslxdff -claude-desktop slots         看 App 签名模型目录认得哪些槽位 id（内置清单与实况比对）
   mslxdff -claude-desktop check [id...] 逐槽向本机 /v1/messages 探活（等价 App 那个 Test connection，但给原因）
-  写配置: mslxdff -setto claude-desktop [modelId ...] [--max N] [--no-alias] [--official]`);
+  写配置: mslxdff -setto claude-desktop [modelId ...] [--max N] [--max-effort <lvl>] [--1m <off|auto|all|列表>] [--no-alias] [--check] [--official]`);
 }
 
 /**
@@ -166,11 +166,16 @@ export async function handleClaudeDesktopSetto(args = [], idx = -1) {
   if (missing) bad(`${missing} 需要取值`);
   const maxRaw = values["--max"];
   const effortRaw = values["--max-effort"];
-  const unknown = flags.filter((f) => !["--max", "--max-effort", "--no-alias", "--check", "--official", "--port"].includes(f));
-  if (unknown.length) bad(`未知参数: ${unknown.join(" ")}（可用：--max N / --max-effort <lvl> / --no-alias / --check / --official）`);
+  const unknown = flags.filter((f) => !["--max", "--max-effort", "--1m", "--no-alias", "--check", "--official", "--port"].includes(f));
+  if (unknown.length) bad(`未知参数: ${unknown.join(" ")}（可用：--max N / --max-effort <lvl> / --1m off|auto|all|列表 / --no-alias / --check / --official）`);
   if (maxRaw !== undefined && !(Number(maxRaw) > 0)) bad("--max 需要一个正整数（要写几条槽位），例如 --max 3");
   const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
   if (effortRaw !== undefined && !EFFORTS.includes(String(effortRaw))) bad(`--max-effort 只能是 ${EFFORTS.join(" | ")}`);
+  // --1m 上下文标记（ADR-0056）：不传=auto；显式传空值与「不传」区分、写盘前拒（评审 2 P1#1）；invalid=纯分隔符值
+  const oneMRaw = values["--1m"];
+  if (oneMRaw !== undefined && !String(oneMRaw).trim()) bad("--1m 取值为空：不传该参数即缺省 auto；或显式传 off | auto | all | <逗号分隔槽位/模型id>");
+  const oneMParsed = parseOneMMode(oneMRaw);
+  if (oneMParsed.mode === "invalid") bad("--1m 取值非法：只接受 off | auto | all | <逗号分隔槽位/模型id>");
 
   const port = effectivePort(args);
   let token = "";
@@ -208,6 +213,7 @@ export async function handleClaudeDesktopSetto(args = [], idx = -1) {
       token,
       max: maxRaw !== undefined ? Number(maxRaw) : undefined,
       maxEffort: effortRaw !== undefined ? String(effortRaw) : undefined,
+      oneM: oneMParsed,
       noAlias: flags.includes("--no-alias"),
       probe: flags.includes("--check"),
     });
@@ -221,8 +227,9 @@ export async function handleClaudeDesktopSetto(args = [], idx = -1) {
   console.log(`  登记:    ${r.metaFile}  appliedId=${r.configId}`);
   console.log(`  baseUrl: http://127.0.0.1:${port}  （App 自己拼 /v1/messages）  scheme=bearer`);
   console.log(`  inferenceModels: ${r.rows.length} 行（槽位 → 真模型）`);
-  for (const row of r.rows) console.log(`    ${row.slot.padEnd(28)} ${slotRole(row.slot).padEnd(7)} → ${row.model}`);
+  for (const row of r.rows) console.log(`    ${row.slot.padEnd(28)} ${slotRole(row.slot).padEnd(7)} → ${row.model}${row.supports1m ? "  1M" : ""}`);
   if (r.overflow) console.log(`  ⚠ 勾选集 ${r.rows.length + r.overflow} 条 > 槽位上限 ${r.slotCap}，已截断 ${r.overflow} 条（${r.dropped.slice(0, 3).join(", ")}${r.dropped.length > 3 ? " …" : ""}）；想换哪条上槽用 -setto claude-desktop <modelId> ...`);
+  for (const line of oneMOutputLines(r.oneM, r.rows.length)) console.log(line);
   if (!r.aliasSkipped) {
     console.log(`  alias: ${r.aliasAdded.length} 条新增/确认、${r.aliasOverwritten.length} 条覆盖 → ${r.aliasFile}（daemon 热读，不用重启）`);
     for (const a of r.aliasOverwritten) console.log(`    ⚠ 覆盖 ${a.slot}: ${a.from} → ${a.to}`);
@@ -250,7 +257,7 @@ export function splitArgs(rest = []) {
   let missing = "";
   for (let i = 0; i < rest.length; i++) {
     const a = String(rest[i]);
-    if (a === "--max" || a === "--max-effort" || a === "--port") {
+    if (a === "--max" || a === "--max-effort" || a === "--port" || a === "--1m") {
       flags.push(a);
       const v = rest[++i];
       if (v === undefined || String(v).startsWith("-")) { missing = a; break; }
@@ -262,3 +269,16 @@ export function splitArgs(rest = []) {
   }
   return { positional, flags, values, missing };
 }
+
+/** --1m 输出行（纯函数=可单测，spec《写入与 status 的 1M 呈现》+ 评审 1 P1-2 保留标披露）。 */
+export function oneMOutputLines(oneM, rowsCount) {
+  if (!oneM || oneM.mode === "off") return [];
+  const kept = oneM.preserved && oneM.preserved.length ? `；已保留盘上 ${oneM.preserved.length} 条既有 1M 标（无证据≠负面证据）` : "";
+  if (oneM.mode === "auto" && oneM.evidenceOk) return [`  1M: ${oneM.markedCount}/${rowsCount} 条打标（证据：本机 /v1/models 已裁决窗口 ≥1M）${oneM.preserved && oneM.preserved.length ? `，其中 ${oneM.preserved.length} 条为保留` : ""}`];
+  if (oneM.mode === "auto") return [`  ℹ 网关证据不可用${oneM.evidenceReason ? `（${oneM.evidenceReason}）` : ""}，本轮未新增打标 —— 先 mslxdff -d 起网关重跑，或 --1m all 用户担保打标${kept}`];
+  if (oneM.mode === "all") return [`  1M: 全 ${oneM.markedCount} 条打标（用户担保，未查证据）`];
+  const lines = [];
+  if (oneM.mode === "list" && oneM.markedCount) lines.push(`  1M: ${oneM.markedCount} 条打标（列表模式，不查窗口证据）`);
+  if (oneM.mode === "list" && oneM.unmatched && oneM.unmatched.length) lines.push(`  ⚠ --1m 列表值未命中任何行: ${oneM.unmatched.join(", ")}`);
+  return lines;
+}

package/src/cli/commands/sync.js

@@ -22,7 +22,7 @@ export async function handleSetto(args) {
   const idx = args.findIndex((x) => x === "-setto" || x === "--setto");
   const target = args[idx + 1];
   if (!["workbuddy", "opencode", "chatgpt", "codex", "claude", "claude-desktop", "claudedesktop"].includes(target)) {
-    console.error("usage: mslxdff -setto workbuddy [modelId] | mslxdff -setto opencode [modelId|--all] | mslxdff -setto chatgpt [modelId] | mslxdff -setto claude [modelId] [--behaves-as <id>] | mslxdff -setto claude-desktop [modelId ...] [--max N] [--no-alias] [--check] [--official]  (claude: 不带 modelId = 写入 modelPicks 勾选集全集，--all 与之同义 / claude-desktop: 写 Claude Desktop 3P profile + 角色槽 alias)");
+    console.error("usage: mslxdff -setto workbuddy [modelId] | mslxdff -setto opencode [modelId|--all] | mslxdff -setto chatgpt [modelId] | mslxdff -setto claude [modelId] [--behaves-as <id>] | mslxdff -setto claude-desktop [modelId ...] [--max N] [--max-effort <lvl>] [--1m <off|auto|all|列表>] [--no-alias] [--check] [--official]  (claude: 不带 modelId = 写入 modelPicks 勾选集全集，--all 与之同义 / claude-desktop: 写 Claude Desktop 3P profile + 角色槽 alias，--1m 缺省 auto=有据才打 1M 标，详见 ADR-0056)");
     process.exit(1);
   }
   if (target === "claude-desktop" || target === "claudedesktop") {

package/src/cli/help.js

@@ -25,7 +25,7 @@ Usage:
   mslxdff -setto workbuddy [modelId]  set default model and sync to WorkBuddy models.json (insert or update 127.0.0.1/v1 entry)
   mslxdff -setto chatgpt [modelId]    set default model and sync to Codex/ChatGPT ~/.codex/config.toml (model_providers.mslxdff → 127.0.0.1/v1/responses, auth via mslxdff -showtoken)
   mslxdff -setto claude [modelId] [--behaves-as <id>]  set default model and sync to Claude Code ~/.claude/settings.json (no modelId = write ALL modelPicks rows, --all is the same thing; env.ANTHROPIC_BASE_URL → 127.0.0.1 without /v1, /v1/messages shell; modelPicker rows carry behavesAs only for ids the client cannot recognize, default claude-sonnet-5; first write backs up settings.pre-mslxdff.json)
-  mslxdff -setto claude-desktop [modelId...] [--max N] [--max-effort <lvl>] [--no-alias] [--check] [--official]  one-click Claude Desktop on 3P (ADR-0048): writes the app's configLibrary profile (role-slot model ids + labelOverride, baseUrl without /v1, bearer scheme) AND model-aliases.json (role slot → real pool model, hot-reloaded); --official retires only our registration; the app does NOT hot-reload → fully quit and reopen
+  mslxdff -setto claude-desktop [modelId...] [--max N] [--max-effort <lvl>] [--1m off|auto|all|ids] [--no-alias] [--check] [--official]  one-click Claude Desktop on 3P (ADR-0048): writes the app's configLibrary profile (role-slot model ids + labelOverride, baseUrl without /v1, bearer scheme) AND model-aliases.json (role slot → real pool model, hot-reloaded); --1m (ADR-0056, default auto) tags entries with supports1m+prefer1m when the local /v1/models says the window is >=1M, so the app stops capping custom models at 200K; --official retires only our registration; the app does NOT hot-reload → fully quit and reopen
   mslxdff -claude-desktop [status|slots|check]  diagnose Claude Desktop 3P (read-only): managed policy → profile registration → per-slot alias → live /v1/messages probe with reasons and next command
   mslxdff -provider add <id> <baseUrl> <key> [allowedModel...]  add a generic OpenAI-compatible provider (myapi/gpt-4, baseUrl https://api.example.com/v1; extra models = allowlist)
   mslxdff -provider add workbuddy https://copilot.tencent.com <key> [allow...]  add WorkBuddy专用供应商（workbuddy/hy3 前缀路由，auths 与 keys 一一对应）

package/src/opencode-identity.js

@@ -1,37 +1,57 @@
 import crypto from "node:crypto";
 
-// opencode 客户端身份规格单一来源（源码 packages/schema/src/identifier.ts +
-// packages/opencode/src/session/llm/request.ts）：id = <prefix>_ + 12 位 hex
-// (timestamp*4096+同毫秒计数，截 48bit) + 14 位 base62，共 26 字符；UA 必须 "opencode/<semver>"。
-// zen 免费层 2026-09-17 起按该规格放行（缺版本 UA 或 id 形状不符 → 403 FreeTierError）；
-// 2026-09-18 起还要求 UA 版本 ≥ 1.18.0（低版本 426 UpgradeRequired），默认跟 npm latest。
+// opencode 客户端身份规格单一来源。真值 = 上游 packages/schema/src/identifier.ts：
+// id = <prefix>_ + 12 位 hex 时间段 + 14 位 base62；UA 必须 "opencode/<semver>"。
+// ⚠ 时间段是**倒序**的：value = ~(timestamp*4096 + counter) & 48bit（descending，最新排最前）。
+//   正序时钟不合规——zen 免费层自 2026-10-13 起把低 12 位**反解回 counter** 校验，只接受 [0,63]；
+//   正序 id 反解出 4094 → 403 FreeTierError（现网实测：counter=1/40 → 200，counter=4094 → 403）。
+//   时钟半段不校验：ms*4096 如今已需 53bit，截到 48bit 必回绕——真客户端自己反解出来是 1972 年。
+//   ⇒ 会话 id 可以继续由摘要确定性派生（跨重启稳定），只需把低 12 位强制成合法 counter。
+// 旧判据全部仍有效：形状正则（2026-09-17）、UA ≥ 1.18.0（2026-09-18，低版本 426 UpgradeRequired）、
+//   以及请求体那半道 agent 形状闸（stream + 核心五工具，见 free-lane.js）。
 const ID_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+const MASK48 = 0xffffffffffffn;
+const MASK12 = 0xfffn;
+// 同毫秒内第 N 个 id：免费层只认反解后 ∈[0,63]，越界必 403 ⇒ 到 63 回头，不无限自增
+const COUNTER_MAX = 63;
 const DEFAULT_OPENCODE_UA = "opencode/1.18.31";
 let idLastTs = 0;
 let idCounter = 0;
 
+/** 合规时间段：倒序的 timestamp*4096+counter 截 48bit，恒 12 位小写 hex */
+export function identifierTimeHex(timestamp = Date.now(), counter = 1) {
+  return ((~(BigInt(timestamp) * 0x1000n + BigInt(counter))) & MASK48).toString(16).padStart(12, "0");
+}
+
+/**
+ * 从 12 位 hex 时间段反解 per-ms 计数——与免费层闸门同一判据。
+ * 值域 0..4095，闸门只放行 ≤63；形状不符返回 NaN（绝不抛，调用方用 Number.isInteger 自检）。
+ */
+export function counterFromTimeHex(hex) {
+  if (typeof hex !== "string" || !/^[0-9a-f]{12}$/i.test(hex)) return Number.NaN;
+  return Number((~BigInt("0x" + hex)) & MASK12);
+}
+
+function base62From(bytes) {
+  let out = "";
+  for (const b of bytes) out += ID_CHARS[b % 62];
+  return out;
+}
+
 export function opencodeIdTail(timestamp = Date.now()) {
   if (timestamp !== idLastTs) {
     idLastTs = timestamp;
     idCounter = 0;
   }
-  idCounter += 1;
-  const value = BigInt(timestamp) * 0x1000n + BigInt(idCounter);
-  let tail = "";
-  for (let i = 0; i < 6; i++) {
-    tail += Number((value >> BigInt(40 - 8 * i)) & 0xffn)
-      .toString(16)
-      .padStart(2, "0");
-  }
-  for (const b of crypto.randomBytes(14)) tail += ID_CHARS[b % 62];
-  return tail;
+  idCounter = (idCounter % COUNTER_MAX) + 1;
+  return identifierTimeHex(timestamp, idCounter) + base62From(crypto.randomBytes(14));
 }
 
-// 摘要派生：同种子恒同 id（会话亲和），形态仍合规
+// 摘要派生：同种子恒同 id（会话亲和——上游按 session 归组免费额度与 prompt cache，改成现取
+// 时钟会让同一会话每请求换号，绝不）。时钟半段照摘要填（不校验），低 12 位强制 counter=1。
 export function digestIdTail(digest) {
-  let tail = digest.subarray(0, 6).toString("hex");
-  for (const b of digest.subarray(6, 20)) tail += ID_CHARS[b % 62];
-  return tail;
+  const time = ((BigInt("0x" + digest.subarray(0, 6).toString("hex")) & ~MASK12) | ((~1n) & MASK12)) & MASK48;
+  return time.toString(16).padStart(12, "0") + base62From(digest.subarray(6, 20));
 }
 
 export function genId(prefix) {

package/src/routes/messages-route.js

@@ -22,6 +22,7 @@ import {
   anthropicError,
 } from "../anthropic/translate.js";
 import { estimateTokens } from "../anthropic/count-tokens.js";
+import { sseToChatJson } from "../anthropic/sse-aggregate.js";
 import {
   detectSearchRequest,
   runWebSearch,
@@ -100,47 +101,6 @@ function tryAggregate(text) {
     return null;
   }
 }
-// 客户端要非流式而上游只会流式（workbuddy 在 provider 层写死 stream:true，SSE 硬吃回来）：
-// collector 收到的 text 是 SSE 帧序列而非 JSON，JSON.parse 必炸 → 此前恒 502。逐行吃 data: 帧
-// 聚成 chat.completion JSON（与 qoder/aggregate.js、zcode 非流式聚合同构），出口复用 chatJsonToAnthropic；
-// 一帧都没有或夹带 in-band 错误帧时返回 null，落回原有 502 + errorText 路径（错误绝不聚合成正文）。
-function sseToChatJson(text, model) {
-  let content = "";
-  let finish = "";
-  let usage = null;
-  let sawChunk = false;
-  const toolSlots = new Map();
-  for (const raw of String(text || "").split("\n")) {
-    const line = raw.trim();
-    if (!line.startsWith("data:")) continue; // 注释帧/keepalive/事件名行全跳过
-    const payload = line.slice(5).trim();
-    if (!payload || payload === "[DONE]") continue;
-    let chunk;
-    try { chunk = JSON.parse(payload); } catch { continue; }
-    if (chunk?.error) return null;
-    sawChunk = true;
-    const choice = chunk.choices?.[0] || {};
-    const delta = choice.delta || {};
-    if (choice.finish_reason) finish = choice.finish_reason;
-    if (chunk.usage) usage = chunk.usage;
-    if (typeof delta.content === "string" && delta.content) content += delta.content;
-    for (const tc of delta.tool_calls || []) {
-      const slot = Number(tc?.index ?? 0);
-      let t = toolSlots.get(slot);
-      if (!t) { t = { id: "", name: "", args: "" }; toolSlots.set(slot, t); }
-      if (tc?.id) t.id = String(tc.id);
-      if (tc?.function?.name) t.name += String(tc.function.name);
-      if (tc?.function?.arguments) t.args += String(tc.function.arguments);
-    }
-  }
-  if (!sawChunk) return null;
-  const toolCalls = [...toolSlots.values()].map((t, i) => ({ id: t.id || `call_${i}`, type: "function", function: { name: t.name, arguments: t.args || "{}" } }));
-  const message = { role: "assistant", content: content || (toolCalls.length ? null : "") };
-  if (toolCalls.length) message.tool_calls = toolCalls;
-  return { id: "", object: "chat.completion", created: Math.floor(Date.now() / 1000), model,
-    choices: [{ index: 0, message, finish_reason: finish || (toolCalls.length ? "tool_calls" : "stop") }],
-    usage: usage || { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } };
-}
 
 
 /**
@@ -348,10 +308,14 @@ export async function messagesHandler(ctx) {
   }));
   const pipeline = createChatPipeline(ctx);
   const fakeReq = withBody(req, chatBody);
+  // ADR-0055：请求侧 token 估算 thunk（路由层也 memoize，与决策 4「每请求至多算一次」对齐；
+  // translator 内部还有一层 memoize，双保险）。
+  let estCache;
+  const estInput = () => (estCache ??= estimateTokens(body).input_tokens);
   const forwardClose = (shim) => { try { req.on?.("close", () => shim.emit("close")); } catch { /* ignore */ } };
   try {
     if (chatBody.stream) {
-      const translator = createAnthropicChunkTranslator(chatBody.model, { thinking: emitThinking() });
+      const translator = createAnthropicChunkTranslator(chatBody.model, { thinking: emitThinking(), estInput });
       const live = createAnthropicForwarder(res, translator);
       forwardClose(live);
       await pipeline.execute({ req: fakeReq, res: live });
@@ -372,11 +336,11 @@ export async function messagesHandler(ctx) {
       }
       // 上游偶发非 chat 形状（无 choices）：包成单 text 块，绝不 500（照 responses-route.js 先例）
       if (!Array.isArray(chatJson.choices)) {
-        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model);
+        const r = chatJsonToAnthropic({ choices: [{ message: { content: String(text).slice(0, 8000) } }] }, chatBody.model, { estInput });
         alog("done-nonchat", JSON.stringify({ ms: Date.now() - t0, bytes: text.length }));
         return json(res, 200, r);
       }
-      const out = chatJsonToAnthropic(chatJson, chatBody.model);
+      const out = chatJsonToAnthropic(chatJson, chatBody.model, { estInput });
       alog("done-json", JSON.stringify({ ms: Date.now() - t0, status, blocks: out.content.length, stop: out.stop_reason, usage: out.usage }));
       return json(res, 200, out);
     }

package/src/text-tokens.js

@@ -0,0 +1,52 @@
+// `/v1/messages` 面 token 估算的单一来源（ADR-0055）：`count_tokens` 读数与响应 `usage` 兜底共用一个公式。
+// 共用面：`src/anthropic/count-tokens.js`（请求侧逐段累加，走 `estimateTextTokens`）、
+// `src/anthropic/translate.js`（上游未报 usage 时的兜底与流式生成侧累计，走 `createTokenCounter`）。
+// 两处必须同源，否则 `count_tokens` 与响应 `usage` 会各说一套读数
+// —— 同 ADR-0053 把 effort 词表收成单一来源的理由。
+//
+// 公式照抄参照实现 `wb_proxy.py:12841-12848`：`cjk + max(1, int(other / 3.6))`（空文本 0），
+// CJK 区间 = \u4e00-\u9fff 主区 + \u3400-\u4dbf 扩展 A。自造系数＝造第二个真相源（design.md 决策 2）。
+// 实现不抄 `re.sub` 再数长度差：那要额外分配一份与原文等长的新串，本实现单遍扫描、无分配。
+// 与 Python 的两处已知差异（不影响本仓自洽，但别写成「逐值相等」）：① astral 字符（emoji）JS 按
+// 2 个 UTF-16 单元计、Python 按 1 个码点计 —— emoji 密集文本可差到 2 倍以上；② falsy 非串（`0`/`false`）
+// Python 直接返回 0、本实现按 `String()` 后非空计 ≥1。现所有调用方传的都是字符串，两条均不可达。
+
+const CJK_HI_START = 0x4e00;
+const CJK_HI_END = 0x9fff; // 主区，占实际中文文本的绝对多数
+const CJK_EXT_A_START = 0x3400;
+const CJK_EXT_A_END = 0x4dbf;
+const OTHER_CHARS_PER_TOKEN = 3.6;
+
+/**
+ * 跨多段累计的计数器。逐段各套一次公式会把参照实现的 `max(1, …)` 下限乘上段数
+ * （流式按 1~3 字一帧下发时，1000 个 ASCII 字会被估成 1000 tokens 而非 277），
+ * 所以累计的是字数、最后一次性套公式。
+ * @returns {{ add: (text: unknown) => void, tokens: () => number }}
+ */
+export function createTokenCounter() {
+  let cjk = 0;
+  let other = 0;
+  return {
+    add(text) {
+      if (text == null) return;
+      const s = typeof text === "string" ? text : String(text);
+      for (let i = 0; i < s.length; i++) {
+        const c = s.charCodeAt(i);
+        if (c >= CJK_HI_START && c <= CJK_HI_END) cjk++;
+        else if (c >= CJK_EXT_A_START && c <= CJK_EXT_A_END) cjk++;
+        else other++;
+      }
+    },
+    tokens() {
+      if (cjk + other <= 0) return 0; // 空文本给 0，不吃 +1 下限
+      return cjk + Math.max(1, Math.floor(other / OTHER_CHARS_PER_TOKEN));
+    },
+  };
+}
+
+/** 单段文本的 token 估算（CJK 每字 1 token，其余每 3.6 字符 1 token，非空至少 1）。 */
+export function estimateTextTokens(text) {
+  const counter = createTokenCounter();
+  counter.add(text);
+  return counter.tokens();
+}