@xiaobuyu/nodesign 0.0.6 → 0.0.8

package/server/engine/agent/hooks/pre-workspace-scope-guard.js

@@ -18,8 +18,11 @@
  *   - 自己出错就放行（fail-open）—— 闸崩了不该把整个会话堵死。
  */
 
+import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { CHALK_DIR } from '../../../lib/chalk.js';
+import { ROLE_SLUG_RE } from '../cast.js';
 
 const TARGET_FIELDS = ['file_path', 'path', 'notebook_path'];
 const WRITE_TOOLS = new Set(['Write', 'Edit', 'MultiEdit', 'NotebookEdit']);
@@ -46,6 +49,36 @@ export function checkWorkspaceScope(toolInput, { workspaceRoot, dataRoot, toolNa
     const v = toolInput?.[field];
     if (typeof v !== 'string' || !v) continue;
     const abs = path.resolve(ws, v);          // 相对路径按工作区解析
+    // ⛔ 角色文件是**判据本身**，不许模型手写（2026-08-26 fable 验收）。
+    //
+    // 派发闸靠读 `.claude/agents/<slug>.md` 的 tools 行决定放不放行，可那份文件
+    // 模型自己能改 —— 于是闸校验的和 CLI 真正使用的**不是同一份内容**：
+    //   ① TOCTOU：写宽版 → 结束回合（CLI 缓存了宽版）→ 覆写成窄版 → 同回合派发。
+    //      我们现读磁盘拿窄版放行，CLI 用回合开工的宽版快照 → 角色真拿到外发/花钱工具。
+    //   ② 解析器分歧：重复的 `tools:` 键，我们的正则取第一处、CLI 的 YAML 取最后一处。
+    // 两条都不是对主 agent 提权（它本来就有这些工具），但这条线的正常用法是**导入
+    // 酒馆卡/世界书**——外来文本能借主 agent 的手造出一个拿着外发工具的角色。
+    // 修法只能是「让判据不可被它改」：正门 cast_role 走服务端 fs（不过这道闸），
+    // 模型这侧一律拒。⚠️ Bash 不归这道闸管，那半靠沙盒（isolation.js）。
+    if (isWrite && insideDir(abs, path.join(ws, '.claude', 'agents'))) {
+      return '角色文件不能手写 —— 用 cast_role。'
+        + '那个目录里的文件同时是「这个角色能用哪些工具」的判据，'
+        + '手写等于自己给自己发权限，所以一律拒绝（改已有角色也走 cast_role）。';
+    }
+    // 接续权的文件面（2026-08-27 编排）：角色写的板书文件，主 agent 不许 Edit/Write。
+    // 板上那半（reply_to/chain）在 write-on-board 闸；这里堵的是「直接改文件正文」——
+    // 改别人的台词比接别人的话头更越界。作者看文件自己的 by: 章（harness 盖的，
+    // 角色没有 Write 工具伪造不了）。读不到/没有章 → 放行（fail-open，主 agent 自己的板书本来就能改）。
+    if (isWrite && insideDir(abs, path.join(ws, ...CHALK_DIR.split('/')))) {
+      try {
+        const m = fs.readFileSync(abs, 'utf8').slice(0, 400).match(/^by:\s*(\S+)/m);
+        // 判据统一走 ROLE_SLUG_RE（08-27 审计）：真角色名必过它
+        if (m && ROLE_SLUG_RE.test(m[1])) {
+          return `这份板书是角色「${m[1]}」写的，它的话不是你的稿子 —— 不改、不润色、不代笔。`
+            + '想让它改：把意见寄给它（SendMessage）或让用户直接跟它说。';
+        }
+      } catch { /* 新建/读不到 → 放行 */ }
+    }
     if (insideDir(abs, ws)) continue;         // 自己的工作区，放行
     if (isWrite) {
       if (tempDirs().some(d => insideDir(abs, d))) continue;   // 临时文件随便写

package/server/engine/agent/hooks/resident-role-lifecycle.js

@@ -0,0 +1,100 @@
+/**
+ * hooks/resident-role-lifecycle.js —— 常驻角色名册的退场那一侧（2026-08-26）
+ *
+ * 进场在 `pre-defaults.js`（PreToolUse 的 rp 分支 `roster.claim()`），退场在这里。
+ * 两边分开是因为事件族不同，不是因为职责不同 —— 改任何一边都要看另一边。
+ *
+ * ## 为什么必须有退场
+ *
+ * claim 发生在 **Agent 工具执行之前**（PreToolUse）。派发要是失败了（最现实的路径：
+ * 模型在角色的 `.claude/agents/<name>.md` 写出来之前就先派了这个还不存在的类型），
+ * 名字已经登记进名册，而进程里根本没有这个 agent。后果两条，都很迷惑：
+ *
+ *   1. **收件人闸的洞在这个窄窗口里重开**：闸看名册说「在场」→ 放行 → 而本会话没有
+ *      同名 in-process agent → CLI 的裸名解析回落到**全机范围** → 信可能落到别人的会话。
+ *      （这正是 H1 的病，名册修好了主干，这里是它的补角。）
+ *   2. **这个名字整个会话被 brick**：重派被硬 deny 且文案谎报「已经在场了」，
+ *      SendMessage 又叫不醒，模型只剩换名一条路。
+ *
+ * claim 留在 PreToolUse 不动（它挡住了同一回合并发派两次同名的竞态，这点比挪到
+ * PostToolUse 更值），失败时在这里补一次 release —— 进场乐观、退场兜底。
+ */
+
+import { isResidentRole, isSlotType } from '../cast.js';
+import { agentNameOf, noteAgentName, takePendingRoleName } from '../actor-trail.js';
+import { noteRoleStart, noteRoleFinish } from '../stage-status.js';
+
+/**
+ * SubagentStart：把这个 agent_id 认成刚派出去的那个角色（2026-08-29）。
+ *
+ * hook input 只有 `agent_id` + `agent_type`（演员位），没有实例名 —— 名字在派发闸
+ * 那一刻就知道了，所以闸把它排进队列（actor-trail.notePendingRoleName），这里取队头
+ * 配对。**这是署名的正门**：harness 在起飞那一刻亲手给的 id，不解析任何模型可写的文本。
+ *
+ * 只认演员位起飞：干活型子代理（vision-checker 那类）不进别名表。
+ */
+export function makeSubagentStartRoleAlias({ projectId = null } = {}) {
+  return async function subagentStartRoleAlias(input) {
+    if (!isSlotType(input?.agent_type) || !input?.agent_id) return {};
+    const known = agentNameOf(input.agent_id);        // 已经认过（唤醒重入）
+    const name = known || takePendingRoleName();
+    if (!name) return {};
+    if (!known) noteAgentName(input.agent_id, name);
+    noteRoleStart(projectId, name);                  // 台上一览：它开始写了
+    return {};
+  };
+}
+
+export function makePostToolUseFailureRoleRelease({ roster = null } = {}) {
+  return async (input) => {
+    if (!roster) return {};
+    // 演员位派发失败：登记的是实例名（tool_input.name），撤的也是它
+    const type = isSlotType(input?.tool_input?.subagent_type)
+      ? input?.tool_input?.name
+      : input?.tool_input?.subagent_type;
+    if (!isResidentRole(type)) return {};
+    if (!roster.release(type)) return {};
+
+    // 「还没拾取到」跟「角色不存在」是两回事，指引也不同。前者**必须原样重派**，
+    // 而模型不会自己这么做：2026-08-26 探针里它撞了 not found 之后既没重试，
+    // 还回了一句「已派」谎报成功 —— 所以这句话要说得比"你可以再派一次"硬。
+    const notFound = /not found/i.test(String(input?.error || ''));
+    return {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUseFailure',
+        // nd:rp-prompt
+        additionalContext: notFound
+          ? `「${type}」没派出来：CLI 还没拾取到它的角色文件（监视器有几秒防抖）。`
+          + `**原样再派一次**，别改参数、别跳过、更不要说"已派"—— 它现在还没上场。`
+          : `「${type}」没派出来，已经把这个名字从在场名册里撤了 —— 你可以再派一次。`
+          + `（如果是因为这个角色还不存在，先用 cast_role 把它的角色文件写出来。）`,
+      },
+    };
+  };
+}
+
+/**
+ * SubagentStop：角色收笔了，记一笔进台上一览（2026-08-26 建；08-29 改写）。
+ *
+ * 08-29 之前这里做两件事：标「散场」+ 用 systemMessage 教主控怎么召回。两件都随
+ * 常驻/散场概念一起退役 —— 新回路里角色本来就写一段结束一轮，「结束」是正常节拍
+ * 不是事故。而且 systemMessage 这条路 08-28 真会话里查无痕迹（SDK 的 SubagentStop
+ * 只有 additionalContext，且按类型定义那是**发给子代理**的），主持人真正收到的是
+ * SDK 自带的 task-notification。所以这里不再试图跟主持人说话，只记账 ——
+ * 状态由每回合状态块的「台上」一节统一注入（user-prompt-submit.js）。
+ *
+ * ⛔ **不 release 名字**：角色收笔 ≠ 不存在了。它的转录还在，SendMessage 叫得回来；
+ * 把名字放回去等于允许重派，而重派会新起一个失忆的同名角色顶掉它。
+ */
+export function makeSubagentStopRoleNotice({ projectId = null } = {}) {
+  return async (input) => {
+    // 角色位实例：agent_type 是位置（rp-role），实例名走别名表。别名没学到就跳过
+    // （不知道是谁收的笔 —— 别把 'rp-role' 当角色记进台上一览）。
+    const name = isSlotType(input?.agent_type)
+      ? agentNameOf(input?.agent_id)
+      : input?.agent_type;
+    if (!name || !isResidentRole(name) || isSlotType(name)) return {};
+    noteRoleFinish(projectId, name, input?.last_assistant_message || null);
+    return {};
+  };
+}

package/server/engine/agent/hooks/slot-alias.js

@@ -0,0 +1,30 @@
+/**
+ * hooks/slot-alias.js —— 唤醒时重新认一遍角色的 agent_id（2026-08-28 建；08-29 收窄）
+ *
+ * 派发那条路 08-29 搬去 `SubagentStart`（harness 亲手给 id，不解析文本，见
+ * resident-role-lifecycle.js 的 makeSubagentStartRoleAlias）。这里只剩**唤醒**一条：
+ * `SendMessage({to:"rp-x"})` 的结果 JSON 带 `resumedAgentId`，服务器重启后别名表
+ * 清零、而角色还活着时，靠这一条重新学回来。
+ *
+ * 匹配用正则怼序列化文本而不是解构对象：tool_response 的形状（数组/对象/字符串）
+ * 随 SDK 版本漂，id 的形状（十六进制串）比包装稳定得多。
+ */
+
+import { isSlotType, ROLE_SLUG_RE } from '../cast.js';
+import { noteAgentName } from '../actor-trail.js';
+
+// 引号写成 \\?"：结果 JSON 常作为字符串再被包一层（stringify 转义成 \"），两层都认
+const RESUMED_RE = /\\?"resumedAgentId\\?"\s*:\s*\\?"([0-9a-f]{8,32})\\?"/;
+
+export function makePostToolUseSlotAliasHandler() {
+  return async function slotAlias(input) {
+    const t = input?.tool_input;
+    if (!t || typeof t !== 'object') return {};
+    // 按名寄信的恢复结果 → 重新学（覆盖重启后别名表清零的窗口）
+    if (typeof t.to === 'string' && ROLE_SLUG_RE.test(t.to) && !isSlotType(t.to)) {
+      const m = RESUMED_RE.exec(JSON.stringify(input?.tool_response ?? ''));
+      if (m) noteAgentName(m[1], t.to);
+    }
+    return {};
+  };
+}

package/server/engine/agent/hooks/user-prompt-submit.js

@@ -1,7 +1,7 @@
 /**
  * UserPromptSubmit handler — 每次用户输入前注入工作区**状态**（2026-08-21 重做）
  *
- * 注的是状态不是指令：cwd、素材清单、旧决策、便利贴、画布关系线、产物清单、tweaks 开关。
+ * 注的是状态不是指令：cwd、素材清单、便利贴、画布关系线、产物清单。
  * 怎么用这些东西（路径表、"先看有没有现成的素材"、工具怎么选）住 prelude，那是缓存的
  * system prompt；每轮再说一遍是上下文里的 N 倍重复。
  *
@@ -23,11 +23,21 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { readUiConfigFile } from '../../../projects/ui-config.js';
+import { readUiConfigFile, withUiDefaults } from '../../../projects/ui-config.js';
 import { readAssetsSummary } from '../../../projects/assets-summary.js';
 import { relationsDigest } from '../../../lib/board-relations.js';
 import { getViewpoint, describeViewpoint } from '../../../projects/viewpoint-store.js';
+import { sheetSummaries, latestSheetId, currentSheet, sheetOfPoint } from '../../../lib/board-sheets.js';
+import { currentSheetIdOf } from '../../../lib/sheet-state.js';
+import { dirtyEvents, describeDirty, splitDirtyByCharge } from '../../../lib/board-dirty.js';
+import { fitFor } from '../../../lib/sketch-layout.js';
+import { readStateVars } from '../../../lib/state-table.js';
+import { parseTriggers, evalTriggers, readLatch, writeLatch } from '../../../lib/state-triggers.js';
 import { recentChalk, CHALK_DIR } from '../../../lib/chalk.js';
+import { listRoleNames } from '../role-card.js';
+import { stageStatus } from '../stage-status.js';
+import { resetBeat } from '../beat-state.js';
+import { roleLabel } from '../../mcp/actor.js';
 import { readBoard } from '../../../projects/board-store.js';
 import { estimateSizeOn } from '../../../lib/board-kind-sizes.js';
 import { layerOf } from '../../../lib/canvas-id.js';
@@ -37,11 +47,6 @@ import {
 } from '../../../lib/artifact-target.js';
 import { getTurnMemory, setTurnMemory, fingerprint, diffItems } from './turn-state-memory.js';
 
-/** UserPromptSubmit hook 读取 spec.json 时的最大字节数 */
-const SPEC_JSON_MAX_BYTES = 200 * 1024;
-/** spec.json.decisions 注入摘要时取最近 N 条 */
-const SPEC_DECISIONS_TAIL = 5;
-
 /** PDF/Office 文档的解法（系统自带工具；python 包没装且装不上 —— 08-19 上报实锤）。只在首次出现二进制文档时说一遍。 */
 const BINARY_DOC_HINT = 'PDF / PPTX / DOCX / XLSX 直接 Read 拿不到结构化内容（二进制或 zip 包）。用系统自带的工具解'
   + '（pdfplumber/PyPDF2/python-docx/openpyxl 这些 python 包**没装且装不上**，别试）：'
@@ -72,25 +77,7 @@ async function collectSections({ workspaceRoot, sessionId, projectId }) {
     }
   } catch { /* 素材读不到就沉默 */ }
 
-  // spec.json 遗产决策：取最近 N 条
-  try {
-    const specPath = path.join(workspaceRoot, 'spec.json');
-    const stat = await fs.stat(specPath);
-    if (stat.size <= SPEC_JSON_MAX_BYTES) {
-      const spec = JSON.parse(await fs.readFile(specPath, 'utf8'));
-      const decisions = Array.isArray(spec?.decisions) ? spec.decisions : [];
-      if (decisions.length > 0) {
-        const recent = decisions.slice(-SPEC_DECISIONS_TAIL);
-        const lines = recent.map((d, i) => {
-          const idx = decisions.length - recent.length + i + 1;
-          const title = (d?.title || '(无标题)').slice(0, 80);
-          const rationale = (d?.rationale || '').slice(0, 200);
-          return `  ${idx}. ${title}${rationale ? ` — ${rationale}` : ''}`;
-        }).join('\n');
-        sections.push({ key: 'decisions', title: '旧决策档案', text: `旧决策档案（spec.json 遗产，共 ${decisions.length} 条，最近 ${recent.length} 条；新决策一律走 record_decision → 任务便利贴）：\n${lines}` });
-      }
-    }
-  } catch { /* spec.json 不存在 / 解析失败：noop */ }
+  // （spec.json 决策档案注入 2026-08-24 拆除：决策体系退役，长期事实走 CLAUDE.md/记忆）
 
   // 便利贴：metadata-not-content，只列文件和首行标题
   try {
@@ -128,13 +115,99 @@ async function collectSections({ workspaceRoot, sessionId, projectId }) {
         w: vp.camera.w, h: vp.camera.h,
       } } : vp;
       const line = describeViewpoint(q, rects);
-      if (line) sections.push({ key: 'viewpoint', title: '用户视点', text: `用户此刻在画布上：${line}。他说「这个/这里/这张」多半指选中的 > 开着的窗 > 视口里的东西；要细节调 read_user_view。` });
+      // 纸（2026-08-29 纸范式）：报当前有哪些纸、剩多少地 —— 空位建议/走向学习
+      // 那套启发式随落位引擎一起退役，agent 的空间账本现在是纸的清单。
+      let spot = null;
+      // 暂存架（2026-08-30）：机器到货的默认座。点名 + 三个安置动词，agent 不动它们就一直在
+      const shelfSeats = Object.entries(board.objects || {})
+        .filter(([, e]) => e?.seat === 'shelf' && !e.zone && Number.isFinite(e?.x))
+        .map(([id]) => id);
+      const pendingSeats = Array.isArray(board.pending) ? board.pending : [];
+      try {
+        const ss = sheetSummaries(board);
+        // 「最新」按登记时间取（latestSheetId 一份算法）—— 不是数组末项那张最下面的
+        const latest = latestSheetId(board);
+        const cur = ss.find(s => s.id === latest) || ss[ss.length - 1];
+        if (cur) {
+          // 报「还能装下什么」不是裸数字（2026-08-30 容量线）：行数是模型真正用来
+          // 决策的量纲 —— 顺手教它超过余量别赌一发，flow 会替它拆
+          const slots = cur.slots?.length
+            ? `；版位 ${cur.slots.map(s => `${s.name} 剩 ~${s.freeLines} 行`).join('、')}`
+            : '；这张没规划版位';
+          spot = `板上 ${ss.length} 张纸；当前 ${cur.id}${cur.title ? `（${cur.title}）` : ''} 还剩 ~${cur.freeH}px 高的空地${slots}`
+            + '（内容眼看要超余量就别赌一发 —— 自己多切几个空位分段填（plan/replan 省掉 at 即竖排接放），'
+            + '或兜底 flow:true；写满**不会**自动翻页，自己 open_sheet 规划下一页；新话题也是 open_sheet）';
+        } else {
+          spot = '板上还没铺过纸 —— 第一笔 write_on_board 会自动铺一张在他视口下，或先 open_sheet';
+        }
+        const unplaced = [...shelfSeats, ...pendingSeats];
+        if (unplaced.length) {
+          spot += `；📦 ${unplaced.length} 件在暂存架等你安置（${unplaced.slice(0, 3).map(r => r.split('/').pop()).join('、')}${unplaced.length > 3 ? '…' : ''}）`
+            + ' —— 给它们规划的地：open_sheet{plan:[…{for:"artifacts"}]} 或逐件 pin_to_board{path,slot} / edit_board move。'
+            + '架不是版面，东西留在架上就是没摆';
+        }
+      } catch { /* 纸读不出就不占字 */ }
+      const dirs = null;
+      /**
+       * 手机 / 平板档的版式（2026-08-28 移动端第二轮，用户拍板「一件 = 一屏，纵向单列」）。
+       *
+       * ⚠️ 这段是**事前**说的，不是靠 write_on_board 的返回文案事后纠正 —— 一块
+       * 1700 宽的板书在 390 的屏上已经写出来了，再告诉它"下次窄一点"没有意义，
+       * 用户这一轮拿到的就是要横着滑四屏的东西。
+       *
+       * ⭐ 同时几何那边也在执行（resolvePlacement 的 column：左右侧一律降级成正下方）。
+       * 两处都做不是重复：提示词管"它主动写多宽"，几何管"它没照做时版面还读得了"。
+       */
+      const fit = fitFor(vp);
+      const laneLine = fit.column
+        ? `⚠️ 他在${fit.lane === 'phone' ? '手机' : '平板'}上（屏幕 ${fit.screen?.w}x${fit.screen?.h}px）。`
+          + `版面规矩：**一件 = 一屏，纵向单列**。每件宽度 ≤${fit.w}（超了就要横向滑动，手机上没人受得了），`
+          + `高度到 ${fit.h} 都行（竖着滚是手机上读长内容的天然姿势）。`
+          + `接着写就往**正下方**接，别用 side:'right'/'left' 并排 —— 并排的第二件在他屏幕外。`
+          + `宁可多拆几件竖着排，也别把一件写宽。`
+        : '';
+      if (line) sections.push({ key: 'viewpoint', title: '用户视点', text: `用户此刻在画布上：${line}。${spot ? `${spot}。` : ''}${dirs ? `${dirs}。` : ''}${laneLine}他说「这个/这里/这张」多半指选中的 > 开着的窗 > 视口里的东西；写板走纸（at = 纸内坐标）。要看画面细节才调 read_user_view。` });
     }
   } catch { /* 视点读不到就沉默 */ }
