@xiaobuyu/nodesign 0.0.7 → 0.0.8

package/server/engine/mcp/server-name.js

@@ -0,0 +1,19 @@
+/**
+ * mcp/server-name.js —— MCP 服务名的唯一真相源（2026-08-25）
+ *
+ * 这个名字有两个读者，而且**改错了不会报错，只会静默失效**：
+ *   1. session-loop.js 的 `mcpServers: { [MCP_SERVER_NAME]: server }` —— 决定
+ *      工具在模型眼里叫 `mcp__<名>__<工具>`
+ *   2. isolation.js 的 `permissions.allow: ['mcp__<名>']` —— 决定这些工具跳不跳
+ *      auto 模式分类器
+ * 两处对不上时：工具照常能用，只是每一次调用又开始过分类器，没有任何报错。
+ * 所以名字收在这里一份，两边都 import，并由 isolation.test.js 钉住。
+ *
+ * 单独一个文件而不是挂在 mcp/index.js：isolation.js 只要这一个字符串，
+ * 不该为此把整棵工具树（连带 DB 模块）拖进来。
+ */
+
+export const MCP_SERVER_NAME = 'nodesign';
+
+/** 给 permissions.allow 用的整服务放行规则 */
+export const MCP_ALLOW_RULE = `mcp__${MCP_SERVER_NAME}`;

package/server/engine/mcp/tools/artifact-session.js

@@ -257,11 +257,12 @@ export const ARTIFACT_BATCHABLE = [
   'screenshot_canvas', 'trace_motion', 'get_computed_styles', 'explain_style', 'query_elements',
 ];
 
