@xiaobuyu/nodesign 0.0.6 → 0.0.8

package/server/lib/sketch-shapes.js

@@ -0,0 +1,152 @@
+/**
+ * server/lib/sketch-shapes.js —— sketch 形状构建（2026-08-27 行数棘轮拆件）
+ *
+ * 从 mcp/tools/write-on-board.js **原样**搬出：入参形状声明 → 局部像素矩形 +
+ * 手绘 path + hug 标记。纯计算、不碰磁盘；语义一字未动，搬家原因只有一个 ——
+ * write-on-board 顶到 600 行棘轮（642），拆最独立的这一块。
+ *
+ * 返回 { shapes } 或 { error }（原来的 err() 出口改成 error 字符串，调用方
+ * 自己包成工具错误 —— 这层不该知道 MCP 的返回形状）。
+ */
+
+import { UNIT, shapePath, roughFreePath } from './sketch-layout.js';
+import { stencilStrokes, STENCIL_NAMES } from './sketch-stencils.js';
+import { expandModifiers } from './sketch-array.js';
+import { flattenClosed, hatchD } from './sketch-hatch.js';
+
+/** 板书墨色表（zod 不硬拒，认不出落 ink —— 风格不用 -32602 管） */
+export const SKETCH_COLORS = ['ink', 'red', 'pencil', 'brass'];
+
+/**
+ * @param {Array} shapesIn  工具入参的 shapes
+ * @param {object} deps
+ *   rectOfNode(key) → {x,y,w,h}|null   已落位节点的局部矩形
+ *   isTaken(id) → boolean              id 是否已被节点/形状占用
+ *   tag                                本张图的 tag（手绘抖动的种子）
+ * @returns {{shapes: Array<{key,rect,d,color,width,hug}>}|{error: string}}
+ */
+export function buildSketchShapes(shapesIn, { rectOfNode, isTaken, tag }) {
+  const shapes = [];
+  for (let i = 0; i < shapesIn.length; i += 1) {
+    const s = shapesIn[i];
+    const sid = s.id || `s${i + 1}`;
+    if (isTaken(sid) || shapes.some(x => x.key === sid)) return { error: `形状 id「${sid}」跟节点/别的形状重名（形状缺省叫 s1,s2…，节点别用这类名）` };
+    const seed = `${tag || 'solo'}:${sid}`;
+    // 缺省一律 ink。曾有个 'ink2'（箭头用更深墨色）的死分支：色板里没这个色，
+    // 落盘前的白名单每次都把它打回 'ink'，意图从未生效 —— 08-28 勘查后铲平。
+    const color = SKETCH_COLORS.includes(s.color) ? s.color : 'ink';
+    const width = s.width || 2;
+    // makeOne：按种子重新生成一份本尊 —— 算子展开的每一份各自的抖（看起来是
+    // 手画了 n 遍，不是图章盖了 n 下）。返回 {rect, d}，d 局部于 rect。
+    let makeOne;
+    if (s.kind === 'path') {
+      // 单位单义（2026-08-30 画图探针案）：d 的坐标与 at/w/h **同一套格**（1 格 =
+      // 24px，小数随意）。此前 schema 写着"d 是像素"而 at 是格 —— 同一个形状两套
+      // 单位，真会话里整幅画的 path 墨迹只有别的图元 1/24 大，agent 误诊成
+      // 「path 不渲染」，从此只敢用 rect/circle 拼图，曲线全灭。
+      if (!s.d || !/^[\dMLQCZ ,.\-eE]+$/.test(s.d)) return { error: `形状 ${sid}：path 只收大写 M/L/Q/C/Z 与数字（绝对坐标，单位=格）` };
+      const nums = s.d.match(/-?\d*\.?\d+(?:[eE][-+]?\d+)?/g)?.map(Number) || [];
+      if (!nums.length) return { error: `形状 ${sid}：path 里没有坐标` };
+      const xs = nums.filter((_, k) => k % 2 === 0); const ys = nums.filter((_, k) => k % 2 === 1);
+      const P = 6;
+      const minX = Math.min(...xs) * UNIT; const minY = Math.min(...ys) * UNIT;
+      const w = Math.max(4, (Math.max(...xs) - Math.min(...xs)) * UNIT);
+      const h = Math.max(4, (Math.max(...ys) - Math.min(...ys)) * UNIT);
+      // ×UNIT 并平移到墨迹包围盒（pad 6）—— rect 跟墨走，选中框不再套住一片空气
+      let k = 0;
+      const local = s.d.replace(/-?\d*\.?\d+(?:[eE][-+]?\d+)?/g, (n) => {
+        const v = Number(n) * UNIT - ((k++ % 2 === 0) ? minX : minY) + P;
+        return String(Math.round(v * 10) / 10);
+      });
+      const rect0 = { x: (s.at?.x || 0) * UNIT + minX - P, y: (s.at?.y || 0) * UNIT + minY - P, w: w + P * 2, h: h + P * 2 };
+      let fillPolys = null;
+      if (s.fill) {
+        const fc = flattenClosed(local);
+        if (!fc.closedAny) return { error: `形状 ${sid}：fill 只对闭合轮廓生效（Z 收尾）—— 这条 path 没有闭合的子路径` };
+        fillPolys = fc.polys;
+      }
+      makeOne = (sx) => ({ rect: { ...rect0 }, d: roughFreePath(local, seed + sx) + (fillPolys ? ' ' + hatchD(fillPolys, seed + sx) : '') });
+    } else if (s.kind === 'stencil') {
+      // 词汇表（刀①）：参数化简笔画 —— 名字 + 位置 + 尺寸，一笔一画归机器
+      if (!STENCIL_NAMES.includes(s.name)) return { error: `形状 ${sid}：stencil 认识这些名字 —— ${STENCIL_NAMES.join(', ')}` };
+      if (!s.at || !s.w) return { error: `形状 ${sid}：stencil 要 at + w（格；h 可省 = 按图形比例）` };
+      const st = stencilStrokes(s.name, s.w * UNIT, s.h ? s.h * UNIT : null);
+      const flipped = s.flip
+        ? st.strokes.map((d) => { let k2 = 0; return d.replace(/-?\d*\.?\d+/g, (n) => ((k2++ % 2 === 0) ? String(Math.round((st.w - Number(n)) * 10) / 10) : n)); })
+        : st.strokes;
+      const rect0 = { x: s.at.x * UNIT - 6, y: s.at.y * UNIT - 6, w: st.w + 12, h: st.h + 12 };
+      let stFill = null;
+      if (s.fill) {
+        const fc = flattenClosed(flipped.join(' '));
+        if (!fc.closedAny) return { error: `形状 ${sid}：这个 stencil 没有闭合轮廓，fill 排不了线` };
+        stFill = fc.polys;
+      }
+      makeOne = (sx) => ({
+        rect: { ...rect0 },
+        d: flipped.map((d2, j) => roughFreePath(d2, `${seed}${sx}:${j}`)).join(' ')
+          + (stFill ? ' ' + hatchD(stFill, seed + sx) : ''),
+      });
+    } else if (s.kind === 'line' || s.kind === 'arrow' || s.kind === 'underline') {
+      if (s.fill) return { error: `形状 ${sid}：${s.kind} 是一笔线，没有内部可填 —— fill 只给闭合形状` };
+      let a; let b;
+      if (s.kind === 'underline' && s.around) {
+        const r = rectOfNode(s.around); if (!r) return { error: `形状 ${sid}：around 指向不存在的节点 ${s.around}` };
+        a = { x: r.x + 2, y: r.y + r.h - 2 }; b = { x: r.x + r.w - 2, y: r.y + r.h - 2 };
+      } else {
+        if (!s.at) return { error: `形状 ${sid}：${s.kind} 要 at 起点` };
+        a = { x: s.at.x * UNIT, y: s.at.y * UNIT };
+        if (s.toNode) {
+          const r = rectOfNode(s.toNode); if (!r) return { error: `形状 ${sid}：toNode 指向不存在的节点 ${s.toNode}` };
+          b = { x: r.x + r.w / 2, y: r.y + r.h / 2 };
+        } else if (s.to) b = { x: s.to.x * UNIT, y: s.to.y * UNIT };
+        else if (s.kind === 'underline') b = { x: a.x + (s.w || 4) * UNIT, y: a.y };
+        else return { error: `形状 ${sid}：${s.kind} 要 to 或 toNode` };
+      }
+      makeOne = (sx) => {
+        const sp = shapePath(s.kind, { to: { x: b.x - a.x, y: b.y - a.y } }, seed + sx);
+        return { rect: { x: Math.min(a.x, b.x) - 6, y: Math.min(a.y, b.y) - 6, w: sp.w, h: sp.h }, d: sp.d };
+      };
+    } else {
+      let box;
+      if (s.around) {
+        const r = rectOfNode(s.around); if (!r) return { error: `形状 ${sid}：around 指向不存在的节点 ${s.around}` };
+        const pad = s.kind === 'rect' ? 8 : 14;
+        box = { x: r.x - pad, y: r.y - pad, w: r.w + pad * 2, h: r.h + pad * 2 };
+        if (s.kind === 'circle') { const dmax = Math.max(box.w, box.h); box = { x: box.x + (box.w - dmax) / 2, y: box.y + (box.h - dmax) / 2, w: dmax, h: dmax }; }
+      } else {
+        if (!s.at || !s.w) return { error: `形状 ${sid}：${s.kind} 要 at + w（+h）或 around` };
+        box = { x: s.at.x * UNIT, y: s.at.y * UNIT, w: s.w * UNIT, h: (s.h || s.w) * UNIT };
+      }
+      let boxFill = null;
+      if (s.fill) {
+        const P2 = 6;
+        if (s.kind === 'rect') {
+          boxFill = [[{ x: P2, y: P2 }, { x: P2 + box.w, y: P2 }, { x: P2 + box.w, y: P2 + box.h }, { x: P2, y: P2 + box.h }]];
+        } else {
+          const rx = box.w / 2; const ry = (s.kind === 'circle' ? box.w : box.h) / 2;
+          const pts = [];
+          for (let a2 = 0; a2 < 24; a2 += 1) {
+            const t2 = (a2 / 24) * Math.PI * 2;
+            pts.push({ x: P2 + rx + Math.cos(t2) * rx, y: P2 + ry + Math.sin(t2) * ry });
+          }
+          boxFill = [pts];
+        }
+      }
+      makeOne = (sx) => {
+        const sp = shapePath(s.kind, { w: box.w, h: box.h }, seed + sx);
+        return { rect: { x: box.x - 6, y: box.y - 6, w: sp.w, h: sp.h }, d: sp.d + (boxFill ? ' ' + hatchD(boxFill, seed + sx) : '') };
+      };
+    }
+    // 算子展开（刀④）：repeat/ring/mirror/scatter —— 等距和对称归机器
+    const pieces = expandModifiers(s, makeOne, sid);
+    if (pieces.error) return { error: pieces.error };
+    // 包着节点的记号记 hug：落盘后编辑侧挪节点它跟着走（散架病的另一半在 edit-board）
+    const hugKey = (s.around && ['rect', 'ellipse', 'circle', 'underline'].includes(s.kind)) ? s.around : null;
+    for (const pc of pieces) {
+      if (isTaken(pc.key) || shapes.some((x) => x.key === pc.key)) return { error: `形状 id「${pc.key}」撞名（算子副本叫 <id>-2, <id>-3…，别的形状别占这些名）` };
+      shapes.push({ key: pc.key, rect: pc.rect, d: pc.d, color, width, hug: hugKey });
+    }
+    if (shapes.length > 120) return { error: `形状展开后超过 120 件（第 ${i + 1} 个展开完是 ${shapes.length}）—— 阵列收敛一点，或拆成几张图` };
+  }
+  return { shapes };
+}