+  // 板上动静（2026-08-29 纸范式刀 4）：用户拖动/搬家/擦组此前完全静默，agent 只能
+  // 撞运气。这里报最近半小时的动静（指纹只在有新动静时变，未变随「未变」行收拢）；
+  // 回合中途的动静另有 PreToolUse 注入器在 agent 摸板前插话。
+  try {
+    const evts = dirtyEvents(projectId, 0);
+    if (evts.length) {
+      const line = describeDirty(evts, { limit: 6 });
+      // 有限负责制（刀⑤ 2026-08-30）：动静按纸分拣 —— 挪进你当前纸的要接手处理，
+      // 挪去别处的是用户自留地，只报不催（板整个是用户随便动，别拔河）。
+      let charge = '';
+      try {
+        const b = await readBoard(projectId);
+        const curId = currentSheet(b, currentSheetIdOf(sessionId))?.id || null;
+        const sheetOf = (id) => {
+          const e = b.objects?.[id];
+          if (!e || !Number.isFinite(e.x)) return null;
+          const sz = estimateSizeOn(b, id, e);
+          return sheetOfPoint(b, { x: e.x + sz.w / 2, y: e.y + sz.h / 2 })?.id || null;
+        };
+        const { inMine, elsewhere } = splitDirtyByCharge(evts, { sheetOf, currentSheetId: curId });
+        if (inMine.length) {
+          charge = `\n⚠️ 其中 ${inMine.slice(0, 4).join('、')}${inMine.length > 4 ? ` 等 ${inMine.length} 件` : ''} 现在落在**你正在写的纸（${curId}）**上：`
+            + '这块工作区的版面归你管 —— 若它挡了你的版位/内容，用 edit_board 给它挪个合适的位置（挪要挪得讲理，别甩出用户视野）；用户明说过要放那儿的除外。';
+        }
+        if (elsewhere.length && inMine.length) {
+          charge += `\n其余 ${elsewhere.length} 件在你的纸外 —— 那是用户自留地，不要去动。`;
+        } else if (elsewhere.length) {
+          charge = '\n这些都在你当前的纸外 —— 用户自留地，看在眼里就好，不要去动。';
+        }
+      } catch { /* 分拣失败就退回不分拣的报法 */ }
+      sections.push({ key: 'boardDirty', title: '板上动静', text:
+        `用户最近亲手动过板面：${line}。这些位置以现状为准 —— 摆放前先 read_board，别按你记忆里的旧位置来。${charge}` });
+    }
+  } catch { /* 动静读不到就沉默 */ }
+
   try {
     const digest = await relationsDigest(projectId, { limit: 12 });
     if (digest) {
-      sections.push({ key: 'relations', title: '画布关系线', text: `画布关系线（用户和你手动画的连线，端点跟着改名走；语义看线上的词）：\n${digest}\n  产出新东西后记得用 relate_on_board 把「改自/对照/接着/取材」画上去。` });
+      sections.push({ key: 'relations', title: '画布关系线', text: `画布关系线（用户和你手动画的连线，端点跟着改名走；语义看线上的词）：\n${digest}\n  产出新东西后记得用 edit_board add_edge 把「改自/对照/接着/取材」画上去。` });
     }
   } catch { /* 板读不到就沉默 */ }
 
