@xiaobuyu/nodesign 0.0.6 → 0.0.8

package/server/lib/canvas-id.js

@@ -10,21 +10,63 @@
 export function normalizeCanvasId(raw) {
   let id = String(raw || '').trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, '');
   if (!id || id.includes('..')) return null;
-  if (id.endsWith('agent-memory/brand/memory.md')) return 'doc:brand';
-  if (id.endsWith('agent-memory/memory.md')) return 'doc:_root';
+  // （doc:brand / doc:_root 映射 2026-08-24 拆除：项目文档并进根 CLAUDE.md，
+  //   记忆住 记忆/，都是普通画布文件，没有特殊 id 了）
   if (!/^(deck|site|doc|text|scribble):/.test(id) && /\.html?$/i.test(id)) return `deck:${id}`;
   return id;
 }
 
+/**
+ * 一个 tag 下所有座位的包络（08-23 案：near 只认节点 id 不认 tag，可 tag 本来
+ * 就是"一片东西的名字"——刚用 tag 画完草图，把 tag 传给 near 是自然写法）。
+ * 返回 { x, y, w, h, anchorId, ids } 或 null；anchorId = 最右那个（贴右侧摆用）。
+ * sizeOf(id, entry) 由调用方给（estimateSizeOn 绑着 board，不在这层 import）。
+ */
+/**
+ * 查 tag 时的归一：剥掉前导 `#`（2026-08-30）。
+ *
+ * ⛔ 我们在 write_on_board 的 `near`、read_board 的 `tag` 等好几处描述里明写
+ * 「Canvas id or **#tag**」，而查询侧一直是 `e.tag === raw` 精确比对，从来没剥过
+ * 这个井号 —— 全库统计：带 # 的写法 5 处，5 处全废；不带 # 的 2773 处全通。
+ * 「注释/描述声称做了、代码没做」的第三例。
+ *
+ * 只用在**查**的一侧。写的一侧（write_on_board 的 tag 参数）走 TAG_RE，本来就
+ * 收不下 # —— 那是 schema 报错，是响的，不用管。
+ */
+export function bareTag(raw) {
+  return String(raw ?? '').trim().replace(/^#+/, '');
+}
+
+export function tagEnvelope(board, rawTag, sizeOf) {
+  const tag = bareTag(rawTag);
+  if (!tag) return null;
+  const hits = Object.entries(board?.objects || {})
+    .filter(([, e]) => e?.tag === tag && Number.isFinite(e?.x));
+  if (!hits.length) return null;
+  let x1 = Infinity; let y1 = Infinity; let x2 = -Infinity; let y2 = -Infinity;
+  let anchorId = null; let rightEdge = -Infinity;
+  for (const [id, e] of hits) {
+    const s = sizeOf(id, e) || { w: 0, h: 0 };
+    x1 = Math.min(x1, e.x); y1 = Math.min(y1, e.y);
+    x2 = Math.max(x2, e.x + s.w); y2 = Math.max(y2, e.y + s.h);
+    if (e.x + s.w > rightEdge) { rightEdge = e.x + s.w; anchorId = id; }
+  }
+  return { x: x1, y: y1, w: x2 - x1, h: y2 - y1, anchorId, ids: hits.map(([id]) => id) };
+}
+
 /**
  * 它住在哪一层（服务端近似版）：显式 zone 字段优先，其次沿路径往上找第一个
  * 已知文件夹。已知集 = board.zones 的 key —— 比前端少了"服务端扫出来的任务
  * 目录"这一路，没摆过的深层目录会归到根。read_board 的输出里写明这是近似。
  */
 export function layerOf(id, entry, knownFolders) {
-  if (entry && typeof entry.zone === 'string') return entry.zone;
+  // 显式 zone 只认**真实存在的层**（'' 或 zones 里有的文件夹）。历史上
+  // pin_to_board 往 zone 里写过 'assets/generated' 这类前端根本不当层渲染的
+  // 路径（iss_mt5t487g：pin 上来的图被判在"assets 层"，arrange 跟根层的草图
+  // 节点一比就拒）——错标签直接落回按路径推，存量脏数据顺带自愈。
+  if (entry && typeof entry.zone === 'string'
+    && (entry.zone === '' || knownFolders?.has?.(entry.zone))) return entry.zone;
   const s = String(id);
-  if (s.startsWith('doc:')) return '';
   const c = s.indexOf(':');
   const p = (c > 0 && /^[a-z]+$/.test(s.slice(0, c))) ? s.slice(c + 1) : s;
   let d = p.includes('/') ? p.slice(0, p.lastIndexOf('/')) : '';

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/export-collect.js

@@ -145,7 +145,9 @@ export async function collectCard({ workspaceRoot, cardId }) {
     const m = await taskManifest(workspaceRoot).catch(() => null);
     const rootSite = (m?.artifacts || []).find(a => a.kind === 'site' && !a.single && !a.srcRoot);
     for (const pg of (rootSite?.pages || [])) {
-      const pRel = String(pg).replace(/\\/g, '/');
+      // ⚠️ pages 是**产物根相对**（构建型根站 root='dist' 时是 'index.html' 不是
+      // 'dist/index.html'）——对着工作区根解析会抓到源文件或落空（08-24 对齐）
+      const pRel = (rootSite.root ? `${rootSite.root}/` : '') + String(pg).replace(/\\/g, '/');
       const pAbs = await safeResolve(workspaceRoot, pRel);
       if (!pAbs) continue;
       try { if ((await fs.stat(pAbs)).isFile()) files.push({ abs: pAbs, rel: pRel }); } catch { /* 页面刚被删 */ }

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>
   /**