@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/lib/chalk-flow.js

@@ -0,0 +1,88 @@
+/**
+ * server/lib/chalk-flow.js —— 长文自动分条（write_on_board 的 flow，2026-08-30）
+ *
+ * ## 为什么要有这个文件
+ *
+ * 「剩 15 行、我这段是 14 行还是 16 行」这道算术模型做不准，也不该由它做 ——
+ * proj_mtfpehm3 首场真会话 14 发 board_batch 挂了 6 发，全是容量拒收，本质全是
+ * 这道算术。flow 把它拿走：agent 交整段内容，机器按**段落边界**拆成若干条
+ * ≤ 一张卡高的小板书，链着往版位/纸里排，装到哪儿是哪儿，装不下的**原样退回**
+ * （绝不静默丢、绝不硬挤、绝不替它翻页 —— 刀 F 的教义一条不破）。
+ *
+ * ## 拆分纪律
+ *
+ *   1. 只在**空行**处拆，且空行必须在围栏（``` fence）外 —— 代码块/nd:controls/
+ *      表格永远整块走，切开它们比写不下更坏。
+ *   2. 单块超高时降级到**句子边界**（。！？.!?; 换行也算），仍不切词。
+ *   3. 一句话就超高的（极少）：整句放行，靠既有的折叠 + 如实报兜底。
+ *   4. 贪心装填：往当前条里续块，直到再续就超 maxH。
+ */
+
+import { textBox } from './sketch-layout.js';
+
+const FENCE_LINE = /^[ \t]*```/;
+
+/**
+ * 按空行拆块（围栏内的空行不算边界）。
+ * @returns {string[]} 原文顺序的块，各自 trim 过、非空
+ */
+export function splitBlocks(body) {
+  const lines = String(body || '').split(/\r?\n/);
+  const blocks = [];
+  let cur = [];
+  let inFence = false;
+  const push = () => {
+    const t = cur.join('\n').trim();
+    if (t) blocks.push(t);
+    cur = [];
+  };
+  for (const l of lines) {
+    if (FENCE_LINE.test(l)) inFence = !inFence;
+    if (!inFence && !l.trim()) { push(); continue; }
+    cur.push(l);
+  }
+  push();
+  return blocks;
+}
+
+/** 单块超高时的降级：按句子边界拆（不切词；拆不动就原样一块） */
+function splitSentences(block) {
+  const parts = String(block).split(/(?<=[。！？!?；;])\s*/).filter((s) => s.trim());
+  return parts.length > 1 ? parts : [block];
+}
+
+/**
+ * 把长文拆成若干条小板书的正文。
+ *
+ * @param {string} body
+ * @param {object} opts
+ * @param {number} opts.wUnits  目标宽（格数，24px 一格）—— 跟真落板同一把尺
+ * @param {string} [opts.size]  字号档（同 write_on_board 的 size）
+ * @param {number} opts.maxH    单条上限（px；通常 CARD_MAX_H）
+ * @returns {string[]}  每条的正文。measure 用的是 textBox —— 跟落位那一刻同一个
+ *   函数量出来的数，不存在"估的和真的不一样"这层误差。
+ */
+export function flowChunks(body, { wUnits, size = 'md', maxH }) {
+  const measure = (t) => textBox(t, size === 'sm' ? 'md' : size, { md: true, wUnits }).h;
+  const fits = (t) => measure(t) <= maxH;
+
+  // 先把超高的单块降级拆开，得到一串"每个都尽量 ≤ maxH"的原子
+  const atoms = [];
+  for (const b of splitBlocks(body)) {
+    if (fits(b)) { atoms.push(b); continue; }
+    for (const s of splitSentences(b)) atoms.push(s);
+  }
+  if (!atoms.length) return [];
+
+  // 贪心装填：能续就续。用 \n\n 拼回 —— 空行本来就是它们之间的边界
+  const chunks = [];
+  let cur = atoms[0];
+  for (const a of atoms.slice(1)) {
+    const joined = `${cur}\n\n${a}`;
+    if (fits(joined)) { cur = joined; continue; }
+    chunks.push(cur);
+    cur = a;
+  }
+  chunks.push(cur);
+  return chunks;
+}

package/server/lib/chalk-rewrite.js

@@ -0,0 +1,63 @@
+/**
+ * server/lib/chalk-rewrite.js —— 「重写一条板书的正文」这一件事，收成一份
+ * （2026-08-30）
+ *
+ * 在这之前只有 `edit_board` 的 set_text 会做这件事（edit-board.js 的板书文件分支），
+ * 而它做对了三件容易漏的：
+ *   1. 读原文 → 只换 body，frontmatter 逐字保留（by/at/anchor/reply_to/tag/session）
+ *      —— `renderChalk` 只回写白名单键，拼错一个键就是整行静默丢失
+ *   2. 宽度沿用现有的（改正文不该改版心），高度按新正文重算
+ *   3. **用户亲手拖出来的留白留得住**（`sized:'user'` 时取重算高与现高的较大者）
+ *      —— 他调的是「这一块留多少空」，重写一次正文就抹掉，是把他的排版意图当缓存
+ *
+ * `set_vars` 要做的是同一件事（改表里一格 = 重写这条板书的正文），所以这里抽出来
+ * 两处共用，而不是抄第二份。抄的话第 3 条几乎必然被漏掉 —— 它是三条里唯一
+ * 「漏了也不报错、只是用户的排版悄悄没了」的那条。
+ *
+ * ⚠️ 笔权（只有作者本人能改自己的话）**不在这里判** —— 那是调用方的事：
+ * edit_board 按 `by` 判，set_vars 有自己的规矩（状态表是场务件不是谁的台词）。
+ * 放进来会让两个调用方共享一条它们其实不共享的语义。
+ */
+
+import { promises as fs } from 'node:fs';
+import { parseChalk, renderChalk } from './chalk.js';
+import { STATE_TABLE_TAG, parseStateTable } from './state-table.js';
+import { UNIT, textBox } from './sketch-layout.js';
+
+/**
+ * 重写一条板书文件的正文，并算出它在板上的新尺寸。
+ *
+ * @param {string} abs      板书文件的绝对路径
+ * @param {string} body     新正文
+ * @param {object} entry    这条板书在 board.json 里的条目（要 w / h / sized / by）
+ * @returns {Promise<{ w:number, h:number }>} 新的盒子（宽沿用、高按正文重算）
+ * @throws  文件读不到 / 写不进时抛，调用方自己决定怎么说
+ */
+export async function rewriteChalkBody(abs, body, entry = {}) {
+  const parsed = parseChalk(await fs.readFile(abs, 'utf8'));
+  const c = parsed.chalk || {};
+  // 状态表堵写口（2026-08-30）：这条板书是载重的（set_vars/nd:triggers/draw_trend
+  // 全读它），一次"成功"的重写就能把它们全弄死 —— glm 真会话用 \r 系字面量重写，
+  // set_text 报 Applied 2/2、表却永久 broken。重写后表必须还在，不在就大声拒。
+  if (c.tag === STATE_TABLE_TAG) {
+    const t = parseStateTable(String(body).replace(/\r\n?/g, '\n'));
+    if (!t.ok) {
+      const ex = new Error(`这一改会把状态表写坏（${t.error === 'no-table' ? '「| 键 | 值 |」表没了' : t.error}）—— 什么都没写。改值用 set_vars；重写正文要保证那张两列表还在。`);
+      ex.code = 'STATE_TABLE';
+      throw ex;
+    }
+  }
+  await fs.writeFile(abs, renderChalk({
+    body,
+    by: c.by || entry.by || 'agent',
+    ...(c.at ? { at: c.at } : {}),
+    anchor: c.anchor,
+    replyTo: c.replyTo,
+    tag: c.tag,
+    sessionId: parsed.sessionId,
+  }), 'utf8');
+
+  const box = textBox(body, 'md', { md: true, wUnits: Math.max(8, Math.round((entry.w || 432) / UNIT)) });
+  const h = entry.sized === 'user' ? Math.max(box.h, Number(entry.h) || 0) : box.h;
+  return { w: box.w, h };
+}

package/server/lib/chalk-size-pref.js

@@ -0,0 +1,48 @@
+/**
+ * lib/chalk-size-pref.js —— 「用户喜欢多宽的板书」（2026-08-28）
+ *
+ * ## 为什么学得到
+ *
+ * 板书的**宽是真排版**（前端 BoardObject 的 `width: sz.w` 决定折行），高只是脚印
+ * （盒子不设 height，由正文撑）。所以用户拖宽一块板书是一个有信息量的动作：他在说
+ * "这个宽度读着舒服"。以前这个动作留不下任何痕迹，下一拍 agent 又按正文估一遍宽，
+ * 用户就得反复调同一件事。
+ *
+ * 学习票源是 `sized: 'user'` —— 前端拖完手柄盖的章，**不是模型能写的东西**
+ * （sanitizeObject 白名单收，模型走 patchBoard 也盖不出别人的章）。
+ *
+ * ## 为什么只学宽不学高
+ *
+ * 高度跟着正文长短走，一段三行的话和一段三十行的话不该一样高。用户拖高度调的是
+ * "这一块留多少空"，那是**这一块**的属性，不是可以套到下一块上的偏好。宽度不同：
+ * 它是版心，跨块稳定。硬把高度也套过去，结果是每块板书都拖着一截空白。
+ *
+ * ## 取最近三块的中位数
+ *
+ * 板书 id 是 `notes/板书/<时间戳>-<slug>.md`，时间戳可直接字典序排 —— 不用另存时间。
+ * 取最近三块：一块就听它的（他刚调完，下一拍就该照做），三块取中位数（一次手滑
+ * 拖出个极端值不至于带偏后面所有的）。
+ */
+
+/** 网格单位（px）。跟 write_on_board 的 width 参数同一把尺 */
+const GRID = 24;
+/** 学习窗口：最近几块用户亲手调过的板书 */
+const WINDOW = 3;
+
+/**
+ * @param {object} board board.json（sanitize 过的）
+ * @returns {number|null} 网格单位的宽；没有票就 null（调用方回落按正文估）
+ */
+export function learnedChalkWidth(board) {
+  const votes = Object.entries(board?.objects || {})
+    .filter(([id, e]) => e?.sized === 'user' && Number(e.w) > 0 && id.includes('/板书/'))
+    .sort(([a], [b]) => (a < b ? 1 : -1))     // id 里的时间戳倒序 = 最近的在前
+    .slice(0, WINDOW)
+    .map(([, e]) => Math.round(Number(e.w) / GRID));
+  if (!votes.length) return null;
+  const sorted = [...votes].sort((a, b) => a - b);
+  const mid = sorted[Math.floor(sorted.length / 2)];
+  // 回到 write_on_board 的合法区间（schema 是 8..60）；超出就当没学到，别拿一个
+  // 会被 schema 打回来的值去顶替一个能用的估算
+  return mid >= 8 && mid <= 60 ? mid : null;
+}

package/server/lib/chalk.js

@@ -11,7 +11,7 @@
  *
  * frontmatter（只认这几个键，其余原样当正文）：
  *   nd: chalk            标记（没有它就是普通便利贴）
- *   by: agent|user
+ *   by: agent | user | rp-<slug>（常驻角色，2026-08-26）
  *   at: ISO 时间
  *   anchor: <canvas id>  这段话关于谁（落盘时顺手画 annotates 线）
  *   reply_to: <path>     回应哪一条板书（线程）
@@ -19,11 +19,26 @@
  *   session: <sid>       （沿用便利贴的归属字段）
  */
 import path from 'node:path';
+import { ROLE_SLUG_RE } from '../engine/agent/cast.js';
 import { promises as fs } from 'node:fs';
 
 export const CHALK_DIR = 'notes/板书';
 const FM_RE = /^---\n([\s\S]{0,800}?)\n---\n?/;
 
+/**
+ * 板书的署名收成三类：`user` / `agent` / 常驻角色的 slug（`rp-*`）。
+ *
+ * 为什么不原样全收：`by` 会被前端拿去显示、被 read_board 拿去分段、将来还要被
+ * 收件箱拿去路由。收任意字符串等于给这几个读者一起开口子（而写这个值的是模型）。
+ * 认不出的一律落回 'agent' —— 老板书没有这个字段，落回去正好是它本来的语义。
+ */
+export function normalizeBy(raw) {
+  const v = String(raw || '').trim();
+  if (v === 'user') return 'user';
+  if (ROLE_SLUG_RE.test(v)) return v;
+  return 'agent';
+}
+
 export function parseChalk(raw) {
   const m = FM_RE.exec(raw);
   if (!m) return { body: raw, chalk: null, sessionId: null };
@@ -35,7 +50,7 @@ export function parseChalk(raw) {
     body,
     sessionId: get('session'),
     chalk: {
-      by: get('by') === 'user' ? 'user' : 'agent',
+      by: normalizeBy(get('by')),
       at: get('at'),
       anchor: get('anchor'),
       replyTo: get('reply_to'),
@@ -50,7 +65,9 @@ export function renderChalk({ body, by = 'agent', at = new Date().toISOString(),
   if (replyTo) lines.push(`reply_to: ${replyTo}`);
   if (tag) lines.push(`tag: ${tag}`);
   if (sessionId) lines.push(`session: ${sessionId}`);
-  lines.push('---', '', String(body).trim(), '');
+  // CR 系换行在唯一写口归一（2026-08-30）：glm 真会话把换行写成 \r 系字面量，
+  // 整张表被压成一行还落了盘 —— CR 在板书正文里没有合法用途，进门就换成 \n。
+  lines.push('---', '', String(body).replace(/\r\n?/g, '\n').trim(), '');
   return lines.join('\n');
 }
 
@@ -79,6 +96,28 @@ export async function writeChalkFile(sharedRoot, fileName, content, { overwrite
   return `${CHALK_DIR}/${name}`;
 }
 
+/**
+ * 软删（2026-08-25，信箱 iss_mt8cvn16：板书 rm 后无法恢复）：删除入口一律把文件
+ * 挪进 `.nd/trash/<YYYYMMDD>/` 而不是 unlink —— `.nd/` 不上画布不进 git，用户体感
+ * 就是删了，但捞得回来。挪不动（跨盘等）才退回真删。
+ */
+export async function trashChalkFile(sharedRoot, absPath) {
+  try {
+    const day = new Date().toISOString().slice(0, 10).replace(/-/g, '');
+    const dir = path.join(sharedRoot, '.nd', 'trash', day);
+    await fs.mkdir(dir, { recursive: true });
+    let dest = path.join(dir, path.basename(absPath));
+    for (let i = 2; i < 100; i += 1) {
+      try { await fs.access(dest); dest = path.join(dir, path.basename(absPath).replace(/\.md$/, `-${i}.md`)); } catch { break; }
+    }
+    await fs.rename(absPath, dest);
+    return dest;
+  } catch {
+    try { await fs.unlink(absPath); } catch { /* 已经没了 */ }
+    return null;
+  }
+}
+
 /** 最近的板书（给注入用）：按文件名（=时间戳）倒序，读前几条的首行 */
 export async function recentChalk(sharedRoot, { limit = 8 } = {}) {
   const dir = path.join(sharedRoot, CHALK_DIR);

package/server/lib/ingress/forward-openai-chat.js

@@ -21,6 +21,9 @@
 import http from 'node:http';
 import https from 'node:https';
 import { toOpenAIChatRequest, fromOpenAIChatResponse, toAnthropicError, OpenAIToAnthropicSSE, truncationOfChatResponse } from './openai-chat.js';
+import { upstreamCostOf } from './upstream-billing.js';
+import { upstreamErrorHint } from './upstream-error-hints.js';
+import { armIdleWatchdog } from './stream-watchdog.js';
 
 export const DEFAULT_EMPTY_RETRIES = 2;
 export const DEFAULT_RETRY_BUDGET_MS = 120_000;
@@ -53,7 +56,7 @@ export function retryBudgetMs(env = process.env) {
 export function forwardOpenAIChat({ parsed, wire, key, res, sidShort, target, path, agent, onOutcome = () => {}, onBilling = () => {}, onTruncated = () => {}, onNotice = () => {} }) {
   const wantStream = !!parsed.stream;
   const label = wire.upstream?.label || wire.upstreamId;
-  const body = toOpenAIChatRequest(parsed, { reasoningEffort: wire.reasoningEffort, maxOutput: wire.maxOutput });
+  const body = toOpenAIChatRequest(parsed, { reasoningEffort: wire.reasoningEffort, maxOutput: wire.maxOutput, bodyExtra: wire.bodyExtra });
   const outBody = Buffer.from(JSON.stringify(body), 'utf8');
   const useHttps = target.protocol === 'https:';
   const headers = {
@@ -214,7 +217,8 @@ export function forwardOpenAIChat({ parsed, wire, key, res, sidShort, target, pa
             if (settled || dead) return;
             settled = true;
             currentReq = null;
-            const msg = text?.trim() ? text : `${label} 上游返回 ${status}（模型暂时不可用，稍后再发一次）`;
+            // 上游 4xx 的英文原文会原样落到用户的聊天框里 —— 能给出路的那几条翻成人话（原文保留在括号里）
+            const msg = upstreamErrorHint(text, wire) || (text?.trim() ? text : `${label} 上游返回 ${status}（模型暂时不可用，稍后再发一次）`);
             console.warn(`[model-ingress] sid=${sidShort} upstream=${wire.upstreamId} ${status} model=${wire.wireModel} body=${String(text || '').slice(0, 200).replace(/\s+/g, ' ')}`);
             failHard(status, msg, `HTTP ${status}${streaming ? ' on retry' : ''}`);
           };
@@ -234,6 +238,12 @@ export function forwardOpenAIChat({ parsed, wire, key, res, sidShort, target, pa
         proxyRes.on('aborted', () => attemptOver('aborted'));
         proxyRes.on('error', (err) => attemptOver(err.code || err.message));
         proxyRes.on('end', () => attemptOver(null));
+        // 断流看门狗（2026-08-29）：destroy 触发上面的 'error' → attemptOver 走
+        // 现成的判决/重发机 —— 不新开收尾路，只补「静默也算死」这一种死法。
+        armIdleWatchdog(proxyRes, { onIdle: (silentMs) => {
+          console.warn(`[model-ingress] sid=${sidShort} upstream=${wire.upstreamId} 流静默 ${Math.round(silentMs / 1000)}s —— 看门狗掐断死流`);
+          try { proxyRes.destroy(new Error('stream idle watchdog')); } catch { /* 已经死了就算了 */ }
+        } });
         proxyRes.pipe(xf, { end: false });   // end:false —— 这条 SSE 还要接着用（可能再打一发）
       }, (detail) => attemptOver(detail, false));   // 连不上 / RST：同一条判决路，绝不自己碰 res
     };
@@ -265,7 +275,8 @@ export function forwardOpenAIChat({ parsed, wire, key, res, sidShort, target, pa
       const text = Buffer.concat(chunks).toString('utf8');
       if (status >= 400) {
         console.warn(`[model-ingress] sid=${sidShort} upstream=${wire.upstreamId} ${status} model=${wire.wireModel} body=${text.slice(0, 200).replace(/\s+/g, ' ')}`);
-        const msg = text.trim() ? text : `${label} 上游返回 ${status}（模型暂时不可用，稍后再发一次）`;
+        // ⚠️ 跟上面流式那条是**孪生的两条路**，翻译要两边都挂（生产走流式，探针走非流式，只补一边会以为修好了）
+        const msg = upstreamErrorHint(text, wire) || (text.trim() ? text : `${label} 上游返回 ${status}（模型暂时不可用，稍后再发一次）`);
         onOutcome(false, `HTTP ${status}`);
         const errBody = JSON.stringify(toAnthropicError(status, msg));
         res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(errBody)) });
@@ -292,7 +303,8 @@ export function forwardOpenAIChat({ parsed, wire, key, res, sidShort, target, pa
       }
       onOutcome(true);
       onTruncated(truncationOfChatResponse(upstreamJson));
-      if (upstreamJson.cost != null || upstreamJson.usage) onBilling({ costUsd: upstreamJson.cost ?? null, usage: upstreamJson.usage || null });
+      const costUsd = upstreamCostOf(upstreamJson);   // Zen 放顶层、Merge 网关放 usage.cost
+      if (costUsd != null || upstreamJson.usage) onBilling({ costUsd, usage: upstreamJson.usage || null });
       const respBody = JSON.stringify(out);
       res.writeHead(200, { 'Content-Type': 'application/json', 'Content-Length': String(Buffer.byteLength(respBody)) });
       res.end(respBody);

package/server/lib/ingress/openai-chat.js

@@ -4,10 +4,12 @@
  * ## 为什么有这层
  *
  * SDK binary 永远说 Anthropic Messages；model-ingress 以前只会**转发**（上游也说 Anthropic）。
- * OpenCode Zen 的免费模型 Ox Alpha（x-preview-f-free）只有 OpenAI chat 格式能用工具
- * （Zen 给它架的 /v1/messages 桥一带 tools 就 [1210]，08-21 四种写法探死），newapi 中转站
- * 同病。所以协议映射得自己做 —— 不上 gproxy（外部守护进程 + 四个已知洞 + 第二个 quirk
- * 真相源），在 ingress 里按上游 `protocol: 'openai-chat'` 分岔，其余上游一字不动。
+ * OpenCode Zen 整家**只有 OpenAI chat 格式能用工具**（它给模型架的 /v1/messages 桥一带 tools
+ * 就 [1210]，08-21 拿当时的 Ox Alpha 四种写法探死），newapi 中转站、NVIDIA build 同病。所以协议
+ * 映射得自己做 —— 不上 gproxy（外部守护进程 + 四个已知洞 + 第二个 quirk 真相源），在 ingress 里按
+ * 上游 `protocol: 'openai-chat'` 分岔，其余上游一字不动。
+ * ⭐ 逼出这层的 Ox 08-26 就下架了，这层照常服务着 zen/zenGo/nvidia 三家 —— **闸和转换层才是耐久
+ * 资产，模型行是插件**（08-21 加 Ox 时写下的判断，一周后应验）。
  *
  * ## 映射要点（都是探针实测逼出来的，不是抄规范）
  *
@@ -16,7 +18,7 @@
  *   文本混排 → 先吐 role:tool 条，再吐 role:user 条（文本 + 提出来的图）
  * - thinking 块不回传（没有 signature 机制）；assistant 历史里的 thinking 合成 reasoning_content
  *   （models.dev 标 interleaved.field=reasoning_content，回传给模型接着想）
- * - Anthropic thinking 参数 → reasoning_effort（行内 reasoningEffort，Ox 三档 low|high|max）
+ * - Anthropic thinking 参数 → reasoning_effort（行内 reasoningEffort；zen 系普遍是 low|high|max 三档，**没有 medium**）
  * - 流式：OpenAI chunk → 合成 message_start / content_block_* / message_delta / message_stop；
  *   usage 在最后一个 chunk（stream_options.include_usage），Anthropic 口径 input 不含 cache 命中
  * - stop_reason：tool_calls→tool_use · stop→end_turn · length→max_tokens；有 tool_calls 但
@@ -34,6 +36,7 @@
  *   会话直接判死 —— 现有的 content_filter→end_turn 在 Claude Code 语境下才是对的
  */
 import { Transform } from 'node:stream';
+import { upstreamCostOf } from './upstream-billing.js';
 
 const STOP_MAP = { tool_calls: 'tool_use', stop: 'end_turn', length: 'max_tokens', content_filter: 'end_turn', function_call: 'tool_use' };
 
@@ -97,7 +100,7 @@ function splitToolResult(block) {
 
 /**
  * @param {object} parsed Anthropic Messages body（已过 transformForUpstream：model 已是 wireModel）
- * @param {{ reasoningEffort?: string, maxOutput?: number }} opts
+ * @param {{ reasoningEffort?: string, maxOutput?: number, bodyExtra?: object|null }} opts
  * @returns {object} OpenAI chat.completions body
  */
 export function toOpenAIChatRequest(parsed, opts = {}) {
@@ -169,6 +172,9 @@ export function toOpenAIChatRequest(parsed, opts = {}) {
   // 档位只看行内 reasoningEffort：Anthropic 的 thinking 字段在进到这里之前已被 transformForUpstream
   // 按行内 thinking:'strip' 删掉（fable 评审抓的：以前以它存在为前提，档位从没发出去过）
   if (opts.reasoningEffort && parsed.thinking?.type !== 'disabled') out.reasoning_effort = opts.reasoningEffort;
+  // 上游要的额外顶层字段（merge 的 `vendor` 点名）。最后合、且允许盖上面任何一个键：
+  // 它是行里明写的上游特配，比这里推导出来的默认值更该赢
+  if (opts.bodyExtra) Object.assign(out, opts.bodyExtra);
   return out;
 }
 
@@ -200,7 +206,10 @@ export function fromOpenAIChatResponse(json) {
   const choice = json.choices[0] || {};
   const m = choice.message || {};
   const content = [];
-  if (m.reasoning_content) content.push({ type: 'thinking', thinking: String(m.reasoning_content), signature: '' });
+  // 思考文本的字段名各家不一样：zen 系是 reasoning_content（models.dev 的 interleaved.field），
+  // Merge 网关是 `thinking`（另带 thinking_signature，我们不回传签名所以不取）。先认前者，回退后者。
+  const reasoning = m.reasoning_content || m.thinking;
+  if (reasoning) content.push({ type: 'thinking', thinking: String(reasoning), signature: '' });
   if (m.content) content.push({ type: 'text', text: String(m.content) });
   if (m.refusal) content.push({ type: 'text', text: String(m.refusal) });
   for (const c of m.tool_calls || []) {
@@ -270,7 +279,7 @@ export class OpenAIToAnthropicSSE extends Transform {
     this.sawText = false;      // 有过可见正文（区分"只想没说"的早断流）
     this.failReason = null;    // 本次以 error 事件收场的原因（forward 层据此记会话失败计数；null = 正常收尾）
     this.truncated = null;     // 本次「半截」收场的原因（见 truncationReason；forward 层据此报给 session-loop 续接）
-    this.cost = null;          // 上游报的本次费用（美元，/zen/go 在 [DONE] 后补的 cost 字段；null = 上游没报）
+    this.cost = null;          // 上游报的本次费用（美元，/zen/go 在 [DONE] 后补顶层 cost、Merge 网关放 usage.cost；null = 上游没报）
     this.doneSeen = false;     // 见过 [DONE]：之后只收 cost，收尾等 _flush
     this.attempts = 1;         // 这条 SSE 一共打了几发上游（就地重发会 ++）
     this.attemptUsage = null;  // 这一发的 usage
@@ -305,13 +314,15 @@ export class OpenAIToAnthropicSSE extends Transform {
   _handleChunk(chunk) {
     this._ensureStart(chunk);
     if (chunk.usage) this.attemptUsage = chunk.usage;
-    if (chunk.cost != null) this.attemptCost = Number(chunk.cost);
+    const chunkCost = upstreamCostOf(chunk);   // 顶层 cost（Zen）或 usage.cost（Merge 网关）
+    if (chunkCost != null) this.attemptCost = chunkCost;
     const choice = chunk.choices?.[0];
     if (!choice) return;
     const d = choice.delta || {};
-    if (d.reasoning_content) {
+    const reasoningDelta = d.reasoning_content || d.thinking;   // 同上：Merge 网关的增量字段叫 thinking
+    if (reasoningDelta) {
       if (this.open?.kind !== 'thinking') this._openBlock('thinking', { type: 'thinking', thinking: '', signature: '' });
-      this._emit('content_block_delta', { type: 'content_block_delta', index: this.open.index, delta: { type: 'thinking_delta', thinking: String(d.reasoning_content) } });
+      this._emit('content_block_delta', { type: 'content_block_delta', index: this.open.index, delta: { type: 'thinking_delta', thinking: String(reasoningDelta) } });
     }
     // content 与 refusal 都是"可见正文"，进同一个 text 块（拒答也是模型说的话，原样吐给用户）
     for (const piece of [d.content, d.refusal]) {
@@ -471,7 +482,7 @@ export class OpenAIToAnthropicSSE extends Transform {
       if (payload === '[DONE]') { this.doneSeen = true; continue; }
       let j;
       try { j = JSON.parse(payload); } catch { continue; }
-      if (this.doneSeen || this.done) { if (j && j.cost != null) this.attemptCost = Number(j.cost); continue; }
+      if (this.doneSeen || this.done) { const c = upstreamCostOf(j); if (c != null) this.attemptCost = c; continue; }
       if (j?.error) {   // 流中途的错误体：转成 Anthropic error 事件
         this._ensureStart(j);
         this._closeOpen();          // 先把开着的块闭合再发 error（顺序反了会出现 error 后面还跟 content_block_stop）

package/server/lib/ingress/session-routes.js

@@ -11,9 +11,9 @@
  * 成功转发不留日志。表级断言封不住（SDK 内部会用哪些名字没法枚举），所以是**会话级路由**：一个会话只认
  * 自己那行和自己的 fast 行，其它一概改道 fast 兜底，绝不跨行。
  *
- * 08-22 起**会话优先**而不是全表优先：本地分发版的外部插槽共用同一个 sdkAlias（表内只剩一个空着的 1M 订阅名，
- * 见 model-context.js EXTERNAL_SDK_ALIAS），全表反查分不出它们，只有会话知道自己是谁。先问会话、再查全表，
- * 对内置行结果不变（自己的 alias 反查到的就是自己）。
+ * 08-22 起**会话优先**而不是全表优先：不写 sdkAlias 的行（外部插槽全部 + 08-25 起的内置新行）共用同一个
+ * spoof 名（model-table.js SHARED_SDK_ALIAS），全表反查分不出它们，只有会话知道自己是谁。先问会话、再查全表，
+ * 对独占别名的行结果不变（自己的 alias 反查到的就是自己）。
  */
 
 import { resolveWireModel, resolveModelRoute, wireNamesOf } from '../../engine/agent/model-context.js';

package/server/lib/ingress/stream-watchdog.js

@@ -0,0 +1,53 @@
+/**
+ * server/lib/ingress/stream-watchdog.js —— 上游流断死看门狗（2026-08-29）
+ *
+ * 现场（proj_mtexu1kp 纸范式验收当晚）：glm-5.3-flash-zai 在开始流 tool_use 入参时
+ * 断粮 —— 没有错误、没有 EOF、没有日志，TCP 就那么开着不再来字节。run 无限挂起，
+ * 前端还留着一张流到一半的工具卡，直到用户手动中断。**用户不该替我们当看门狗。**
+ *
+ * 判据：SSE 的正常节奏是亚秒级 chunk（thinking 长停顿也有事件/ping 垫着），静默
+ * 超过 IDLE_MS = 死流。掐掉（destroy）让下游走各自现成的错误路：
+ *   - Anthropic 直连透传路：CLI 收到流错误 → 自己重试
+ *   - openai-chat 转换路：proxyRes 'error' → attemptOver → 就地重发/判决机
+ *
+ * 只对流式响应上岗（非流式的整包响应可以长时间零字节，是合法的慢）。
+ */
+
+const DEFAULT_IDLE_MS = 180_000;
+const CHECK_MS = 15_000;
+
+export function idleMsFromEnv() {
+  const n = Number(process.env.NODESIGN_INGRESS_IDLE_MS);
+  return Number.isFinite(n) && n >= 1_000 ? n : DEFAULT_IDLE_MS;
+}
+
+/**
+ * 给一条上游响应流装看门狗。返回解除函数（幂等）。
+ * @param {import('http').IncomingMessage} stream  上游响应
+ * @param {{ idleMs?: number, checkMs?: number, onIdle: (silentMs: number) => void }} opts
+ *   onIdle 只会被调用一次；由调用方决定怎么掐（destroy）和记账（noteOutcome/日志）。
+ */
+export function armIdleWatchdog(stream, { idleMs = idleMsFromEnv(), checkMs = CHECK_MS, onIdle }) {
+  let last = Date.now();
+  let fired = false;
+  const bump = () => { last = Date.now(); };
+  stream.on('data', bump);
+  const timer = setInterval(() => {
+    if (fired) return;
+    const silent = Date.now() - last;
+    if (silent > idleMs) {
+      fired = true;
+      stop();
+      try { onIdle(silent); } catch { /* 看门狗自己绝不抛 */ }
+    }
+  }, checkMs);
+  timer.unref?.();
+  function stop() {
+    clearInterval(timer);
+    stream.removeListener('data', bump);
+  }
+  stream.on('end', stop);
+  stream.on('close', stop);
+  stream.on('error', stop);
+  return stop;
+}

package/server/lib/ingress/upstream-billing.js

@@ -12,6 +12,21 @@
  * 上游没报 cost（cost 为 null）就不动任何东西 —— 假数据比没有更坏。
  */
 
+/**
+ * 上游把「这一发花了多少钱」放在哪儿，各家不一样：Zen（/zen/go）放在**顶层** `cost`
+ * （流式在 [DONE] 之后补一条 {"choices":[],"cost":"0.00123"}），Merge 网关放在 **usage.cost** 里
+ * （非流式在响应体的 usage 上，流式在 include_usage 那个末块的 usage 上）。两处都认，顶层优先。
+ * ⚠️ 缺席或不是数一律 null —— 记账那侧看见 null 就不动任何东西（假数据比没有更坏）。
+ */
+export function upstreamCostOf(obj) {
+  for (const v of [obj?.cost, obj?.usage?.cost]) {
+    if (v == null) continue;
+    const n = Number(v);
+    if (Number.isFinite(n)) return n;
+  }
+  return null;
+}
+
 export class UpstreamBilling {
   constructor() { this.map = new Map(); }   // sid → Map<appModel, acc>
   /**

package/server/lib/ingress/upstream-error-hints.js

@@ -0,0 +1,36 @@
+/**
+ * 上游 4xx 的人话翻译（08-30 建）。
+ *
+ * 为什么需要：上游的错是**给开发者看的英文**，可它会原样穿过 SDK 落到用户的聊天框里。
+ * 用户看到的是「API Error: 400 GLM requests accept at most 8 inline PNG, JPEG, WEBP…」——
+ * 这句话没有一个字告诉他该怎么办，而这里恰好有个一句话就能给出的出路（换一条线）。
+ *
+ * ⭐ 只翻译**用户自己能处理**的那几条。上游挂了、限流、鉴权坏了这些他做不了什么，
+ *   翻译过去只是把英文换成中文，没有增益，反而把原文这个排查线索藏了 —— 所以不收。
+ * ⚠️ 原文一律保留在括号里：翻译是加一句，不是换一句。看日志和看聊天框的是同一个人。
+ */
+
+/** 一条上游原文里的图片张数上限（particle 是 8）。这条闸只有 particle 有，zai 到 20 张都收 */
+const INLINE_IMAGE_CAP = /accept at most (\d+) inline/i;
+
+/**
+ * @param {string} raw       上游回的错误正文
+ * @param {object} [wire]    这一发用的行（要 bodyExtra.vendors 判是不是"只走 particle"那条）
+ * @returns {string|null}    加了人话的完整文案；没有可翻译的就回 null（调用方原样透传）
+ */
+export function upstreamErrorHint(raw, wire) {
+  const text = String(raw || '');
+  const cap = text.match(INLINE_IMAGE_CAP);
+  if (cap) {
+    const n = cap[1];
+    // 只有"演出"那条线（点死 particle）才该建议换线；默认那条线不该撞到这条闸，
+    // 真撞到了说明是别的原因，别把人往一条同样会挂的线上引。
+    const onlyParticle = Array.isArray(wire?.bodyExtra?.vendors)
+      && wire.bodyExtra.vendors.length === 1 && wire.bodyExtra.vendors[0] === 'particle';
+    const hint = onlyParticle
+      ? `「演出」这条线整场最多带 ${n} 张图，这一轮超了。在模型菜单里换成「GLM-5.3-Flash · 设计」就没有这个限制 —— 同一个模型、同样的价钱，只是每一步稍慢一点。`
+      : `这一轮带的图超过了上游的 ${n} 张上限。少发几张、或者开一个新会话再继续。`;
+    return `${hint}（上游原文：${text.slice(0, 200).replace(/\s+/g, ' ')}）`;
+  }
+  return null;
+}

package/server/lib/json-preview.js

@@ -0,0 +1,58 @@
+/**
+ * server/lib/json-preview.js —— json 文件卡的结构预览（2026-08-29 占位契约刀 B）
+ *
+ * 站主点名「给 json 一个预览器和显示器」。原来 json 跟 txt/csv 走同一条路：
+ * 截前 1KB 原样塞进等宽 <pre>，于是卡面上是半行 `{"name":"…` 就没了 —— 既看不出
+ * 结构，也**没法在前端画折叠树**（截断的 json parse 不动）。
+ *
+ * 这里做的是"裁剪"不是"截断"：按深度/数组长度/字符串长度各自设限，产出的仍然是
+ * **合法 json**，前端 JSON.parse 得动就能画可折叠的键值树。被裁掉的地方留一句人话
+ * （`… +42 more`），不假装内容到此为止 —— 跟卡的折叠角标同一条纪律：
+ * 省略要看得见。
+ */
+
+const MAX_DEPTH = 4;
+const MAX_ITEMS = 12;      // 数组/对象每层最多留几项
+const MAX_STR = 120;       // 单个字符串值
+const MAX_OUT = 4096;      // 产出上限，超了降一档深度重来
+
+/** 折叠标记：值是以这个开头的字符串 = 这里被裁过（前端据此画成灰色省略号） */
+export const ELLIPSIS = '…';
+
+function shrink(v, depth, maxDepth) {
+  if (v === null || typeof v === 'number' || typeof v === 'boolean') return v;
+  if (typeof v === 'string') return v.length > MAX_STR ? `${v.slice(0, MAX_STR)}${ELLIPSIS}` : v;
+  if (Array.isArray(v)) {
+    if (depth >= maxDepth) return [`${ELLIPSIS} ${v.length} items`];
+    const out = v.slice(0, MAX_ITEMS).map(x => shrink(x, depth + 1, maxDepth));
+    if (v.length > MAX_ITEMS) out.push(`${ELLIPSIS} +${v.length - MAX_ITEMS} more`);
+    return out;
+  }
+  if (typeof v === 'object') {
+    const keys = Object.keys(v);
+    if (depth >= maxDepth) return { [ELLIPSIS]: `${keys.length} keys` };
+    const out = {};
+    for (const k of keys.slice(0, MAX_ITEMS)) out[k] = shrink(v[k], depth + 1, maxDepth);
+    if (keys.length > MAX_ITEMS) out[ELLIPSIS] = `+${keys.length - MAX_ITEMS} more keys`;
+    return out;
+  }
+  return String(v);
+}
+
+/**
+ * @param {string} raw  文件原文
+ * @returns {string|null}  裁剪后的合法 json 文本；不是合法 json 时返回 null（调用方退回原样预览）
+ */
+export function jsonPreview(raw) {
+  let data;
+  try {
+    data = JSON.parse(raw);
+  } catch {
+    return null;    // 不是合法 json（或本来就是片段）：退回等宽原样，别假装看得懂
+  }
+  for (let d = MAX_DEPTH; d >= 1; d -= 1) {
+    const text = JSON.stringify(shrink(data, 0, d), null, 2);
+    if (text.length <= MAX_OUT || d === 1) return text.slice(0, MAX_OUT);
+  }
+  return null;
+}