@@ -160,35 +233,121 @@ async function collectSections({ workspaceRoot, sessionId, projectId }) {
     }
   } catch { /* 扫不动就不说 */ }
 
-  // tweaks 开关：文件不存在 = 用户没碰过 = 沉默
-  // 最近板书（2026-08-23）：你/用户在画布上说过的最近几句 —— 对话在板上，得记得板上说了什么
+  // 最近板书（2026-08-23；08-24 记忆改版时被误删，同日修回）：你/用户在画布上
+  // 说过的最近几句 —— 对话在板上，得记得板上说了什么
   try {
-    const recent = await recentChalk(workspaceRoot, { limit: 8 });
+    const all = await recentChalk(workspaceRoot, { limit: 24 });
+    const roleNames = await listRoleNames(workspaceRoot);
+    // 前 8 条 + 保底：每个角色最新那条就算被 GM 自己的章节/状态板挤出前 8 也要在 ——
+    // GM 需要知道台上角色说了什么（08-28 用户拍板），漏了它就会旁白转述/代笔补戏。
+    const recent = all.slice(0, 8);
+    const seenRole = new Set(recent.map(c => c.by));
+    for (const c of all.slice(8)) {
+      if (c.by && c.by !== 'agent' && c.by !== 'user' && !seenRole.has(c.by)) {
+        recent.push(c); seenRole.add(c.by);
+      }
+    }
     if (recent.length) {
-      const lines = recent.map(c => `  ${c.path}（${c.by === 'user' ? '用户' : '你'}${c.anchor ? `，关于 ${c.anchor}` : ''}${c.replyTo ? `，回应 ${c.replyTo.replace(`${CHALK_DIR}/`, '')}` : ''}）「${c.first}」`);
+      // 这段是注给**主 agent** 的，所以「你」= 主 agent；角色写的板书报它的名字，
+      // 否则主 agent 会把角色写的东西当成自己写的（RP 线里那是大部分板书）。
+      const lines = recent.map(c => `  ${c.path}（${c.by === 'user' ? '用户' : c.by && c.by !== 'agent' ? roleLabel(c.by, roleNames.get(c.by)) : '你'}${c.anchor ? `，关于 ${c.anchor}` : ''}${c.replyTo ? `，回应 ${c.replyTo.replace(`${CHALK_DIR}/`, '')}` : ''}）「${c.first}」`);
       sections.push({ key: 'chalk', title: '最近板书', text: `画布上最近的板书（${CHALK_DIR}/，新在前；正文 Read 文件）：\n${lines.join('\n')}`, items: recent.map(c => c.path) });
     }
   } catch { /* 板书读不到就沉默 */ }
