@xiaobuyu/nodesign 0.0.1

package/server/engine/agent/isolation.js

@@ -0,0 +1,159 @@
+/**
+ * agent/isolation.js —— 会话隔离配置的单一来源（2026-08-15）
+ *
+ * 一件事被拆成两道闸，因为 SDK 的工具分两拨跑：
+ *
+ *   ① sandbox  → **只管 Bash**。bwrap 起独立 mount/net namespace：写只落工作区、
+ *                 凭据读不到、env 里的 key 被 unset、AF_UNIX 与回环被切断、
+ *                 外网走代理。开关在 runtime/platform.js（NODESIGN_SANDBOX=on）。
+ *   ② settings.permissions.deny → 管 **Read / Grep / Glob / Write / Edit**。
+ *                 这些是 SDK 进程内工具，根本不进 bwrap，沙盒对它们零作用。
+ *
+ * 缺一半等于没关。第三块（跨项目边界）在 hooks/pre-workspace-scope-guard.js ——
+ * deny 规则写不出"除了自己这个项目"（deny 压过 allow，项目又是动态新建的）。
+ *
+ * 08-15 开这套时真跑出来的四件事，改之前先读：
+ *   1. `dangerouslyDisableSandbox` 默认允许，agent 撞到偶发失败会自己拿它关沙盒
+ *      —— 必须 allowUnsandboxedCommands:false 焊死。
+ *   2. deny 规则的路径必须是**双斜杠**绝对形式，单斜杠静默失效。
+ *   3. npm 默认缓存在 ~/.npm，沙盒里 HOME 不可写 → `npm i` EROFS，构建道整条断。
+ *   4. 目录级 denyRead 拦得住读文件，拦不住 `ls` 看文件名（接受：名字不是秘密）。
+ */
+
+import path from 'node:path';
+import os from 'node:os';
+import fs from 'node:fs/promises';
+import { platform } from '../../runtime/platform.js';
+import { autoModeSettings } from './auto-mode-rules.js';
+
+/**
+ * 会话要用的缓存/临时目录一次备齐（2026-08-19 从 session-loop 下沉）。
+ *
+ * - npmCacheDir：共用 npm 缓存（数据根下；内容寻址 + 完整性校验，跨会话共用
+ *   不构成投毒面）。沙盒里 HOME 不可写，不给它 `npm i` 直接 EROFS。
+ * - agentTmpDir：沙盒里 Bash 的 $TMPDIR。SDK 按 CLAUDE_CODE_TMPDIR 派生沙盒
+ *   tmp（没设就 os.tmpdir()），而派生出来的 /tmp/claude 在 bwrap 里只读 ——
+ *   agent 装个 py7zr 连撞四堵墙、venv 静默失败（iss_msz25m5p_v5so）。
+ *   ⚠️ 必须短：SDK 二进制里有条 warn —— 这个路径超 ~30 字节时 AF_UNIX socket
+ *   放不下，子进程 $TMPDIR **静默回退**默认值（= 白配）。所以挂 /tmp/nd 下、
+ *   按项目分目录；沙盒里遮兄弟目录见 buildIsolationOptions。
+ * - pip 缓存指进 agentTmpDir/pip，不然每条 pip 命令先吐一段
+ *   ~/.cache/pip 不可写的 WARNING 噪音。
+ *
+ * 目录必须先存在 —— bwrap 绑一个不存在的路径会起不来；建不出来也不拦会话。
+ * envPatch 直接摊进 sdkEnv。
+ */
+export async function prepareAgentDirs({ dataRoot, projectId, sessionId }) {
+  const npmCacheDir = path.join(dataRoot, '.npm-cache');
+  const agentTmpRoot = path.join(os.tmpdir(), 'nd');
+  const agentTmpDir = path.join(agentTmpRoot, projectId || String(sessionId || 'anon').slice(0, 12));
+  for (const d of [npmCacheDir, path.join(agentTmpDir, 'pip')]) {
+    try { await fs.mkdir(d, { recursive: true }); } catch { /* 起不来也不该拦会话 */ }
+  }
+  return {
+    npmCacheDir,
+    agentTmpRoot,
+    agentTmpDir,
+    envPatch: {
+      npm_config_cache: npmCacheDir,
+      CLAUDE_CODE_TMPDIR: agentTmpDir,
+      PIP_CACHE_DIR: path.join(agentTmpDir, 'pip'),
+    },
+  };
+}
+
+/**
+ * bwrap 垫片的 env（PATH 前插一个目录，里面的 `bwrap` 是我们的包装脚本）
+ *
+ * 治的是 `apply-seccomp: unshare(CLONE_NEWUSER): Invalid argument` 这个偶发
+ * —— 内核级竞态，机器越闲越容易撞，实测每十几次 Bash 调用炸一次，而且会把
+ * agent 带进错误推断（有一次它干脆自己拿 `dangerouslyDisableSandbox` 绕过去）。
+ * 原理与安全不变量写在 server/ops/sandbox-shim/bwrap 里。
+ *
+ * 📮 上游 issue：https://github.com/anthropics/claude-code/issues/86928
+ * ⏳ **临时设施**：垫片认的是 SDK 内部的命令前缀，**SDK 一升级前缀变了就静默
+ *    失效**（原样透传 = 悄悄退回那个偶发，不报错）。升级后查
+ *    `<数据根>/.sandbox-shim.log` 里 `rewrote=1` 的计数还在不在涨；
+ *    上游修好之后连这个函数带 ops/sandbox-shim/ 一起删掉。
+ * 关掉：`NODESIGN_SANDBOX_SHIM=off`。
+ */
+export function sandboxShimEnv({ baseEnv = process.env, dataRoot } = {}) {
+  if (!platform.sandboxEnabled) return {};
+  if (process.env.NODESIGN_SANDBOX_SHIM === 'off') return {};
+  const dir = path.join(platform.repoRoot, 'server', 'ops', 'sandbox-shim');
+  return {
+    PATH: `${dir}${path.delimiter}${baseEnv.PATH || ''}`,
+    // 改写次数记一笔：SDK 升级后 pattern 变了会静默退回现状，靠这个计数发现
+    ...(dataRoot ? { NODESIGN_SHIM_LOG: path.join(dataRoot, '.sandbox-shim.log') } : {}),
+  };
+}
+
+/**
+ * @param {object} o
+ * @param {string} o.cwdRoot       会话工作区（= sharedRoot，扁平化之后同一个目录）
+ * @param {string} o.sharedRoot    项目共享根
+ * @param {string} o.npmCacheDir   共用 npm 缓存（在数据根下，必须可写可读）
+ * @param {string} [o.agentTmpRoot] 所有项目沙盒 tmp 的根（/tmp/nd）—— 整体遮读
+ * @param {string} [o.agentTmpDir]  本项目的沙盒 tmp（CLAUDE_CODE_TMPDIR 指它）——
+ *                                  开可写可读天窗。两个一起传或都不传。
+ * @param {string} o.dataRoot      PROJECTS_DATA_ROOT
+ * @param {object} o.env           传给 SDK 的 env（凭据抹除按它的键名算）
+ * @returns {{ sandbox: object, settings: object }} 直接摊进 query options
+ */
+export function buildIsolationOptions({ cwdRoot, sharedRoot, npmCacheDir, agentTmpRoot, agentTmpDir, dataRoot, env }) {
+  return {
+    sandbox: {
+      enabled: platform.sandboxEnabled,
+      failIfUnavailable: false,
+      // ⭐ 逃生门焊死：SDK 给 Bash 留了 `dangerouslyDisableSandbox` 参数，**默认允许**。
+      // 08-15 开沙盒当天就被 agent 自发用上了 —— 它撞到 apply-seccomp 偶发失败，
+      // 第三次自己带上这个参数关掉沙盒，然后读到了隔壁项目的文件（它老实汇报了，
+      // 所以我们看见了）。一个能被工具参数关掉的沙盒等于没有沙盒。
+      allowUnsandboxedCommands: false,
+      network: {
+        allowLocalBinding: false,
+        // 全域允许：这层留着不是为了管出口，是为了 Linux 上顺带切断 unix socket
+        // —— pm2 的 rpc.sock 就在家目录里，通了的话 `pm2 start` 能起一个沙盒外的
+        // 进程（完整逃逸）。只读挂载拦不住 socket 连接，实测过。
+        allowedDomains: ['*'],
+      },
+      filesystem: {
+        allowWrite: [
+          cwdRoot,
+          ...(sharedRoot ? [
+            path.join(sharedRoot, '.claude', 'agent-memory'),
+            path.join(sharedRoot, 'assets'),
+          ] : []),
+          npmCacheDir,
+          // 本项目的沙盒 tmp（CLAUDE_CODE_TMPDIR / $TMPDIR / pip 缓存都指这里）。
+          // 没有它 Bash 的 tmp 只读：venv 静默失败、pip --user EROFS、npm 装不上
+          ...(agentTmpDir ? [agentTmpDir] : []),
+        ],
+        denyWrite: ['/etc', '/usr', '/bin', '/sbin', '/private/etc'],
+        // 数据根整个盖住、再用 allowRead 给自己的工作区开天窗。
+        // ⚠️ 口径要准（08-18 上生产时实测纠正）：`ls 数据根` **看得见别的项目的
+        // 目录名**（沙盒里实测列出了另一个 pid），拦住的是**进去读**——
+        // `cat <别人的>/board.json` 与 `ls <别人的>/` 都空。
+        // 原注释写的"连 ls 数据根都只看得见自己那一个条目"过强，是错的；
+        // platform.js 那边的说法才对：「目录级 denyRead 拦得住 cat，拦不住 ls
+        // 看文件名 —— 文件名不是秘密，接受」。
+        // agentTmpRoot（/tmp/nd）同 dataRoot 一个待遇：根整个遮住、自己的子目录
+        // 开天窗 —— 不遮的话 /tmp/nd/<别的项目>/ 就是跨项目读通道
+        denyRead: [...platform.credentialBlacklist(), dataRoot, ...(agentTmpRoot ? [agentTmpRoot] : [])],
+        allowRead: [cwdRoot, npmCacheDir, ...(agentTmpDir ? [agentTmpDir] : [])],
+      },
+      credentials: {
+        // filesystem 那层拦得住 `cat .env`，拦不住 `env` —— 服务端 process.env
+        // 原样继承给了 Bash 子进程，key 就明晃晃躺着。按名字在沙盒内 unset。
+        envVars: platform.secretEnvVarNames(env).map(name => ({ name, mode: 'deny' })),
+      },
+    },
+    settings: {
+      permissions: { deny: platform.protectedPathRules({ dataRoot }) },
+      // auto 模式的分类器规则（只在开了 auto 时注入，省得白占 settings）。
+      // ⚠️ 按节替换不是追加 —— 为什么只覆盖 environment / hard_deny 两节，
+      // 见 auto-mode-rules.js 文件头。
+      ...(platform.autoModeEnabled ? { autoMode: autoModeSettings() } : {}),
+    },
+  };
+}