-export function makeArtifactBatchTool({ tools }) {
+export function makeArtifactBatchTool({ tools, resolve = null }) {
   const names = ARTIFACT_BATCHABLE.filter(n => tools.some(t => t.name === n));
   return makeBatchTool({
     name: 'artifact_batch',
     tools,
+    resolve,
     batchable: ARTIFACT_BATCHABLE,
     finalShot: { name: 'artifact_computer', input: { action: 'screenshot' } },
     description: `Run several artifact-session steps in ONE round trip: open → click → type →

package/server/engine/mcp/tools/browse-find-batch.js

@@ -85,20 +85,36 @@ as an error telling you to find again.`,
  * @param {string[]} o.batchable     允许的名字
  * @param {{name:string, input:object}} [o.finalShot]   结尾补的那张"当前状态"；不传就不补
  */
-export function makeBatchTool({ name, description, tools, batchable, finalShot }) {
+export function makeBatchTool({ name, description, tools = [], batchable, resolve = null, finalShot }) {
+  // resolve（2026-08-27 重置，清 08-26 那条「batch 绕闸」挂账）：传了它，子工具在
+  // **运行时**从装配完成后的注册表取（index.js 在包装管线跑完后回填 wrappedByName），
+  // 能力闸 / 参数消毒 / 模式过滤对 batch 内的调用照常生效。batchable 仍是**政策名单**
+  // （哪些名字许进 batch）；resolve 查不到 = 这台机器/该模式把它下架了，如实报。
+  // 不传 resolve 走旧的实例表（单测直连用 —— 但生产装配一律传 resolve）。
   const byName = new Map(tools.filter(t => batchable.includes(t.name)).map(t => [t.name, t]));
-  const names = [...byName.keys()];
+  const lookup = (n) => (resolve ? (batchable.includes(n) ? resolve(n) : undefined) : byName.get(n));
+  const names = resolve ? [...batchable] : [...byName.keys()];
+  const shotDefault = finalShot ? finalShot.default !== false : false;
   return tool(
     name,
     description,
     {
-      actions: z.array(z.object({
+      // looseObject（2026-08-29）：**放错层的参数不许静默消失**。模型很自然会写
+      // {name, chain:true, input:{…}} —— chain 是 write_on_board 的参数，写在了
+      // action 这一层。z.object 默认剥掉未知键，于是那一步照跑、只是丢了半个意图
+      // （真会话 proj_mtdr2xpa：两章的 chain:true 都这么没的，章节不接线程、
+      // 落到兜底位，正文列当场散架，用户看到的是"摆位乱了"）。收下它们，在
+      // handler 里按子工具的 schema 归位，并如实报一句。
+      actions: z.array(z.looseObject({
         name: z.string().describe(`Tool name: one of ${names.join(' | ')}.`),
-        input: z.record(z.string(), z.unknown()).optional().describe("That tool's input, same shape as calling it directly."),
+        input: z.record(z.string(), z.unknown()).optional().describe("That tool's input, same shape as calling it directly. Put the tool's OWN parameters in here — a parameter written beside `name` instead of inside `input` is folded in for you and reported."),
       })).min(1).max(MAX_ITEMS)
         .describe(`1-${MAX_ITEMS} items, run in order. Each item: {"name": <tool>, "input": {...}}.`),
-      screenshotAfter: z.boolean().optional()
-        .describe('Append a screenshot of the resulting state at the end (default true). Set false for text-only sequences to save tokens.'),
+      // 没有 finalShot 就不放这个参数 —— 写一个永远无效的旋钮是在骗模型
+      ...(finalShot ? { screenshotAfter: z.boolean().optional()
+        .describe(shotDefault
+          ? 'Append a look at the resulting state at the end (default true). Set false for text-only sequences to save tokens.'
+          : 'Pass true to append a look at the resulting state at the end (default false — most board upkeep is text work; ask for eyes when looks matter).') } : {}),
     },
     async ({ actions, screenshotAfter }, extra) => {
       const out = [];
@@ -106,18 +122,60 @@ export function makeBatchTool({ name, description, tools, batchable, finalShot }
       let failedAt = -1;
       let failText = '';
       let lastHadImage = false;
+      let shotLifted = false;
       for (let i = 0; i < n; i += 1) {
-        const { name: toolName, input } = actions[i];
+        const { name: toolName, input, ...stray } = actions[i];
         const label = `[${i + 1}/${n}] ${toolName}${input?.action ? ` ${input.action}` : ''}`;
         if (failedAt >= 0) { out.push({ type: 'text', text: `${label}: ${HALT_TEXT}` }); continue; }
-        const def = byName.get(toolName);
+        const def = lookup(toolName);
         if (!def) {
           failedAt = i;
-          failText = `"${toolName}" is not batchable here (use one of ${names.join(', ')}).`;
+          failText = batchable.includes(toolName)
+            ? `"${toolName}" 在这台机器/该项目模式下没有注册（能力或模式闸下架了它）——这一步换别的路。`
+            : `"${toolName}" is not batchable here (use one of ${names.join(', ')}).`;
           out.push({ type: 'text', text: `${label}: Error: ${failText}` });
           continue;
         }
-        const parsed = z.object(def.inputSchema).safeParse(input || {});
+        // 归位（08-29）：action 这一层的多余键按子工具的 schema 收进 input；
+        // screenshotAfter 是 batch 自己的旋钮，抬到 batch 层。都如实报 —— 静默
+        // 修正会让下一次还写错，静默丢弃会让这一次就出错。
+        let folded = input || {};
+        const notes = [];
+        const own = new Set(Object.keys(def.inputSchema || {}));
+        const strayKeys = Object.keys(stray);
+        if (strayKeys.length) {
+          const patch = {};
+          for (const k of strayKeys) {
+            if (k === 'screenshotAfter') { shotLifted = shotLifted || stray[k] === true; notes.push('screenshotAfter 是整批的旋钮，已抬到 batch 层'); continue; }
+            if (own.has(k) && !(k in folded)) { patch[k] = stray[k]; continue; }
+            notes.push(`${k} 不是 ${toolName} 的参数，忽略了`);
+          }
+          if (Object.keys(patch).length) {
+            folded = { ...folded, ...patch };
+            notes.push(`${Object.keys(patch).join('/')} 本该写在 input 里（已收进去，下次直接写 input 内）`);
+          }
+        }
+        // 双层信封（2026-08-30）：{"input":{"input":{…},"op":"x"}} 真实发生过 ——
+        // 模型要拼两级嵌套，多包一层不出声。里层不是这个工具的参数、而里面的键是，
+        // 就摊平上来。
+        if (!own.has('input') && folded.input && typeof folded.input === 'object' && !Array.isArray(folded.input)) {
+          const inner = folded.input;
+          if (Object.keys(inner).some((k) => own.has(k))) {
+            const { input: _drop, ...rest } = folded;
+            folded = { ...inner, ...rest };
+            notes.push('input 里又套了一层 input，已摊平（下次一层就够）');
+          }
+        }
+        // ⛔ input **内部**的未知键：z.object 静默 strip，不报错不留痕。08-29 那把
+        // looseObject 只盖住了写在 name 旁边的（action 这一层），差一层没盖到 ——
+        // 真会话里 write_on_board 收到过整份 `facts`（一长串剧情事实），一个字没落、
+        // 一句话没报。归不了位就点名，别静默丢。
+        const unknownIn = Object.keys(folded).filter((k) => !own.has(k));
+        if (unknownIn.length) {
+          notes.push(`⛔ ${unknownIn.join('/')} 不是 ${toolName} 的参数，这次**整个丢掉了**（内容没落盘）`
+            + `—— ${toolName} 收的是：${[...own].join('/')}`);
+        }
+        const parsed = z.object(def.inputSchema).safeParse(folded);
         if (!parsed.success) {
           failedAt = i;
           const why = parsed.error.issues.map(is => `${is.path.join('.') || '(root)'}: ${is.message}`).join('; ');
@@ -134,10 +192,12 @@ export function makeBatchTool({ name, description, tools, batchable, finalShot }
         // 第一块文本前面挂上 [i/n] 标签；没有文本块（纯图）就补一行标签再放图
         if (!blocks.some(b => b.type === 'text')) out.push({ type: 'text', text: `${label}: done` });
         let prefixed = false;
+        const tail = notes.length ? `\n⚠ ${notes.join('；')}` : '';
         for (const b of blocks) {
-          if (b.type === 'text' && !prefixed) { out.push({ type: 'text', text: `${label}: ${b.text}` }); prefixed = true; }
+          if (b.type === 'text' && !prefixed) { out.push({ type: 'text', text: `${label}: ${b.text}${tail}` }); prefixed = true; }
           else out.push(b);
         }
+        if (!prefixed && tail) out.push({ type: 'text', text: `${label}:${tail}` });
         if (r?.isError) {
           failedAt = i;
           failText = blocks.find(b => b.type === 'text')?.text || '(no error text)';
@@ -154,8 +214,9 @@ export function makeBatchTool({ name, description, tools, batchable, finalShot }
             + `Steps 1-${failedAt} already ran — do NOT re-run the whole batch; continue from the failed step.`,
         });
       }
-      if (finalShot && screenshotAfter !== false && !lastHadImage) {
-        const shotDef = byName.get(finalShot.name);
+      const wantShot = screenshotAfter === undefined ? (shotLifted || shotDefault) : screenshotAfter;
+      if (finalShot && wantShot && !lastHadImage) {
+        const shotDef = lookup(finalShot.name);
         if (shotDef) {
           try {
             const s = await shotDef.handler(finalShot.input || {}, extra);
@@ -171,11 +232,12 @@ export function makeBatchTool({ name, description, tools, batchable, finalShot }
   );
 }
 
-export function makeBrowserBatchTool({ tools }) {
+export function makeBrowserBatchTool({ tools, resolve = null }) {
   const names = BATCHABLE.filter(n => tools.some(t => t.name === n));
   return makeBatchTool({
     name: 'browser_batch',
     tools,
+    resolve,
     batchable: BATCHABLE,
     finalShot: { name: 'browser_screenshot', input: {} },
     description: `Run a sequence of browser tool calls in ONE round trip. Each item is

package/server/engine/mcp/tools/browse.js

@@ -458,7 +458,7 @@ about why they were taken is landfill.`,
             normalize: normalizeShot,
           });
           for (const f of r.files) {
-            try { ctx?.emit?.({ type: 'run.file_changed', path: f.rel, change: 'add' }); } catch { /* */ }
+            try { ctx?.emit?.({ type: 'run.file_changed', filePath: f.rel, event: 'add' }); } catch { /* */ }
           }
           const lines = [`从 ${r.data.title || r.data.url} 采下来了：`];
           for (const f of r.files) lines.push(`  ${f.rel}（${(f.bytes / 1024).toFixed(0)} KB，${f.kind}）`);

package/server/engine/mcp/tools/cast-role.js

@@ -0,0 +1,167 @@
+/**
+ * mcp/tools/cast-role.js — cast_role MCP tool（2026-08-26 建；2026-08-28 演员位重构重写）
+ *
+ * ## 重写前后
+ *
+ * 旧语义：写 `.claude/agents/rp-<id>.md`（一角色一个子代理定义），派发要等 CLI 重扫。
+ * ⛔ 那条路 08-28 勘定为生产不可靠：会话中途写入的定义文件只有**写入时活着的那个
+ * CLI 进程**认得（chokidar 事件），resume 换进程后永久 `not found`（三场真会话：
+ * 12 连败 / 恰好成功 / 永久失明）。等待、轮询、公告续接五版都救不了，全史见 git
+ * 里本文件的旧版头注。
+ *
+ * 新语义：角色卡是**数据**，子代理是**预注册的演员位**（rp-actor / rp-narrator，
+ * 建项目时就落盘，见 cast.js slotAgentFile）。cast_role 只做两件事：
+ *   1. 把人设写成 `角色/<名>/角色卡.md`（用户在画布上看得见、随时能改的文件夹范式）
+ *   2. 在 `.nd/cast.json` 登记 slug → 展示名/笔权/卡路径（板书署名与名册 API 的展示源）
+ * 写完**当回合就能派**：Agent(subagent_type: 演员位, name: "rp-<id>", prompt: 卡)。
+ *
+ * 登记不是上场的前置（不登记直接派也行），它换来的是：板上署名是「程晚」不是
+ * slug、重启后按卡重新开演有据可查、用户能在角色文件夹里改人设。
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { ROLE_PREFIX, ROLE_SLOT, isSlotType, isValidRoleSlug } from '../../agent/cast.js';
+import { readCastRegistry } from '../../agent/role-card.js';
+
+/** 角色 id（不含 rp- 前缀）：ASCII、能当文件名、能当 SendMessage 收件人名。
+ *  ⚠️ 这是 cast.js `ROLE_SLUG_RE` 的**收紧子集**（这边只许小写、≥2 字符）——
+ *  两个判据的蕴含关系（ID_RE 过的 id 拼上前缀必被 ROLE_SLUG_RE 认）由
+ *  cast-role.test.js 钉着；改任何一边先看那条测试。导出仅供测试。 */
+export const ID_RE = /^[a-z0-9][a-z0-9_-]{1,40}$/;
+
+const ROLES_DIR = '角色';
+const REGISTRY_REL = '.nd/cast.json';
+const PERSONA_MAX = 20000;
+
+/** 自由文本压一行：控制字符/行终止符全清（进 JSON 与返回话术都安全） */
+function oneLine(v, max) {
+  return String(v ?? '')
+    .replace(/[\r\n\u2028\u2029]+/g, ' ')
+    .replace(/[\u0000-\u001f\u007f]/g, '')
+    .trim().slice(0, max);
+}
+
+/** 展示名 → 文件夹名：剥路径分隔与点前缀，空了退回 slug（文件夹名坏不了路径） */
+function folderNameFor(displayName, slug) {
+  const cleaned = oneLine(displayName, 40).replace(/[\/\\]/g, '').replace(/^\.+/, '').trim();
+  return cleaned || slug;
+}
+
+export function makeCastRoleTool({ workspaceRoot, sessionId = null, ctx, roster = null }) {
+  void sessionId; void roster;   // 旧签名的调用方兼容位（公告续接与回合闸已随重构退役）
+  return tool(
+    'cast_role',
+    `Register a character card so this person has a fixed identity to act from.
+
+Writes the card to ${ROLES_DIR}/<name>/角色卡.md (user-visible, user-editable) and records
+the display name. The card is DATA, and in this build it is a reference for YOU:
+character subagents are disabled, so you write everyone on stage yourself.
+
+Use it for anyone who has a name, will show up again, and whom the user may want to talk
+to. Re-read the card right before you write that person's lines — that is the thing that
+keeps several characters from all sounding like you. A walk-on with one line needs no card.
+
+⛔ Do NOT dispatch a role subagent after this: no Agent(subagent_type: "${ROLE_SLOT}"),
+no SendMessage to a character. That path is being debugged; the cards you write now will
+plug straight back in once it returns.
+When the user hands you a ready-made character card, prefer copying it in verbatim over
+rewriting it.`,
+    {
+      id: z.string().describe('ASCII slug, no prefix: lowercase letters/digits/_/- , 2-41 chars. Becomes the address (rp-<id>).'),
+      name: z.string().min(1).max(40).describe('Display name, any language — what this character is actually called. Board signatures use it.'),
+      duty: z.string().min(1).max(400).describe('One line: who this is and when you would talk to them.'),
+      persona: z.string().min(1).describe("The card itself: who this person is, how they speak, what they would never do, plus two or three short samples of their voice. You read this back before writing their lines, so write it for that use — no meta rules about who writes what."),
+    },
+    async (args) => {
+      const fail = (msg) => ({ content: [{ type: 'text', text: msg }], isError: true });
+      if (!workspaceRoot) return fail('没有工作区，cast_role 不可用。');
+
+      const id = String(args.id || '').trim();
+      if (!ID_RE.test(id)) {
+        return fail(`角色 id「${id}」不合法：只能用小写字母、数字、下划线、连字符，2-41 个字符，首字符是字母或数字。`
+          + `（这个 id 要当 SendMessage 的收件人名，收件人名不收中文和空格 —— 中文名字放 name 参数。）`);
+      }
+      const slug = `${ROLE_PREFIX}${id}`;
+      if (!isValidRoleSlug(slug) || isSlotType(slug)) return fail(`角色名「${slug}」过不了名册校验（演员位的名字不能当角色名）。`);
+
+      const displayName = oneLine(args.name, 40);
+      if (!displayName) return fail('name 清洗后是空的 —— 换个展示名。');
+      const persona = String(args.persona || '').trim();
+      if (!persona) return fail('persona 是空的 —— 角色卡就是这个角色的全部身份，不能空。');
+      if (persona.length > PERSONA_MAX) {
+        return fail(`persona 有 ${persona.length} 字符，超过 ${PERSONA_MAX} 上限。`
+          + `把大部头设定挪进世界书/设定文件让角色自己 grep，卡上留人设主干。`);
+      }
+
+      // 卡落盘：角色/<名>/角色卡.md（文件夹范式：这个文件夹就是该角色的家，
+      // 之后的记忆/日记等件都住这里；用户随时可改，改动对"下次派发/唤醒后重读卡"生效）
+      const folder = folderNameFor(displayName, slug);
+      const dir = path.join(workspaceRoot, ROLES_DIR, folder);
+      const file = path.join(dir, '角色卡.md');
+      if (!path.resolve(file).startsWith(path.resolve(workspaceRoot, ROLES_DIR) + path.sep)) {
+        return fail('角色卡路径异常，拒绝写入。');
+      }
+      // 一个家只住一个角色（2026-08-28 对账发现）：文件夹按展示名取，两个不同的
+      // slug 用同一个展示名就会共用 角色/<名>/ —— 卡被后来者覆盖，**记忆.md 也共用**，
+      // 于是 A 的 jot_memory 写进 B 的记忆里，谁都不会发现。堵在写口，不是在
+      // roleHomeDir 那头兜（判据别建在模型可写的登记表上）。
+      // 同一个 slug 重登（改卡）不受影响 —— 那本来就是同一个人。
+      const claimedBy = Object.entries((await readCastRegistry(workspaceRoot)).roles || {})
+        .find(([s2, e2]) => s2 !== slug && typeof e2?.card === 'string'
+          && e2.card.split('/').slice(0, 2).join('/') === `${ROLES_DIR}/${folder}`);
+      if (claimedBy) {
+        return fail(`「${displayName}」这个家已经是 ${claimedBy[0]} 的了（角色/${folder}/）。`
+          + `同名两个角色会共用角色卡和记忆件 —— 换个展示名，`
+          + `或者你要的其实是同一个人的话，用 ${claimedBy[0]} 这个名字重登（改卡就是重登同一个 slug）。`);
+      }
+      let existed = false;
+      try { await fs.access(file); existed = true; } catch { /* 新角色 */ }
+      await fs.mkdir(dir, { recursive: true });
+      // 记忆件骨架（只在不存在时铺）：角色 jot_memory 追加，用户/GM 可整理
+      const memFile = path.join(dir, '记忆.md');
+      try { await fs.access(memFile); } catch {
+        await fs.writeFile(memFile, `# 记忆\n\n<!-- ${slug} 的记忆：角色自己 jot_memory 追加，用户和 GM 可整理改写。还是空的。 -->\n`, 'utf8');
+      }
+      await fs.writeFile(file, [
+        `# ${displayName}`,
+        '',
+        `<!-- ${slug} · cast_role 登记。`,
+        '     正文就是角色的人设，派发时全文随 prompt 进入角色 —— 想改人设直接改这里，',
+        '     对已在场的角色用 SendMessage 告知，对下次开演自动生效。 -->',
+        '',
+        persona,
+        '',
+      ].join('\n'), 'utf8');
+
+      // 登记表：板书署名与名册 API 的展示名来源（fail-soft：登记坏了不拦上场）
+      const cardRel = path.join(ROLES_DIR, folder, '角色卡.md');
+      try {
+        const reg = await readCastRegistry(workspaceRoot);
+        reg.roles[slug] = { name: displayName, duty: oneLine(args.duty, 400), card: cardRel };
+        await fs.mkdir(path.join(workspaceRoot, '.nd'), { recursive: true });
+        await fs.writeFile(path.join(workspaceRoot, REGISTRY_REL), JSON.stringify(reg, null, 2), 'utf8');
+      } catch { /* 展示层，坏了角色照样能上场（署名退回 slug） */ }
+
+      try { ctx?.emit?.({ type: 'run.role_cast', slug, name: displayName }); } catch { /* 事件失败不挡正事 */ }
+
+      // ⚠️ 这段话和工具 description 是**同一条教义的两个读者**，改一头必须改另一头 ——
+      // 08-30 停用子代理那一刀只改了 description，这里还留着「现在就可以派它上场」，
+      // 而返回文案离模型的下一个动作更近，等于白改（fable 评审当场抓到）。
+      const lines = [
+        `${existed ? '改写' : '写好'}了角色卡「${displayName}」→ ${cardRel}（登记为 ${slug}）`,
+        '',
+        `⛔ **不要派子代理**：这一版角色由你自己演，`
+        + `Agent(subagent_type: "${ROLE_SLOT}") 和 SendMessage 给角色这两条路正在调试。`,
+        `轮到「${displayName}」说话时，**先 Read 一遍 ${cardRel}** 把腔调找回来，再由你写他这一段。`,
+        `几个人同场就一个个来，每人开口前各读各的卡 —— 这是防止全场一个腔的正事。`,
+      ];
+      if (existed) {
+        lines.push('', '⚠️ 卡改了，下次写他的话之前重新 Read 一遍 —— 你上下文里那份是旧的。');
+      }
+      return { content: [{ type: 'text', text: lines.join('\n') }] };
+    },
+  );
+}

package/server/engine/mcp/tools/draw-trend.js

@@ -0,0 +1,104 @@
+/**
+ * mcp/tools/draw-trend.js —— `draw_trend`：状态表历史 → 手绘趋势线
+ * （2026-08-30 画图能力线·「活图」第一块）
+ *
+ * 数据不用记：状态表住在板书文件里、文件进 git、**每回合落一个 commit** ——
+ * 「好感度随拍数怎么走」的序列是现成的，git 就是时间轴（lib/state-trend.js）。
+ *
+ * 重画语义：同 key 再调一次 = 原地重画（旧的擦掉、**位置保留** —— 用户拖过它
+ * 摆在哪就还在哪）。所以每拍 set_vars 之后想让曲线长一格，再调一次就行。
+ */
+
+import { tool } from '@anthropic-ai/claude-agent-sdk';
+import { z } from 'zod';
+import { readBoard, patchBoard, removeByTag } from '../../../projects/board-store.js';
+import { trendSeries, trendGeometry } from '../../../lib/state-trend.js';
+import { roughFreePath, textBox } from '../../../lib/sketch-layout.js';
+import { KEY_MAX } from '../../../lib/state-table.js';
+import { currentSheet, toWorld } from '../../../lib/board-sheets.js';
+import { currentSheetIdOf } from '../../../lib/sheet-state.js';
+import { estimateSizeOn } from '../../../lib/board-kind-sizes.js';
+import { Events } from '../../agent/events.js';
+
+let seq = 0;
+const stamp = () => `${Date.now().toString(36)}${(seq++ % 1000).toString(36)}`;
+
+export function makeDrawTrendTool({ projectId, sharedRoot, sessionId, ctx }) {
+  return tool(
+    'draw_trend',
+    `Draw a hand-inked trend line of one state-table key over the story so far — 好感度
+climbing across eight beats, HP bleeding down. The series comes from the workspace's
+git history (one commit per turn), so there is nothing to record: if the number lived
+in the state table, its past is already there. Call it again after set_vars and the
+chart redraws IN PLACE (position kept, even if the user dragged it). Needs ≥2 numeric
+points — early beats will refuse loudly, that is normal.`,
+    {
+      key: z.string().min(1).max(KEY_MAX).describe('Which state-table key to chart (must hold numbers — 8/10 counts as 8)'),
+      at: z.object({ x: z.number().min(0).max(12000), y: z.number().min(0).max(12000) }).optional()
+        .describe('Sheet-local pixels for first placement. Omit it: lands under the state-table card (or where the previous chart of this key sits)'),
+    },
+    async (args) => {
+      const err = (t) => ({ content: [{ type: 'text', text: t }], isError: true });
+      if (!projectId) return err('No project bound.');
+      const s = await trendSeries(sharedRoot, args.key);
+      if (!s.ok) return err(`⛔ ${s.why}`);
+
+      const g = trendGeometry(s.points);
+      const tag = `trend-${args.key}`.slice(0, 40);
+      const board = await readBoard(projectId);
+
+      // 落点：旧图原位 > at（纸内像素） > 状态表卡正下方
+      let origin = null;
+      const prev = Object.entries(board.objects || {}).filter(([, e]) => e?.tag === tag && Number.isFinite(e?.x));
+      if (prev.length) {
+        origin = { x: Math.min(...prev.map(([, e]) => e.x)), y: Math.min(...prev.map(([, e]) => e.y)) };
+        await removeByTag(projectId, tag);
+      } else if (args.at) {
+        const sheet = currentSheet(board, currentSheetIdOf(sessionId));
+        if (!sheet) return err('还没有纸 —— 先 open_sheet，或者省掉 at 让它落在状态表卡下面。');
+        origin = toWorld(sheet, args.at);
+      } else {
+        const e = board.objects?.[s.rel];
+        if (!e || !Number.isFinite(e.x)) {
+          return err(`状态表那条板书（${s.rel}）不在板上（没有座位）—— 传 at:{x,y}（纸内像素）指个位置。`);
+        }
+        const sz = estimateSizeOn(board, s.rel, e);
+        origin = { x: e.x, y: e.y + sz.h + 16 };
+      }
+
+      // 标签在图上方一行；曲线 ink、基线 pencil、现值小圈 red —— 全过同一支抖动笔
+      const label = `${args.key}  ${s.points[0]} → ${s.points[s.points.length - 1]}（${s.points.length} 拍，${g.min}~${g.max}）`;
+      const lb = textBox(label, 'sm');
+      const seed = `trend:${args.key}`;
+      const objects = {
+        [`text:a${stamp()}`]: {
+          x: Math.round(origin.x), y: Math.round(origin.y), w: lb.w, h: lb.h, z: 1, kind: 'text',
+          data: { t: label, font: 'kai', size: 'sm' }, zone: '', by: 'agent', seat: 'agent', tag,
+        },
+        [`scribble:a${stamp()}`]: {
+          x: Math.round(origin.x), y: Math.round(origin.y + lb.h + 4), w: g.w, h: g.h, z: 1, kind: 'scribble',
+          data: { d: roughFreePath(g.baselineD, `${seed}:base`), color: 'pencil', width: 1 }, zone: '', by: 'agent', seat: 'agent', tag,
+        },
+        [`scribble:b${stamp()}`]: {
+          x: Math.round(origin.x), y: Math.round(origin.y + lb.h + 4), w: g.w, h: g.h, z: 1, kind: 'scribble',
+          data: { d: roughFreePath(g.lineD, `${seed}:line`), color: 'ink', width: 2 }, zone: '', by: 'agent', seat: 'agent', tag,
+        },
+        [`scribble:c${stamp()}`]: {
+          x: Math.round(origin.x), y: Math.round(origin.y + lb.h + 4), w: g.w, h: g.h, z: 1, kind: 'scribble',
+          data: { d: g.dotD, color: 'red', width: 2 }, zone: '', by: 'agent', seat: 'agent', tag,
+        },
+      };
+      await patchBoard(projectId, { objects });
+      const rect = { x: Math.round(origin.x), y: Math.round(origin.y), w: g.w, h: g.h + lb.h + 4 };
+      try {
+        ctx?.emit?.({ type: 'board.updated', sessionId: null, summary: `画了 ${args.key} 的趋势线` });
+        ctx?.emit?.(Events.boardFocus(rect, { tag, layer: '', soft: true }));
+      } catch { /* fail-soft */ }
+      return { content: [{ type: 'text', text:
+        `Trend #${tag}: ${s.points.length} points (${s.points.join(' → ')}), range ${g.min}~${g.max}, `
+        + `at (${rect.x},${rect.y}) ${rect.w}x${rect.h}${prev.length ? ' — redrawn in place' : ''}.\n`
+        + `Call draw_trend again after set_vars to grow it; move/group it like any sketch (tag #${tag} — `
+        + `edit_board follow can pin it to the 状态板 group).` }] };
+    },
+  );
+}

package/server/engine/mcp/tools/edit-board-schema.js

@@ -0,0 +1,56 @@
+/**
+ * edit_board 的 ops schema（2026-08-30 从 edit-board.js 拆出 —— 行数棘轮）。
+ * 纯数据；弱模型方言垫片（$text 剥壳）与坐标钳制都住在这里。
+ */
+
+import { z } from 'zod';
+import { BINDING_TYPE_IDS, BINDING_MATERIALS } from '../../../lib/binding-types.js';
+import { SLOT } from './open-sheet.js';
+
+const clampTo = (lo, hi) => (v) => (typeof v === 'number' && Number.isFinite(v) ? Math.max(lo, Math.min(hi, v)) : v);
+const GAP = z.preprocess(clampTo(0, 400), z.number().min(0).max(400));
+const PX_DELTA = z.preprocess(clampTo(-20000, 20000), z.number().min(-20000).max(20000));
+/** 弱模型方言垫片：免费档模型给字符串字段裹 {$text:"…"} 壳（27/61 条真实错误，
+ *  且读不懂 zod 报文会原样重试到死）。单键 $text 自动剥壳，合法对象碰不到。 */
+const unwrapText = (v) => (v && typeof v === 'object' && !Array.isArray(v)
+  && typeof v.$text === 'string' && Object.keys(v).length === 1) ? v.$text : v;
+const ENDPOINT = z.preprocess(unwrapText, z.string().min(1).max(300));
+
+const REL = z.object({
+  ref: z.string().min(1).max(300).describe('canvas id to place relative to'),
+  side: z.enum(['right', 'left', 'above', 'below']),
+  gap: GAP.optional().describe('PIXELS of breathing room between the two (default 24, max 400) — same unit as every position you read back'),
+});
+const DELTA = z.object({ dx: PX_DELTA, dy: PX_DELTA }).describe('PIXELS to shift by (+x right, +y down) — the same pixels read_board reports');
+// 纸内绝对坐标（2026-08-29 纸范式）：以某张纸版心左上为原点的像素。sheet 缺省 = 当前纸
+const ABS = z.object({
+  x: z.preprocess((v) => (typeof v === 'number' && Number.isFinite(v) ? Math.max(0, Math.min(12000, v)) : v), z.number().min(0).max(12000)),
+  y: z.preprocess((v) => (typeof v === 'number' && Number.isFinite(v) ? Math.max(0, Math.min(12000, v)) : v), z.number().min(0).max(12000)),
+  sheet: z.string().max(40).optional().describe('which sheet these pixels are on (default the current one)'),
+}).describe("PIXELS from a sheet's top-left writable corner — exact placement, you own the layout");
+const TO = z.union([REL, ABS, DELTA]);
+
+export const OP = z.discriminatedUnion('op', [
+  z.object({ op: z.literal('set_text'), id: z.string().min(1).max(300), text: z.string().min(1).max(8000).optional(), format: z.enum(['plain', 'md']).optional(), size: z.enum(['sm', 'md', 'lg', 'xl']).optional(), color: z.enum(['ink', 'red', 'pencil', 'brass']).optional(), font: z.enum(['pen', 'kai', 'sans', 'serif', 'mono']).optional() }),
+  z.object({ op: z.literal('move'), id: z.string().min(1).max(300), to: TO }),
+  z.object({ op: z.literal('move_group'), tag: z.string().min(1).max(40), to: TO }),
+  z.object({ op: z.literal('remove'), id: z.string().min(1).max(300) }),
+  z.object({ op: z.literal('add_node'), id: z.string().regex(/^[A-Za-z0-9_-]{1,24}$/).optional().describe('local handle for later ops of this call'), text: z.string().min(1).max(8000), 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: REL, tag: z.string().max(40).optional() }),
+  z.object({ op: z.literal('add_shape'), kind: z.enum(['rect', 'ellipse', 'circle', 'underline']), around: z.string().min(1).max(300).describe('canvas id to wrap/underline — the mark HUGS it and follows when it moves'), color: z.enum(['ink', 'red', 'pencil', 'brass']).optional(), width: z.number().min(1).max(12).optional(), tag: z.string().max(40).optional() }),
+  z.object({ op: z.literal('set_shape'), id: z.string().min(1).max(300), color: z.enum(['ink', 'red', 'pencil', 'brass']).optional(), width: z.number().min(1).max(12).optional() }),
+  z.object({ op: z.literal('add_edge'), from: ENDPOINT, to: ENDPOINT, type: z.enum(BINDING_TYPE_IDS).optional(), material: z.enum(BINDING_MATERIALS).optional(), label: z.string().max(60).optional(), tag: z.string().max(40).optional() }),
+  z.object({ op: z.literal('set_edge'), id: z.string().min(1).max(300), label: z.string().max(60).optional(), type: z.enum(BINDING_TYPE_IDS).optional(), material: z.enum(BINDING_MATERIALS).optional(), from: ENDPOINT.optional().describe('re-point the line: new source end'), to: ENDPOINT.optional().describe('re-point the line: new target end') }),
+  z.object({ op: z.literal('remove_edge'), id: z.string().min(1).max(300) }),
+  z.object({ op: z.literal('reflow'), tag: z.string().min(1).max(40), layout: z.enum(['column', 'row']).optional().describe('default column: restack the group in reading order with real sizes (use after set_text changes heights)') }),
+  z.object({ op: z.literal('follow'), group_tag: z.string().min(1).max(40).describe('the group that should follow (e.g. a status panel)'), target_tag: z.string().min(1).max(40).describe('whenever a new item with this tag lands, the group auto-moves beside it and the anchor line re-points'), side: z.enum(['right', 'left', 'above', 'below']).optional(), label: z.string().max(60).optional() }),
+  z.object({ op: z.literal('unfollow'), group_tag: z.string().min(1).max(40) }),
+  z.object({ op: z.literal('commit'), tag: z.string().max(40).optional().describe('make staging solid; omit tag = everything staging') }),
+  z.object({ op: z.literal('erase_group'), tag: z.string().min(1).max(40).describe('delete the whole tagged group (notes/shapes/lines; artifact cards only lose the tag)') }),
+  z.object({ op: z.literal('roll'), tag: z.string().min(1).max(40).describe('STOW a finished group: hides it behind a compact scroll card, everything kept in place (seats reserved, files intact, one click to unroll). For a scene/act/chapter that is DONE — use erase_group only to destroy'), label: z.string().max(60).optional().describe('scroll card title (default: the tag)') }),
+  z.object({ op: z.literal('unroll'), tag: z.string().min(1).max(40).describe('expand a rolled group back — everything returns to its original seat') }),
+  z.object({ op: z.literal('feature'), id: z.string().min(1).max(300).describe('make this the hero of the desktop') }),
+  z.object({ op: z.literal('unfeature') }),
+  z.object({ op: z.literal('transform_group'), tag: z.string().min(1).max(40), scale: z.number().min(0.3).max(3).optional(), rotate: z.number().min(-180).max(180).optional().describe('degrees clockwise') }),
+  z.object({ op: z.literal('replan'), sheet: z.string().max(40).optional().describe('which sheet (default: the current one)'), plan: z.array(SLOT).min(1).max(24).describe('slots to ADD or RESIZE on an existing sheet (merged by name; slots you do not mention stay). Same local-pixel coordinates as open_sheet{plan}') }),
+  z.object({ op: z.literal('chalk_edit'), on: z.boolean().describe('true = turn ON the user-side 改板书 toggle (notes become freely draggable/editable for the user); false = back to guarded mode') }),
+]);