-  // 黑板模式（2026-08-23）：用户在画布上专注思考时开。这一节只在开着时注入，关着不提。
+
+  // 状态表（2026-08-30）：板上那张 `| 键 | 值 |` 的现值，每轮开头端到手边 ——
+  // 演出里"会变、要记得"的东西（好感度/时间/线索）不该靠模型自己在上下文里背。
+  //
+  // ⚠️ 这一节**不给 items**，走整节 hash 比对（renderTurnState 的默认分支）。
+  // 给了 items 会被 diffItems 渲染成「新增 好感度=4；移除 好感度=3」—— 信息对、
+  // 话是错的（那个渲染器被 9 个节共用，为一张小表去改它不值）。而且对读者来说，
+  // 变了的时候看到**整表现值**比看到增量有用：它按现值行事，不按 delta 行事。
+  //
+  // ⛔ 「解析不出来」必须出声。collectSections 的房规是"采不到就不出现"，对普通节
+  // 是对的，对这一节就是坑：表被 set_text / 用户手改写坏之后会静默消失，而写口闸
+  // 只守得住 set_vars 那一路（另外两路是合法的写入方）。所以 broken 一律推一节。
   try {
-    const cfg = await readUiConfigFile(workspaceRoot);
-    if (cfg?.blackboard_mode === true) {
+    const st = await readStateVars(workspaceRoot);
+    if (st.state === 'ok' && st.rows.length) {
+      const table = st.rows.map(r => `  ${r.key} = ${r.value}`).join('\n');
+      const parts = [];
+
+      // 条件触发器（2026-08-30）：求值点 = 注入点。只在这里求一次，命中就写进
+      // 这一轮的状态块 —— 不在 set_vars 里求值攒到下一轮，那样中间一次进程重启
+      // 就静默吞掉一次触发。沿状态落 .nd/（派生记账，丢了只是"上膛不击发"）。
+      let trig = null;
+      try {
+        const parsed = parseTriggers(st.body || '');
+        if (parsed.triggers.length || parsed.errors.length) {
+          const { latch, fresh } = await readLatch(workspaceRoot);
+          trig = evalTriggers(parsed.triggers, st.rows, latch, { fresh });
+          try { await writeLatch(workspaceRoot, trig.latch); } catch (e) {
+            console.warn('[vars] 沿状态写不进去，下一轮可能重复触发：', e.message);
+          }
+          if (trig.fired.length) {
+            parts.push(`⚡ 这一拍有 ${trig.fired.length} 个条件命中了（你之前挂的）：\n`
+              + trig.fired.map(f => `  · ${f.message}\n    （条件：${f.raw}）`).join('\n'));
+          }
+          const roster = [];
+          if (trig.armed) roster.push(`${trig.armed} 条挂着`);
+          if (trig.retired) roster.push(`${trig.retired} 条已退休`);
+          if (roster.length) parts.push(`  触发器：${roster.join('、')}（声明在 ${st.rel} 的 \`\`\`nd:triggers 围栏里，删一行就是撤一条）`);
+          for (const e of [...parsed.errors, ...trig.errors]) {
+            parts.push(`  ⚠️ 触发器写错了，这条一直不会响：${e}`);
+          }
+        }
+      } catch (e) { console.warn('[vars] 触发器求值失败：', e.message); }
+
+      parts.push(`状态表现值（${st.rel}，共 ${st.rows.length} 格）：\n${table}\n`
+        + `  改数字用 set_vars（只动那一格）；改表的结构/加说明文字才用 edit_board 的 set_text。`);
+      sections.push({ key: 'vars', title: '状态表', text: parts.join('\n') });
+    } else if (st.state === 'broken') {
+      sections.push({
+        key: 'vars',
+        title: '状态表',
+        text: `⚠️ 状态表读不出来了：${st.why}\n`
+          + `  在修好之前 set_vars 会一直拒绝（它不会"尽力写"，那只会把表写得更坏）。`
+          + `${st.rel ? ` Read 一下 ${st.rel} 看看表被改成什么样了。` : ''}`,
+      });
+    }
+  } catch { /* 状态表这一节自己不能变成故障源 */ }
+
+  // 台上（2026-08-29）：角色现在的状态。判据全是 harness 盖的章（SubagentStart/Stop，
+  // 见 stage-status.js）—— 此前主持人对这件事是半盲的：只在角色**结束**时收到一条
+  // 通知，中间既不知道谁在写，也不知道谁写完在等它接。08-28 真会话里用户替它问出了
+  // 这个洞（「说书人是不是要重启一下？」），而主持人手上没有任何工具能回答。
+  try {
+    const st = stageStatus(projectId);
+    if (st.length) {
+      const names = await listRoleNames(workspaceRoot);
+      const mins = (ms) => Math.round(ms / 60000);
+      const lines = st.map((r) => {
+        const who = roleLabel(r.slug, names.get(r.slug));
+        if (r.writing) return `  ${who}（${r.slug}）正在写`;
+        const idle = r.idleMs > 90000 ? `，${mins(r.idleMs)} 分钟没动了` : '';
+        return `  ${who}（${r.slug}）写完了这一段${idle}${r.lastLine ? `，收笔时说：「${r.lastLine}」` : ''}`;
+      });
+      sections.push({ key: 'stage', title: '台上', text:
+        `这场故事里的角色：\n${lines.join('\n')}\n`
+        + `写完的角色这一轮已经结束了 —— 要它接着演，SendMessage 寄给它的名字（当场醒，记得之前所有事）；`
+        + `不用重新派（重派会新起一个失忆的同名角色顶掉它）。` });
+    }
+  } catch { /* 台上读不到就沉默 */ }
+
+  // 黑板模式（2026-08-23；08-24 起默认开 —— 没写过这个键的按开算，显式 false 才算关）
+  try {
+    const cfg = withUiDefaults(await readUiConfigFile(workspaceRoot));
+    if (cfg.blackboard_mode === true) {
       sections.push({ key: 'blackboard', title: '黑板模式', text:
-        '【黑板模式：开】用户此刻在画布上专注思考。这一轮默认这么做：想事情就画成图（sketch_on_board，'
-        + '小改动用 edit_sketch 原地改别重画）；做完一件东西在它旁边写一条板书（write_on_board near=）；'
+        '【黑板模式：开】用户此刻在画布上专注思考。这一轮默认这么做：先有纸再动笔（新话题 open_sheet）；'
+        + '想事情就画成图（write_on_board 给 nodes/edges，小改动用 edit_board 原地改别重画）；'
+        + '做完一件东西在它旁边写一条板书（near= 连线说明它说的是谁）；'
         + '用户标注了板上的东西就接在那条下面回（reply_to=）。侧栏照常回复，但板上已经写的别大段重复。'
-        + '尺寸守规范（0.8 倍一屏可读、正文 md 起、一条板书说一件事）；画完 look_at_board 看一眼再收。' });
+        + '尺寸守规范（一张纸 = 一屏、正文 md 起、一条板书说一件事）；画完 look_at_board 看一眼再收。' });
     }
   } catch { /* 读失败：不注入 */ }