package/server/engine/agent/model-context.js

@@ -0,0 +1,359 @@
+/**
+ * server/engine/agent/model-context.js — 模型的单一真相源（2026-08-19 重建）。
+ *
+ * 历史形态是三张平行表（APP_TO_SDK_MODEL / APP_MODEL_REAL_WINDOW / SELECTABLE_MODELS），
+ * 文件头自己就写着"写错一个字，两处都只会静默降级"。现在收成一张 MODELS 表 +
+ * 一张 UPSTREAMS 表，旧的每个导出都从表派生，加载时做一致性断言（撞车当场炸，
+ * 不静默）。
+ *
+ * ## 两条通路
+ *
+ * - **订阅**（没有 api 字段的行）：模型真名 SDK 认识，session-loop 不注入任何
+ *   ANTHROPIC_* env，binary 走 ~/.claude 的 OAuth。今天生产的全部流量。
+ * - **API**（有 api 字段的行）：请求经 server/lib/model-ingress.js（进程内
+ *   Anthropic 范式通用入口）打到上游。SDK 视角看到的是 sdkAlias（让它把
+ *   context window 算对），入口在出口把 alias 还原成 wireModel、按上游换钥匙、
+ *   按行开怪癖修补（tool_result 图片提升等）。
+ *
+ * ## SDK spoofing 为什么存在（Kimi 时代的发现，机制不变）
+ *
+ * SDK binary 内部 model registry 不识别非 Claude 名 → rawMaxTokens fallback
+ * 200k → auto-compact 在 ~180k 触发，浪费上游真实容量。喂 SDK 一个它认识的
+ * 1M alias，autoCompactWindow=230400 真生效。SDK 序列化请求时会剥 `[1m]`
+ * 后缀，所以入口的反查表要同时认带后缀和不带后缀两种形态。
+ *
+ * ## 记账
+ *
+ * SDK 的 costUSD 按 alias 的 Claude 价目表算，API 模型全是虚价（Kimi 时代按
+ * Opus 价虚高 30×）。repriceUsageDeltas 把 usage key 还原成 appModel、按行内
+ * prices 重算 costUsd。行没填 prices = 沿用 SDK 虚价（接真流量前必须填价）。
+ *
+ * ⚠️ 硬约束：一个 sdkAlias 不能被两个 API 模型共用 —— 反查靠它，撞了整条
+ * 路由和记账都错。模块加载断言兜底。
+ */
+
+import { can, localGenApproved, DENIAL } from '../../auth/tier.js';
+import { platform } from '../../runtime/platform.js';
+import { UPSTREAMS_BUILTIN, MODELS_BUILTIN, BRANDS } from './model-table.js';
+import { loadLocalConfig } from '../../runtime/local-config.js';
+
+export { BRANDS };
+
+// ── 内置表 + 用户插槽合并（08-22）──
+// 外部行（runtime/local-config.js）全部共用这一个 sdkAlias：表内唯一空着的 1M 订阅名。全表反查分不出它们，
+// 靠 ingress/session-routes.js 会话优先路由（一个会话只认自己那行）。所以外部行**不进 WIRE_LOOKUP 的 alias 键**，
+// 只按 id 可查；没注册会话的请求用这个 alias 发过来一律 502（探针要带会话前缀）。
+export const EXTERNAL_SDK_ALIAS = 'claude-sonnet-4-6[1m]';
+const external = loadLocalConfig();
+export const UPSTREAMS = Object.freeze({ ...UPSTREAMS_BUILTIN, ...external.upstreams });
+/** 配置条目 → 表行（字段名一一对应，见 local-config.js 文件头） */
+function toExternalRow(m) {
+  const { id, label, desc, brand, window, uncensored, upstream, wireModel, fastModel, ...api } = m;
+  return Object.freeze({
+    id, window, brand, external: true, ...(uncensored ? { uncensored: true } : {}),
+    select: Object.freeze({ label, desc }),
+    api: Object.freeze({ upstream, wireModel, sdkAlias: EXTERNAL_SDK_ALIAS, fastModel: fastModel || id, ...api }),
+  });
+}
+const MODELS = Object.freeze([...MODELS_BUILTIN, ...external.models.map(toExternalRow)]);
+/** 外部插槽被整条丢掉的原因（启动日志一份、GET /api/local/config 一份，同一个数组） */
+export const MODEL_CONFIG_ERRORS = external.errors;
+
+// ── 派生索引（模块加载时构建 + 断言）──
+// 分级：内置行的错照旧当场炸（那是代码错）；外部行的错丢行 + 记进 MODEL_CONFIG_ERRORS（那是用户配置错，别拉下整站）
+
+const BY_ID = new Map();
+/** wire 名（appModel / sdkAlias / alias 剥 [1m] 后缀形态）→ 行。入口反查用 */
+const WIRE_LOOKUP = new Map();
+
+function checkRow(row) {
+  if (!BRANDS.includes(row.brand)) throw new Error(`[model-context] ${row.id} 的 brand 必须是 BRANDS 之一：${row.brand}`);
+  if (!row.api) return;
+  if (!UPSTREAMS[row.api.upstream]) throw new Error(`[model-context] ${row.id} 指向不存在的 upstream: ${row.api.upstream}`);
+  // alias 必须是本表里的订阅 Claude 名 —— SDK 才认识、窗口才查得到
+  if (!row.api.sdkAlias || !BY_ID.has(row.api.sdkAlias) || BY_ID.get(row.api.sdkAlias).api) throw new Error(`[model-context] ${row.id} 的 sdkAlias 必须是表内订阅模型名：${row.api.sdkAlias}`);
+  const fast = BY_ID.get(row.api.fastModel);
+  if (!fast || !fast.api) throw new Error(`[model-context] ${row.id} 的 fastModel 必须是表内 API 模型：${row.api.fastModel}`);
+}
+for (const row of MODELS) {
+  if (BY_ID.has(row.id)) throw new Error(`[model-context] 模型 id 重复：${row.id}`);
+  BY_ID.set(row.id, row);
+}
+for (const row of MODELS) {
+  try { checkRow(row); } catch (err) {
+    if (!row.external) throw err;
+    BY_ID.delete(row.id); MODEL_CONFIG_ERRORS.push({ where: `models (${row.id})`, message: err.message }); continue;
+  }
+  if (!row.api) continue;
+  const keys = row.external ? [row.id] : [row.id, row.api.sdkAlias, row.api.sdkAlias.replace(/\[1m\]$/i, '')];
+  for (const k of keys) {
+    const prev = WIRE_LOOKUP.get(k);
+    if (prev && prev !== row) throw new Error(`[model-context] wire 名撞车：'${k}' 同时属于 ${prev.id} 和 ${row.id}（一个 sdkAlias 不能共用）`);
+    WIRE_LOOKUP.set(k, row);
+  }
+}
+if (MODEL_CONFIG_ERRORS.length) {
+  console.warn(`[model-context] 本地插槽配置有 ${MODEL_CONFIG_ERRORS.length} 处问题（对应条目已跳过）${external.path ? `：${external.path}` : ''}`);
+  for (const e of MODEL_CONFIG_ERRORS) console.warn(`  - ${e.where}: ${e.message}`);
+}
+
+/** 当前进程里真正生效的外部行 id（配置页据此判「已生效 / 要重启」） */
+export function externalModelIds() {
+  return [...BY_ID.values()].filter((r) => r.external).map((r) => r.id);
+}
+
+/** 一行在入口会以哪些 body.model 名出现（id / sdkAlias / 剥 [1m] 的 alias）。session-routes 会话优先匹配用；不认识的 id → [] */
+export function wireNamesOf(appModel) {
+  const row = appModel ? BY_ID.get(appModel) : null;
+  if (!row) return [];
+  return row.api ? [row.id, row.api.sdkAlias, row.api.sdkAlias.replace(/\[1m\]$/i, '')] : [row.id];
+}
+
+// ── 旧导出（签名不变，全部改为查表）──
+
+/**
+ * picker 的**全量**清单（含带闸门的行）。⚠️ 对外接口一律用
+ * `selectableModelsFor(user)`，直接用这个等于把闸门拆了。保留导出是因为它是
+ * 「表里哪些行可选」的唯一真相，闸门只是在它上面过滤。
+ */
+export const SELECTABLE_MODELS = Object.freeze(
+  MODELS.filter((m) => m.select).map((m) => Object.freeze({ id: m.id, brand: m.brand, ...m.select })),
+);
+
+/** 这个 appModel 出自谁家（BRANDS 之一）。不认识的 id → null，调用方自己决定兜底，别猜。 */
+export function brandOfModel(appModel) {
+  return BY_ID.get(appModel)?.brand || null;
+}
+
+/**
+ * 按用户过滤可选模型。两种闸不同语义（08-21）：
+ *   - `gate: 'localGen'`：**看不见**。只对 admin / 已批准本地产线的账号露出（同 roll_film 那套批准制）
+ *   - `gate: 'subscription'`：**看得见选不了**。订阅 Claude 行对没有订阅资格的账号
+ *     （auth/tier.js can(user,'subscription')=false：basic 档/公开注册号）仍在清单里，但带 `locked: true`；
+ *     用户拍板「选择器依旧在，无配额账户无法请求，并且弹框提示」—— 让人知道有更强的档、
+ *     怎么拿到（邀请码），而不是当它不存在
+ *
+ * ⚠️ 三处消费方必须都走它/allowedModelsFor：GET /model 的清单、PUT /model 的校验、
+ * turn.js 的模型校验。少一处就是一个绕过闸门的后门 —— 2026-08-19 的独立评审正是在
+ * turn.js 抓到过这种漏校验。校验用 allowedModelsFor（不含 locked），清单用本函数。
+ */
+export const SUBSCRIPTION_LOCK_REASON = DENIAL.subscription;
+
+export function hasSubscriptionAccess(user) {   // 订阅 Claude 资格 = 档位能力（auth/tier.js）；薄封装只为调用点读着顺
+  return can(user, 'subscription');
+}
+
+const upstreamKeyPresent = (row) => { if (!row.api) return !!platform.claudeAuthPresent(); const up = UPSTREAMS[row.api.upstream]; return !up || up.authStyle === 'none' || !!up.key || !!(up.keyEnv && process.env[up.keyEnv]); };   // 无 api = 内置 Claude 行：本地版看本机凭据
+export function selectableModelsFor(user) {
+  const approved = localGenApproved(user);   // 档位 + 逐人批准，同 paint_still / roll_film / 演出端点一把尺
+  const subscribed = hasSubscriptionAccess(user);
+  const out = [];
+  for (const m of SELECTABLE_MODELS) {
+    if (platform.isLocal && !upstreamKeyPresent(BY_ID.get(m.id))) continue;   // 本地版藏没配钥匙的行（含没登录/没 key 时的内置 Claude 行）；hosted 不过滤（缺钥匙让请求 502 fail-loud）
+    if (m.gate === 'localGen') { if (approved) out.push(m); continue; }
+    if (m.gate === 'subscription' && !subscribed) { out.push({ ...m, locked: true, lockReason: SUBSCRIPTION_LOCK_REASON }); continue; }
+    out.push(m);
+  }
+  return out;
+}
+
+/** 真能请求的（不含 locked）。PUT /model 与 turn.js 校验用这份 */
+export function allowedModelsFor(user) {
+  return selectableModelsFor(user).filter((m) => !m.locked);
+}
+
+/** 这个模型对这个用户是「看得见选不了」吗（在清单里且 locked）。turn 拒绝时据此回 403 而不是 400 */
+export function isModelLockedFor(user, appModel) {
+  return selectableModelsFor(user).some((m) => m.id === appModel && m.locked);
+}
+
+/**
+ * 这个用户没选过时用哪个：表里标 `default: true` 的行（08-21 = ox-alpha），它对该用户
+ * 不可选时退到第一个可选的。前端 picker 与新会话的兜底都问这条，不再各自硬编码。
+ */
+export function defaultModelFor(user) {
+  const allowed = allowedModelsFor(user);
+  return (allowed.find((m) => m.default) || allowed[0])?.id || null;
+}
+
+/**
+ * 会话中途从 openai-chat 行（Ox）切到别的通路要拦（08-21 fable 评审 P3）：转换层合成的 thinking 块
+ * 没有 signature，CLI 会把它们原样回传给 Anthropic → 400 invalid signature。返回拒绝理由或 null。
+ */
+export function crossLaneSwitchReason(fromModel, toModel) {
+  if (!fromModel || !toModel || fromModel === toModel) return null;
+  const from = resolveWireModel(fromModel);
+  const to = resolveWireModel(toModel);
+  if (from?.protocol === 'openai-chat' && to?.protocol !== 'openai-chat') {
+    return '这个会话是在 Ox（免费）上开的，它的思考记录换到 Claude 会被拒收。想用 Claude 请新开一个会话';
+  }
+  return null;
+}
+
+/** 免费行（API 行且四价全 0）：金额配额对它无意义，turn.js 改走按轮次的免费闸 */
+export function modelIsFree(appModel) {
+  const p = BY_ID.get(appModel)?.api?.prices;
+  return !!p && ['input', 'output', 'cacheRead', 'cacheWrite'].every((k) => Number(p[k]) === 0);
+}
+
+/**
+ * 这个模型是不是跑在无审查权重上（表里的 `uncensored` 位）。
+ *
+ * 唯一消费方是 prelude 渲染：为 true 的行不注入「底线」那一节（见
+ * agent-shared.renderPrelude）。查表，未知名字一律 false —— 拼错一个字
+ * 只该退回**更严**的那一档，绝不能因为查不到就当成无审查。
+ */
+export function isUncensoredModel(appModel) {
+  if (!appModel) return false;
+  return BY_ID.get(appModel)?.uncensored === true;
+}
+
+/** 决定 sdkOptions.model 喂什么。API 行给 alias；订阅/未知原样返回（让 SDK 自己 fallback） */
+export function resolveSdkSpoofModel(appModel) {
+  if (!appModel) return appModel;
+  const row = BY_ID.get(appModel);
+  return row?.api ? row.api.sdkAlias : appModel;
+}
+
+/** 真实 context window。查表；未命中按 pattern fallback；都不匹配返 null */
+export function resolveModelContextWindow(appModel) {
+  if (!appModel) return null;
+  const row = BY_ID.get(appModel);
+  if (row) return row.window;
+  if (/^kimi[-_]/i.test(appModel)) return 256_000;
+  if (/\[1m\]$/i.test(appModel))   return 1_000_000;
+  return null;
+}
+
+/**
+ * 按 model 选 thinking config（喂 sdkOptions.thinking）。
+ *
+ * API 行统一走 enabled+budget（older-model 路径）——真正的出口形态由
+ * model-ingress 按行内 thinking 字段决定（'strip' 会把字段整个删掉），
+ * 这里给 SDK 的值只影响 SDK 内部行为，不到线上。
+ *
+ * 订阅行沿用原 regex 逻辑：
+ *   - adaptive 一族：Opus 4.6+ / Sonnet 5+ / Fable / Mythos。
+ *     ⚠️ Sonnet 5 起 budgetTokens 已被 API 移除（enabled+budget 会 400）。
+ *   - display 必须显式 'summarized'：默认 'omitted' 时 thinking 块是空文本，
+ *     前端思考期完全静默（2026-07-23 "失联"问题主因）。
+ */
+export function pickThinkingConfig(model) {
+  const row = model ? BY_ID.get(model) : null;
+  if (row?.api) return { type: 'enabled', budgetTokens: 8192 };
+  if (model && /^claude-(?:opus-(?:4-[6789]|[5-9])|sonnet-[5-9]|fable|mythos)/.test(model)) {
+    return { type: 'adaptive', display: 'summarized' };
+  }
+  return { type: 'enabled', budgetTokens: 8192 };
+}
+
+// ── 新导出：路由 ──
+
+/**
+ * 会话模型 → 通路描述。session-loop 据此决定 env 注入。
+ *
+ * `window` 要喂给 `CLAUDE_CODE_AUTO_COMPACT_WINDOW`：2026-08-19 盒上实测，
+ * SDK 的压缩窗口 = **min(该 env, 别名的 rawMaxTokens)**（getContextUsage 的
+ * autocompactSource 会从 model-default/auto 变成 env）。两个都得对：
+ *   - 只靠别名：200k 名白扔容量，1M 名会一路涨到远超上游 n_ctx 然后炸
+ *   - 只靠 env：会被别名的 rawMaxTokens 钳住（200k 别名 + env 262144 = 200000）
+ * 所以 sdkAlias 一律选 1M 档打底，真实值由这个 env 钉死。
+ *
+ * @returns {{ mode: 'subscription' } | {
+ *   mode: 'api', appModel: string, sdkAlias: string, fastModel: string,
+ *   window: number, upstreamId: string, upstream: object,
+ * }}
+ */
+export function resolveModelRoute(appModel) {
+  const row = appModel ? BY_ID.get(appModel) : null;
+  if (!row?.api) return { mode: 'subscription' };
+  return {
+    mode: 'api',
+    appModel: row.id,
+    sdkAlias: row.api.sdkAlias,
+    fastModel: row.api.fastModel,
+    window: row.window,
+    upstreamId: row.api.upstream,
+    upstream: UPSTREAMS[row.api.upstream],
+  };
+}
+
+/**
+ * 入口反查：请求 body.model（可能是 appModel、sdkAlias 或剥了 [1m] 的 alias）
+ * → 该发往哪里、怎么修。查不到返回 null（入口 fail-loud 502，不静默转发）。
+ */
+export function resolveWireModel(bodyModel) {
+  const row = typeof bodyModel === 'string' ? WIRE_LOOKUP.get(bodyModel) : null;
+  if (!row) return null;
+  return {
+    appModel: row.id,
+    wireModel: row.api.wireModel,
+    upstreamId: row.api.upstream,
+    upstream: UPSTREAMS[row.api.upstream],
+    thinking: row.api.thinking || 'strip',
+    liftImages: !!row.api.liftImages,
+    protocol: UPSTREAMS[row.api.upstream]?.protocol || 'anthropic',
+    reasoningEffort: row.api.reasoningEffort || null,
+    // helper 请求（标题生成 / auto 分类器 / 摘要 —— 凡 body.model 不是会话主行的）用的档位：
+    // 行内可写 helperReasoningEffort 显式指定，没写就 'low'（Ox 实测 low=0 reasoning token）。
+    // 主 agent 想多少是主行的事，helper 一句话的活不该跟着 high/max 想几分钟
+    helperReasoningEffort: row.api.helperReasoningEffort || (row.api.reasoningEffort ? 'low' : null),
+    maxOutput: row.api.maxOutput || null,
+    // 「只想了没说」的就地重发额度（lib/ingress/forward-openai-chat.js）。**按行配**而不是全局：
+    // 这是某个模型的体质问题不是协议的 —— 08-21 深夜实测当天 4 次全在 Ox 两个主行上（它吐第一个字前
+    // 要想很久，深想档一发约 45 秒，Zen 掐流的窗口就长），所以那两行放宽到 6 次 / 360 秒，别的行走
+    // 全局默认（env / 2 次 / 120 秒）；helper 不放宽（一句话的活，重发只是白占上游）。
+    // ⭐天花板由 CLI 定：流式请求走 SDK 客户端 timeout 600 秒，而预算是**开新一发之前**查的 →
+    // 预算 + 单发最长挂起（实测 185 秒）必须 < 600 秒（配了断言，见 upstream-truncation.test.js）。
+    emptyRetries: Number.isFinite(row.api.emptyRetries) ? row.api.emptyRetries : null,
+    retryBudgetMs: Number.isFinite(row.api.retryBudgetMs) ? row.api.retryBudgetMs : null,
+  };
+}
+
+/**
+ * usage 差分 reprice：key 从 SDK alias 还原成 appModel，按行内 prices 重算
+ * costUsd。多个 key 归并到同一 appModel 时逐字段相加。context.js 的
+ * absorbResult 在差分之后调这一步。
+ *
+ * ⚠️ 必须带 sessionAppModel 且只对 API 会话生效：SDK 报的 usage key 是 alias，
+ * 而 alias 同时也是真实存在的订阅 Claude 名（sonnet-4-6[1m] 既是 Gemini 的
+ * spoof 也是一个真模型）——不看会话通路就 remap，订阅会话跑 sonnet-4-6 会被
+ * 错记成 Gemini 的账。订阅会话原样返回，一个字段都不动。
+ *
+ * @param {Record<string, {inputTokens, outputTokens, cacheReadTokens, cacheCreateTokens, costUsd}>} deltas
+ * @param {string} sessionAppModel  本会话的 appModel（AgentContext.appModel）
+ * @returns 同构对象（API 会话新建；订阅会话原样返回入参）
+ */
+export function repriceUsageDeltas(deltas, sessionAppModel) {
+  if (!deltas || typeof deltas !== 'object') return deltas;
+  const sessionRow = sessionAppModel ? BY_ID.get(sessionAppModel) : null;
+  if (!sessionRow?.api) return deltas;
+  // API 会话的所有请求必经 ingress：表内 key 按表归；不在表里的 key（SDK 内部
+  // helper 用 config 默认 Claude 名发的请求）必然被 ingress 的会话 fast 兜底
+  // 承接 —— 归到 fastModel 头上是精确归因，不是猜测。
+  const fastRow = BY_ID.get(sessionRow.api.fastModel);
+  const out = {};
+  for (const [key, d] of Object.entries(deltas)) {
+    const row = WIRE_LOOKUP.get(key) || fastRow;
+    const appKey = row ? row.id : key;
+    const p = row?.api?.prices;
+    const repriced = p ? {
+      ...d,
+      costUsd: (
+        d.inputTokens * p.input
+        + d.outputTokens * p.output
+        + d.cacheReadTokens * (p.cacheRead || 0)
+        + d.cacheCreateTokens * (p.cacheWrite || 0)
+      ) / 1e6,
+    } : { ...d };
+    const prev = out[appKey];
+    out[appKey] = prev ? {
+      inputTokens: prev.inputTokens + repriced.inputTokens,
+      outputTokens: prev.outputTokens + repriced.outputTokens,
+      cacheReadTokens: prev.cacheReadTokens + repriced.cacheReadTokens,
+      cacheCreateTokens: prev.cacheCreateTokens + repriced.cacheCreateTokens,
+      costUsd: prev.costUsd + repriced.costUsd,
+    } : repriced;
+  }
+  return out;
+}