@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/lib/state-triggers.js

@@ -0,0 +1,199 @@
+/**
+ * server/lib/state-triggers.js —— 状态表的条件触发器（2026-08-30）
+ *
+ * 「把会变的东西写在板上，设条件，需要的时候被动拿回来」的后半截。
+ * 前半截（值住在一张 markdown 表里）见 state-table.js。
+ *
+ * ## 声明住在正文里，不住在第二个存储里
+ *
+ * 触发器写成一段 ```nd:triggers 围栏，就在状态表那条板书的正文里 ——
+ * 跟 `nd:controls`（画布控件的声明）是同一个范式：**机器可读的声明住在用户看得见、
+ * 编得动的散文里**。这样用户能看到「现在挂着哪些条件」，也能自己删掉一条。
+ *
+ * 语法（一行一条，故意窄）：
+ *
+ *   ```nd:triggers
+ *   - [好感度_苏绵 >= 5] once -> 她开始主动找你说话了，这一拍给她一个开口的机会
+ *   - [体力 <= 2 && 时间 == 夜] on_cross -> 体力见底又是夜里：这一拍必须有代价
+ *   ```
+ *
+ * `&&` 是唯一的连接词（全都成立才算命中）。没有 `||`、没有括号 —— 那两样一进来
+ * 就得写真正的表达式解析器，而**模型拼错一个变量名时静默求值成 false** 是这条线
+ * 最怕的那种失效。窄语法换来的是：每一种写错都能当场指出来。
+ *
+ * ## 触发的是「穿越」，不是「为真」
+ *
+ * `好感度 >= 5` 一旦满足，之后每一拍都满足。按「为真就触发」写，它会每拍注一遍，
+ * 上线当天就变成噪音源。所以只有两档：
+ *   - `once`     命中一次就退休（一次性的剧情钩子）
+ *   - `on_cross` 每次**从假变真**才触发（会来回摆的条件，比如昼夜、体力）
+ *
+ * ## 沿状态（上一次是真是假）放 `.nd/`，这次是对的
+ *
+ * `.nd/` 在 gitignore 里，所以**玩法真相不能放那儿**（那是 state-table.js 头注
+ * 否掉 `.nd/vars.json` 的理由）。但沿状态是**派生记账**：丢了的代价只是一次
+ * 「上膛不击发」，不是丢故事状态。语义写死：
+ *   - 文件缺失 / 解析失败 → 按当前值重新上膛、**不击发**、log 一行
+ *   - `revertWorkspace` 不回滚它（gitignore），后果是回滚后已触发过的不会重触发 —— 可接受
+ *
+ * ## 求值点 = 注入点
+ *
+ * 只在 UserPromptSubmit 里求值（读盘上的表 + 盘上的沿状态，命中就写进这一轮的
+ * 状态块）。不在 set_vars 里求值攒到下一轮 —— 那样中间一次进程重启就静默吞掉一次
+ * 触发，正是「哑掉的机制不报错」那族病。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { fingerprint } from '../engine/agent/hooks/turn-state-memory.js';
+
+const FENCE_RE = /^[ \t]*```[ \t]*nd:triggers[ \t]*$/;
+const FENCE_END_RE = /^[ \t]*```[ \t]*$/;
+/** - [<条件>] <mode> -> <话> */
+const LINE_RE = /^\s*-\s*\[([^\]]+)\]\s*(once|on_cross)\s*->\s*(.+?)\s*$/;
+const OPS = ['>=', '<=', '!=', '==', '>', '<'];
+
+export const LATCH_REL = '.nd/vars-latch.json';
+/** 一条触发器的话最多这么长：它是注给模型的一句提醒，不是一段剧本 */
+export const MESSAGE_MAX = 200;
+export const MAX_TRIGGERS = 24;
+
+/** 把一条条件文本拆成若干个比较（`&&` 连接，全都成立才算命中） */
+function parseCond(text) {
+  const parts = String(text).split('&&').map((p) => p.trim()).filter(Boolean);
+  if (!parts.length) return { error: '条件是空的' };
+  const cmps = [];
+  for (const p of parts) {
+    const op = OPS.find((o) => p.includes(o));
+    if (!op) return { error: `「${p}」里没有比较符（用 >= <= > < == != 其中之一）` };
+    const idx = p.indexOf(op);
+    const key = p.slice(0, idx).trim();
+    const value = p.slice(idx + op.length).trim();
+    if (!key) return { error: `「${p}」缺左边的键名` };
+    if (!value) return { error: `「${p}」缺右边的值` };
+    cmps.push({ key, op, value });
+  }
+  return { cmps };
+}
+
+/**
+ * 从正文里解析 ```nd:triggers 围栏。
+ * @returns {{ triggers: Array<{id,cmps,mode,message,raw}>, errors: string[] }}
+ *   errors 里每条都指得出是哪一行错在哪 —— 写错要能被看见，不能静默丢。
+ */
+export function parseTriggers(body) {
+  const lines = String(body || '').split(/\r?\n/);
+  const triggers = []; const errors = [];
+  let inFence = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    const l = lines[i];
+    if (!inFence) { if (FENCE_RE.test(l)) inFence = true; continue; }
+    if (FENCE_END_RE.test(l)) { inFence = false; continue; }
+    if (!l.trim()) continue;
+    const m = LINE_RE.exec(l);
+    if (!m) {
+      errors.push(`第 ${i + 1} 行看不懂：${l.trim().slice(0, 60)}\n    （格式是 \`- [键 >= 值] once -> 要说的话\`，mode 只能是 once 或 on_cross）`);
+      continue;
+    }
+    const [, condText, mode, messageRaw] = m;
+    const { cmps, error } = parseCond(condText);
+    if (error) { errors.push(`第 ${i + 1} 行条件写错了：${error}`); continue; }
+    const message = messageRaw.slice(0, MESSAGE_MAX);
+    // id 只由「条件 + 档」决定：改那句提醒的措辞不该把沿状态重置掉
+    const id = fingerprint(`${cmps.map((c) => `${c.key}${c.op}${c.value}`).join('&&')}|${mode}`);
+    triggers.push({ id, cmps, mode, message, raw: l.trim() });
+    if (triggers.length >= MAX_TRIGGERS) {
+      errors.push(`触发器超过 ${MAX_TRIGGERS} 条，后面的没读 —— 挂太多等于没挂。`);
+      break;
+    }
+  }
+  if (inFence) errors.push('```nd:triggers 围栏没闭合，后面的行都没读。');
+  return { triggers, errors };
+}
+
+const NUM_RE = /^-?\d+(\.\d+)?$/;
+
+/**
+ * 求一个比较的值。
+ * @returns {{ v:boolean } | { error:string }}
+ *
+ * ⛔ 跨类型的大小比较**大声拒绝**，不隐式转换：`时间 >= 戌时` 按字典序比出来的
+ * 结果看着像那么回事，但它不是任何人想要的语义。钳住但要说 —— 这是 B+ 没有类型
+ * 系统换来的代价，只能在求值时付。
+ */
+function compare(cmp, rows) {
+  const row = rows.find((r) => r.key === cmp.key);
+  if (!row) return { error: `表里没有「${cmp.key}」这个键` };
+  const l = String(row.value).trim(); const r = String(cmp.value).trim();
+  const bothNum = NUM_RE.test(l) && NUM_RE.test(r);
+  if (cmp.op === '==') return { v: bothNum ? Number(l) === Number(r) : l === r };
+  if (cmp.op === '!=') return { v: bothNum ? Number(l) !== Number(r) : l !== r };
+  if (!bothNum) {
+    return { error: `「${cmp.key} ${cmp.op} ${cmp.value}」比不了：${NUM_RE.test(l) ? '右边' : '左边'}不是数字（大小比较只对数字生效；想比文字用 == 或 !=）` };
+  }
+  const a = Number(l); const b = Number(r);
+  if (cmp.op === '>=') return { v: a >= b };
+  if (cmp.op === '<=') return { v: a <= b };
+  if (cmp.op === '>') return { v: a > b };
+  return { v: a < b };
+}
+
+/**
+ * 求值一批触发器。**纯函数** —— 落盘由调用方做，好测。
+ *
+ * @param triggers parseTriggers 的产物
+ * @param rows     状态表的现值
+ * @param latch    上一次的沿状态 { [id]: { last:boolean, fired:number } }
+ * @param opts.fresh  true = 这是本项目第一次求值（沿状态文件不存在/坏了）
+ *                    → **上膛不击发**：按当前值记下来，一条都不触发
+ * @returns {{ fired:Array<{id,message,raw}>, latch:object, errors:string[], armed:number, retired:number }}
+ */
+export function evalTriggers(triggers, rows, latch = {}, { fresh = false } = {}) {
+  const next = {}; const fired = []; const errors = [];
+  let armed = 0; let retired = 0;
+  for (const t of triggers) {
+    const prev = latch[t.id] || null;
+    const firedCount = prev?.fired || 0;
+    if (t.mode === 'once' && firedCount > 0) { next[t.id] = prev; retired += 1; continue; }
+
+    let v = true; let bad = null;
+    for (const c of t.cmps) {
+      const r = compare(c, rows);
+      if (r.error) { bad = r.error; break; }
+      if (!r.v) { v = false; break; }
+    }
+    if (bad) {
+      errors.push(`${t.raw}\n    → ${bad}`);
+      next[t.id] = prev || { last: false, fired: firedCount };   // 求不出来不动沿状态
+      armed += 1;
+      continue;
+    }
+
+    const was = prev ? !!prev.last : false;
+    // 上膛不击发：第一次见到这条触发器（或沿状态丢了）只记录，不触发 ——
+    // 否则每次进程重启都会把所有当前为真的条件重放一遍
+    const shouldFire = !fresh && !!prev && v && !was;
+    if (shouldFire) fired.push({ id: t.id, message: t.message, raw: t.raw });
+    next[t.id] = { last: v, fired: firedCount + (shouldFire ? 1 : 0) };
+    if (t.mode === 'once' && next[t.id].fired > 0) retired += 1; else armed += 1;
+  }
+  return { fired, latch: next, errors, armed, retired };
+}
+
+export async function readLatch(sharedRoot) {
+  try {
+    const raw = await fs.readFile(path.join(sharedRoot, LATCH_REL), 'utf8');
+    const j = JSON.parse(raw);
+    if (!j || typeof j !== 'object') return { latch: {}, fresh: true };
+    return { latch: j, fresh: false };
+  } catch {
+    // 缺失或坏了都走 fresh：按当前值重新上膛、不击发
+    return { latch: {}, fresh: true };
+  }
+}
+
+export async function writeLatch(sharedRoot, latch) {
+  const abs = path.join(sharedRoot, LATCH_REL);
+  await fs.mkdir(path.dirname(abs), { recursive: true });
+  await fs.writeFile(abs, JSON.stringify(latch, null, 2), 'utf8');
+}