-  try {
-    const cfg = await readUiConfigFile(workspaceRoot);
-    if (cfg) {
-      const on = cfg?.tweaks_mode_enabled !== false;
-      sections.push({ key: 'tweaks', title: 'Tweaks 开关', text: on
-        ? '【Tweaks 模式：启用】用户偏好"可调产品"——deck 形态稳定后，建议调 expose_tweaks 暴露核心微调参数（颜色 / 字号 / 排版密度等）让用户拖滑杆即时改样式。'
-        : '【Tweaks 模式：禁用】用户在 toolbar 关闭了 Tweaks——这次跳过 expose_tweaks，按对话方式让用户提需求你来 Edit。已暴露的 controls 保留不动，不新增 / 不重 expose。' });
-    }
-  } catch { /* 读失败：默认行为，不注入 */ }
+
+  // （tweaks 开关注入 2026-08-24 随 expose_tweaks 暂退役一起摘除；工具升级后再回来）
 
   return sections;
 }
@@ -241,6 +400,8 @@ export function renderTurnState(sections, prev) {
 
 export function makeUserPromptSubmitHandler({ ctx: _ctx, workspaceRoot, sessionId, projectId }) {
   return async (_input, _toolUseId, _options) => {
+    // 新的一轮：收尾闸重新记账（判的是「这一轮」，见 beat-state.js）
+    resetBeat(sessionId);
     try {
       if (!workspaceRoot) return {};
       const sections = await collectSections({ workspaceRoot, sessionId, projectId });