package/server/lib/sketch-stencils.js

@@ -0,0 +1,170 @@
+/**
+ * server/lib/sketch-stencils.js —— 图形词汇表（2026-08-30 画图能力线刀①）
+ *
+ * 参数化简笔画：agent 说「这里一座房子、两格宽」，机器展开成手工调好的 path。
+ * 跟落位那条线同一个哲学 —— **语义归 agent，几何外包**：画什么、放哪、多大
+ * 它定，一笔一画的坐标不用它算。
+ *
+ * ## 词表纪律
+ *
+ * 词表就是 agent 的词汇量（风格命名那条经验）：几十个精选 > 无限自由。入选判据
+ * 是「侦探板 / 跑团 / 示意图里真会反复用到」。每个 stencil 是 0..100 规范框里的
+ * 一组笔画（多条 d），使用时缩放到目标尺寸、逐笔过手绘抖动 —— 跟整个画图族
+ * 同一支笔。新增一个词 = 加一条数据，代码零改动。
+ *
+ * ⚠️ 笔画坐标手工调过、**逐个看过渲染**（scripts 探针）。改的时候别信脑内想象，
+ * 渲染出来看 —— 画错的 path 比没有更坏。
+ */
+
+/** 每个词：strokes = 0..100 框内的笔画（大写绝对 M/L/Q/C/Z）；aspect = 高/宽 */
+export const STENCILS = {
+  person: {
+    aspect: 1.6,
+    strokes: [
+      'M50,4 C60,4 66,11 66,20 C66,29 60,36 50,36 C40,36 34,29 34,20 C34,11 40,4 50,4 Z',
+      'M50,36 L50,64',
+      'M22,52 L50,42 L78,52',
+      'M50,64 L32,98',
+      'M50,64 L68,98',
+    ],
+  },
+  house: {
+    aspect: 1,
+    strokes: [
+      'M14,48 L50,14 L86,48',
+      'M22,48 L22,92 L78,92 L78,48',
+      'M44,92 L44,66 L58,66 L58,92',
+    ],
+  },
+  tree: {
+    aspect: 1.3,
+    strokes: [
+      'M50,96 L50,58',
+      'M50,58 C28,62 16,46 28,34 C26,16 52,8 60,22 C78,20 84,42 68,48 C66,58 56,62 50,58 Z',
+    ],
+  },
+  pine: {
+    aspect: 1.5,
+    strokes: [
+      'M50,4 L30,36 L42,36 L24,64 L38,64 L18,92 L82,92 L62,64 L76,64 L58,36 L70,36 Z',
+      'M50,92 L50,100',
+    ],
+  },
+  mountain: {
+    aspect: 0.6,
+    strokes: [
+      'M2,96 L34,28 L50,58 L66,10 L98,96',
+      'M58,34 L66,22 L74,36',
+    ],
+  },
+  boat: {
+    aspect: 0.9,
+    strokes: [
+      'M18,74 L82,74 L70,92 L30,92 Z',
+      'M52,74 L52,12',
+      'M52,16 L84,68 L52,68 Z',
+      'M48,24 L24,68 L48,68 Z',
+    ],
+  },
+  flag: {
+    aspect: 1.4,
+    strokes: [
+      'M32,4 L32,98',
+      'M32,8 Q54,16 74,10 L74,34 Q54,40 32,32 Z',
+    ],
+  },
+  star: {
+    aspect: 1,
+    strokes: [
+      'M50,6 L60,36 L92,37 L66,56 L76,88 L50,69 L24,88 L34,56 L8,37 L40,36 Z',
+    ],
+  },
+  moon: {
+    aspect: 1.2,
+    strokes: [
+      'M62,6 C36,14 24,42 34,66 C41,83 55,93 70,92 C50,84 40,62 46,42 C50,28 55,14 62,6 Z',
+    ],
+  },
+  sun: {
+    aspect: 1,
+    strokes: [
+      'M50,28 C63,28 72,37 72,50 C72,63 63,72 50,72 C37,72 28,63 28,50 C28,37 37,28 50,28 Z',
+      'M50,2 L50,16 M50,84 L50,98 M2,50 L16,50 M84,50 L98,50',
+      'M17,17 L27,27 M73,73 L83,83 M83,17 L73,27 M27,73 L17,83',
+    ],
+  },
+  cloud: {
+    aspect: 0.55,
+    strokes: [
+      'M24,78 C6,78 6,54 24,54 C24,32 52,26 60,42 C70,26 94,36 90,54 C104,58 100,78 84,78 Z',
+    ],
+  },
+  scroll: {
+    aspect: 1.2,
+    strokes: [
+      'M18,18 C18,10 82,10 82,18 C82,26 18,26 18,18 Z',
+      'M24,26 L24,80 M76,26 L76,80',
+      'M18,86 C18,78 82,78 82,86 C82,94 18,94 18,86 Z',
+      'M36,42 L64,42',
+      'M36,54 L64,54',
+      'M36,66 L58,66',
+    ],
+  },
+  sword: {
+    aspect: 1.6,
+    strokes: [
+      'M50,2 L43,60 L50,70 L57,60 Z',
+      'M34,62 L66,62',
+      'M50,70 L50,92',
+      'M44,95 L56,95',
+    ],
+  },
+  dice: {
+    aspect: 1,
+    strokes: [
+      'M20,20 L80,20 L80,80 L20,80 Z',
+      'M35,33 C38,33 38,37 35,37 C32,37 32,33 35,33 Z',
+      'M50,48 C53,48 53,52 50,52 C47,52 47,48 50,48 Z',
+      'M65,63 C68,63 68,67 65,67 C62,67 62,63 65,63 Z',
+    ],
+  },
+  heart: {
+    aspect: 0.95,
+    strokes: [
+      'M50,88 C16,58 22,20 50,36 C78,20 84,58 50,88 Z',
+    ],
+  },
+  door: {
+    aspect: 1.6,
+    strokes: [
+      'M26,96 L26,26 C26,10 74,10 74,26 L74,96',
+      'M26,96 L74,96',
+      'M62,56 C65,56 65,60 62,60 C59,60 59,56 62,56 Z',
+    ],
+  },
+};
+
+export const STENCIL_NAMES = Object.keys(STENCILS);
+
+/**
+ * 展开一个词：缩放到 w×h（像素），返回未抖动的笔画（抖动由调用方按 seed 加 ——
+ * 阵列的每份要各自的抖）。
+ * @returns {{ strokes: string[], w:number, h:number }}
+ */
+export function stencilStrokes(name, wPx, hPx = null) {
+  const st = STENCILS[name];
+  if (!st) return null;
+  const w = Math.max(8, wPx);
+  const h = Math.max(8, hPx || w * st.aspect);
+  // ⚠️ 奇偶计数器**每条笔画各自数**：跨笔画累计的话，一条 d 的数字个数为奇数
+  // 就把后面所有笔画的 x/y 错位成 y/x
+  return { strokes: st.strokes.map((d) => scaleD(d, w / 100, h / 100)), w, h };
+}
+
+function scaleD(d, sx, sy) {
+  let k = 0;
+  return d.replace(/-?\d*\.?\d+/g, (n) => {
+    const v = Number(n) * ((k++ % 2 === 0) ? sx : sy);
+    return String(Math.round(v * 10) / 10);
+  }).replace(/,/g, ' ');
+}

