@xiaobuyu/nodesign 0.0.6 → 0.0.8

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 } : {}),
+  };
 }
 

package/server/projects/board-store.js

@@ -20,15 +20,17 @@
 import { promises as fs } from 'fs';
 import path from 'path';
 import { getSharedDir, ensureProjectWorkspace, gitRenamesSince } from './workspace.js';
-import { CHALK_DIR } from '../lib/chalk.js';
+import { CHALK_DIR, trashChalkFile } from '../lib/chalk.js';
+import { estimateSizeOn } from '../lib/board-kind-sizes.js';
 
 export {
   DEFAULT_BOARD_SIZE, MAX_BOARD_BYTES, MAX_OBJECTS, MAX_ZONES, MAX_BINDINGS,
 } from './board-limits.js';
 export { TEXT_FONTS } from './board-sanitize.js';
-import { DEFAULT_BOARD_SIZE, MAX_BOARD_BYTES, MAX_OBJECTS, MAX_ZONES, MAX_BINDINGS } from './board-limits.js';
+import { DEFAULT_BOARD_SIZE, MAX_BOARD_BYTES, MAX_OBJECTS, MAX_ZONES, MAX_BINDINGS, MAX_LANES, MAX_SHEETS } from './board-limits.js';
 import {
-  clampNum, sanitizeSize, sanitizeTag, sanitizeObject, sanitizeBinding, sanitizeZone, sanitizeBoard, isSafeCanvasId,
+  clampNum, sanitizeSize, sanitizeTag, sanitizeObject, sanitizeBinding, sanitizeZone, sanitizeBoard, sanitizeLane, sanitizeRoll, sanitizeSheet,
+  isSafeCanvasId,
 } from './board-sanitize.js';
 
 // 分区自动铺位常数 —— 与前端 BoardCanvas 的 ZONE_* 保持一致（数值约定，非共享代码）
@@ -107,7 +109,14 @@ export function patchBoard(pid, patch) {
         if (!isSafeCanvasId(rawId)) continue;
         const id = fwd(rawId);
         if (o === null) { delete board.objects[id]; removed.add(id); continue; }
-        const s = sanitizeObject(o, board.size);
+        // **合并语义**（2026-08-25）：patch 条目盖在已有条目上，缺席字段保留。
+        // 病根：前端本地 layout 会落后于服务端（board.json 一次性加载闸门），
+        // 入座把 agent 刚写的条目当新客回写一条 {x,y,z} —— 整条替换语义下
+        // by/seat/w/h/tag/staging 全被抹掉且零报错（08-25 体检三陷阱之②）。
+        // 合并后瘦条目只更新它带来的字段。要删整条传 null；单字段清除走
+        // 各自的专用路（commitStaging 清 staging、removeByTag 摘 tag）。
+        const merged = board.objects[id] ? { ...board.objects[id], ...o } : o;
+        const s = sanitizeObject(merged, board.size);
         if (s && (board.objects[id] || Object.keys(board.objects).length < MAX_OBJECTS)) board.objects[id] = s;
       }
     }
@@ -115,13 +124,81 @@ export function patchBoard(pid, patch) {
       for (const [id, b] of Object.entries(patch.bindings)) {
         if (typeof id !== 'string' || id.length > 300) continue;
         if (b === null) { delete board.bindings[id]; continue; }
-        const s = sanitizeBinding(b);
+        // 合并语义同 objects（08-25）：改材质/label 的瘦 patch 别抹掉 follow 等字段
+        const s = sanitizeBinding(board.bindings[id] ? { ...board.bindings[id], ...b } : b);
         if (!s) continue;
         // 端点也要转发：agent 本轮拿旧路径连的线，落下来必须连到新名字上
         const fixed = { ...s, from: fwd(s.from), to: fwd(s.to) };
         if (board.bindings[id] || Object.keys(board.bindings).length < MAX_BINDINGS) board.bindings[id] = fixed;
       }
     }