package/server/lib/tavern-json.js

@@ -152,3 +152,51 @@ export function fetchEntries(doc, 选) {
   }
   return 出;
 }
+
+/**
+ * PNG 角色卡（2026-08-25，四方世界卡案：iss 上报「不是合法 JSON：�PNG」）。
+ * 酒馆的卡就是一张 PNG，角色数据 base64 后塞在 tEXt 块里：V3 用键 `ccv3`，
+ * V2 用键 `chara`。两个都在时 ccv3 赢（V3 是超集）。不是卡的普通 PNG 返回 null。
+ */
+export function extractCardFromPng(buf) {
+  if (!Buffer.isBuffer(buf) || buf.length < 16) return null;
+  if (buf.readUInt32BE(0) !== 0x89504e47) return null;   // \x89PNG
+  let off = 8;
+  const found = {};
+  while (off + 12 <= buf.length) {
+    const len = buf.readUInt32BE(off);
+    const type = buf.toString('latin1', off + 4, off + 8);
+    if (type === 'tEXt' && len > 0 && off + 8 + len <= buf.length) {
+      const data = buf.subarray(off + 8, off + 8 + len);
+      const nul = data.indexOf(0);
+      if (nul > 0) {
+        const key = data.toString('latin1', 0, nul);
+        if (key === 'ccv3' || key === 'chara') found[key] = data.subarray(nul + 1).toString('latin1');
+      }
+    }
+    off += 12 + len;
+    if (type === 'IEND') break;
+  }
+  const payload = found.ccv3 || found.chara;
+  if (!payload) return null;
+  try { return JSON.parse(Buffer.from(payload, 'base64').toString('utf8')); } catch { return null; }
+}
+
+/**
+ * 世界书条目全量（带正文）——给 export_book 机械搬运用。判断归 agent（常驻挑选、
+ * 引擎条目丢弃），搬运归机器（375 条 61.8 万字符不该流经上下文）。
+ */
+export function listBookEntries(doc) {
+  const kind = detectKind(doc);
+  const book = kind === 'lorebook' ? doc : (doc?.data?.character_book || doc?.character_book);
+  if (!book) return [];
+  const list = Array.isArray(book.entries) ? book.entries : Object.values(book.entries || {});
+  return list.map((e, i) => ({
+    id: String(e.uid ?? e.id ?? i),
+    名字: e.comment || e.name || (Array.isArray(e.key) ? e.key.join('/') : '') || `条目${i + 1}`,
+    触发: Array.isArray(e.key) ? e.key : (Array.isArray(e.keys) ? e.keys : []),
+    常驻: !!(e.constant),
+    停用: e.enabled === false || e.disable === true,
+    正文: String(e.content || ''),
+  }));
+}