package/server/lib/ssrf-guard.js

@@ -267,6 +267,14 @@ export function blockReason(rawIp) {
 /** 只允许这两个 scheme 发起网络请求；data:/blob: 不出网所以另算 */
 const NET_SCHEMES = new Set(['http:', 'https:']);
 const OFFLINE_SCHEMES = new Set(['data:', 'blob:', 'about:']);
+/**
+ * Chromium 内置 PDF viewer（component extension，id 硬编码在 Chromium 源里）。
+ * 它渲染 PDF 时会加载自己的静态资源（pdf_embedder.css 等）——不出网、出不了扩展
+ * 包目录，跟 file:// 不是一个量级。不放行的话浏览器里所有 PDF 都渲染不出来
+ * （08-24 案）。⚠️ 只放这个 id：别的 chrome-extension:// 照旧拒 + 记账，
+ * 将来谁 --load-extension 也不会自动继承放行。
+ */
+const PDF_VIEWER_ORIGIN = 'chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/';
 
 /**
  * 一个 URL 能不能让浏览器去。**解析 DNS 后逐个 IP 判**。
@@ -297,6 +305,7 @@ export async function checkUrl(raw, { timeoutMs = 4000 } = {}) {
   try { u = new URL(String(raw)); } catch { return { ok: false, reason: `not a valid URL: ${raw}` }; }
 
   if (OFFLINE_SCHEMES.has(u.protocol)) return { ok: true, ips: [] };   // 不出网
+  if (String(raw).startsWith(PDF_VIEWER_ORIGIN)) return { ok: true, ips: [] };  // 内置 PDF viewer 自身资源，不出网
   if (!NET_SCHEMES.has(u.protocol)) {
     return { ok: false, reason: `scheme ${u.protocol} is not allowed (only http/https; file:// would read local files)` };
   }

package/server/lib/state-table.js

@@ -0,0 +1,237 @@
+/**
+ * server/lib/state-table.js —— 状态表：板上那张 `| 键 | 值 |` 的解析与改写
+ * （2026-08-30）
+ *
+ * ## 为什么真相是一张 markdown 表，不是一份 JSON
+ *
+ * 演出里"会变、要记得"的东西（好感度 / 时间 / 线索 / 体力）此前住在状态板的正文里，
+ * 是一段自由文本，每拍靠 agent 整卡重写。想让程序参与（下一轮提醒它、将来按条件
+ * 触发）就得有结构。
+ *
+ * 结构可以另起一份存储（`.nd/vars.json` 之类），但那条路被两件事否掉：
+ *   - `.nd/` 在 gitignore 里（workspace-templates.js）。存那儿 = 用户在画布上看不见、
+ *     git 里没历史、`revertWorkspace` 回滚正文却不回滚它 →「旧故事配新数值」，
+ *     而且没有任何东西会报这个错。
+ *   - 另起一份 = 同一件事两份真相。状态板的字**已经**在 `notes/板书/` 里、已经进 git、
+ *     已经每轮 commit。再存一份就是这条线上翻过最多次车的那种账。
+ *
+ * 所以：**真相仍是那条板书文件，只是约定它正文里有一张固定格式的表。**
+ * 服务端只读解析出派生值喂每轮状态块；`set_vars` 做的是"精确改表里那一格"，
+ * 不是重写整张卡。文件内容 = 显示内容 = agent Read 到的内容，三者逐字相同。
+ *
+ * ## 定位判据：tag，不是文件名、不是隐形标记
+ *
+ * ⛔ **不能用藏在 frontmatter 里的自造键**：`renderChalk` 只回写白名单键，
+ *    一次 `edit_board set_text` 就把它整行丢掉，而且不报错。
+ * ⛔ **不能用固定文件名**（`状态表.md` 那种）：chalk 目录的文件名是时间戳，
+ *    `recentChalk` 和首页摘句都拿"文件名倒序"当"最近"判据 —— 一个 CJK 开头的
+ *    固定名在字典序里排在所有数字时间戳之后，倒序后永远第一，
+ *    结果是**首页每个演出项目的卡常年显示「| 键 | 值 |」**。
+ * ✅ 用 `tag: 状态表`（专用 tag，跟状态板那个**组** tag 分开）。tag 是少数能双向
+ *    往返的字段（parseChalk 读、renderChalk 写、set_text 保留），改名搬位都不影响。
+ */
+
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { CHALK_DIR, parseChalk } from './chalk.js';
+
+/** 状态表专用 tag。⚠️ 跟 blackboard-rp 的「状态板」组 tag 是两个东西：
+ *  那个是一**组**卡（PC卡/场景/明骰表）的组名，这个专指承载键值表的那一条。 */
+export const STATE_TABLE_TAG = '状态表';
+
+/** 值的上限：一格里塞长文是把表当笔记本用，那是板书正文的活 */
+export const VALUE_MAX = 120;
+/** 键的上限与字符集：键要能当标识符用（将来触发器按它寻址），别收任意文本 */
+export const KEY_MAX = 40;
+const KEY_RE = /^[\p{L}\p{N}_][\p{L}\p{N}_·-]{0,39}$/u;
+
+/**
+ * 剥掉围栏块再找表。
+ * 板书里最常见的围栏是 ```nd:controls（控件声明），里面完全可能出现竖线。
+ * 判据抄 board-excerpt.js 的 excerptOf —— 那儿已经为同一个理由剥过一次。
+ */
+export function stripFences(body) {
+  return String(body || '')
+    .replace(/^[ \t]*```[\s\S]*?^[ \t]*```[ \t]*$|^[ \t]*```[\s\S]*$/gm, '');
+}
+
+const SEP_RE = /^\s*\|?[\s:-]*-[-\s:|]*\|?\s*$/;      // | --- | --- |
+const HEAD_RE = /^\s*\|\s*键\s*\|\s*值\s*\|\s*$/;
+const FENCE_RE = /^[ \t]*```/;
+
+/**
+ * 逐行标出「这一行在围栏里吗」。
+ *
+ * ⚠️ 不能用 stripFences 之后的**文本**去比对（第一版就是这么写的，当场翻车）：
+ * 围栏里那行 `| 键 | 值 |` 和真表头**逐字相同**，按内容判membership 两行都算"活着"，
+ * 于是一张表被数成两张。判据必须落在**行号**上，不是行的内容。
+ * 未闭合的围栏一路吃到末尾（跟 board-excerpt 的取舍一致：宁可少认，不能把源码当数据）。
+ */
+function fenceMask(lines) {
+  const mask = new Array(lines.length).fill(false);
+  let open = false;
+  for (let i = 0; i < lines.length; i += 1) {
+    if (FENCE_RE.test(lines[i])) { mask[i] = true; open = !open; continue; }
+    mask[i] = open;
+  }
+  return mask;
+}
+
+function cells(line) {
+  return line.replace(/^\s*\|/, '').replace(/\|\s*$/, '').split('|').map((c) => c.trim());
+}
+
+/**
+ * 从正文里解析状态表。
+ *
+ * @returns {{ ok:true, start:number, end:number, rows:Array<{key,value}> }
+ *         | { ok:false, error:string }}
+ *   start/end 是表在**原始行数组**里的下标区间（含表头与分隔行），改写时按它回填。
+ *   ok:false 的两种：没有表、或者有歧义（多张表 / 重复键）—— 一律**大声**，
+ *   不 fail-soft 成空表。空表和"读不懂"是两件事，混在一起就是那条最贵的教训。
+ */
+export function parseStateTable(body) {
+  const raw = String(body || '').split(/\r?\n/);
+  const inFence = fenceMask(raw);
+  const heads = [];
+  for (let i = 0; i < raw.length; i += 1) {
+    if (!HEAD_RE.test(raw[i])) continue;
+    if (inFence[i]) continue;                     // 表头在围栏里 → 不算表
+    heads.push(i);
+  }
+  if (!heads.length) return { ok: false, error: 'no-table' };
+  if (heads.length > 1) {
+    return { ok: false, error: `这条板书里有 ${heads.length} 张「| 键 | 值 |」表 —— 状态表只能有一张，另一张挪到别的板书上去（明骰表用别的表头）。` };
+  }
+  const start = heads[0];
+  if (!SEP_RE.test(raw[start + 1] || '')) {
+    return { ok: false, error: '「| 键 | 值 |」下面缺分隔行（`|---|---|`），这不是一张合法的 markdown 表。' };
+  }
+  const rows = []; const seen = new Map();
+  let end = start + 1;
+  for (let i = start + 2; i < raw.length; i += 1) {
+    const line = raw[i];
+    if (!/^\s*\|/.test(line)) break;              // 表到此为止
+    const c = cells(line);
+    if (c.length < 2) break;
+    const key = c[0]; const value = c[1];
+    if (!key) { end = i; continue; }               // 空键行：留着但不算数据
+    if (seen.has(key)) {
+      return { ok: false, error: `表里「${key}」出现了两次（第 ${seen.get(key) + 1} 行和第 ${i + 1} 行）—— 键必须唯一，先把重复的那行删掉。` };
+    }
+    seen.set(key, i);
+    rows.push({ key, value });
+    end = i;
+  }
+  return { ok: true, start, end, rows };
+}
+
+/** 值清洗：压一行、去掉会把表撑破的字符。钳了要说（返回 clamped 让调用方如实报） */
+export function sanitizeValue(v) {
+  const src = String(v ?? '');
+  const s = src
+    // 控制字符（含换行、制表、行分隔符）先抹平：一格里塞多行会把表拆散，
+    // 而且拆散之后解析器只会少读几行，不会报错 —— 这类静默降级要堵在写口。
+    .replace(/[\u0000-\u001f\u007f\u2028\u2029]/g, ' ')
+    .replace(/\|/g, '/')                       // 竖线会当场炸表
+    .replace(/\s+/g, ' ')
+    .trim();
+  return { value: s.slice(0, VALUE_MAX), clamped: s.length > VALUE_MAX || src.includes('|') };
+}
+
+export function validateKey(k) {
+  const s = String(k ?? '').trim();
+  if (!s) return '键是空的';
+  if (s.length > KEY_MAX) return `键「${s.slice(0, 12)}…」超过 ${KEY_MAX} 字`;
+  if (!KEY_RE.test(s)) return `键「${s}」含不能用的字符（只收字母数字、中文、下划线、连字符、间隔号，且不能以连字符开头）`;
+  return null;
+}
+
+/** 把一张表渲染回 markdown 行（列宽不对齐 —— 对齐了 diff 会整片变） */
+export function renderRows(rows) {
+  return ['| 键 | 值 |', '| --- | --- |', ...rows.map((r) => `| ${r.key} | ${r.value} |`)];
+}
+
+/**
+ * 在正文里改/加若干个键，返回新正文与实际发生的变化。
+ * 表不存在或看不懂时**抛** —— 调用方负责把话说清楚。
+ */
+export function applyVars(body, vars) {
+  const parsed = parseStateTable(body);
+  if (!parsed.ok) {
+    const err = new Error(parsed.error === 'no-table'
+      ? '这条板书里没有「| 键 | 值 |」表。'
+      : parsed.error);
+    err.code = parsed.error === 'no-table' ? 'NO_TABLE' : 'BAD_TABLE';
+    throw err;
+  }
+  const rows = parsed.rows.map((r) => ({ ...r }));
+  const changed = []; const added = []; const clamped = [];
+  for (const [rawKey, rawVal] of Object.entries(vars)) {
+    const key = String(rawKey).trim();
+    const bad = validateKey(key);
+    if (bad) { const e = new Error(bad); e.code = 'BAD_KEY'; throw e; }
+    const { value, clamped: cl } = sanitizeValue(rawVal);
+    if (cl) clamped.push(key);
+    const hit = rows.find((r) => r.key === key);
+    if (hit) { if (hit.value !== value) changed.push({ key, from: hit.value, to: value }); hit.value = value; }
+    else { rows.push({ key, value }); added.push({ key, value }); }
+  }
+  const lines = String(body).split(/\r?\n/);
+  const next = [...lines.slice(0, parsed.start), ...renderRows(rows), ...lines.slice(parsed.end + 1)];
+  return { body: next.join('\n'), rows, changed, added, clamped };
+}
+
+/**
+ * 在工作区里找那条状态表板书。
+ * @returns {{ found:true, rel, abs, raw, body, chalk }
+ *         | { found:false, reason:'none' }
+ *         | { found:false, reason:'multiple', rels:string[] }}
+ */
+export async function findStateTable(sharedRoot) {
+  const dir = path.join(sharedRoot, CHALK_DIR);
+  let names;
+  try {
+    names = (await fs.readdir(dir)).filter((n) => n.endsWith('.md') && !n.startsWith('.'));
+  } catch { return { found: false, reason: 'none' }; }
+  const hits = [];
+  for (const n of names) {
+    let raw;
+    try { raw = await fs.readFile(path.join(dir, n), 'utf8'); } catch { continue; }
+    const { body, chalk } = parseChalk(raw);
+    if (chalk?.tag === STATE_TABLE_TAG) {
+      hits.push({ rel: `${CHALK_DIR}/${n}`, abs: path.join(dir, n), raw, body, chalk });
+    }
+  }
+  if (!hits.length) return { found: false, reason: 'none' };
+  if (hits.length > 1) return { found: false, reason: 'multiple', rels: hits.map((h) => h.rel) };
+  return { found: true, ...hits[0] };
+}
+
+/**
+ * 给每轮状态块用的读侧。**永远返回一个可渲染的结果**，但「读不懂」和「没有」
+ * 是两种不同的返回 —— 上一轮还解析得出、这一轮解析不出，调用方要能报警。
+ * @returns {{ state:'none' } | { state:'ok', rel, rows, body } | { state:'broken', rel?, why }}
+ */
+export async function readStateVars(sharedRoot) {
+  const f = await findStateTable(sharedRoot);
+  if (!f.found) {
+    if (f.reason === 'multiple') {
+      return { state: 'broken', why: `板上有 ${f.rels.length} 条 tag 是「${STATE_TABLE_TAG}」的板书（${f.rels.join('、')}）—— 只能有一条。` };
+    }
+    return { state: 'none' };
+  }
+  const parsed = parseStateTable(f.body);
+  if (!parsed.ok) {
+    return {
+      state: 'broken',
+      rel: f.rel,
+      why: parsed.error === 'no-table'
+        ? `${f.rel} 挂着「${STATE_TABLE_TAG}」的 tag，但正文里找不到「| 键 | 值 |」表。`
+        : parsed.error,
+    };
+  }
+  // body 一起带回：触发器的声明（```nd:triggers 围栏）就住在这条板书的正文里，
+  // 调用方拿它去解析，省一次读盘也省一次"两边读的是不是同一份"的疑虑。
+  return { state: 'ok', rel: f.rel, rows: parsed.rows, body: f.body };
+}

package/server/lib/state-trend.js

@@ -0,0 +1,94 @@
+/**
+ * server/lib/state-trend.js —— 状态表的历史序列（2026-08-30 画图能力线·活图第一块）
+ *
+ * 状态表住在一条板书文件里、板书文件进 git、工作区**每回合落一个 commit**
+ * （session-loop turn commit）—— 所以「好感度随拍数怎么走」的序列是**现成的**，
+ * 不用第二份存储不用记账，git 就是时间轴。这是别家没有的弹药。
+ *
+ * 读侧纪律与状态表同款：拿不到就大声说拿不到（没有表 / 历史不足 / 值不是数字），
+ * 不画一根瞎编的线。git 操作全只读（log/show），不进写 mutex。
+ */
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { findStateTable, parseStateTable } from './state-table.js';
+import { parseChalk } from './chalk.js';
+
+const run = promisify(execFile);
+const MAX_POINTS = 80;
+
+/** 值里抠数字：`5`→5、`8/10`→8、`≈3.5`→3.5；抠不出返回 null */
+export function numOf(value) {
+  const m = /-?\d+(?:\.\d+)?/.exec(String(value ?? ''));
+  return m ? Number(m[0]) : null;
+}
+
+/**
+ * 某个键的历史序列（旧→新，末尾是**盘上现值**——本回合改了还没 commit 的也算数）。
+ * @returns {{ ok:true, points:number[], rel:string } |
+ *           { ok:false, why:string, rel?:string, points?:number[] }}
+ */
+export async function trendSeries(sharedRoot, key) {
+  const f = await findStateTable(sharedRoot);
+  if (!f.found) return { ok: false, why: f.reason === 'multiple' ? '有两条挂着状态表 tag 的板书，先合成一条' : '板上还没有状态表（tag: 状态表 的那条板书）' };
+  const rel = f.rel;
+
+  let hashes = [];
+  try {
+    const { stdout } = await run('git', ['log', '--format=%H', '--reverse', '--follow', '--', rel], { cwd: sharedRoot });
+    hashes = stdout.trim().split('\n').filter(Boolean);
+  } catch { /* 没有 git 历史就只有现值 */ }
+  if (hashes.length > MAX_POINTS) hashes = hashes.slice(hashes.length - MAX_POINTS);
+
+  const points = [];
+  for (const h of hashes) {
+    try {
+      const { stdout } = await run('git', ['show', `${h}:${rel}`], { cwd: sharedRoot });
+      const rows = parseStateTable(parseChalk(stdout).body || '');
+      if (!rows.ok) continue;
+      const row = rows.rows.find((r) => r.key === key);
+      if (!row) continue;
+      const v = numOf(row.value);
+      if (v === null) continue;
+      // 同值连点不压缩：横盘也是信息（十拍没动 = 一条平线）
+      points.push(v);
+    } catch { /* 某个版本读不出就跳过 */ }
+  }
+
+  // 盘上现值收尾（本回合 set_vars 改过、还没 commit）
+  const { readStateVars } = await import('./state-table.js');
+  const live = await readStateVars(sharedRoot);
+  if (live.state === 'ok') {
+    const row = live.rows.find((r) => r.key === key);
+    const v = row ? numOf(row.value) : null;
+    if (v !== null && (points.length === 0 || v !== points[points.length - 1])) points.push(v);
+    if (row && v === null) return { ok: false, rel, why: `「${key}」的现值是「${row.value}」，抠不出数字 —— 趋势线只画得了数` };
+    if (!row) return { ok: false, rel, why: `状态表里没有「${key}」这个键` };
+  }
+  if (points.length < 2) {
+    return { ok: false, rel, points, why: `「${key}」目前只有 ${points.length} 个数据点（历史随每回合的 git commit 长出来）—— 至少两点才有线，过几拍再画` };
+  }
+  return { ok: true, points, rel };
+}
+
+/**
+ * 序列 → 手绘折线的**几何**（局部像素；抖动由调用方加，跟全族同一支笔）。
+ * @returns {{ w,h, lineD:string, baselineD:string, dotD:string, min:number, max:number }}
+ */
+export function trendGeometry(points, { w = 336, h = 120 } = {}) {
+  const P = 8;
+  const min = Math.min(...points); const max = Math.max(...points);
+  const span = (max - min) || 1;
+  const iw = w - P * 2; const ih = h - P * 2;
+  const xy = points.map((v, i) => ({
+    x: P + (points.length === 1 ? iw / 2 : (i / (points.length - 1)) * iw),
+    y: P + ih - ((v - min) / span) * ih,
+  }));
+  const f = (n) => Math.round(n * 10) / 10;
+  const lineD = xy.map((p, i) => `${i ? 'L' : 'M'} ${f(p.x)} ${f(p.y)}`).join(' ');
+  const last = xy[xy.length - 1];
+  // 端点小圈（现值在哪）
+  const r = 3;
+  const dotD = `M ${f(last.x - r)} ${f(last.y)} C ${f(last.x - r)} ${f(last.y - r * 1.4)} ${f(last.x + r)} ${f(last.y - r * 1.4)} ${f(last.x + r)} ${f(last.y)} C ${f(last.x + r)} ${f(last.y + r * 1.4)} ${f(last.x - r)} ${f(last.y + r * 1.4)} ${f(last.x - r)} ${f(last.y)}`;
+  return { w, h, lineD, baselineD: `M ${P} ${h - P} L ${w - P} ${h - P}`, dotD, min, max };
+}