@xiaobuyu/nodesign 0.0.1

package/server/engine/chatai/openai-compat.js

@@ -0,0 +1,152 @@
+/**
+ * openai-compat.js —— OpenAI 兼容协议的模型通路
+ *
+ * 一次补全调用，没别的。传 system + messages，回来文本和用量。
+ * 谁来拼 messages、拼什么，不是这一层的事。
+ *
+ * ⚠️ 实测（2026-08-14，中转站 + gemini-3.7-flash-low）：
+ *   - **思考 token 关不掉**。一次普通生成正文 240、思考 903，接近四倍。
+ *     reasoningTokens 必须单列，否则看着正文纳闷账单为什么是三倍。
+ *   - **这条路上没有任何 cache 字段**。同一请求重打两次，prompt_tokens 一模一样
+ *     （3748 → 3748），但延迟从 10.0s 掉到 1.8s —— 上游隐式缓存在起作用，但计费
+ *     口径上不可见也不可控。所以 cacheReadTokens 在 Gemini 路上恒为 0，别拿它算账。
+ *   - 流式分片很粗（一句话四片），因为中转站是把上游收完再重组的。别指望逐字流。
+ */
+
+const DEFAULT_TIMEOUT_MS = 180_000;
+
+/**
+ * 「[done]」收尾标记（2026-08-15 实测）：中转站「流式抗截断」系列在**流式**下会
+ * 往正文末尾追加 `\n\n[done]` —— claude 那几个变体每次都带，gemini 不带，非流式
+ * 不带。那是抗截断协议的收尾信号，中转站自己没摘。不管它就会当台词演给用户看、
+ * 还写进 对话.jsonl。而且它是**跨分片来的**（实测尾三片 `"。\n\n["` + `"done]"`），
+ * 逐片过滤拦不住，只能压着尾巴发。
+ */
+const SENTINEL_RE = /\s*\[done\]\s*$/;
+const HOLD = 12;   // 压住末尾这么多字符不发；中转站分片本来就粗（一句话四片），看不出延迟
+
+export function stripSentinel(text) {
+  return String(text ?? '').replace(SENTINEL_RE, '');
+}
+
+/** 流式尾巴过滤：压住末尾不发，收尾时剥掉标记再把剩下的补出去 */
+export function makeTailFilter(onDelta) {
+  let text = '';
+  let emitted = 0;
+  return {
+    push(piece) {
+      text += piece;
+      const upTo = Math.max(emitted, text.length - HOLD);
+      if (upTo > emitted) { onDelta(text.slice(emitted, upTo)); emitted = upTo; }
+    },
+    /** @returns {string} 剥干净的全文 */
+    end() {
+      const clean = stripSentinel(text);
+      if (clean.length > emitted) onDelta(clean.slice(emitted));
+      return clean;
+    },
+  };
+}
+
+function normalizeUsage(u = {}) {
+  const details = u.completion_tokens_details || {};
+  return {
+    inputTokens: u.prompt_tokens ?? u.input_tokens ?? 0,
+    outputTokens: u.completion_tokens ?? u.output_tokens ?? 0,
+    reasoningTokens: details.reasoning_tokens ?? u.reasoning_tokens ?? 0,
+    cacheReadTokens:
+      u.prompt_tokens_details?.cached_tokens ?? u.cache_read_input_tokens ?? 0,
+    raw: u,
+  };
+}
+
+/**
+ * @param {object} opts
+ *   base/key/model      通路配置
+ *   system              系统提示（字符串，可空）
+ *   messages            [{role, content}]，至少一条
+ *   maxTokens/signal    常规
+ *   onDelta             给了就走流式
+ */
+export async function callOpenAICompat({
+  base, key, model, system = '', messages = [], maxTokens = 2000, signal, onDelta,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+} = {}) {
+  const stream = typeof onDelta === 'function';
+  const body = {
+    model,
+    messages: [
+      ...(system ? [{ role: 'system', content: system }] : []),
+      ...messages,
+    ],
+    max_tokens: maxTokens,
+    stream,
+  };
+
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(new Error('chatai 超时')), timeoutMs);
+  if (signal) signal.addEventListener('abort', () => ctrl.abort(signal.reason), { once: true });
+
+  let res;
+  try {
+    res = await fetch(`${base}/v1/chat/completions`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${key}` },
+      body: JSON.stringify(body),
+      signal: ctrl.signal,
+    });
+  } catch (err) {
+    clearTimeout(timer);
+    throw Object.assign(new Error(`chatai 请求失败：${err.message}`), { code: 'CHATAI_NETWORK' });
+  }
+
+  if (!res.ok) {
+    clearTimeout(timer);
+    const text = await res.text().catch(() => '');
+    throw Object.assign(
+      new Error(`chatai 上游 ${res.status}：${text.slice(0, 400)}`),
+      { code: 'CHATAI_UPSTREAM', status: res.status },
+    );
+  }
+
+  if (!stream) {
+    clearTimeout(timer);
+    const j = await res.json();
+    return {
+      text: stripSentinel(j.choices?.[0]?.message?.content ?? ''),
+      usage: normalizeUsage(j.usage),
+      finish: j.choices?.[0]?.finish_reason ?? null,
+    };
+  }
+
+  const tail = makeTailFilter(onDelta);
+  let text = '';
+  let usage = {};
+  let finish = null;
+  let buf = '';
+  try {
+    for await (const chunk of res.body) {
+      buf += Buffer.from(chunk).toString('utf8');
+      const lines = buf.split('\n');
+      buf = lines.pop() ?? '';
+      for (const line of lines) {
+        const s = line.trim();
+        if (!s.startsWith('data:')) continue;
+        const payload = s.slice(5).trim();
+        if (payload === '[DONE]') continue;
+        let j;
+        try { j = JSON.parse(payload); } catch { continue; }
+        const d = j.choices?.[0];
+        const piece = d?.delta?.content;
+        if (piece) tail.push(piece);       // 思考走 delta.reasoning_content，本来就不进正文
+        if (d?.finish_reason) finish = d.finish_reason;
+        if (j.usage) usage = j.usage;      // 中转站每片都带 usage，最后一片为准
+      }
+    }
+  } finally {
+    clearTimeout(timer);
+    text = tail.end();
+  }
+
+  return { text, usage: normalizeUsage(usage), finish };
+}

package/server/engine/chatai/orchestrate.js

@@ -0,0 +1,309 @@
+/**
+ * orchestrate.js —— 编排编译：把演出文件夹里的 `编排.yaml` 变成一次 chatai
+ * 调用的 system + messages。
+ *
+ * 三区模型（2026-08-15 定案，来路：酒馆的播放单心智 + NovelAI 的三位置 +
+ * Anthropic 的排序纪律）：
+ *
+ *   系统层  → system 参数。身份/世界观/规则/文风，整区冻结，是缓存的本体。
+ *   历史    → 对话.jsonl。弹性区：被「上下文预算」从最旧挤压，被摘要折叠。
+ *   尾部    → 拼进当轮 user 消息前部。唯一允许每轮变化的区。
+ *
+ * ⭐ 触发条目只许住尾部——这是结构性的缓存保护，不是纪律约束。酒馆把触发
+ * 词条插在前缀中段，573 条词库实测缓存命中率 0%、一轮一美元；把易变的东西
+ * 全部关进「最新对话之后」的位置，前缀想不稳定都难。
+ *
+ * 机制层不认识「角色卡 / 世界书 / 文风锚」——那些是 skill 教 agent 的类型学。
+ * 这里只有条目（名字 / 文件或内容 / 触发 / 停用）和区归属。
+ *
+ * 「每轮允许多大范围变化」的旋钮 = 条目的区归属：放系统层是冻住换缓存，
+ * 挪尾部是放开换灵活。设置页把它画成拖过一条线。
+ */
+
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import YAML from 'yaml';
+import { readLog, readSummary } from './chat-log.js';
+import { LEVELS } from './index.js';
+
+export const CONFIG_FILE = '编排.yaml';
+
+/** 触发词的扫描窗口：最近 8 条记录（≈4 轮）+ 当轮输入。写死不做旋钮。 */
+const TRIGGER_SCAN_RECORDS = 8;
+
+const DEFAULTS = Object.freeze({
+  最大输出: 2000,
+  上下文预算: 60000,
+  历史: Object.freeze({ 文件: '对话.jsonl', 保留轮数: 40 }),
+  摘要: Object.freeze({ 启用: true, 保留轮数: 12, 触发轮数: 24, 长度: 500 }),
+});
+
+function fail(msg) {
+  throw Object.assign(new Error(msg), { code: 'ORCH_INVALID' });
+}
+
+/**
+ * token 估算（下限口径）：CJK 按 1 字 1 token，其余按 4 字符 1 token。
+ * 不含聊天模板开销，只用于预算挤压和设置页展示，不用于计费。
+ */
+export function estTokens(text) {
+  const s = String(text || '');
+  const cjk = (s.match(/[⺀-鿿豈-﫿＀-￯]/g) || []).length;
+  return cjk + Math.ceil((s.length - cjk) / 4);
+}
+
+/** 文件引用只许指向文件夹内部（配置是用户/agent 写的，但端点跑在服务端） */
+export function resolveInside(dir, rel, ctx) {
+  const abs = path.resolve(dir, String(rel));
+  if (abs !== path.resolve(dir) && !abs.startsWith(path.resolve(dir) + path.sep)) {
+    fail(`${ctx}：文件引用「${rel}」跑出了演出文件夹`);
+  }
+  return abs;
+}
+
+function normalizeEntry(raw, zone, i) {
+  if (!raw || typeof raw !== 'object') fail(`${zone}第 ${i + 1} 条不是对象`);
+  const 名字 = String(raw.名字 || `${zone}${i + 1}`);
+  const hasFile = raw.文件 != null;
+  const hasText = raw.内容 != null;
+  if (hasFile && hasText) fail(`${zone}「${名字}」同时给了 文件 和 内容，只能二选一`);
+  if (!hasFile && !hasText) fail(`${zone}「${名字}」既没有 文件 也没有 内容`);
+  let 触发 = null;
+  if (raw.触发 != null) {
+    if (zone === '系统层') {
+      fail(`系统层「${名字}」带了触发——触发条目只能住尾部（缓存稳定性的结构保证），要么去掉触发，要么整条挪到尾部`);
+    }
+    if (!Array.isArray(raw.触发) || !raw.触发.length || raw.触发.some(k => typeof k !== 'string' || !k.trim())) {
+      fail(`尾部「${名字}」的触发要是非空字符串数组`);
+    }
+    触发 = raw.触发.map(k => k.trim());
+  }
+  return {
+    名字, 触发,
+    文件: hasFile ? String(raw.文件) : null,
+    内容: hasText ? String(raw.内容) : null,
+    停用: raw.停用 === true,
+  };
+}
+
+/**
+ * 思考档：只认词表里的四个词，空=按模型默认档（每个模型的默认档都是最省的那档）。
+ * 「这个模型有没有这一档」不在这儿判——那是通路层的事（resolveModelVariant 会
+ * 降级并报出来），配置层拦词不拦搭配，免得换渠道时老配置全被拒开。
+ */
+function levelField(v, name) {
+  if (v == null || v === '') return null;
+  const s = String(v).trim();
+  if (!LEVELS.includes(s)) fail(`${name} 只能是 ${LEVELS.join(' / ')} 之一，拿到的是 ${JSON.stringify(v)}`);
+  return s;
+}
+
+function intField(v, def, name, { min = 1 } = {}) {
+  if (v == null) return def;
+  const n = Number(v);
+  if (!Number.isInteger(n) || n < min) fail(`${name} 要是 ≥${min} 的整数，拿到的是 ${JSON.stringify(v)}`);
+  return n;
+}
+
+/**
+ * 读并校验 `编排.yaml`。硬错误直接抛（演出拒开比带病开演好——
+ * 假数据教训的同族：静默兜底比报错更坏）。
+ */
+export async function loadOrchestration(dir) {
+  let raw;
+  try {
+    raw = await fs.readFile(path.join(dir, CONFIG_FILE), 'utf8');
+  } catch {
+    throw Object.assign(
+      new Error(`这个文件夹没有 ${CONFIG_FILE}，不是演出文件夹`),
+      { code: 'ORCH_NO_CONFIG' },
+    );
+  }
+  let doc;
+  try { doc = YAML.parse(raw); } catch (e) {
+    fail(`${CONFIG_FILE} 不是合法 YAML：${e.message}`);
+  }
+  return normalizeOrchestration(doc);
+}
+
+/**
+ * 校验并归一一份编排配置（对象形态）。设置页 PUT 落盘前也走这一份——
+ * 校验只有一个实现，读路径和写路径不许各自为政。
+ */
+export function normalizeOrchestration(doc) {
+  if (!doc || typeof doc !== 'object') fail(`${CONFIG_FILE} 顶层要是对象`);
+
+  const 系统层 = (doc.系统层 ?? []).map((e, i) => normalizeEntry(e, '系统层', i));
+  const 尾部 = (doc.尾部 ?? []).map((e, i) => normalizeEntry(e, '尾部', i));
+
+  const 历史 = {
+    文件: String(doc.历史?.文件 ?? DEFAULTS.历史.文件),
+    保留轮数: intField(doc.历史?.保留轮数, DEFAULTS.历史.保留轮数, '历史.保留轮数', { min: 0 }),
+  };
+  const 摘要 = {
+    启用: doc.摘要?.启用 !== false,
+    模型: doc.摘要?.模型 ? String(doc.摘要.模型) : null,
+    // 摘要不跟着主模型的思考档走：不写就按默认档（最省那档）。折叠一次要吃十几轮
+    // 对话，跟着主档开高思考是纯烧钱，而摘要的活是压缩不是创作。
+    思考: levelField(doc.摘要?.思考, '摘要.思考'),
+    提示: doc.摘要?.提示 ? String(doc.摘要.提示) : null,
+    保留轮数: intField(doc.摘要?.保留轮数, DEFAULTS.摘要.保留轮数, '摘要.保留轮数'),
+    触发轮数: intField(doc.摘要?.触发轮数, DEFAULTS.摘要.触发轮数, '摘要.触发轮数'),
+    长度: intField(doc.摘要?.长度, DEFAULTS.摘要.长度, '摘要.长度'),
+  };
+  if (摘要.触发轮数 <= 摘要.保留轮数) {
+    fail(`摘要.触发轮数(${摘要.触发轮数}) 必须大于 摘要.保留轮数(${摘要.保留轮数})，不然每轮都在摘要`);
+  }
+
+  return {
+    模型: doc.模型 ? String(doc.模型) : null,
+    思考: levelField(doc.思考, '思考'),
+    最大输出: intField(doc.最大输出, DEFAULTS.最大输出, '最大输出'),
+    上下文预算: intField(doc.上下文预算, DEFAULTS.上下文预算, '上下文预算'),
+    系统层, 历史, 尾部, 摘要,
+  };
+}
+
+/**
+ * 归一后的配置 → YAML 文本（设置页保存路径）。
+ * 只写非默认/非空的东西，条目字段按 名字/文件|内容/触发/停用 的稳定顺序。
+ * 注释保不住（结构化编辑后重生成）——所以 skill 教"说明写进名字字段"。
+ */
+export function serializeOrchestration(cfg) {
+  const entry = (e) => ({
+    名字: e.名字,
+    ...(e.文件 != null ? { 文件: e.文件 } : { 内容: e.内容 ?? '' }),
+    ...(e.触发 ? { 触发: e.触发 } : {}),
+    ...(e.停用 ? { 停用: true } : {}),
+  });
+  const doc = {
+    ...(cfg.模型 ? { 模型: cfg.模型 } : {}),
+    ...(cfg.思考 ? { 思考: cfg.思考 } : {}),
+    最大输出: cfg.最大输出,
+    上下文预算: cfg.上下文预算,
+    系统层: cfg.系统层.map(entry),
+    历史: { 文件: cfg.历史.文件, 保留轮数: cfg.历史.保留轮数 },
+    摘要: {
+      启用: cfg.摘要.启用,
+      ...(cfg.摘要.模型 ? { 模型: cfg.摘要.模型 } : {}),
+      ...(cfg.摘要.思考 ? { 思考: cfg.摘要.思考 } : {}),
+      触发轮数: cfg.摘要.触发轮数,
+      保留轮数: cfg.摘要.保留轮数,
+      长度: cfg.摘要.长度,
+      ...(cfg.摘要.提示 ? { 提示: cfg.摘要.提示 } : {}),
+    },
+    尾部: cfg.尾部.map(entry),
+  };
+  return `# ${CONFIG_FILE} —— 此文件的顺序 = 进模型的顺序\n` + YAML.stringify(doc, { lineWidth: 0 });
+}
+
+async function resolveEntryText(dir, entry, zone) {
+  if (entry.内容 != null) return entry.内容;
+  const abs = resolveInside(dir, entry.文件, `${zone}「${entry.名字}」`);
+  try {
+    return await fs.readFile(abs, 'utf8');
+  } catch {
+    fail(`${zone}「${entry.名字}」引用的文件不存在：${entry.文件}`);
+  }
+}
+
+/**
+ * 编译一轮演出的上下文。
+ *
+ * 拼装次序（= 进模型的次序）：
+ *   system  = 系统层条目按配置顺序拼接
+ *   messages = [摘要折叠后的历史…, 当轮 user 消息]
+ *   当轮 user 消息 = (无历史时的前情提要) + 尾部资料块 + 用户输入
+ *
+ * 前情提要注入进第一条 user 消息（历史为空时进当轮输入），不占独立消息位——
+ * 两种协议对消息交替的要求不同，塞进已有 user 消息是最不挑协议的做法。
+ *
+ * ⭐ 注入每轮现算现拼，绝不写进 对话.jsonl。记录只存双方真实发言，否则注入
+ * 随历史滚雪球，且改配置无法影响已有对话。
+ *
+ * @returns {{ model, maxTokens, system, messages, meta }}
+ */
+export async function compileContext({ dir, userInput, config = null }) {
+  const cfg = config || await loadOrchestration(dir);
+  const input = String(userInput ?? '').trim();
+  if (!input) fail('当轮输入是空的');
+
+  const meta = { 条目: [], 历史: {}, 估算: {} };
+
+  // ── 系统层 ──
+  const sysTexts = [];
+  for (const e of cfg.系统层) {
+    if (e.停用) { meta.条目.push({ 区: '系统层', 名字: e.名字, 进入: false, 因: '停用' }); continue; }
+    const text = await resolveEntryText(dir, e, '系统层');
+    sysTexts.push(text.trim());
+    meta.条目.push({ 区: '系统层', 名字: e.名字, 进入: true, tokens: estTokens(text) });
+  }
+  const system = sysTexts.join('\n\n');
+
+  // ── 历史与摘要边界 ──
+  const all = await readLog(dir, cfg);
+  const summary = await readSummary(dir);
+  const boundary = summary?.至 ?? 0;
+  // 开头允许是 assistant —— RP 惯例是角色先开口，agent 建场时往记录里种一条
+  // 开场白（assistant, seq 1）。它不算轮（轮按 user 记录数），够老了会随摘要折叠。
+  const live = all.filter(r => r.seq > boundary);
+
+  // ── 尾部触发扫描：最近 8 条记录 + 当轮输入 ──
+  const scanText = live.slice(-TRIGGER_SCAN_RECORDS).map(r => r.text).concat(input).join('\n');
+  const tailBlocks = [];
+  for (const e of cfg.尾部) {
+    if (e.停用) { meta.条目.push({ 区: '尾部', 名字: e.名字, 进入: false, 因: '停用' }); continue; }
+    if (e.触发 && !e.触发.some(k => scanText.includes(k))) {
+      meta.条目.push({ 区: '尾部', 名字: e.名字, 进入: false, 因: '未触发' });
+      continue;
+    }
+    const text = await resolveEntryText(dir, e, '尾部');
+    tailBlocks.push(`<资料 名="${e.名字}">\n${text.trim()}\n</资料>`);
+    meta.条目.push({ 区: '尾部', 名字: e.名字, 进入: true, tokens: estTokens(text), ...(e.触发 ? { 因: '触发命中' } : {}) });
+  }
+
+  // ── 历史挤压：先按保留轮数截，再按预算从最旧丢，切口永远落在 user 记录上 ──
+  const userIdxs = live.map((r, i) => (r.role === 'user' ? i : -1)).filter(i => i >= 0);
+  let cut = userIdxs.length > cfg.历史.保留轮数
+    ? userIdxs[userIdxs.length - cfg.历史.保留轮数]
+    : 0;
+  const summaryBlock = summary ? `<前情提要>\n${summary.内容.trim()}\n</前情提要>` : null;
+  const fixedEst = estTokens(system) + estTokens(tailBlocks.join('')) + estTokens(input)
+    + (summaryBlock ? estTokens(summaryBlock) : 0);
+  let dropped = 0;
+  const histEst = () => live.slice(cut).reduce((n, r) => n + estTokens(r.text), 0);
+  while (cut < live.length && fixedEst + histEst() > cfg.上下文预算) {
+    const next = userIdxs.find(i => i > cut);
+    dropped += 1;
+    if (next == null) { cut = live.length; break; }
+    cut = next;
+  }
+  const hist = live.slice(cut).map(r => ({ role: r.role, content: r.text }));
+
+  meta.历史 = {
+    总轮数: all.filter(r => r.role === 'user').length,
+    摘要已折叠: boundary > 0,
+    进入轮数: hist.filter(m => m.role === 'user').length,
+    预算丢弃轮数: dropped,
+  };
+
+  // ── 拼消息 ──（前情提要注进第一条 user 消息；没有就落到当轮输入）
+  const firstUser = hist.findIndex(m => m.role === 'user');
+  if (summaryBlock && firstUser >= 0) {
+    hist[firstUser] = { ...hist[firstUser], content: `${summaryBlock}\n\n${hist[firstUser].content}` };
+  }
+  const currentParts = [];
+  if (summaryBlock && firstUser < 0) currentParts.push(summaryBlock);
+  currentParts.push(...tailBlocks, input);
+  const messages = [...hist, { role: 'user', content: currentParts.join('\n\n') }];
+
+  meta.估算 = {
+    系统层: estTokens(system),
+    历史: hist.reduce((n, m) => n + estTokens(m.content), 0),
+    当轮: estTokens(messages[messages.length - 1].content),
+    预算: cfg.上下文预算,
+  };
+  meta.估算.合计 = meta.估算.系统层 + meta.估算.历史 + meta.估算.当轮;
+
+  return { model: cfg.模型, 思考: cfg.思考, maxTokens: cfg.最大输出, system, messages, meta };
+}

package/server/engine/chatai/perform.js

@@ -0,0 +1,40 @@
+/**
+ * perform.js —— 一轮完整演出：编译 → 调用 → 落盘 → （必要时）折叠摘要。
+ *
+ * 这是将来 HTTP 端点的核心；限流、owner 隔离、计量入库都归端点层，
+ * 这里只管把一轮跑对。摘要折叠放在回复落盘之后串行执行：它只在每
+ * 攒够一批轮次时发生一次，多出的几秒延迟落在「本轮已经拿到回复之后」，
+ * 用户无感；换成后台跑要多一套失败通知机制，v1 不值。
+ */
+
+import { runChatai } from './index.js';
+import { loadOrchestration, compileContext } from './orchestrate.js';
+import { appendTurn } from './chat-log.js';
+import { maybeSummarize } from './summarize.js';
+
+/**
+ * @param {object} opts  dir / userInput / signal / onDelta
+ * @returns {{ text, usage, costUsd, model, meta, 摘要: null|object }}
+ */
+export async function performTurn({ dir, userInput, signal, onDelta }) {
+  const config = await loadOrchestration(dir);
+  const compiled = await compileContext({ dir, userInput, config });
+  const out = await runChatai({
+    system: compiled.system,
+    messages: compiled.messages,
+    model: compiled.model || undefined,
+    思考: compiled.思考,
+    maxTokens: compiled.maxTokens,
+    signal, onDelta,
+  });
+  await appendTurn(dir, config, String(userInput).trim(), out.text);
+
+  let 摘要 = null;
+  try {
+    摘要 = await maybeSummarize({ dir, config, signal });
+  } catch (err) {
+    // 摘要失败不吞掉本轮回复：边界不动，下一轮还会再试。往上抛消息但带着结果。
+    摘要 = { 失败: err.message };
+  }
+  return { ...out, meta: compiled.meta, 摘要 };
+}

package/server/engine/chatai/summarize.js

@@ -0,0 +1,79 @@
+/**
+ * summarize.js —— 滚动前情提要。
+ *
+ * 长演出的记忆基础设施：活历史（摘要边界之后的轮次）攒到 摘要.触发轮数 就
+ * 折叠一次——把「旧提要 + 除最近 保留轮数 外的活轮次」交给 chatai 压成一份
+ * 新提要，边界前移。触发轮数 > 保留轮数 的差值就是滞回区间，保证不会每轮
+ * 都在摘要，也保证缓存前缀只在折叠瞬间断一次、之后又稳定到下次折叠。
+ *
+ * 摘要本身是一次独立的 chatai 调用（chatai 没有工具，摘要不可能是 agent 的
+ * 副作用），花费单独记在 摘要.json 里，端点计量时要把它加进这轮的账。
+ */
+
+import { runChatai } from './index.js';
+import { readLog, readSummary, writeSummary } from './chat-log.js';
+
+const DEFAULT_PROMPT = (长度) => `把下面这段对话压缩成一份前情提要，供后续继续演出时当作记忆。只输出提要本身，不要任何前后缀。
+要求：保留人物与称呼、关系变化、承诺与约定、得到或失去的东西、时间地点的推进、未解决的伏笔；去掉寒暄和过程性描写；用第三人称陈述句；${长度}字以内。
+如果下面给了旧提要，把它和新对话并成一份完整提要，旧提要里仍然有效的信息不能丢。`;
+
+/**
+ * 该不该折叠、折叠到哪。纯函数，方便测试。
+ * @returns {null | { 至: number, fold: records[] }}  至 = 折叠后的新边界 seq
+ */
+export function needsSummary(records, summary, config) {
+  if (!config.摘要.启用) return null;
+  const boundary = summary?.至 ?? 0;
+  const live = records.filter(r => r.seq > boundary);
+  const userIdxs = live.map((r, i) => (r.role === 'user' ? i : -1)).filter(i => i >= 0);
+  if (userIdxs.length < config.摘要.触发轮数) return null;
+  // 保留最近 保留轮数 轮，其余折叠；新边界 = 保留区第一条 user 记录的前一条
+  const keepFrom = userIdxs[userIdxs.length - config.摘要.保留轮数];
+  const fold = live.slice(0, keepFrom);
+  if (!fold.length) return null;
+  return { 至: fold[fold.length - 1].seq, fold };
+}
+
+function renderTranscript(records) {
+  return records
+    .map(r => `${r.role === 'user' ? '用户' : '演出'}：${r.text}`)
+    .join('\n\n');
+}
+
+/**
+ * 检查并执行一次折叠。没到触发线 → null；执行了 → 摘要对象（含花费）。
+ * 失败直接抛给调用方——摘要失败不该静默，下一轮编译仍按旧边界走，不丢戏。
+ */
+export async function maybeSummarize({ dir, config, signal }) {
+  const records = await readLog(dir, config);
+  const prev = await readSummary(dir);
+  const need = needsSummary(records, prev, config);
+  if (!need) return null;
+
+  const parts = [];
+  if (prev) parts.push(`【旧提要】\n${prev.内容.trim()}`);
+  parts.push(`【新对话】\n${renderTranscript(need.fold)}`);
+
+  const out = await runChatai({
+    system: config.摘要.提示 || DEFAULT_PROMPT(config.摘要.长度),
+    messages: [{ role: 'user', content: parts.join('\n\n') }],
+    model: config.摘要.模型 || config.模型 || undefined,
+    // 思考档不继承主配置：没专门给摘要设档就走默认档（最省的那档）。压缩不是创作。
+    思考: config.摘要.思考,
+    maxTokens: Math.max(500, config.摘要.长度 * 2),
+    signal,
+  });
+  const text = out.text.trim();
+  if (!text) throw Object.assign(new Error('摘要调用返回了空文本，边界不动'), { code: 'SUMMARY_EMPTY' });
+
+  const summary = {
+    至: need.至,
+    内容: text,
+    时: new Date().toISOString(),
+    模型: out.model,
+    用量: out.usage,
+    花费: out.costUsd,
+  };
+  await writeSummary(dir, summary);
+  return summary;
+}

package/server/engine/mcp/capability-gate.js

@@ -0,0 +1,52 @@
+/**
+ * engine/mcp/capability-gate.js — 工具 × 本机能力位（runtime/capabilities.js）的唯一对照表 + 闸。
+ *
+ * 两种模式：
+ *   - block：能力缺席时工具描述前缀「⛔ CURRENTLY UNAVAILABLE + 装法」（照 roll_film 的先例，agent 看到就不会调），
+ *            真调了也在这里拦住，返回同一句话让它转告用户——不让裸的 ENOENT / 500 漏到 agent 面前
+ *   - note ：工具仍可用，只在描述末尾加一句降级说明（build_docx 没有 LibreOffice 时仍能出文件，只是没页图）
+ * 没探过（capabilityState 为 null：单测 / 脚本直接 import）→ 原样放行，这层不猜。
+ */
+
+import { capabilityState } from '../../runtime/capabilities.js';
+
+const CHROMIUM_TOOLS = [
+  'screenshot_canvas', 'screenshot_url', 'list_pages', 'query_elements', 'get_computed_styles', 'explain_style',
+  'profile_scroll', 'trace_motion',
+  'browser_navigate', 'browser_read', 'browser_click', 'browser_screenshot', 'browser_capture', 'browser_computer',
+  'browser_find', 'browser_batch', 'browser_request_help',
+  'artifact_open', 'artifact_computer', 'artifact_find', 'artifact_motion', 'artifact_batch',
+];
+
+/** 工具名 → { cap, mode }。没列的工具不归这层管 */
+export const TOOL_CAPABILITIES = Object.freeze({
+  ...Object.fromEntries(CHROMIUM_TOOLS.map((t) => [t, { cap: 'chromium', mode: 'block' }])),
+  build_docx: { cap: 'libreoffice', mode: 'note' },
+  remove_background: { cap: 'rembg', mode: 'block' },
+  web_search: { cap: 'webSearch', mode: 'block' },
+  generate_image: { cap: 'imageGen', mode: 'block' },
+  publish_site: { cap: 'publish', mode: 'block' },
+});
+
+export function unavailableMessage(c) {
+  return `本机缺 ${c.label}（${c.detail}）。装法：${c.fix}`;
+}
+
+export function withCapabilityGate(toolDef) {
+  const spec = TOOL_CAPABILITIES[toolDef.name];
+  if (!spec) return toolDef;
+  const c = capabilityState(spec.cap);
+  if (!c || c.available) return toolDef;
+  const msg = unavailableMessage(c);
+  if (spec.mode === 'note') {
+    return { ...toolDef, description: `${toolDef.description}\n\n⚠️ ${msg} 本工具仍可用，但依赖它的步骤（页图/体检）会缺席。` };
+  }
+  return {
+    ...toolDef,
+    description: `⛔ CURRENTLY UNAVAILABLE — ${msg} Do not call this tool; tell the user what to install (原话转告，不要重试).\n\n${toolDef.description}`,
+    handler: async () => ({
+      content: [{ type: 'text', text: `${toolDef.name} 不可用：${msg}。把这句话原话转告用户，装好后重启 Nodesign 再试；不要重试本工具。` }],
+      isError: true,
+    }),
+  };
+}