+    // 线注册表（08-27 空间规划）：合并语义同 objects；parent 也走改名转发
+    if (patch?.lanes && typeof patch.lanes === 'object') {
+      board.lanes = board.lanes || {};
+      for (const [name, l] of Object.entries(patch.lanes)) {
+        const tag = sanitizeTag(name);
+        if (!tag) continue;
+        if (l === null) { delete board.lanes[tag]; continue; }
+        const s = sanitizeLane(board.lanes[tag] ? { ...board.lanes[tag], ...l } : l);
+        if (!s) continue;
+        const fixed = s.parent ? { ...s, parent: fwd(s.parent) } : s;
+        if (board.lanes[tag] || Object.keys(board.lanes).length < MAX_LANES) board.lanes[tag] = fixed;
+      }
+      if (!Object.keys(board.lanes).length) delete board.lanes;
+    }
+    // 卷（2026-08-27 收纳器）：合并语义同 lanes；null = 展开（删条目）。
+    // 只动状态位不动成员座位 —— 展开即归位靠的就是这里什么都不搬。
+    if (patch?.rolls && typeof patch.rolls === 'object') {
+      board.rolls = board.rolls || {};
+      for (const [name, r] of Object.entries(patch.rolls)) {
+        const tag = sanitizeTag(name);
+        if (!tag) continue;
+        if (r === null) { delete board.rolls[tag]; continue; }
+        const s = sanitizeRoll(board.rolls[tag] ? { ...board.rolls[tag], ...r } : r);
+        if (!s) continue;
+        if (board.rolls[tag] || Object.keys(board.rolls).length < MAX_LANES) board.rolls[tag] = s;
+      }
+      if (!Object.keys(board.rolls).length) delete board.rolls;
+    }
+    // 纸（2026-08-29 纸范式）：合并语义同 lanes；null = 撕掉登记（成员座位不动）。
+    // 纸名不是路径，不走改名转发。
+    if (patch?.sheets && typeof patch.sheets === 'object') {
+      board.sheets = board.sheets || {};
+      for (const [name, s0] of Object.entries(patch.sheets)) {
+        const nm = sanitizeTag(name);
+        if (!nm) continue;
+        if (s0 === null) { delete board.sheets[nm]; continue; }
+        const s = sanitizeSheet(board.sheets[nm] ? { ...board.sheets[nm], ...s0 } : s0);
+        if (!s) continue;
+        if (board.sheets[nm] || Object.keys(board.sheets).length < MAX_SHEETS) board.sheets[nm] = s;
+      }
+      if (!Object.keys(board.sheets).length) delete board.sheets;
+    }
+    // 跟随规则（2026-08-30）：`{ 组tag: {target,side?,label?} | null }`。规则和线分开存
+    // —— 线要求两端此刻都在板上，规则不要求，所以「开场先立规则再写第一章」这条
+    // skill 教了、模型也一直照做的顺序，第一次真的走得通。
+    if (patch?.follows && typeof patch.follows === 'object') {
+      board.follows = board.follows || {};
+      for (const [g, r] of Object.entries(patch.follows)) {
+        const gt = sanitizeTag(g);
+        if (!gt) continue;
+        if (r === null) { delete board.follows[gt]; continue; }
+        board.follows[gt] = r;
+      }
+      const clean = sanitizeBoard({ ...board, follows: board.follows }).follows;
+      if (clean) board.follows = clean; else delete board.follows;
+    }
+    // 待摆产物队列（刀 G）：整表替换（写方只有 board-seater 一个，diff 没意义）
+    if (patch?.pending !== undefined) {
+      const clean = sanitizeBoard({ ...board, pending: patch.pending }).pending;
+      if (clean?.length) board.pending = clean; else delete board.pending;
+    }
+    // 暂存架原点（2026-08-30）：整值替换，写方只有 board-seater / board-tasklist；
+    // null = 撤架（下批到货重立）
+    if (patch?.shelf !== undefined) {
+      const clean = sanitizeBoard({ ...board, shelf: patch.shelf }).shelf;
+      if (clean) board.shelf = clean; else delete board.shelf;
+    }
     // 主角覆盖：null = 撤销（回到 pickHero 自动推断），字符串 = 显式立主角
     if (patch?.hero !== undefined) {
       if (patch.hero === null) delete board.hero;
@@ -205,7 +282,8 @@ export function removeByTag(pid, tag) {
       // 以进程身份删任意文件；sanitize 现在也拒 `..`，这里是第二道闸）
       if (id.startsWith(`${CHALK_DIR}/`)) {
         const abs = chalkAbsPath(pid, id);
-        if (abs) { try { await fs.unlink(abs); } catch { /* 已经没了 */ } }
+        // 软删进 .nd/trash/（08-25：擦掉的板书要捞得回来）
+        if (abs) await trashChalkFile(getSharedDir(pid), abs);
         delete board.objects[id]; gone.add(id); removed += 1; continue;
       }
       delete o.tag;
@@ -214,6 +292,8 @@ export function removeByTag(pid, tag) {
       if (b.tag === t || gone.has(b.from) || gone.has(b.to)) { delete board.bindings[id]; removed += 1; }
     }
     if (board.hero && gone.has(board.hero)) delete board.hero;
+    // 擦组连卷的状态位一起清（收着的组被 erase_group 后不该留一张空卷卡）
+    if (board.rolls?.[t]) { delete board.rolls[t]; if (!Object.keys(board.rolls).length) delete board.rolls; }
     await writeBoard(pid, board);
     return { board, removed };
   });