package/server/lib/user-uploads.js

@@ -0,0 +1,88 @@
+/**
+ * lib/user-uploads.js —— 用户上传件的落点与增删查（2026-08-28）
+ *
+ * ## 为什么单独挪出来
+ *
+ * 以前上传一律落 `shared/assets/`，而 `assets/` 在画布的文件夹清单里是**基础设施
+ * 目录**（RESERVED_DIRS / NOT_A_FOLDER），于是每个上传件都 homeOf 到根 —— 用户拖
+ * 一张参考图进来，它就直接摊在桌面上跟产物混作一堆。用户原话：「有一件事很膈应」。
+ *
+ * ## 修法：给它一个真目录，不是在画布上造一个虚拟分组
+ *
+ * 文件夹在这套体系里从来就等于磁盘上的真目录（见 api/assets.js 的收纳文件夹注释）。
+ * 凭空多一种只存在于画布上的分组，「文件系统即真相」这条就破了。真目录还白拿了
+ * 整套现成能力：文件夹卡、拖进拖出、改名、MoveTo、agent 的 mv。
+ *
+ * ⚠️ 老项目 `assets/` 里已有的上传件**不迁**：物件 id 就是路径，搬家等于改 id，
+ * 得连 board.json 绑定一起转发。它们照旧扫成 upload 摊在根上 —— 所以这里的列举和
+ * 删除都**两个落点都认**，新的优先。
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+/** 上传落点（工作区相对）。画布上就显示成这个名字的文件夹 */
+export const USER_UPLOAD_DIR = '用户内容';
+
+/** 两个落点，新的在前 —— 列举顺序、删除尝试顺序都按它 */
+const LOOKUP_DIRS = [USER_UPLOAD_DIR, 'assets'];
+
+/** 上传写到哪（不存在就建） */
+export async function ensureUploadDir(sharedRoot) {
+  const dir = path.join(sharedRoot, USER_UPLOAD_DIR);
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+/** agent / 前端拿到的引用路径。cwd 是 sessions/<sid>/，所以 `../../shared/<dir>/<name>` */
+export function uploadRefPath(dirRel, filename) {
+  return `../../shared/${dirRel}/${filename}`;
+}
+
+/**
+ * 列两个落点下的上传件（只看顶层文件，子目录归画布的文件夹机制管）。
+ * @returns {Promise<Array<{path, name, dir, size, mtime}>>} 按 mtime 新→旧
+ */
+export async function listUploadedAssets(sharedRoot) {
+  const out = [];
+  for (const dirRel of LOOKUP_DIRS) {
+    let entries;
+    try {
+      entries = await fs.readdir(path.join(sharedRoot, dirRel), { withFileTypes: true });
+    } catch (err) {
+      if (err.code === 'ENOENT') continue;
+      throw err;
+    }
+    for (const e of entries) {
+      if (!e.isFile()) continue;
+      let stat;
+      try { stat = await fs.stat(path.join(sharedRoot, dirRel, e.name)); } catch { continue; }
+      out.push({
+        path: uploadRefPath(dirRel, e.name), name: e.name, dir: dirRel,
+        size: stat.size, mtime: stat.mtime.toISOString(),
+      });
+    }
+  }
+  out.sort((a, b) => (a.mtime < b.mtime ? 1 : -1));
+  return out;
+}
+
+/**
+ * 删一个上传件。两个落点依次试，**每个目录各自 resolve 复核**（别拿一个目录的
+ * 判据去删另一个目录的文件）。
+ * @returns {Promise<'deleted'|'not_found'|'invalid'>}
+ */
+export async function deleteUploadedAsset(sharedRoot, filename) {
+  for (const dirRel of LOOKUP_DIRS) {
+    const dirAbs = path.join(sharedRoot, dirRel);
+    const filePath = path.resolve(dirAbs, filename);
+    if (!filePath.startsWith(dirAbs + path.sep)) return 'invalid';
+    try {
+      await fs.unlink(filePath);
+      return 'deleted';
+    } catch (err) {
+      if (err.code !== 'ENOENT') throw err;
+    }
+  }
+  return 'not_found';
+}

package/server/projects/board-limits.js

@@ -3,10 +3,12 @@
  * board-store（写盘前查字节数）和 board-sanitize（逐类计数）都要，单独一份免循环依赖。
  */
 export const DEFAULT_BOARD_SIZE = { w: 4000, h: 2600 };
-export const MAX_BOARD_BYTES = 512 * 1024;
-export const MAX_OBJECTS = 2000;
+export const MAX_BOARD_BYTES = 2 * 1024 * 1024;   // 08-25 放大（板是整读整写 JSON，这是失控兜底不是风格闸）
+export const MAX_OBJECTS = 8000;
 export const MAX_ZONES = 200;
 // 关系线上限。取值理由：一块板上人能看懂的线远少于这个数，1000 是防脱缰
 // （agent 循环里连画）的闸门，不是设计目标。超了直接不收，不做淘汰 ——
 // 静默丢最旧的会让"我明明画了"变成玄学。
-export const MAX_BINDINGS = 1000;
+export const MAX_BINDINGS = 4000;
+export const MAX_LANES = 60;      // 线（lane 注册表）：几十条线的脑图已是极限读感
+export const MAX_SHEETS = 200;    // 纸（sheet 注册表，2026-08-29 纸范式）：一纸一屏，200 张已是长篇连载量级

package/server/projects/board-sanitize.js

@@ -6,12 +6,29 @@
  * 行数棘轮，语义一个字没改。
  *
  * schema 见 board-store 头注释。黑板字段（2026-08-23）：
- *   object.tag / object.staging / text.data.format
+ *   object.tag / object.staging / text.data.format / text.data.lid
  *   binding.material / binding.tag / binding.staging
  */
 
 import { isBindingType, isBindingMaterial } from '../lib/binding-types.js';
-import { DEFAULT_BOARD_SIZE, MAX_OBJECTS, MAX_ZONES, MAX_BINDINGS } from './board-limits.js';
+import { ROLE_SLUG_RE } from '../engine/agent/cast.js';
+import { DEFAULT_BOARD_SIZE, MAX_OBJECTS, MAX_ZONES, MAX_BINDINGS, MAX_LANES, MAX_SHEETS } from './board-limits.js';
+import { ONE_SCREEN } from '../lib/screen.js';
+
+/**
+ * 板上署名的白名单：'user' / 'agent' / 常驻角色 slug（`rp-*`，见 engine/agent/cast.js）。
+ * 认不出的一律丢掉（落回无归属），**不透传** —— 这个值由模型写，而它的读者有一串：
+ * 前端标题与线标签、read_board 的分段、板书注入、将来的收件箱路由。
+ *
+ * ⚠️ **有东西寄生在这个值域上**：`lib/board-hero.js` 与 `web/src/lib/hero.js`（parity 对）
+ * 把「手画的线」判成 `by && by !== 'auto'` —— 那是个黑名单，只在「值域被这里钉死」的
+ * 前提下才与白名单等价。放宽这里的值域前，先去看那两处。
+ */
+function sanitizeBy(v) {
+  const s = typeof v === 'string' ? v.trim() : '';
+  if (s === 'user' || s === 'agent') return s;
+  return ROLE_SLUG_RE.test(s) ? s : null;
+}
 
 export function clampNum(v, min, max, fallback) {
   const n = Number(v);
@@ -48,19 +65,19 @@ const CANVAS_NATIVE_KINDS = new Set(['scribble', 'text']);
 const COORD_LIMIT = 1e6;
 
 /** 涂鸦路径串上限。一条随手画的线约 300~800 字符，8000 够长且撑不爆 board.json */
-const MAX_SCRIBBLE_PATH = 8000;
+const MAX_SCRIBBLE_PATH = 24000;
 /**
  * 画布文字的字数上限。
  *
  * 它是"写在白板上的一句话"，不是文档 —— 长东西该写成 .md（那是便利贴，
  * agent 读得到）。2000 字够写一段说明，也撑不爆 board.json。
  */
-const MAX_TEXT_LEN = 2000;
+const MAX_TEXT_LEN = 8000;
 /**
  * md 档文字的上限（2026-08-23 黑板）。画布上的 markdown/KaTeX/mermaid 节点比手写
  * 一句话长，但它仍是"黑板上的一块"不是文档 —— 想写长的走 .md。
  */
-const MAX_MD_TEXT_LEN = 4000;
+const MAX_MD_TEXT_LEN = 8000;
 /** 文字的排版格式：plain = 原样手写；md = Markdown（含 KaTeX 与 mermaid 围栏） */
 const TEXT_FORMATS = ['plain', 'md'];
 /**
@@ -83,6 +100,7 @@ export function isSafeCanvasId(id) {
   return !p.split('/').some(seg => seg === '..');
 }
 
+export { TAG_RE };
 export function sanitizeTag(v) {
   return typeof v === 'string' && TAG_RE.test(v) ? v : null;
 }
@@ -117,6 +135,10 @@ function sanitizeCanvasData(kind, data) {
       font: TEXT_FONTS.includes(data?.font) ? data.font : 'kai',
       size: TEXT_SIZES.includes(data?.size) ? data.size : 'md',
       color: ['ink', 'red', 'pencil', 'brass'].includes(data?.color) ? data.color : 'ink',
+      // lid = sketch_on_board 里那个局部 id（linfan / zhangwei…）。留着它，
+      // edit_sketch 才能按 agent 当初起的名字找回这个节点 —— 否则局部 id 一落定
+      // 就作废，加条线得先去翻上一次调用的返回。这层是白名单重建，不列就丢。
+      ...(typeof data?.lid === 'string' && /^[A-Za-z0-9_-]{1,24}$/.test(data.lid) ? { lid: data.lid } : {}),
       ...sanitizeTransform(data),
     };
   }
@@ -151,9 +173,31 @@ export function sanitizeObject(o, size) {
     ...(o.expanded ? { expanded: true } : {}),
     // 显式归属：'' = 明确无归属（覆盖 sid 派生），非空 = 所属工作区 id
     ...(typeof o.zone === 'string' && o.zone.length <= 300 ? { zone: o.zone } : {}),
-    // 出处（2026-08-14 agent 摆位/建元素）：agent 落的座/写的字标出来，
-    // 用户的是默认不标 —— 跟关系线的 by 同一条纪律
-    ...(o.by === 'agent' ? { by: 'agent' } : {}),
+    // 出处（2026-08-14 agent 摆位/建元素）：谁**造**的这件东西。08-25 起也收
+    // 'user'（原来只认 agent，跟 bindings 三值不对称是口径病）；08-26 起再收
+    // 常驻角色的 slug（rp-*）—— RP 场里板上大半东西是角色写的，全落回 'agent'
+    // 就丢了归属。⚠️ 这里是白名单，不是透传：写这个值的是模型，而 by 有一串读者
+    // （前端显示 / read_board 分段 / 板书注入 / 将来的收件箱路由）。
+    ...(sanitizeBy(o.by) ? { by: sanitizeBy(o.by) } : {}),
+    // 座位出处（2026-08-25 范式重做）：谁**摆**的这个座。三值：
+    //   user  = 用户亲手拖的 —— 出处记号+学习票源（inferFlowDir 认它学摆放方向）。
+    //           08-28 起**不再是禁令**（用户拍板全放开）：move/reflow/组操作都挪得动，
+    //           但工具返回必须注明"原是用户亲手摆的"，且他拖回去就是定案。
+    //   auto  = 入座算法排的 —— 可以被重排
+    //   agent = agent 显式摆的 —— 用户可拖走（拖走后变 user）
+    // 没有这个字段，用户拖的和自动排的在数据上分不清
+    // （08-25 体检结论：老数据 by 被前端回写抹掉）。
+    //   shelf = 暂存架上等安置（2026-08-30）—— 机器到货默认座。pin_to_board /
+    //           edit_board move / 用户拖拽一改写 seat 就自然离架（lib/board-shelf.js）
+    ...(o.seat === 'user' || o.seat === 'auto' || o.seat === 'agent' || o.seat === 'shelf' ? { seat: o.seat } : {}),
+    // 尺寸出处（2026-08-28）：'user' = 这块板书的宽高是用户亲手拖出来的。
+    // 两个用途：① 重排/估算别拿内容宽度盖掉他调过的宽 ② 写入端拿它当**学习票源**
+    // 推断"他喜欢多宽的板书"（lib/chalk-size-pref.js）。跟 seat 是两件事 ——
+    // seat 说"谁摆的位置"，sized 说"谁定的大小"，用户可以只调一个。
+    ...(o.sized === 'user' ? { sized: 'user' } : {}),
+    // 贴身跟随（2026-08-27 shapes 编辑面）：这个涂鸦是"圈住 hug 那件东西"的记号，
+    // 挪那件东西时它跟着走（edit_board move/move_group/reflow；前端拖拽同口径）
+    ...(typeof o.hug === 'string' && o.hug.length <= 300 ? { hug: o.hug } : {}),
     // 分组标签 + 草稿位（2026-08-23 黑板）。staging = agent 这一轮还在打草稿：
     // 入座不看它、read_board 默认不列它、画面上半透明；落定（commitStaging）清位。
     ...(sanitizeTag(o.tag) ? { tag: sanitizeTag(o.tag) } : {}),
@@ -188,12 +232,17 @@ export function sanitizeBinding(b) {
       : {}),
     // 谁画的。用户画的线 agent 不该擅自删，反过来也一样；auto = 机器可证的
     // 引用关系（auto-relations.js 对账层专属，只有它增删自家 b:auto:* 条目）。
-    ...(b.by === 'agent' || b.by === 'user' || b.by === 'auto' ? { by: b.by } : {}),
+    ...(b.by === 'auto' ? { by: 'auto' } : sanitizeBy(b.by) ? { by: sanitizeBy(b.by) } : {}),
     // 材质（2026-08-23 黑板）：语义之外的第二个轴 —— 墨线/手绘/丝线。不落默认值，
     // 渲染侧按语义给缺省材质；存了默认值以后改缺省就改不动存量。
     ...(isBindingMaterial(b.material) && b.material !== 'ink' ? { material: b.material } : {}),
     ...(sanitizeTag(b.tag) ? { tag: sanitizeTag(b.tag) } : {}),
     ...(b.staging === true ? { staging: true } : {}),
+    // 跟随线（2026-08-25 范式重做，RP「状态板重锚」案）：follow = 目标 tag ——
+    // 这条线的 to 端永远指向该 tag 最新落板的那件，服务端在新件落板时自动重指
+    // 并把 from 端所在的组挪过去（board-follow.js）。followSide = 挪到哪一侧。
+    ...(sanitizeTag(b.follow) ? { follow: sanitizeTag(b.follow) } : {}),
+    ...(['right', 'left', 'above', 'below'].includes(b.followSide) ? { followSide: b.followSide } : {}),
   };
 }
 
@@ -218,6 +267,94 @@ export function sanitizeZone(z) {
   };
 }
 
+/**
+ * 线（lane）注册表条目（2026-08-27 空间规划）：{x,y,w,parent}。
+ * 键 = tag（线就是 tag，见 lib/board-lanes.js 头注）；frontier 不存 —— 从成员现算。
+ */
+export function sanitizeLane(l) {
+  if (!l || typeof l !== 'object') return null;
+  const x = Number(l.x); const y = Number(l.y);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  const parent = typeof l.parent === 'string' && l.parent.length <= 300 ? l.parent : null;
+  return {
+    x: Math.round(x), y: Math.round(y),
+    w: clampNum(l.w, 96, 2400, 480),
+    ...(parent ? { parent } : {}),
+  };
+}
+
+/**
+ * 卷（2026-08-27 收纳器）：{ at, by, label? }。有条目 = 这个 tag 收着。
+ * 只是视觉收纳的状态位 —— 成员对象的座位原样留在 objects 里（展开即归位），
+ * 落位引擎照旧把它们当障碍。
+ */
+export function sanitizeRoll(r) {
+  if (!r || typeof r !== 'object') return null;
+  const at = typeof r.at === 'string' && r.at.length <= 40 ? r.at : new Date().toISOString();
+  const by = typeof r.by === 'string' && r.by.length <= 40 ? r.by : 'user';
+  const label = typeof r.label === 'string' && r.label.trim() ? r.label.trim().slice(0, 60) : null;
+  return { at, by, ...(label ? { label } : {}) };
+}
+
+/**
+ * 纸（sheet 注册表，2026-08-29 纸范式）：{ x, y, w, h, by?, at?, title? }。
+ * 键 = 纸名（TAG_RE 字符集）。纸是**分配纪律不是本体容器**：成员按几何派生
+ * （中心点落在纸内），这里只登记「这块地是谁在什么时候铺的、多大」。
+ * w/h 显式存 —— 纸尺寸取决于铺纸那一刻的设备档（手机纸小、桌面纸大），
+ * 不能全局常量化。
+ */
+/** 一张纸上最多规划几块地（版面切太碎就不是版面了） */
+export const MAX_SLOTS = 24;
+
+/**
+ * 版位（slot，2026-08-29 占位契约刀 E）：开工时先把这一屏切成几块地，各自起名。
+ *
+ * ⚠️ 坐标**跟 at 同一套**：纸内局部像素、原点在版心左上角。不用格数 —— 同一组
+ * 字段两种单位是站主点过名的老坑（"同字段按数值切单位＝中间那段必错且不出声"）。
+ */
+export function sanitizeSlot(s) {
+  if (!s || typeof s !== 'object') return null;
+  const x = Number(s.x); const y = Number(s.y);
+  const w = Number(s.w); const h = Number(s.h);
+  if (![x, y, w, h].every(Number.isFinite)) return null;
+  if (w < 48 || h < 24) return null;      // 比这还小的地放不下一行字
+  return {
+    x: Math.round(Math.min(Math.max(0, x), 12000)),
+    y: Math.round(Math.min(Math.max(0, y), 12000)),
+    w: Math.round(Math.min(w, 12000)),
+    h: Math.round(Math.min(h, 12000)),
+    ...(typeof s.about === 'string' && s.about.trim() ? { about: s.about.trim().slice(0, 60) } : {}),
+    // 收产物的那块地（2026-08-30 刀 G）：`for:'artifacts'` 一张纸上最多一块。
+    // 产物（生成的图、写出来的文件、目录型产物）是 agent 干活的**副产品**，
+    // 它没法在写之前一件件点名落位 —— 但它可以提前说「这一页的产物都放这儿」。
+    // 没有这块地，机器就只能自己决定，那就又回到「机器定版面」了。
+    ...(s.for === 'artifacts' ? { for: 'artifacts' } : {}),
+  };
+}
+
+export function sanitizeSheet(s) {
+  if (!s || typeof s !== 'object') return null;
+  const x = Number(s.x); const y = Number(s.y);
+  if (!Number.isFinite(x) || !Number.isFinite(y)) return null;
+  const slots = {};
+  let slotN = 0;
+  for (const [nm, v] of Object.entries(s?.slots && typeof s.slots === 'object' ? s.slots : {})) {
+    if (slotN >= MAX_SLOTS) break;
+    if (!TAG_RE.test(nm)) continue;
+    const sl = sanitizeSlot(v);
+    if (sl) { slots[nm] = sl; slotN += 1; }
+  }
+  return {
+    x: Math.round(x), y: Math.round(y),
+    w: clampNum(s.w, 240, 8000, ONE_SCREEN.w),
+    h: clampNum(s.h, 240, 12000, ONE_SCREEN.h),
+    ...(sanitizeBy(s.by) ? { by: sanitizeBy(s.by) } : {}),
+    ...(typeof s.at === 'string' && s.at.length <= 40 ? { at: s.at } : {}),
+    ...(typeof s.title === 'string' && s.title.trim() ? { title: s.title.trim().slice(0, 60) } : {}),
+    ...(slotN ? { slots } : {}),
+  };
+}
+
 export function sanitizeBoard(raw) {
   const size = sanitizeSize(raw?.size);
   const objects = {};
@@ -247,6 +384,79 @@ export function sanitizeBoard(raw) {
   // 主角覆盖（2026-08-14 agent 摆位）：显式立的主角压过前端 pickHero 的推断。
   // 存 id 不存理由 —— 理由在会话里，画布只要知道谁站 C 位
   const hero = typeof raw?.hero === 'string' && raw.hero.length <= 300 ? raw.hero : null;
-  return { size, zones, objects, bindings, ...(hero ? { hero } : {}) };
+  const lanes = {};
+  let lCount = 0;
+  for (const [name, l] of Object.entries(raw?.lanes && typeof raw.lanes === 'object' ? raw.lanes : {})) {
+    if (lCount >= MAX_LANES) break;
+    const tag = sanitizeTag(name);
+    if (!tag) continue;
+    const s = sanitizeLane(l);
+    if (s) { lanes[tag] = s; lCount += 1; }
+  }
+  const rolls = {};
+  let rCount = 0;
+  for (const [name, r] of Object.entries(raw?.rolls && typeof raw.rolls === 'object' ? raw.rolls : {})) {
+    if (rCount >= MAX_LANES) break;   // 卷跟线同量级：一线一卷
+    const tag = sanitizeTag(name);
+    if (!tag) continue;
+    const s = sanitizeRoll(r);
+    if (s) { rolls[tag] = s; rCount += 1; }
+  }
+  const sheets = {};
+  let sCount = 0;
+  for (const [name, s0] of Object.entries(raw?.sheets && typeof raw.sheets === 'object' ? raw.sheets : {})) {
+    if (sCount >= MAX_SHEETS) break;
+    const nm = sanitizeTag(name);
+    if (!nm) continue;
+    const s = sanitizeSheet(s0);
+    if (s) { sheets[nm] = s; sCount += 1; }
+  }
+  /**
+   * 跟随规则（2026-08-30）：`{ 组tag: { target, side?, label? } }`。
+   *
+   * 以前 follow 只有「线」这一种形态，而线要求两端**此刻都在板上**。真会话里最常见的
+   * 写法是开场先立规则再写第一章（skill 的原话就是「开场画一次状态板，然后立一条跟随
+   * 规则」）—— 那一刻目标 tag 还是空的，于是必炸。全库 5 次、跨 4 个项目，形态一模一样。
+   * 规则和线分开存之后，规则可以先立着，目标一出现 applyFollows 顺手把线接上。
+   */
+  const follows = {};
+  let fCount = 0;
+  for (const [g, r] of Object.entries(raw?.follows && typeof raw.follows === 'object' ? raw.follows : {})) {
+    if (fCount >= 12) break;
+    const gt = sanitizeTag(g);
+    const target = sanitizeTag(r?.target);
+    if (!gt || !target || gt === target) continue;
+    follows[gt] = {
+      target,
+      ...(['right', 'left', 'above', 'below'].includes(r?.side) ? { side: r.side } : {}),
+      ...(typeof r?.label === 'string' && r.label.trim() ? { label: r.label.trim().slice(0, 60) } : {}),
+    };
+    fCount += 1;
+  }
+  /**
+   * 待摆产物（2026-08-30 刀 G）：磁盘上有、但板上还没地方放的工作区相对路径。
+   * 入座不再自己铺纸（那是「机器替 agent 定版面」），排不下就进这条队列，
+   * 每回合状态块点名，等 agent 规划出地方再落座。
+   */
+  const pending = [];
+  for (const v of Array.isArray(raw?.pending) ? raw.pending : []) {
+    if (pending.length >= 50) break;
+    if (typeof v !== 'string') continue;
+    const t = v.trim();
+    if (!t || t.length > 300 || t.includes('..') || t.startsWith('/')) continue;
+    if (!pending.includes(t)) pending.push(t);
+  }
+  // 暂存架原点（2026-08-30，lib/board-shelf.js）：机器到货码放的竖带左上角
+  const shelf = (raw?.shelf && Number.isFinite(Number(raw.shelf.x)) && Number.isFinite(Number(raw.shelf.y)))
+    ? { x: clampNum(raw.shelf.x, -COORD_LIMIT, COORD_LIMIT, 0), y: clampNum(raw.shelf.y, -COORD_LIMIT, COORD_LIMIT, 0) }
+    : null;
+  return {
+    size, zones, objects, bindings,
+    ...(hero ? { hero } : {}), ...(lCount ? { lanes } : {}), ...(rCount ? { rolls } : {}),
+    ...(sCount ? { sheets } : {}),
+    ...(fCount ? { follows } : {}),
+    ...(pending.length ? { pending } : {}),
+    ...(shelf ? { shelf } : {}),
+  };
 }