@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/engine/mcp/tools/sketch-on-board.js

@@ -1,345 +0,0 @@
-/**
- * mcp/tools/sketch-on-board.js —— sketch_on_board / finish_sketch（2026-08-23 黑板）
- *
- * 让 agent 把画布当黑板：一次调用落一整张示意图（节点 + 形状 + 线），而不是
- * 像 create_on_board 那样一条条写。设计要点（跟用户商定的形状）：
- *   - **没有几何容器**：一张图 = 一批带同一 #tag 的普通物件和线。read_board 按
- *     连通分量 + tag 分段读，用户可以整组选/整组擦，入座算法照旧绕着走
- *   - **两阶段**：落下来的默认是 staging（半透明，"正在画"），finish_sketch 或
- *     回合结束自动落定；落定只清 staging 位，tag 留着当逻辑分组
- *   - **结构不是像素**：agent 给模板 + 网格坐标（1 格 = 24px），服务端算像素与落位
- *   - **形状是涂鸦**：rect/ellipse/arrow… 在服务端生成带手绘抖动的路径，落成
- *     普通 scribble 对象，前端零改动；自由路径（path）也收，同一白名单
- *   - 线的材质缺省 pencil（手绘）—— 草图上的线是人顺手拉的；要丝线/墨线自己说
- *
- * 护栏：每回合 3 张图；每张 ≤ 40 节点 / 30 形状 / 60 线。
- */
-
-import { tool } from '@anthropic-ai/claude-agent-sdk';
-import { z } from 'zod';
-import { readBoard, patchBoard, commitStaging, removeByTag, TEXT_FONTS } from '../../../projects/board-store.js';
-import { estimateSizeOn } from '../../../lib/board-kind-sizes.js';
-import { layerOf, normalizeCanvasId, tagEnvelope } from '../../../lib/canvas-id.js';
-import { BINDING_TYPE_IDS, BINDING_MATERIALS } from '../../../lib/binding-types.js';
-import { UNIT, SKETCH_FIT, SKETCH_MAX, textBox, shapePath, layoutNodes, bboxOf, findSpot, fitFor } from '../../../lib/sketch-layout.js';
-import { getViewpoint } from '../../../projects/viewpoint-store.js';
-import { Events } from '../../agent/events.js';
-
-const MAX_NODES = 40;
-const MAX_SHAPES = 30;
-const MAX_EDGES = 60;
-
-let seq = 0;
-const stamp = () => `${Date.now().toString(36)}${(seq++ % 1000).toString(36)}`;
-const COLORS = ['ink', 'red', 'pencil', 'brass'];
-
-const LOCAL_ID = z.string().regex(/^[A-Za-z0-9_-]{1,24}$/, 'local id: letters/digits/_/-');
-const GRID_PT = z.object({ x: z.number().min(-400).max(400), y: z.number().min(-400).max(400) });
-
-export function makeSketchOnBoardTool({ projectId, ctx }) {
-  const turnStamp = { turn: -1, count: 0 };   // 只记数（返回里不再报余额）
-  return tool(
-    'sketch_on_board',
-    `Draw a whole sketch on the canvas in ONE call — notes, shapes and lines, laid out
-together: a comparison table, a flow, a mind map, a detective board linking real
-artifacts. The canvas is the blackboard; use it when thinking out loud with the user
-would be clearer as a picture than as prose.
-
-How it works
-- You describe STRUCTURE; the server does pixels. Pick a layout template (column /
-  row / grid / mindmap) or place nodes yourself on a grid (1 cell = ${UNIT}px, layout
-  'free', at:{x,y}). Whole sketch lands beside \`near\` (a canvas id from read_board)
-  or under the desktop's current content.
-- nodes: plain handwriting or format:'md' (Markdown + KaTeX $…$ + \`\`\`mermaid fences).
-  Use md for lists/tables/formulas; mermaid only for dense formal diagrams
-  (sequence/state) — anything that should connect to real artifacts must be nodes+edges.
-- shapes: rect / ellipse / circle / line / arrow / underline (hand-drawn look is
-  applied for you) or path (raw SVG M/L/Q in local px) — all in grid units.
-- edges: between local node ids and/or real canvas ids. type = the relation
-  vocabulary (link/annotates/flow/contrast/derives-from/ref); material = ink (quiet
-  archive line) / pencil (hand-drawn, default here) / yarn (detective red string + pins
-  for hypotheses and evidence).
-- Everything carries one #tag (a group): read_board {tag} reads just it, the user can
-  select/erase it as a whole, finish_sketch commits or erases it.
-- Items land as STAGING (half-transparent = you are still drawing). Call finish_sketch
-  when done, or they commit automatically when the turn ends. Look at the result with
-  look_at_board before you call it done — agent scribbles only make sense with eyes.
-- Readability rule: the user reads the board at 80–100% zoom. Body text stays md/lg
-  (sm only for captions ≤40 chars); one sketch ≤ ${SKETCH_FIT.w}x${SKETCH_FIT.h} world px (one screen at 80%),
-  hard limit ${SKETCH_MAX.w}x${SKETCH_MAX.h} — split into two tagged sketches instead of one huge one.
-- To change an existing sketch use edit_sketch (move/retext/add/remove by id) — do NOT
-  erase and redraw the whole thing for a small change.
-Per sketch: ≤${MAX_NODES} nodes, ${MAX_SHAPES} shapes, ${MAX_EDGES} edges (split big ones).`,
-    {
-      title: z.string().max(60).optional().describe('Optional heading written at the top of the sketch'),
-      tag: z.string().regex(/^[\w一-鿿぀-ヿ-]{1,40}$/).optional()
-        .describe('Group tag (letters/digits/_/-/CJK, ≤40). Default: auto "sk-<stamp>"'),
-      near: z.string().max(300).optional().describe('Canvas id to place the sketch beside (right side; falls back to below)'),
-      layout: z.enum(['auto', 'free', 'column', 'row', 'grid', 'mindmap']).optional()
-        .describe('auto = free if any node has at, else column (≤4) / grid'),
-      cols: z.number().int().min(1).max(8).optional().describe('grid columns'),
-      staging: z.boolean().optional().describe('Default true. false = land committed (solid) immediately'),
-      nodes: z.array(z.object({
-        id: LOCAL_ID.describe('Local id to reference from edges/shapes'),
-        text: z.string().min(1).max(4000),
-        format: z.enum(['plain', 'md']).optional(),
-        size: z.enum(['sm', 'md', 'lg', 'xl']).optional(),
-        font: z.enum(['pen', 'kai', 'sans', 'serif', 'mono']).optional(),
-        color: z.enum(['ink', 'red', 'pencil', 'brass']).optional(),
-        at: GRID_PT.optional().describe('Grid position (layout free); top-left of the node'),
-        w: z.number().min(3).max(22).optional().describe('Width in grid units (md nodes; default by content; ≤22 = 528px — paragraphs grow down, not wide)'),
-      })).max(MAX_NODES).optional(),
-      shapes: z.array(z.object({
-        id: LOCAL_ID.optional(),
-        kind: z.enum(['rect', 'ellipse', 'circle', 'line', 'arrow', 'underline', 'path']),
-        at: GRID_PT.optional().describe('Grid position (top-left for rect/ellipse; start point for line/arrow). Or use around:'),
-        around: LOCAL_ID.optional().describe('rect/ellipse/circle/underline: wrap this node (pad applied) instead of at/w/h'),
-        w: z.number().min(0).max(200).optional().describe('grid units'),
-        h: z.number().min(0).max(200).optional().describe('grid units'),
-        to: GRID_PT.optional().describe('line/arrow end point (grid)'),
-        toNode: LOCAL_ID.optional().describe('line/arrow: aim at this node\'s center instead of to'),
-        d: z.string().max(8000).optional().describe('path kind: SVG path (M/L/Q/Z only) in local px'),
-        color: z.enum(['ink', 'red', 'pencil', 'brass']).optional(),
-        width: z.number().min(1).max(12).optional(),
-      })).max(MAX_SHAPES).optional(),
-      edges: z.array(z.object({
-        from: z.string().min(1).max(300).describe('local node id or canvas id'),
-        to: z.string().min(1).max(300).describe('local node id or canvas id'),
-        type: z.enum(BINDING_TYPE_IDS).optional().describe('default link'),
-        material: z.enum(BINDING_MATERIALS).optional().describe('default pencil'),
-        label: z.string().max(60).optional(),
-      })).max(MAX_EDGES).optional(),
-    },
-    async (args) => {
-      if (!projectId) return { content: [{ type: 'text', text: 'No project bound.' }], isError: true };
-      const err = (t) => ({ content: [{ type: 'text', text: t }], isError: true });
-      // 回合闸 08-23 用户拍板先不设（「别设置限制吧先」）：只记数不拦
-      const turn = ctx?.runId ?? -1;
-      if (turnStamp.turn !== turn) { turnStamp.turn = turn; turnStamp.count = 0; }
-
-      const nodesIn = args.nodes || [];
-      const shapesIn = args.shapes || [];
-      const edgesIn = args.edges || [];
-      if (!nodesIn.length && !shapesIn.length) return err('空图不落板：至少给一个节点或形状。');
-      const tag = args.tag || `sk-${stamp()}`;
-      const staging = args.staging !== false;
-
-      // ── 节点身位 ──
-      const localIds = new Set();
-      const nodes = [];
-      if (args.title) {
-        nodes.push({ key: '__title', text: `## ${args.title}`, format: 'md', size: 'md', font: 'kai', color: 'ink', at: null, w: null });
-      }
-      for (const n of nodesIn) {
-        if (localIds.has(n.id)) return err(`节点 id 重复：${n.id}`);
-        localIds.add(n.id);
-        // 可读性规范：正文不低于 md（0.8 倍下 12.8 屏幕像素是底线）；sm 只给 ≤40 字的题注
-        const size = (n.size === 'sm' && n.text.length > 40) ? 'md' : (n.size || 'md');
-        nodes.push({ key: n.id, text: n.text, format: n.format || 'plain', size, font: n.font || 'pen', color: n.color || 'ink', at: n.at || null, w: n.w || null });
-      }
-      for (const n of nodes) {
-        const box = textBox(n.text, n.size, { md: n.format === 'md', wUnits: n.w });
-        n.w = box.w; n.h = box.h;
-      }
-      // 标题永远在最上面：free 模式给它 (0,-2)，模板模式它就是第一个
-      const titleNode = nodes.find(n => n.key === '__title');
-      let tpl = args.layout || 'auto';
-      if (tpl === 'auto') tpl = nodes.some(n => n.at) ? 'free' : (nodes.length - (titleNode ? 1 : 0) <= 4 ? 'column' : 'grid');
-      const layoutInput = titleNode && tpl === 'mindmap' ? nodes.filter(n => n !== titleNode) : nodes;
-      const pos = layoutNodes(layoutInput, { template: tpl, cols: args.cols });
-      if (titleNode && !pos.has('__title')) {
-        const bb = bboxOf([...pos.entries()].map(([k, p]) => ({ x: p.x, y: p.y, ...nodes.find(n => n.key === k) })));
-        pos.set('__title', { x: bb.x, y: bb.y - titleNode.h - 12 });
-      } else if (titleNode && tpl === 'free' && !titleNode.at) {
-        const bb = bboxOf([...pos.entries()].filter(([k]) => k !== '__title').map(([k, p]) => ({ x: p.x, y: p.y, ...nodes.find(n => n.key === k) })));
-        pos.set('__title', { x: bb.x, y: bb.y - titleNode.h - 12 });
-      }
-      const rectOfNode = (key) => { const n = nodes.find(x => x.key === key); const p = pos.get(key); return n && p ? { x: p.x, y: p.y, w: n.w, h: n.h } : null; };
-
-      // ── 形状（局部像素）──
-      const shapes = [];
-      for (let i = 0; i < shapesIn.length; i += 1) {
-        const s = shapesIn[i];
-        const sid = s.id || `s${i + 1}`;
-        if (localIds.has(sid) || shapes.some(x => x.key === sid)) return err(`形状 id「${sid}」跟节点/别的形状重名（形状缺省叫 s1,s2…，节点别用这类名）`);
-        const seed = `${tag}:${sid}`;
-        const color = COLORS.includes(s.color) ? s.color : (s.kind === 'arrow' || s.kind === 'line' ? 'ink2' : 'ink');
-        const width = s.width || 2;
-        let rect; let d;
-        if (s.kind === 'path') {
-          if (!s.d || !/^[\dMLQCZ ,.\-eE]+$/.test(s.d)) return err(`形状 ${sid}：path 只收 M/L/Q/Z 与数字`);
-          // 自由路径：算它的包围盒，平移到 (at 或 0,0)
-          const nums = s.d.match(/-?\d*\.?\d+(?:[eE][-+]?\d+)?/g)?.map(Number) || [];
-          const xs = nums.filter((_, k) => k % 2 === 0); const ys = nums.filter((_, k) => k % 2 === 1);
-          const w = Math.max(4, Math.max(...xs) - Math.min(0, Math.min(...xs))); const h = Math.max(4, Math.max(...ys) - Math.min(0, Math.min(...ys)));
-          rect = { x: (s.at?.x || 0) * UNIT, y: (s.at?.y || 0) * UNIT, w: w + 6, h: h + 6 };
-          d = s.d;
-        } else if (s.kind === 'line' || s.kind === 'arrow' || s.kind === 'underline') {
-          let a; let b;
-          if (s.kind === 'underline' && s.around) {
-            const r = rectOfNode(s.around); if (!r) return err(`形状 ${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 err(`形状 ${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 err(`形状 ${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 err(`形状 ${sid}：${s.kind} 要 to 或 toNode`);
-          }
-          const sp = shapePath(s.kind, { to: { x: b.x - a.x, y: b.y - a.y } }, seed);
-          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 err(`形状 ${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 err(`形状 ${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 };
-          }
-          const sp = shapePath(s.kind, { w: box.w, h: box.h }, seed);
-          rect = { x: box.x - 6, y: box.y - 6, w: sp.w, h: sp.h };
-          d = sp.d;
-        }
-        shapes.push({ key: sid, rect, d, color: COLORS.includes(color) ? color : 'ink', width });
-      }
-
-      // ── 先分配 id、解析线 ──
-      // 线要先于落位算：一条连到真实产物卡的线会改变**主角判断**（手画线 +0.5 焦点分），
-      // 那张卡可能因此放大 1.5 倍 —— 落位必须按"线画上去之后"的尺寸避让
-      // （08-23 首跑真踩：草图连了一条丝线到纸本站，纸本当场成主角，身体盖住半张图）。
-      const board = await readBoard(projectId);
-      const known = new Set(Object.keys(board.zones || {}));
-      const idOf = new Map();     // local → canvas id
-      for (const n of nodes) idOf.set(n.key, `text:a${stamp()}`);
-      for (const sh of shapes) idOf.set(sh.key, `scribble:a${stamp()}`);
-      const resolveEnd = (raw) => {
-        if (idOf.has(raw)) return idOf.get(raw);
-        const cid = normalizeCanvasId(raw);
-        if (cid && board.objects?.[cid]) return cid;
-        if (cid && board.zones?.[cid] !== undefined) return cid;
-        return null;
-      };
-      const bindings = {};
-      const badEdges = [];
-      for (const e of edgesIn) {
-        const from = resolveEnd(e.from); const to = resolveEnd(e.to);
-        if (!from || !to || from === to) { badEdges.push(`${e.from}→${e.to}`); continue; }
-        bindings[`b:a${stamp()}`] = {
-          type: e.type || 'link', from, to, by: 'agent', material: e.material || 'pencil', tag,
-          ...(staging ? { staging: true } : {}), ...(e.label ? { label: e.label } : {}),
-        };
-      }
-      // 落位用"线画上之后"的板来估尺寸（主角可能换人）
-      const after = { ...board, bindings: { ...(board.bindings || {}), ...bindings } };
-
-      // ── 宏观落位 ──
-      const local = bboxOf([
-        ...nodes.map(n => ({ ...pos.get(n.key), w: n.w, h: n.h })),
-        ...shapes.map(sh => sh.rect),
-      ]);
-      let zone = '';
-      let anchor = null;
-      if (args.near) {
-        const nid = normalizeCanvasId(args.near);
-        const e = nid ? board.objects?.[nid] : null;
-        if (e && Number.isFinite(e.x)) {
-          zone = layerOf(nid, e, known);
-          anchor = { x: e.x, y: e.y, ...estimateSizeOn(after, nid, e) };
-        } else {
-          // near 也认 tag（08-23 案，同 write_on_board）
-          const env = tagEnvelope(board, args.near, (id2, e2) => estimateSizeOn(after, id2, e2));
-          if (!env) return err(`锚点 ${args.near} 还没有座位，也不是板上任何 tag（read_board 里看不到就锚不上）。`);
-          zone = layerOf(env.anchorId, board.objects[env.anchorId], known);
-          anchor = { x: env.x, y: env.y, w: env.w, h: env.h };
-        }
-      }
-      const obstacles = [];
-      let contentBottom = 0;
-      for (const [id, e] of Object.entries(board.objects || {})) {
-        if (!Number.isFinite(e?.x) || layerOf(id, e, known) !== zone) continue;
-        const r = { x: e.x, y: e.y, ...estimateSizeOn(after, id, e) };
-        obstacles.push(r); contentBottom = Math.max(contentBottom, r.y + r.h);
-      }
-      if (!zone) for (const zz of Object.values(board.zones || {})) if (Number.isFinite(zz?.y)) contentBottom = Math.max(contentBottom, zz.y + 240);
-      // 尺寸规范：硬上限直接拒（一张图说一件事），推荐上限以上给提醒
-      if (local.w > SKETCH_MAX.w || local.h > SKETCH_MAX.h) {
-        return err(`这张图太大了（${Math.round(local.w)}x${Math.round(local.h)} 世界像素，上限 ${SKETCH_MAX.w}x${SKETCH_MAX.h}）：用户在 80%~100% 缩放下看不全。拆成两张（各自一个 tag，之间用线连），或减节点/缩 w。`);
-      }
-      // 用户视口（同一层才算；黑板是主窗口时画在他眼前）+ 按他的屏幕算"一屏"
-      const vp = getViewpoint(projectId);
-      const vpRect = (vp && (vp.layer || '') === zone && vp.camera) ? vp.camera : null;
-      const fit = fitFor(vp);
-      const spot = findSpot({ w: local.w + 24, h: local.h + 24, near: anchor, obstacles, contentBottom, viewport: vpRect });
-      const ox = spot.x - local.x + 12; const oy = spot.y - local.y + 12;
-
-      // ── 落盘 ──
-      const objects = {};
-      const common = { z: 1, zone, by: 'agent', tag, ...(staging ? { staging: true } : {}) };
-      for (const n of nodes) {
-        const p = pos.get(n.key);
-        objects[idOf.get(n.key)] = {
-          x: Math.round(p.x + ox), y: Math.round(p.y + oy), w: n.w, h: n.h, kind: 'text',
-          data: { t: n.text, ...(n.format === 'md' ? { format: 'md' } : {}), font: TEXT_FONTS.includes(n.font) ? n.font : 'pen', size: n.size, color: n.color },
-          ...common,
-        };
-      }
-      for (const sh of shapes) {
-        objects[idOf.get(sh.key)] = { x: Math.round(sh.rect.x + ox), y: Math.round(sh.rect.y + oy), w: Math.round(sh.rect.w), h: Math.round(sh.rect.h), kind: 'scribble', data: { d: sh.d, color: sh.color, width: sh.width }, ...common };
-      }
-      const saved = await patchBoard(projectId, { objects, bindings });
-      const landed = Object.keys(objects).filter(id => saved.objects?.[id]).length;
-      if (!landed) return err('草图被 board 拒了（内容或字段不合法）。');
-      turnStamp.count += 1;
-      const world = { x: Math.round(local.x + ox), y: Math.round(local.y + oy), w: Math.round(local.w), h: Math.round(local.h) };
-      try {
-        ctx?.emit?.({ type: 'board.updated', sessionId: null, summary: `画了一张草图 #${tag}` });
-        // 镜头提示（前端只在黑板模式跟随；不是劫持，是"黑板是主窗口"的约定）
-        ctx?.emit?.(Events.boardFocus(world, { tag, layer: zone }));
-      } catch { /* fail-soft */ }
-      const lines = [
-        `Sketch #${tag} landed${staging ? ' as STAGING (半透明)' : ''}: ${Object.keys(objects).length - shapes.length} nodes, ${shapes.length} shapes, ${Object.keys(bindings).length} lines; layout ${tpl}; at world (${world.x},${world.y}) ${world.w}x${world.h}${anchor ? ` (${spot.side} of ${args.near})` : ' (below current content)'}.`,
-        `ids: ${[...idOf].map(([k, v]) => `${k}=${v}`).join(', ')}`,
-      ];
-      if (badEdges.length) lines.push(`Skipped ${badEdges.length} edge(s) with unknown endpoints: ${badEdges.slice(0, 6).join(', ')}`);
-      if (world.w > fit.w || world.h > fit.h) lines.push(`⚠ Bigger than one screen at 80% zoom${fit.screen ? ` (user's screen ${fit.screen.w}x${fit.screen.h}px → ${fit.w}x${fit.h} world px fits)` : ` (${fit.w}x${fit.h} fits)`} — the user will have to pan. Split into two tagged sketches (side by side or stacked) next time.`);
-      if (vp?.zoom && vp.zoom < 0.8) lines.push(`User's zoom is ${vp.zoom} (<0.8): text this size is small on their screen. Keep nodes md/lg and say in one line that there is a sketch on the board.`);
-      lines.push(spot.side === 'viewport' ? 'Placed inside the user\'s current viewport.' : `Placed ${spot.side === 'bottom' ? 'below current content' : spot.side + ' of the anchor'}${vpRect ? ' (no room in the user\'s viewport)' : ''}.`);
-      lines.push(staging
-        ? 'Next: look_at_board {tag} to check it, then finish_sketch {tag} (or it commits at turn end). Mention the sketch to the user in one line.'
-        : 'Next: look_at_board {tag} to check it.');
-      return { content: [{ type: 'text', text: lines.join('\n') }] };
-    },
-  );
-}
-
-export function makeFinishSketchTool({ projectId, ctx }) {
-  return tool(
-    'finish_sketch',
-    `Commit a staging sketch (make it solid) — or erase it. Pass the #tag from
-sketch_on_board; omit tag to commit everything still staging. erase:true deletes the
-whole group (its notes/shapes/lines; real artifact cards only lose the tag).`,
-    {
-      tag: z.string().max(40).optional(),
-      erase: z.boolean().optional(),
-    },
-    async ({ tag, erase }) => {
-      if (!projectId) return { content: [{ type: 'text', text: 'No project bound.' }], isError: true };
-      if (erase) {
-        if (!tag) return { content: [{ type: 'text', text: 'erase needs a tag.' }], isError: true };
-        const { removed } = await removeByTag(projectId, tag);
-        try { ctx?.emit?.({ type: 'board.updated', sessionId: null, summary: `擦掉了草图 #${tag}` }); } catch { /* */ }
-        return { content: [{ type: 'text', text: `Erased #${tag}: ${removed} item(s)/line(s) removed.` }] };
-      }
-      const { committed } = await commitStaging(projectId, { tag: tag || null });
-      if (committed) { try { ctx?.emit?.({ type: 'board.updated', sessionId: null, summary: `草图落定${tag ? ` #${tag}` : ''}` }); } catch { /* */ } }
-      return { content: [{ type: 'text', text: committed ? `Committed ${committed} item(s)${tag ? ` of #${tag}` : ''}.` : 'Nothing was staging.' }] };
-    },
-  );
-}

package/server/engine/plugins/nodesign/skills/rp-craft/SKILL.md

@@ -1,235 +0,0 @@
----
-name: rp-craft
-version: 0.1.1
-description: NoDesign 互动演出（RP）方法论 —— 搭一场角色扮演：编排上下文（编排.yaml 三区模型）、写角色与世界、造演出页前端、串起 chatai 通路。只要用户想角色扮演就用本 skill —— 包括直接说「开一场RP」「我们来玩角色扮演」并当场给出人物设定的情况：你是搭台的场务，不是台上的演员，绝不在设计对话里亲自扮演角色，而是按本 skill 把演出搭成能反复进场的作品（角色在专门的演出页里开口，那条通路便宜得多、也不占设计会话）。也用于把酒馆（SillyTavern）角色卡搬进来。不要用于写小说（那是另一回事，别拿这套硬套）。
----
-
-# 一场演出是什么
-
-三样东西住在**一个文件夹**里，缺一不可：
-
-1. `编排.yaml` —— 上下文的播放单（进模型的一切按它拼）
-2. 设定文件 —— 角色、世界、文风，自由组织，被播放单引用
-3. `index.html` —— 演出页。有它这个文件夹就会被认成站点，用通用站点窗打开
-
-对话记录 `对话.jsonl` 和摘要 `摘要.json` 演出中自动生成。**摘要是派生态，永远别手写。**
-
-台上说话的是 **chatai**：一次纯补全调用，没有工具、没有会话、改不了任何文件。
-你（agent）只负责搭台和调台，不在台上。演出的每一轮花费按平台单价表记入用户额度。
-
-# 机制契约（这一节照抄不走样）
-
-## 编排.yaml 全貌
-
-```yaml
-模型: gemini-3.7-flash   # 可省 = 平台默认。摘要可单配便宜的（摘要.模型）
-思考: 低                 # 思考档，可省 = 该模型最省的那档。gemini 系 低/中/高、
-                         # claude 系 关/高（开扩展思考）；写了模型没有的档不报错，
-                         # 按默认档跑并在回包里说明。摘要另有 摘要.思考，不写就走
-                         # 默认档（压缩不是创作，别给摘要开高思考烧钱）
-最大输出: 400            # RP 短回合是质量旋钮：300–600 合适，放大了戏会水
-上下文预算: 60000        # 输入侧预算：系统层和尾部照给，历史是弹性区被从最旧挤压
-
-系统层:                  # → system 参数。整区冻结，是缓存的本体
-  - 名字: 身份与规则
-    文件: 设定/老芦.md
-  - 名字: 世界观
-    文件: 设定/夜行集市.md
-  - 名字: 文风
-    内容: |
-      第二人称现在时，只写可感知的事，结尾留一个能接的动作或问题。
-
-历史:
-  保留轮数: 40           # 硬上限；预算不够时还会再被挤
-
-摘要:                    # 滚动前情提要：活历史攒到触发轮数就折叠一次
-  保留轮数: 12
-  触发轮数: 24           # 必须 > 保留轮数，差值是滞回区间
-  长度: 500
-
-尾部:                    # → 拼进当轮 user 消息前部。唯一允许每轮变的区
-  - 名字: 当前场景
-    文件: 状态/场景.md    # 谁改这个文件，下一轮就生效
-  - 名字: 交易提醒
-    内容: 涉及买卖时报价要具体到铜币数目。
-    触发: [买, 卖, 价钱]  # 触发词命中最近几轮或当轮输入才插入
-    # 停用: true          # 播放单开关
-```
-
-铁律三条：条目 `文件`/`内容` 二选一；**触发条目只能住尾部**（住系统层直接拒开演）；
-文件引用不许跑出演出文件夹。配置错了端点会拒演并报人话，照改就是。
-
-## 两条 API（演出页用，cookie 同源自动带）
-
-- `GET /api/projects/<pid>/chatai/log?dir=<文件夹>` → `{records, 摘要, 配置}`，开场铺台用
-- `POST /api/projects/<pid>/chatai/turn` body `{dir, input}` → SSE 流：
-  `data:{delta}`… 最后 `data:{done, text, usage, costUsd}`；错误 `data:{error}`。
-  拒绝码：429 太快或额度尽、409 上一轮没回完、403 账号未开通演出通路
-
-## 开场白（角色先开口）
-
-往 `对话.jsonl` 种第一条记录：
-
-```
-{"seq":1,"role":"assistant","text":"<开场白>","at":"<ISO时间>"}
-```
-
-它不算轮数，够老了会随摘要折叠。用户视角：一进场角色已经在说话。
-
-# 三区纪律 —— 为什么这么摆
-
-顺序即上下文：**稳定的在前吃缓存，易变的在后换自由。** 缓存按字节精确匹配前缀，
-前缀里任何一个字变了，它后面的一切全部重算。
-
-反面教材是酒馆的世界书：几百个词条按关键词触发、插在前缀中段，每轮触发集一变
-后面全废 —— 实测 573 条词库缓存命中率 **0%，一轮一美元**。所以这里触发条目被
-结构性关进尾部：尾部本来就在最新对话之后、缓存必然失效的位置，触发集怎么变都
-伤不到前缀。
-
-「每轮允许多大范围变化」是用户的取舍旋钮，空间化了：一段内容放系统层 = 冻住换
-缓存，挪尾部 = 放开换灵活。用户要"自由一点"，就是把东西往尾部挪。
-
-# 特化菜谱（参考，不当分类）
-
-**身份与规则**（系统层第一条）：演谁、对用户用什么人称、回合怎么接（只推进一拍，
-别替用户行动）、回复长度、这场戏的禁区。这一条的质量决定八成体验。
-
-**世界观：整本冻结，别切条。** 这条路是 1M 窗口 + 便宜的 flash，几万字设定冻在
-系统层一次写进缓存，比切几百条按关键词捞又稳又便宜。酒馆玩家的切条肌肉记忆是
-8k 窗口时代逼出来的，别带过来。
-
-**文风锚**：三五条"怎么写"的约束 + 一小段范文，比一堆形容词管用。范文是最强的锚。
-
-**状态文件当活道具**：`状态/场景.md` 这类尾部条目，演出中你或用户改文件就等于
-改状态，不需要任何变量系统。要推进剧情就改状态文件——**不要去读 `对话.jsonl`**
-（见下方隐私纪律；平台也会拦）。用户想跟你讨论某段戏，会自己粘贴过来。
-
-**触发条目 = 导演小纸条**，一场十条以内：战斗时收紧节奏、某个名字出现时提醒一段
-旧怨。它是"到了这一幕才递的条子"，不是知识检索。
-
-# 从酒馆搬东西进来
-
-⚠️ **任何酒馆导出的 JSON 都先用 `read_tavern_json`，不要用 Read。** 真样本
-（一份社区预设）464KB、210 条提示词而启用的只有 56 条 —— Read 一次就是十几万
-token 进上下文，换回来的绝大部分是停用的备选。工具两步走：`mode="digest"` 看结构
-（名字/角色/字数/一句引子），挑好了再 `mode="fetch"` + `entries=[…]` 拿正文。它只读不写，怎么分组
-是你的判断。
-
-酒馆导出的 JSON 有三种，别搞混：
-
-## ① 预设（Chat Completion preset）—— `prompts[]` + `prompt_order[]`
-
-**它跟 `编排.yaml` 是同一类东西**：管的是"每次请求怎么拼上下文 + 采样参数"，
-里面没有角色也没有剧情。搬法：
-
-1. `read_tavern_json` 摘要 → 看清启用了哪些、顺序如何。
-2. 跟用户过一遍**分歧点**（预设通常把同一功能备了好几版只开一个）：文风、
-   思维链、人称、对白量、NSFW 档。问"这几个开关你要哪一档"，不要自己替他选。
-3. `mode="fetch"` 拿选中条目的正文，按功能并成两三份设定文件（例：
-   `设定/规则.md`、`设定/文风.md`、`设定/思维链.md`），**顺序照抄原顺序**，
-   全部进**系统层**（它们每轮不变，正是缓存本体）。
-4. **丢掉**：marker 占位条（角色描述/性格/场景/Chat History —— 我们由
-   编排.yaml 自己管历史和角色）、0 字的分节标题、以及针对特定平台的破甲话术
-   （这条通路不过内容审查，尺度由账号档位定，那些绕过话术在这儿没有意义，
-   还白占前缀）。
-5. 采样参数（temperature / top_p / 各种惩罚）**我们没有这些旋钮**，照实告诉
-   用户：这边能调的是 模型 / 思考档 / 最大输出 / 上下文预算。预设里的
-   `openai_max_tokens` 可以参考着填 `最大输出`，但 RP 短回合 300–600 更好。
-
-一个真数字供你估：那份 56 条的预设，正文合计约 9.8k 字符 ≈ 4–5k token 常驻前缀。
-搬进系统层没问题，但要跟用户说清这是每轮都在的开销。
-
-## ② 角色卡（V2/V3）—— `spec: chara_card_v2` 或有 `first_mes`
-
-`description/personality/scenario` 并成一份角色文件进系统层；`first_mes` 种成
-开场白（往 `对话.jsonl` 写 assistant seq 1）；`mes_example` 提炼进文风锚；
-`alternate_greetings` 问用户要哪一条。`character_book` 见下。
-
-## ③ 世界书（lorebook）—— `entries`
-
-constant 的并进世界观正文（系统层）；带 keys 的挑**十条以内**做成尾部触发条目
-（`触发: [关键词…]`），其余并进世界观。别把整本世界书搬成触发条目 —— 触发条目
-住尾部是为了缓存稳定，几十条一起塞进去就把尾部撑成第二个前缀了。
-
-# 建场流程
-
-1. **先问再动手**：题材与基调、角色是谁跟用户什么关系、文风参照（有没有喜欢的
-   作品口吻）、回复长短、禁区、谁先开口。两三个问题一起问，别拷问。
-2. 落设定文件和 `编排.yaml`，要开场白就种上。
-3. 造前端，两件事分开做：
-   - **管线不用自己写，也不用去找**：加载本 skill 时平台已经把 `演出.template.js`
-     拷进工作区根，直接 `cp 演出.template.js <演出文件夹>/演出.js`，**一个字都别改**。
-     URL 自省、铺场、SSE 跨分片解析、错误话术、中断、输入法回车、滚动锚定、
-     摘要提示、隐私声明自检、探针模式全在里面 —— 这些是协议不是设计，现写必错
-     （真页面统计：三张手写的里两张漏了隐私声明和探针分支，还有一张每来一片就
-     抢滚动，用户往上翻看前情会被拽回底部）。
-   - **皮肤自己长**：`index.html` 按题材重设计 —— 字体、色纸、气泡形态、台面装饰
-     都是戏的一部分，手机窄屏必须能玩。接管线只需要回答"一条消息长什么样"：
-
-     ```html
-     <!-- ⚠️ classic script，**不许写 type="module"**：你自检截图走 file://，
-          ES module 在那儿被当跨源拦掉，整页脚本一起死 -->
-     <script src="演出.js"></script>
-     <script>
-       const 台 = document.getElementById('台');
-       const 条 = (cls, 文) => { const el = document.createElement('div');
-         el.className = cls; el.textContent = 文; 台.appendChild(el); return el; };
-       ND演出.挂载({
-         台,
-         输入: document.getElementById('输入'),
-         发送钮: document.getElementById('发送'),
-         画: {
-           用户: (文) => 条('回合 用户', 文),
-           演出: () => { const el = 条('回合 演出 等', '');
-             return { 写: (全) => { el.classList.remove('等'); el.textContent = 全; },
-                      完成: (全) => { el.classList.remove('等'); el.textContent = 全; },
-                      撤: () => el.remove() }; },
-           提示: (文) => 条('提示', 文),
-           出错: (文) => 条('出错', 文),
-         },
-       });
-     </script>
-     ```
-
-     `写(全文)` 每来一片调一次，给的是**到目前为止的全文**不是增量，直接
-     `textContent = 全文` 最省事。想看一整张能跑的皮肤范例：
-     `patterns/演出页-最小实现.html`（找不到就算了，上面这段就够接）。
-
-4. 自检：screenshot 演出页，确认铺场正常、开场白在台上。第一轮留给用户开。
-5. 告诉用户：点开这个文件夹的站点窗就能进场；想调口味（换文风、改场景、挪冻结
-   范围）随时叫你改 —— 你就是这场戏的场务。
-
-# 价钱小抄（跟用户聊配置时用）
-
-gemini-3.7-flash：$0.75/M 入、$3.75/M 出（促销价，思考 token 计入输出且关不掉，
-实测约为正文的三倍半）；claude-sonnet：$3/$15。一轮典型 RP（几千字上下文、几百字
-回复）flash 约 $0.003–0.008。预算紧就守住：最大输出别超 600、上下文预算 4–6 万。
-
-思考档不是免费的旋钮：思考 token 一律按输出价计。gemini 三档实测差异有限（别拿它
-当质量保证），claude 的「高」是真开扩展思考、一轮更贵。用户没提就别自作主张往上调。
-
-# 隐私纪律（跟机制契约同级，照办）
-
-演出记录是用户的隐私：**台词只活在 chatai 通路里，永远不进你的上下文。**
-
-- **不读 `对话.jsonl` / `摘要.json`**（Read/Grep 会被平台拦下）。调度剧情的接口
-  是 状态/ 文件；用户想给你看片段会自己粘贴——主动粘贴即知情同意。
-- 这两道保险住在 `演出.js` 里，改皮时**不许删也不许改**：`<meta name="nd-privacy">`
-  （用户在演出页上标注元素时，平台据此剥文本只发结构给你；模块发现页面没有会
-  自己补一条）；探针分支（显式带 `?nd_probe=1` 打开时渲样例台账——⚠️ 你的自检截图走 http、跟用户预览同源，**不会**自动进这个分支；你看到的就是用户看到的，别把真问题当样例——
-  screenshot 走的就是 file://，所以你看到的是样例，那是**正常的**，不是页面坏了，
-  别去"修"）。
-- 自检截图想看特定版面状态：`artifact_open` 开进会话真的点到那一步再量（量具带 `live:true`），或 `beforeShot` 塞假台账 —— 两条都行，别想办法弄真记录。
-
-# 边界
-
-- 页面里永远不出现任何密钥（不需要：端点靠 cookie）。
-- 页面不做定时轮询、自动重发 —— 限频闸会拦，但根上就别写。
-- 演出内容平台不审（chatai 无工具无副作用），尺度是用户和角色设定之间的事。
-
-## 板书（交稿纪律）
-做完这一轮的东西，在它旁边写一条板书（`write_on_board near=那张卡`）：这版是什么 / 为什么这么做 /
-看哪里。改了几处就写几条要点，一条说一件事。同一件东西出了新版本，画一条「改自」线
-（`relate_on_board` derives-from）；有参考来源画「取材」。用户在你的板书上标注了，用
-`write_on_board reply_to=` 接在那条下面回。多步任务先 TodoWrite 列步骤 —— 步骤清单会自动上板、
-每步的产物自动连过去。