@@ -451,6 +531,8 @@ export async function reconcileBoardRenames(pid) {
  *    文件夹没坐标（还没被摆过）时就摆到桌面上，前端下一轮会给它安排位置。
  */
 export function pinToZone(pid, { objectId, zoneId = '' }) {
+  // 08-27 审计修：这里是 patchBoard 之外唯一的 objects 写入口，原先没有数量闸 ——
+  // 反复 pin 新 id 可把 board.objects 撑过 MAX_OBJECTS（只剩 2MB 字节兜底）。
   return withBoardLock(pid, async () => {
     const board = await readBoard(pid);
     const now = Date.now();
@@ -473,7 +555,7 @@ export function pinToZone(pid, { objectId, zoneId = '' }) {
      */
     const CELL_W = 320; const CELL_H = 220; const PAD = 10;
     const dirOf = (id) => {
-      if (typeof id !== 'string' || id.startsWith('doc:')) return '';
+      if (typeof id !== 'string') return '';
       const c = id.indexOf(':');
       const path = (c > 0 && /^[a-z]+$/.test(id.slice(0, c))) ? id.slice(c + 1) : id;
       const i = path.lastIndexOf('/');
@@ -494,14 +576,62 @@ export function pinToZone(pid, { objectId, zoneId = '' }) {
     }
     if (!slot) slot = { x: PAD, y: PAD };
 
+    if (!board.objects[oid] && Object.keys(board.objects).length >= MAX_OBJECTS) {
+      throw new Error(`board 已有 ${MAX_OBJECTS} 件，pin 不进新条目（失控兜底，正常用不该撞到）`);
+    }
     const zMax = Math.max(10, ...Object.values(board.objects).map(o => o.z || 0));
+    // 落座即写估算 w/h（2026-08-29 纸范式刀 3）：此前 pin 出来的条目只有坐标，
+    // read_board 只能报形态表猜值。估算先落盘、前端渲染后按真值回写（useMeasuredSize）。
+    const sz = estimateSizeOn(board, oid, board.objects[oid] || null);
     board.objects[oid] = {
       ...(board.objects[oid] || {}),
       x: clampNum(slot.x, 0, board.size.w, PAD),
       y: clampNum(slot.y, 0, board.size.h, PAD),
       z: zMax + 1,
+      ...(Number.isFinite(board.objects[oid]?.w) ? {} : { w: Math.round(sz.w), h: Math.round(sz.h) }),
     };
     await writeBoard(pid, board);
     return { board, zone: zid ? { id: zid } : null, placed: board.objects[oid] };
   });
 }
+
+/**
+ * 悬空关系线清扫（2026-08-24，iss_mszz20zn）：删掉产物后 board.json 里会留下
+ * 端点指向已不存在文件的 binding —— 关系线只能画不能删，agent 收尾时"我制造的
+ * 东西我清不掉"。关系线依附于产物存在：产物没了线自然该没。
+ *
+ * 端点合法 = 板上有座位（board.objects）或磁盘上真有这个路径（kind 前缀剥掉后）。
+ * 两条都不满足才剪 —— 宁可留一条可疑的，不错杀一条活的。30s 节流：挂在
+ * /artifacts 热路径上，每张板最多半分钟对账一次。
+ */
+const pruneStamp = new Map();   // pid → last run ms
+const PRUNE_INTERVAL_MS = 30_000;
+
+export function pruneDanglingBindings(pid) {
+  const now = Date.now();
+  if ((pruneStamp.get(pid) || 0) + PRUNE_INTERVAL_MS > now) return Promise.resolve({ pruned: 0 });
+  pruneStamp.set(pid, now);
+  return withBoardLock(pid, async () => {
+    const board = await readBoard(pid);
+    const entries = Object.entries(board.bindings || {});
+    if (!entries.length) return { pruned: 0 };
+    const root = getSharedDir(pid);
+    const alive = async (ep) => {
+      const id = String(ep || '');
+      if (!id) return false;
+      if (board.objects?.[id]) return true;
+      const bare = id.replace(/^(deck|site|docx|text|scribble):/, '');
+      if (!bare || bare.includes('..')) return false;
+      try { await fs.access(path.resolve(root, bare)); return true; } catch { return false; }
+    };
+    const dead = [];
+    for (const [bid, b] of entries) {
+      if (!(await alive(b?.from)) || !(await alive(b?.to))) dead.push(bid);
+    }
+    if (!dead.length) return { pruned: 0 };
+    for (const bid of dead) delete board.bindings[bid];
+    await writeBoard(pid, board);
+    console.log(`[board] ${pid} 清掉 ${dead.length} 条悬空关系线`);
+    return { pruned: dead.length };
+  });
+}

package/server/projects/memory-migration.js

@@ -0,0 +1,85 @@
+/**
+ * projects/memory-migration.js — 记忆体系改版迁移（2026-08-24，幂等）
+ *
+ * ensureProjectWorkspace 每次调用（源不在了就什么都不做）：
+ *   ① .claude/CLAUDE.md → <root>/CLAUDE.md（根上已有就把旧文件并进末尾再删）
+ *   ② .claude/agent-memory/memory.md、brand/memory.md → 并进根 CLAUDE.md 的
+ *      「用户习惯」/「风格档案」节末尾，源删除
+ *   ③ .claude/agent-memory/auto/* → 记忆/（SDK auto-memory 新家，画布可见）
+ * 三步全是"搬走后源删除"，跑几遍结果一样。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { MEMORY_DIR_NAME } from '../engine/agent/memory-config.js';
+import { DEFAULT_CLAUDE_MD } from './workspace-templates.js';
+
+/** 改版前的默认模板原文（迁移判据用：全文相等 = 用户没写过一个字，不搬） */
+const OLD_DEFAULT_CLAUDE_MD = `# Project Instructions
+
+This file is read by the AI agent at the start of every session as part of its
+system prompt. Write project-specific guidance here — design intent,
+constraints, vocabulary, must-do / must-not-do.
+
+The agent will see this verbatim. Keep it concise and actionable.
+
+## Examples
+- Design tone: minimal, editorial, generous whitespace
+- Hard constraints: never use red as a primary color
+- Vocabulary: refer to the user as "the team"
+
+(Edit this file from the NoDesign UI — the agent picks up changes on next session.)
+`;
+
+export async function migrateMemoryLayout(root, { fileExists }) {
+  const rootMd = path.join(root, 'CLAUDE.md');
+  const appendTo = async (heading, text, label) => {
+    const body = String(text || '').trim();
+    if (!body) return;
+    let cur = '';
+    try { cur = await fs.readFile(rootMd, 'utf8'); } catch { /* 还没有 */ }
+    if (!cur.trim()) cur = DEFAULT_CLAUDE_MD;   // 起新文件时以「项目档案」模板打底
+    await fs.writeFile(rootMd, `${cur ? `${cur.replace(/\n+$/, '')}\n\n` : ''}${heading}\n（${label}，2026-08-24 自动迁入）\n\n${body}\n`, 'utf8');
+  };
+  const oldMd = path.join(root, '.claude', 'CLAUDE.md');
+  try {
+    const t = await fs.readFile(oldMd, 'utf8');
+    // 旧英文默认模板（用户一个字没改，**全文精确比对**才算）没有搬运价值 ——
+    // 删掉让 ensure 落新版「项目档案」模板。差一个字都按用户内容原样搬，宁可
+    // 多搬不可误删（判据宽了会吃掉用户在模板上的增改）。
+    if (t.trim() === OLD_DEFAULT_CLAUDE_MD.trim()) {
+      await fs.rm(oldMd, { force: true });
+    } else {
+      if (await fileExists(rootMd)) await appendTo('## 项目指引', t, '原 .claude/CLAUDE.md');
+      else await fs.writeFile(rootMd, t, 'utf8');
+      await fs.rm(oldMd, { force: true });
+    }
+  } catch { /* 没有旧文件：新项目 */ }
+  const memRoot = path.join(root, '.claude', 'agent-memory');
+  try {
+    const t = await fs.readFile(path.join(memRoot, 'memory.md'), 'utf8');
+    await appendTo('## 用户习惯', t, '原用户偏好记忆');
+    await fs.rm(path.join(memRoot, 'memory.md'), { force: true });
+  } catch { /* */ }
+  try {
+    const t = await fs.readFile(path.join(memRoot, 'brand', 'memory.md'), 'utf8');
+    await appendTo('## 风格档案', t, '原风格档案');
+    await fs.rm(path.join(memRoot, 'brand'), { recursive: true, force: true });
+  } catch { /* */ }
+  // auto/ 的存量记忆搬去 记忆/（同名不覆盖：目标已有的跳过，宁可留双份可见）
+  const autoDir = path.join(memRoot, 'auto');
+  try {
+    const entries = await fs.readdir(autoDir, { withFileTypes: true });
+    const dest = path.join(root, MEMORY_DIR_NAME);
+    await fs.mkdir(dest, { recursive: true });
+    for (const e of entries) {
+      const from = path.join(autoDir, e.name);
+      const to = path.join(dest, e.name);
+      if (await fileExists(to)) continue;
+      await fs.rename(from, to).catch(() => {});
+    }
+    const left = await fs.readdir(autoDir).catch(() => []);
+    if (left.length === 0) await fs.rm(autoDir, { recursive: true, force: true });
+  } catch { /* 没有 auto/：多数项目 */ }
+}
+

package/server/projects/move-entry.js

@@ -19,6 +19,7 @@ import { getSharedDir } from './workspace.js';
 import { renameBoardPaths } from './board-store.js';
 import { taskManifest, KIND_SITE } from '../lib/artifact-target.js';
 import { RESERVED_DIRS } from '../lib/task-scan.js';
+import { CHALK_DIR } from '../lib/chalk.js';
 
 export class MoveError extends Error {
   constructor(status, message) { super(message); this.status = status; }
@@ -62,8 +63,17 @@ export async function moveEntry(pid, fromRaw, toRaw, { createFolder = false } =
   if (NO_MOVE_OUT.has(guardSeg(from)) || guardSeg(from).startsWith('.')) {
     throw new MoveError(400, '这个位置的东西不参与搬家');
   }
+  // 板书不参与搬家（08-24，上报 iss_mt5qujy1）：它是画布上的**话**，不是文件产物。
+  // 拖拽误触把它挪出 notes/板书/ 会丢 chalk 身份渲染成普通细条卡，且没有正规
+  // 归位通道。搬出一律拒；搬回（下面目标守卫的例外）留给误逃文件的恢复。
+  if (from === CHALK_DIR || from.startsWith(`${CHALK_DIR}/`)) {
+    throw new MoveError(400, '板书是画布上的话，不参与搬家');
+  }
   if (to && (RESERVED_DIRS.has(guardSeg(to)) || guardSeg(to).startsWith('.'))) {
-    throw new MoveError(400, '不能搬进这个目录');
+    // 唯一例外：把误逃的 .md 送**回**板书目录（恢复通道；organize_board 同享。
+    // 不限根层 —— groupInto 误触会把板书埋进"新建文件夹/"里，也得捞得回来）
+    const isChalkReturn = to === CHALK_DIR && /\.md$/i.test(from);
+    if (!isChalkReturn) throw new MoveError(400, '不能搬进这个目录');
   }
   // 搬进自己肚子里（文件夹拖到它自己的子文件夹上）—— fs.rename 会报
   // EINVAL，但那时目录树已经没法自洽了，提前拦住