@xiaobuyu/nodesign 0.0.6 → 0.0.8

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/issues-store.js

@@ -59,7 +59,9 @@ db.exec(`
  */
 export function signatureOf(text) {
   const norm = String(text || '')
-    .replace(/[/~][\w.\-/@ 一-鿿]+/g, '<path>')   // 路径
+    // 字符类里不能有空格：不然一个孤立的 "/" 会贪婪吞掉后面一整串词（08-24 案，
+    // artifact_find 输出里的 "→ https://…" 之后的文字被不定长吃掉，指纹漂移不聚合）
+    .replace(/[/~][\w.\-/@一-鿿]+/g, '<path>')    // 路径
     .replace(/\b[0-9a-f]{8,}\b/gi, '<hash>')      // id / hash
     .replace(/\d+/g, 'N')                          // 行号、字节数、耗时
     .replace(/\s+/g, ' ')

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;
+}

package/server/lib/kinds/docx.js

@@ -264,16 +264,23 @@ export default {
   async describe(taskDir, artifact) {
     const label = `word ${artifact.entryRel}`;
     const src = artifact.sourceFile;
+    // 文件夹里的**全部**成员都要点名（08-19 案：目录里 v3/v4 两份，清单只报
+    // 默认那份，agent 对着过时的 v3 干了一整轮 —— 注入的清单让人默认它是全的，
+    // 半份状态比没状态更误导）
+    const others = (artifact.members || [])
+      .map(m => m.file)
+      .filter(f => f && f !== artifact.entryRel);
+    const memberNote = others.length ? ` · 同夹还有：${others.join(' / ')}` : '';
     try {
       const stat = await fs.stat(path.join(taskDir, artifact.entryRel));
       const kb = (stat.size / 1024).toFixed(0);
       return src
-        ? `${label} · ${kb}KB · 源 ${src}（改源重建，别直接改 .docx）`
-        : `${label} · ${kb}KB · 外来文档，没有 token 源`;
+        ? `${label} · ${kb}KB · 源 ${src}（改源重建，别直接改 .docx）${memberNote}`
+        : `${label} · ${kb}KB · 外来文档，没有 token 源${memberNote}`;
     } catch {
       return src
-        ? `${label} · 还没构建（源 ${src} 已就位）`
-        : `${label} · 入口读不到`;
+        ? `${label} · 还没构建（源 ${src} 已就位）${memberNote}`
+        : `${label} · 入口读不到${memberNote}`;
     }
   },
 

package/server/lib/kinds/index.js

@@ -30,7 +30,9 @@ import docx from './docx.js';
 
 export const KINDS = Object.freeze({ [deck.id]: deck, [site.id]: site, [docx.id]: docx });
 
-export { RESERVED_DIRS, isReservedFile } from '../task-scan.js';
+import { readTaskMarker } from '../task-scan.js';
+
+export { RESERVED_DIRS, isReservedFile, readTaskMarker } from '../task-scan.js';
 
 export function kindDef(kind) {
   return KINDS[kind] || null;
@@ -57,21 +59,9 @@ export function can(kind, cap) {
   return !!KINDS[kind]?.capabilities?.includes(cap);
 }
 
-/**
- * 读产物标记（`.nd-project.json`）。没有 / 读不动 → null。
- *
- * 2026-08-07 从 `.nd-task.json` 改名。旧文件里有两个字段：`sessionId`（这个
- * 任务属于哪次对话 —— 正是要废的那条绑定，迁移时直接删）和 `root`（构建型
- * 站点显式声明产物根，agent 刚写完源还没 build 的窗口期靠它认出"站已经在了"）。
- * 后者还有用，所以标记本身留着，只是不再承载归属。
- */
-export async function readTaskMarker(root) {
-  try {
-    const raw = await fs.readFile(path.join(root, '.nd-project.json'), 'utf8');
-    const parsed = JSON.parse(raw);
-    return (parsed && typeof parsed === 'object') ? parsed : null;
-  } catch { return null; }
-}
+// readTaskMarker 本体 2026-08-24 迁去 task-scan.js（site.js 要按子目录读 marker，
+// 住这里会循环 import）。上面 re-export 保住老调用方。历史注释一并搬走：
+// `.nd-project.json` 2026-08-07 从 `.nd-task.json` 改名，只剩 `root` 字段有用。
 
 /**
  * 任务的完整 manifest —— 服务端唯一的解析器，前端、感知工具、导出都吃这份。

package/server/lib/kinds/site.js

@@ -12,12 +12,16 @@
 
 import path from 'node:path';
 import fs from 'node:fs/promises';
-import { walkTaskFiles, loadIgnore, DRAFTS_DIR, RESERVED_DIRS } from '../task-scan.js';
+import { walkTaskFiles, loadIgnore, readTaskMarker, DRAFTS_DIR, RESERVED_DIRS } from '../task-scan.js';
 
 const ENTRY = 'index.html';
 
-/** 构建产物的约定目录，按序探测（谁有 index.html 认谁）。任务根有 index.html 时不看这些 */
-const OUTPUT_DIRS = ['dist', 'out', 'build', '_site', 'public'];
+/**
+ * 构建产物的约定目录，按序探测（谁有 index.html 认谁）。
+ * export：assets.js 的文件夹递归要用同一张表把构建目录挡在"独立站点/文件夹"之外
+ * （08-24 案：dist/ 被递归成第二张 site 卡）。
+ */
+export const OUTPUT_DIRS = ['dist', 'out', 'build', '_site', 'public'];
 
 /** 站点页面扫描深度（产物根之下；子页 / posts/ / pages/ 够用） */
 const PAGE_DEPTH = 4;
@@ -31,18 +35,36 @@ function normRoot(r) {
   return (!s || s === '.' || s.includes('..')) ? '' : s;
 }
 
+/**
+ * 根 index.html 是不是**构建源**（vite / react / vue 工程的开发入口）：
+ * module script 引用 src/ 目录或 .tsx/.jsx/.ts/.vue 源文件。构建源不是可浏览的
+ * 产物 —— 浏览器直接打开是白屏（脚本路径只有 dev server / 构建器认识）。
+ * 只认强证据；读不动 / 不确定一律按"真产物"处理（老行为）。
+ */
+async function isBuildSourceEntry(dirAbs) {
+  try {
+    const html = await fs.readFile(path.join(dirAbs, ENTRY), 'utf8');
+    return /<script[^>]+src=["'](?:\.?\/)?src\/[^"']+["']/i.test(html)
+      || /<script[^>]+src=["'][^"']+\.(?:tsx|jsx|ts|vue)["']/i.test(html);
+  } catch { return false; }
+}
+
 /**
  * 产物根（相对任务目录，'' = 任务根）。
  * marker.root 是显式声明，最优先 —— 哪怕入口还没构建出来（agent 刚写完源、
  * 还没跑 build 的窗口期），寻址也该指向将要出现的地方而不是源目录。
+ * 任务根的 index.html 是构建源且约定目录里已有构建产物时，优先产物
+ * （08-24 案：vite 工程源码 index.html 引 /src/main.tsx，预览白屏）。
  */
 async function artifactRoot(taskDir, marker) {
   const declared = normRoot(marker?.root);
   if (declared) return declared;
-  if (await exists(path.join(taskDir, ENTRY))) return '';
+  const hasRootEntry = await exists(path.join(taskDir, ENTRY));
+  if (hasRootEntry && !(await isBuildSourceEntry(taskDir))) return '';
   for (const d of OUTPUT_DIRS) {
     if (await exists(path.join(taskDir, d, ENTRY))) return d;
   }
+  // 构建源但还没 build 出产物：退回任务根（至少寻址不落空；build 完自动切换）
   return '';
 }
 
@@ -67,7 +89,10 @@ async function discoverInstances(taskDir, marker) {
   if (rootSite) {
     out.push({ srcRoot: '', root, single: false });
   } else {
-    // 无根站：一级子目录各自为站
+    // 无根站：一级子目录各自为站。每个子目录按自己的 marker + 构建证据算产物根
+    // （08-24 案：jet-engine/ 里的 .nd-project.json 以前读不到、dist/ 轮不上，
+    //  构建型子目录站没有干净路径）。root 是**任务根相对**（jet-engine/dist），
+    //  srcRoot 是子目录名 —— 卡片身份挂 srcRoot 那个文件夹，寻址走 root。
     let entries = [];
     try { entries = await fs.readdir(taskDir, { withFileTypes: true }); } catch { /* */ }
     const ignore = await loadIgnore(taskDir);
@@ -75,8 +100,16 @@ async function discoverInstances(taskDir, marker) {
       if (!e.isDirectory() || e.name.startsWith('.') || e.name === DRAFTS_DIR) continue;
       if (RESERVED_DIRS.has(e.name)) continue;
       if (ignore(e.name, true)) continue;
-      if (await exists(path.join(taskDir, e.name, ENTRY))) {
-        out.push({ srcRoot: e.name, root: e.name, single: false });
+      const subDir = path.join(taskDir, e.name);
+      const subMarker = await readTaskMarker(subDir);
+      const subRoot = await artifactRoot(subDir, subMarker);
+      const subDeclared = normRoot(subMarker?.root);
+      if (subDeclared || await exists(path.join(subDir, subRoot || '.', ENTRY))) {
+        out.push({
+          srcRoot: e.name,
+          root: subRoot ? `${e.name}/${subRoot}` : e.name,
+          single: false,
+        });
       }
     }
   }

package/server/lib/model-ingress.js

@@ -39,6 +39,7 @@ import { resolveWireModel, UPSTREAMS } from '../engine/agent/model-context.js';
 import { resolveSessionWire, fallbackLogged } from './ingress/session-routes.js';
 import { forwardOpenAIChat } from './ingress/forward-openai-chat.js';
 import { failStreaks, exhaustedErrorBody } from './ingress/upstream-fail-streak.js';
+import { armIdleWatchdog } from './ingress/stream-watchdog.js';
 import { noteUpstreamBilling } from './ingress/upstream-billing.js';
 import { noteUpstreamTruncation } from './ingress/upstream-truncation.js';
 import { noticeSession } from './ingress/session-notice.js';
@@ -295,6 +296,15 @@ async function handleRequest(req, res, bodyBuf) {
       noteOutcome(true);
     }
     res.writeHead(proxyRes.statusCode, proxyRes.headers);
+    // 断流看门狗（2026-08-29，proj_mtexu1kp 现场）：上游 SSE 半路断粮不报错不 EOF，
+    // run 会无限挂起。只对流式响应上岗；掐掉后 CLI 收到流错误自己重试。
+    if (proxyRes.statusCode < 400 && String(proxyRes.headers['content-type'] || '').includes('event-stream')) {
+      armIdleWatchdog(proxyRes, { onIdle: (silentMs) => {
+        console.warn(`[model-ingress] sid=${sidShort} upstream=${wire.upstreamId} 流静默 ${Math.round(silentMs / 1000)}s —— 看门狗掐断死流`);
+        noteOutcome(false, 'stream idle');
+        try { proxyRes.destroy(new Error('ingress stream idle watchdog')); } catch { /* 已经死了就算了 */ }
+      } });
+    }
     proxyRes.pipe(res);
   });
 
@@ -327,7 +337,12 @@ export async function transformForUpstream(parsed, wire) {
 
   // thinking：'strip' = 删字段让上游自决（Gemini thinking 关不掉、参数过桥行为
   // 未知）；'enabled8k' = adaptive 改写成 enabled+budget（Kimi 实测 adaptive =
-  // 0 thinking blocks）
+  // 0 thinking blocks）；'adaptive' = 反过来，enabled+budget 改写成 adaptive。
+  //
+  // ⚠️ 本站给**每一条 API 行**发的都是 enabled+8192（model-context.pickThinkingConfig），
+  // 对"自己会判断该不该想"的模型等于逐轮强制想满预算。MiniMax M3 是这一类（08-25 实测
+  // GMI 部署 adaptive/disabled/enabled 三种都收）：agent 一轮里大半是读文件调工具，
+  // 该不该想交给它自己。
   if (wire.thinking === 'strip') {
     if ('thinking' in parsed) { delete parsed.thinking; mutated = true; }
   } else if (wire.thinking === 'enabled8k') {
@@ -335,6 +350,12 @@ export async function transformForUpstream(parsed, wire) {
       parsed.thinking = { type: 'enabled', budget_tokens: 8192 };
       mutated = true;
     }
+  } else if (wire.thinking === 'adaptive') {
+    // 'disabled' 不动：那是调用方明确要求别想，行的默认档不该压过它
+    if (parsed.thinking && parsed.thinking.type !== 'adaptive' && parsed.thinking.type !== 'disabled') {
+      parsed.thinking = { type: 'adaptive' };
+      mutated = true;
+    }
   }
 
   // tool_result 里的图提升到 user message 顶层（丢图桥的必修 shim）
@@ -349,6 +370,10 @@ export async function transformForUpstream(parsed, wire) {
     if (await normalizeImages(parsed.messages, VISION_MAX_DIM, allowed)) mutated = true;
   }
 
+  // 上游要的额外顶层字段（merge 的 vendor 点名）。放在这里是 **Anthropic 透传腿的读者** ——
+  // 那条腿直接 JSON.stringify(parsed)。openai-chat 腿另有一个读者，见 toOpenAIChatRequest
+  if (wire.bodyExtra) { Object.assign(parsed, wire.bodyExtra); mutated = true; }
+
   return mutated;
 }
 

package/server/lib/moderation.js

@@ -20,7 +20,9 @@
  * 强度三档，**per-user、per-通路可调**（站主在控制台按人设）。08-20 起按模型通路分成
  * 两个独立旋钮：users.moderation_level 管订阅模型（Sonnet/Opus，跑在站主账号上），
  * users.moderation_level_api 管本地 qwen / 中转站那些走 ingress 的 API 行。哪条通路
- * 由 model-context 的 resolveModelRoute 说了算，这里不判模型名。两边默认档推导相同。
+ * 由 model-context 的 resolveModelRoute 说了算，这里不判模型名。
+ * ⭐ **08-30 起两边的默认档也各算各的**（tier.js 的 moderationDefault / moderationDefaultApi）：
+ * 订阅 strict、非订阅 off。在此之前两边推导同一个值，"订阅严、其他放开"只能靠逐人钉。
  * 同一档位值同时管 GPT 外审和 prelude 的成人句（见 agent/system-prompts.js）。
  *   off     不审
  *   loose   只拦"换个说法也还是违法"的硬线：未成年人色情 / 恐怖主义 / 武器毒品
@@ -29,8 +31,10 @@
  *           小说 / RP 形态天然要碰这些，误伤创作比漏审更伤产品。
  *   strict  loose 全部 + 露骨色情 / 美化煽动真实暴力 / 群体仇恨歧视。
  *
- * 默认档（users.moderation_level 为 NULL 时）：试用号 strict / 正式号 loose /
- * admin off。改默认档不影响已显式设过的号。`NODESIGN_MODERATION=off` 是全站总闸。
+ * 默认档（该旋钮为 NULL 时）走 tier.js 的能力表：订阅通路 admin off / pro·basic strict，
+ * API 通路一律 off。改默认档不影响已显式钉过档的号 —— 所以改默认时要顺手看一眼库里还有多少
+ * 显式值压着（08-30 那次把 41 个显式的 API 档清回 NULL，就是为了让这张表真的说了算）。
+ * `NODESIGN_MODERATION=off` 是全站总闸。
  */
 
 import db from '../engine/runs/store.js';
@@ -94,9 +98,10 @@ export function levelForKnob(user, knob) {
   if (!user) return 'off';
   const explicit = knob === 'api' ? user.moderationLevelApi : user.moderationLevel;
   if (LEVELS.includes(explicit)) return explicit;
-  // 默认档按账号档位（auth/tier.js 能力表）：admin off / pro loose / basic strict。
+  // 默认档按账号档位**和通路**（auth/tier.js 能力表）：订阅 admin off / pro·basic strict，API 一律 off。
   // 08-21 前这里猜的是 lifetimeCostLimitUsd（试用码 ⇒ strict），开放注册号该字段为 null 被当成正式号拿 loose。
-  return defaultModerationLevel(user);
+  // ⚠️ knob 必须往下传：08-30 之前这里不传，于是 tier 表里就算分了两栏也读不到第二栏。
+  return defaultModerationLevel(user, knob);
 }
 
 export function shouldModerate(user, appModel = null) {

package/server/lib/quota.js

@@ -222,12 +222,22 @@ export function usedTodayByFamily(userId, now = Date.now()) {
 //
 // 08-21 经营态转向后分两档：
 // - 订阅行（花站主的订阅）：全局固定数 NODESIGN_MAX_CONCURRENT_RUNS（默认 3）
-// - 免费行（Ox 这类零价模型）：不受全局固定数限制。它的约束只剩机器本身 ——
+// - 非订阅行（走 ingress 的 API 行）：不受全局固定数限制。它的约束只剩机器本身 ——
 //   每个 claude CLI 进程 350MB~1GB、机器 1 vCPU/8G 无 swap，所以改成**内存闸**：
 //   MemAvailable 低于 NODESIGN_MIN_FREE_MEM_MB（默认 700）就拒，外加一个防失控的
 //   上限 NODESIGN_FREE_MAX_CONCURRENT_RUNS（默认 12）。内存闸对两档都生效（订阅行
 //   的固定数 3 本来就是按内存拍的，内存先见底时固定数也救不了）
 // - 每用户同时 1 个（admin 免）两档都一样：这是公平性不是资源
+//
+// ⭐⭐ **2026-08-30 判据从「免费/付费」改成「订阅/非订阅」**。起因：全员默认行换成
+// glm-5.3-flash-merge（付费但极便宜，$0.015/M）。按老判据它落进"付费"那一档，站点默认
+// 路径的并发天花板会从 12 掉到 3，而这台盒子实测峰值在飞 turn 是 4 —— 第 4 个人当场
+// 吃「现在有点挤」。
+// 这不是把闸放松，是**把闸对准它本来护的东西**：那个 3 从头到尾护的是站主的 Claude 订阅
+// （同时开太多 query 会烧额度、也会被上游限流），跟"这一轮花不花钱"没有关系。一条
+// $0.015/M 的网关行既不烧订阅、也不烧机器以外的任何东西，它该受的约束就是内存。
+// ⚠️ 于是**付费的 API 行现在也走 12 + 内存闸**（deepseek 视觉行、merge 行）。真要给某一家
+// 单独收并发，那是 per-upstream 的闸，不是把它塞回订阅那一档。
 
 export function memAvailableMb() {
   try {
@@ -236,13 +246,20 @@ export function memAvailableMb() {
   } catch { return null; }   // 非 Linux / 读不到 → 不以内存拒
 }
 
-/** 纯决策：输入全是数，方便测 */
-export function decideConcurrency({ running, mine, isAdmin, free, memMb, env = process.env }) {
+/**
+ * 纯决策：输入全是数，方便测。
+ * @param {boolean} offSubscription 这一轮**不花站主订阅**（走 ingress 的 API 行）。
+ *   ⚠️ 08-30 前这个参数叫 `free`、判据是"模型免不免费"，改名是因为那个名字骗过人一次：
+ *   默认行换成一条付费但极便宜的 API 行时，它被判进订阅那一档、天花板从 12 掉到 3。
+ */
+export function decideConcurrency({ running, mine, isAdmin, offSubscription, free, memMb, env = process.env }) {
+  // 老参数名还认（旧调用方 / 测试），但新名优先
+  const offSub = offSubscription !== undefined ? offSubscription : !!free;
   const minMem = Number(env.NODESIGN_MIN_FREE_MEM_MB) || 700;
   if (memMb != null && memMb < minMem) {
     return { ok: false, code: 'BUSY', message: `机器内存快满了（${running} 个任务在跑），稍等一会儿再发` };
   }
-  const globalMax = free
+  const globalMax = offSub
     ? (Number(env.NODESIGN_FREE_MAX_CONCURRENT_RUNS) || 12)
     : (Number(env.NODESIGN_MAX_CONCURRENT_RUNS) || 3);
   if (running >= globalMax) {
@@ -257,7 +274,7 @@ export function decideConcurrency({ running, mine, isAdmin, free, memMb, env = p
   return { ok: true };
 }
 
-export function checkConcurrency(user, { free = false } = {}) {
+export function checkConcurrency(user, { offSubscription = false, free = false } = {}) {
   // running turn → user 归属：runId 查 runs.user_id（不给 session 注册表加
   // userId 字段 —— 正在跑的 turn 就几个，查表成本可忽略）
   let mine = 0;
@@ -266,5 +283,8 @@ export function checkConcurrency(user, { free = false } = {}) {
       if (getRun(rid)?.userId === user?.id) mine += 1;
     }
   }
-  return decideConcurrency({ running: countRunningTurns(), mine, isAdmin: user?.role === 'admin', free, memMb: memAvailableMb() });
+  return decideConcurrency({
+    running: countRunningTurns(), mine, isAdmin: user?.role === 'admin',
+    offSubscription: offSubscription || free, memMb: memAvailableMb(),
+  });
 }

package/server/lib/rect.js

@@ -0,0 +1,50 @@
+/**
+ * server/lib/rect.js —— 矩形原语（2026-08-27 审计收敛）
+ *
+ * 收敛前的账：AABB 重叠判定在服务端手写了 4 份、包围盒 5 份、UNIT=24 两处
+ * export，各自维护、容差和空集语义悄悄分叉（bbox 空集有的返回 null 有的返回
+ * 零框）。改判定只改这一份；需要不同空集语义的调用方自己在出口包一层。
+ *
+ * 前端的对应物是 web/src/lib/board-geometry.js 的 rectsHit —— 语义必须一致
+ * （相邻贴边 = 不重叠）。改这边记得看那边。
+ */
+
+/** 网格步长：全部世界坐标的公倍数。曾在 board-place / sketch-layout 各 export 一份。 */
+export const UNIT = 24;
+
+/** AABB 重叠（贴边不算重叠）。pad = 双方各让的身位。 */
+export const overlaps = (a, b, pad = 0) => !(
+  a.x + a.w + pad <= b.x || b.x + b.w <= a.x - pad
+  || a.y + a.h + pad <= b.y || b.y + b.h <= a.y - pad
+);
+
+/** 一组矩形的包围盒；空集返回 null（要零框语义自己在出口兜）。 */
+export function bboxOf(rects) {
+  let x0 = Infinity; let y0 = Infinity; let x1 = -Infinity; let y1 = -Infinity;
+  for (const r of rects) {
+    x0 = Math.min(x0, r.x); y0 = Math.min(y0, r.y);
+    x1 = Math.max(x1, r.x + (r.w || 0)); y1 = Math.max(y1, r.y + (r.h || 0));
+  }
+  return Number.isFinite(x0) ? { x: x0, y: y0, w: x1 - x0, h: y1 - y0 } : null;
+}
+
+/** 点在矩形内（含边）。 */
+export const pointIn = (pt, r) => pt.x >= r.x && pt.x <= r.x + r.w && pt.y >= r.y && pt.y <= r.y + r.h;
+
+/**
+ * 线段 a→b 是否穿过矩形 r（Liang-Barsky 裁剪；端点擦边也算穿）。
+ * 落位引擎用它判「连线走廊」：新块和它锚点之间那条线会不会压在第三块身上。
+ */
+export function segHitsRect(a, b, r) {
+  const dx = b.x - a.x; const dy = b.y - a.y;
+  let t0 = 0; let t1 = 1;
+  const clip = (p, q) => {
+    if (p === 0) return q >= 0;               // 与这条边平行：q<0 = 整段在外
+    const t = q / p;
+    if (p < 0) { if (t > t1) return false; if (t > t0) t0 = t; }
+    else { if (t < t0) return false; if (t < t1) t1 = t; }
+    return true;
+  };
+  return clip(-dx, a.x - r.x) && clip(dx, r.x + r.w - a.x)
+    && clip(-dy, a.y - r.y) && clip(dy, r.y + r.h - a.y);
+}

package/server/lib/rewrite-refs.js

@@ -0,0 +1,110 @@
+/**
+ * rewrite-refs.js —— 搬文件后把全工作区的引用改写到新路径（2026-08-24，iss_mt38uih6）
+ *
+ * 用户的方法论原话：「新建一个文件夹然后改个索引」。organize_board 归纳素材时
+ * 磁盘和画布身份跟着走了，但 HTML/MD 里的 src/href 还指旧路径 —— 裂图。这里把
+ * "改索引"那半补上：对每个文本文件，把指向被搬条目的引用按**相对该文件目录**
+ * 的写法换算后替换。
+ *
+ * 设计取舍：
+ *   - 引用是相对路径（站点路径铁律），所以同一个目标在不同文件里的写法不同
+ *     （根上的 deck 写 `assets/x.png`，子页写 `../assets/x.png`）——逐文件换算。
+ *   - 被搬的文件**自己**也可能引用别人：它落了新家后自己的相对引用基准变了，
+ *     按"旧目录里的写法 → 新目录里的写法"改（哪怕目标没动）。
+ *   - 边界字符防误伤：只有前后都像"引用上下文"（引号/括号/=/空白/行首尾/`/`
+ *     延续）才替换。改了多少处如实报给调用方 —— 自动改写用户内容，必须可核对。
+ *   - 搬的是文件夹时按前缀匹配（`素材/x.png` 里的 `素材` 段）。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { walkTaskFiles, loadIgnore } from './task-scan.js';
+
+const TEXT_EXTS = /\.(html?|css|md|markdown|js|mjs|json|svg|ya?ml|txt)$/i;
+const MAX_BYTES = 2 * 1024 * 1024;
+
+const relFrom = (dirRel, targetRel) => path.posix.relative(dirRel || '.', targetRel);
+const escRe = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+/**
+ * 纯函数：一段文本里把 pairs（[旧工作区相对路径, 新路径]）的引用改写掉。
+ * @param {string} text
+ * @param {string} oldDirRel  这段文本**写下时**所在目录（工作区相对，'' = 根）
+ * @param {string} newDirRel  这段文本现在所在目录（自己没被搬则与 oldDirRel 相同）
+ * @param {Array<[string,string]>} pairs
+ * @returns {{ text: string, hits: number }}
+ */
+export function rewriteTextRefs(text, oldDirRel, newDirRel, pairs) {
+  let out = text; let hits = 0;
+  const variants = [];
+  for (const [oldRel, newRel] of pairs) {
+    const oldRef = relFrom(oldDirRel, oldRel);
+    const newRef = relFrom(newDirRel, newRel);
+    if (!oldRef || oldRef === newRef) continue;
+    variants.push([oldRef, newRef]);
+    const encOld = encodeURI(oldRef); const encNew = encodeURI(newRef);
+    if (encOld !== oldRef) variants.push([encOld, encNew]);
+  }
+  // 长的先替：`素材` 与 `素材/子` 并存时避免前缀误吞
+  variants.sort((a, b) => b[0].length - a[0].length);
+  for (const [o, n] of variants) {
+    const re = new RegExp(`(^|["'\\(=,\\s])${escRe(o)}(?=["'\\)\\s#?,]|/|$)`, 'gm');
+    out = out.replace(re, (m, p1) => { hits += 1; return `${p1}${n}`; });
+  }
+  return { text: out, hits };
+}
+
+/**
+ * 自己被搬过的文本文件：**所有**相对引用的基准都变了（不只指向被搬条目的）。
+ * 把每个像相对路径的 token 按旧目录解析、按新目录重写；目标自己也搬了就再查
+ * moves 表。只认引号/括号里带扩展名的 token，http/data//#/绝对路径不碰。
+ */
+export function rebaseSelfRefs(text, oldDirRel, newDirRel, movesMap) {
+  let hits = 0;
+  const out = text.replace(
+    /(["'(=])((?:\.\.\/|\.\/)?[^"'\s()#?]*\.[A-Za-z0-9]{1,8})(?=["')\s#?]|$)/gm,
+    (m, pre, ref) => {
+      if (/^(?:[a-z][a-z0-9+.-]*:|\/\/|\/|#)/i.test(ref)) return m;
+      const target = path.posix.normalize(path.posix.join(oldDirRel || '.', decodeURI(ref)));
+      if (target.startsWith('..')) return m;   // 出工作区的不碰
+      const finalTarget = movesMap.get(target) || target;
+      const next = relFrom(newDirRel, finalTarget);
+      if (next === ref) return m;
+      hits += 1;
+      return `${pre}${next}`;
+    },
+  );
+  return { text: out, hits };
+}
+
+/**
+ * 扫全工作区文本文件，改写指向 pairs 的引用。
+ * @param {string} root   工作区根（绝对路径）
+ * @param {Array<{from: string, to: string}>} moves  已完成的搬家（工作区相对）
+ * @returns {Promise<{files: number, hits: number, lines: string[]}>}
+ */
+export async function rewriteWorkspaceRefs(root, moves) {
+  const pairs = moves.map((m) => [m.from, m.to]);
+  const movesMap = new Map(pairs);
+  const movedTo = new Map(moves.map((m) => [m.to, m.from]));
+  const ignore = await loadIgnore(root);
+  const all = await walkTaskFiles(root, { maxDepth: 6, ignore, includeDrafts: true });
+  let files = 0; let hits = 0; const lines = [];
+  for (const f of all) {
+    if (!TEXT_EXTS.test(f.name) || f.size > MAX_BYTES) continue;
+    const newDir = path.posix.dirname(f.rel) === '.' ? '' : path.posix.dirname(f.rel);
+    const selfOld = movedTo.get(f.rel);
+    let raw;
+    try { raw = await fs.readFile(f.abs, 'utf8'); } catch { continue; }
+    // 自己被搬过 → 整体换基准（含指向没搬目标的引用）；没搬 → 只改指向被搬条目的
+    const r = selfOld
+      ? rebaseSelfRefs(raw, path.posix.dirname(selfOld) === '.' ? '' : path.posix.dirname(selfOld), newDir, movesMap)
+      : rewriteTextRefs(raw, newDir, newDir, pairs);
+    if (r.hits > 0 && r.text !== raw) {
+      try { await fs.writeFile(f.abs, r.text, 'utf8'); } catch { continue; }
+      files += 1; hits += r.hits;
+      lines.push(`  ↻ ${f.rel}：${r.hits} 处`);
+    }
+  }
+  return { files, hits, lines };
+}

package/server/lib/screen.js

@@ -0,0 +1,36 @@
+/**
+ * server/lib/screen.js —— 「一屏」的唯一基准（2026-08-29 纸范式刀 0）
+ *
+ * 纸范式拍板：一张纸 = **0.75 倍缩放下等于用户一屏**的矩形工作区。
+ * 在这之前「一屏」有三个同源近邻值各自散落（fitFor 的 /0.8、board-place 的
+ * ONE_SCREEN 1750×1125、sketch-layout 的 SKETCH_FIT 1700×1100），注释里互相
+ * 提醒「改缩放基准要几处一起看」—— 现在基准只有这一份，改这里就是改全部。
+ *
+ * DEFAULT_SCREEN 是没有视点上报时的兜底屏（普通笔记本 1400×900）；真实纸尺寸
+ * 永远优先按上报的 device 屏幕算（见 sketch-layout.js fitFor）。
+ */
+
+export const ZOOM_BASIS = 0.75;
+
+export const DEFAULT_SCREEN = { w: 1400, h: 900 };
+
+/** 兜底「一屏」世界像素（1400×900 ÷ 0.75 = 1867×1200） */
+export const ONE_SCREEN = {
+  w: Math.round(DEFAULT_SCREEN.w / ZOOM_BASIS),
+  h: Math.round(DEFAULT_SCREEN.h / ZOOM_BASIS),
+};
+
+/**
+ * 一张卡的高度天花板（2026-08-29 占位契约刀 B，站主定「一张纸的 40%」）。
+ *
+ * 生产真板上最高一条板书 **2471px** —— 312 宽、2471 高，一整章小说写成一根柱子。
+ * 卡的高度原来完全由内容决定、没有上限，于是两件坏事同时发生：版面被柱子劈开，
+ * 而落位系统按估算高度排好队之后，渲染回写又把卡撑大去压邻居。
+ *
+ * 定成固定值而不是「按当前纸算」，是因为卡的高度不该随看它的设备变 —— 同一块板
+ * 在手机和大屏上看，卡的版面必须是同一个。384 = 16 格，也接近 973 高的纸的 40%。
+ *
+ * 超出的部分不是丢掉：卡上折叠（可展开，展开是临时的、不改占位），工具如实告诉
+ * agent「你这条被折叠了，实际 N px」——「越界钳住但要说」。
+ */
+export const CARD_MAX_H = 384;

package/server/lib/sheet-state.js

@@ -0,0 +1,19 @@
+/**
+ * server/lib/sheet-state.js —— 「当前纸」的会话指针（2026-08-29 纸范式）
+ *
+ * 每个会话记一张「正写在哪张纸上」。进程内存不落盘：丢了也无害 —— 读侧回落到
+ * 登记时间最新的一张（board-sheets.js currentSheet 的兜底），agent 重新铺纸或
+ * 点名纸名都能续上。放 board.json 是错的：两个会话同时开工会互相抢指针。
+ */
+
+const cur = new Map();   // sessionId → sheet name
+
+export function setCurrentSheetId(sessionId, id) {
+  if (sessionId && typeof id === 'string') cur.set(sessionId, id);
+}
+
+export function currentSheetIdOf(sessionId) {
+  return (sessionId && cur.get(sessionId)) || null;
+}
+
+export function _resetSheetState() { cur.clear(); }