lume-dsh-plugin 0.7.3 → 0.8.0

package/lib/core/ledger.js

@@ -1,3 +1,4 @@
+import { isRequirementStatement } from "./coverage.js";
 /**
  * 任务载具的纯逻辑层：任务契约、改动台账、假设台账、项目知识。
  *
@@ -11,6 +12,8 @@
  * 本模块只做纯逻辑（类型/解析/归一/渲染/上限），IO 在 host/project.ts。
  */
 import { fnv1a32 } from "./sampling.js";
+import { memoryId, numberFacts } from "./memory-id.js";
+import { classifyScope, visibleForTask } from "./scope.js";
 /** 契约字段长度上限：契约是「一屏能看完」的东西，写长了自己也不看。 */
 export const CONTRACT_TEXT_CAP = 240;
 export const CONTRACT_LIST_CAP = 8;
@@ -21,6 +24,12 @@ export const CHANGE_TEXT_CAP = 160;
 export const HYPOTHESIS_CAP = 20;
 /** 项目知识上限：按时间挤旧，死路记录优先保留（它最省时间）。 */
 export const PROJECT_FACT_CAP = 40;
+/** 设计决策上限：一次任务的设计决策点到 20 个已经很多了。 */
+export const DESIGN_CAP = 20;
+/** 需求锚点上限：保留首条（原始需求）+ 最近若干条（修正与追加）。 */
+export const REQUIREMENT_CAP = 10;
+export const REQUIREMENT_TEXT_CAP = 800;
+export const DESIGN_TEXT_CAP = 160;
 export const FACT_TEXT_CAP = 200;
 const FACT_LABEL = {
     build: "构建",
@@ -30,7 +39,10 @@ const FACT_LABEL = {
     deadend: "死路（不要重复）",
 };
 function clip(value, cap) {
-    return String(value ?? "").trim().replace(/\s+/g, " ").slice(0, cap);
+    return String(value ?? "")
+        .trim()
+        .replace(/\s+/g, " ")
+        .slice(0, cap);
 }
 function clipList(value, cap = CONTRACT_LIST_CAP) {
     const list = Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
@@ -48,11 +60,18 @@ function asCount(value) {
     const n = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
     return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : null;
 }
-/** 项目键：跨会话共享的项目知识按工作目录归属（同一仓库的多个会话共用一份）。 */
+/**
+ * 项目键：跨会话共享的项目知识按工作目录归属（同一仓库的多个会话共用一份）。
+ *
+ * 拿不到工作目录时返回 **null**，不返回 "unknown"——实测踩过：写入口（工具 exec / 会话事件）
+ * 里的 session 视图不一定带 cwd，回落成 "unknown" 会把**所有项目**的知识塞进同一个桶，
+ * 跨会话隔离直接失效（现场取证：facts 表的键就是 "unknown"）。调用方拿到 null 必须
+ * 「不写跨会话表」，宁可不记也不要串味。
+ */
 export function projectKeyOf(cwd) {
     const normalized = clip(cwd, 240).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
     if (!normalized)
-        return "unknown";
+        return null;
     return fnv1a32(normalized).toString(16).padStart(8, "0");
 }
 /** 从工具入参归一化契约（截断 + 去重 + 上限）。 */
@@ -93,10 +112,13 @@ export function normalizeHypothesis(input, at) {
         text,
         evidence: clip(input.evidence, CHANGE_TEXT_CAP),
         status: status === "testing" || status === "confirmed" || status === "excluded" ? status : "open",
+        // 裁决三件套里的另外两件：结构化保存（不折进 evidence，否则「多少结论带反例检查」没法机械统计）
+        method: clip(input.method, CHANGE_TEXT_CAP),
+        counter: clip(input.counter, CHANGE_TEXT_CAP),
         at,
     };
 }
-export function normalizeProjectFact(input, at) {
+export function normalizeProjectFact(input, at, options = {}) {
     const text = clip(input.text, FACT_TEXT_CAP);
     if (!text)
         return null;
@@ -105,6 +127,10 @@ export function normalizeProjectFact(input, at) {
         kind: kind === "test" || kind === "module" || kind === "convention" || kind === "deadend" ? kind : "build",
         text,
         at,
+        // 内容寻址 id：同主题 → 同 id（去重/覆盖靠它，不再靠字面相似度）
+        id: memoryId(typeof kind === "string" ? kind : "build", text),
+        // 作用域：需求特有的结论不该污染别的需求（判定见 core/scope.ts，机械规则）
+        ...classifyScope(text, { taskTitle: options.taskTitle, requirementHints: options.requirementHints }),
     };
 }
 /** 台账计数：渲染与触发器都要用（"x 项已改未验" 是增量验证的判据）。 */
@@ -139,12 +165,14 @@ export function renderContract(contract, delivery = false) {
     if (!contract || !contract.goal)
         return null;
     const lines = [];
-    lines.push(delivery ? "〔契约对账〕交付前逐项对账（以下是开工时写下的原始判据，不是你现在的记忆版本）：" : `〔任务契约｜第 ${contract.turn} 轮写入〕`);
+    lines.push(delivery
+        ? "〔契约对账〕交付前逐项对账（以下是开工时写下的原始判据，不是你现在的记忆版本）："
+        : `〔任务契约｜第 ${contract.turn} 轮写入〕`);
     lines.push(`目标：${contract.goal}`);
     if (contract.scope.length > 0)
         lines.push(`范围：${contract.scope.join("；")}`);
-    if (contract.expectCount !== null || contract.actualCount !== null) {
-        const expect = contract.expectCount === null ? "?" : contract.expectCount;
+    if (true) {
+        const expect = contract.expectCount === null ? "未估" : contract.expectCount;
         const actual = contract.actualCount === null ? "未回填" : contract.actualCount;
         lines.push(`数量：预计 ${expect} → 实际 ${actual}`);
     }
@@ -180,32 +208,115 @@ export function renderHypotheses(list, limit = 8) {
     if (list.length === 0)
         return null;
     const lines = list.slice(-limit).map((item) => {
-        const mark = item.status === "excluded" ? "[已排除]" : item.status === "confirmed" ? "[已证实]" : item.status === "testing" ? "[验证中]" : "[待验证]";
-        const evidence = item.evidence ? `（证据：${item.evidence}）` : "";
-        return `- ${mark} ${item.text}${evidence}`;
+        const mark = item.status === "excluded"
+            ? "[已排除]"
+            : item.status === "confirmed"
+                ? "[已证实]"
+                : item.status === "testing"
+                    ? "[验证中]"
+                    : "[待验证]";
+        const parts = [
+            item.evidence ? `证据：${item.evidence}` : "",
+            item.method ? `裁决：${item.method}` : "",
+            item.counter ? `反例：${item.counter}` : "",
+        ].filter(Boolean);
+        return `- ${mark} ${item.text}${parts.length > 0 ? `（${parts.join(" ｜ ")}）` : ""}`;
     });
     const excluded = list.filter((item) => item.status === "excluded").length;
     const foot = excluded > 0 ? "\n已排除的假设不要重提；要推翻它必须给出新的证据。" : "";
     return `〔假设台账〕\n${lines.join("\n")}${foot}`;
 }
+/** 知识新鲜度：跨会话知识必须一眼看出是多久前记的（过时的事实比没有更危险）。 */
+function ageLabel(at, now = Date.now()) {
+    const hours = (now - at) / 3_600_000;
+    if (!Number.isFinite(hours) || hours < 0)
+        return "";
+    if (hours < 1)
+        return "（刚记）";
+    if (hours < 48)
+        return `（${Math.round(hours)} 小时前）`;
+    return `（${Math.round(hours / 24)} 天前）`;
+}
 /** 渲染项目知识：按类别归组；死路单独成节（它最省时间）。 */
-export function renderProjectFacts(facts, limit = 14) {
+export function renderProjectFacts(facts, limit = 14, currentTask) {
     if (facts.length === 0)
         return null;
     const order = ["build", "test", "convention", "module", "deadend"];
-    const picked = facts.slice(-limit);
+    // 作用域隔离：通用知识人人可见；需求级知识只给同一需求看（否则会拿别的需求的结论误导当前需求）。
+    const numbered = numberFacts(facts.filter((fact) => visibleForTask(fact, currentTask)));
+    if (numbered.length === 0)
+        return null;
+    const picked = numbered.slice(-limit);
     const lines = [];
     for (const kind of order) {
-        const group = picked.filter((fact) => fact.kind === kind);
+        const group = picked.filter((entry) => entry.item.kind === kind);
         if (group.length === 0)
             continue;
         lines.push(`${FACT_LABEL[kind]}：`);
-        for (const fact of group)
-            lines.push(`- ${fact.text}`);
+        // 编号（#n）+ 短 id：用户可点名纠正（“#7 过时了”），模型可引用；id 跨裁剪稳定。
+        for (const entry of group)
+            lines.push(`- #${entry.n}${entry.item.id ? `·${entry.item.id.slice(0, 4)}` : ""} ${entry.item.text}${entry.item.scope === "task" ? "（本需求）" : ""}${ageLabel(entry.item.at)}`);
     }
     return `〔项目知识｜本目录，跨会话累积〕\n${lines.join("\n")}`;
 }
-/** 台账/契约是否存在未验证项——触发器「连写不验」与交付对账都要用。 */
-export function hasUnverified(items) {
-    return items.some((item) => item.status === "done" || item.status === "planned");
+export function normalizeDesign(input, at) {
+    const point = clip(input.point, CONTRACT_ITEM_CAP);
+    const choice = clip(input.choice, DESIGN_TEXT_CAP);
+    if (!point || !choice)
+        return null;
+    return { point, choice, rejected: clip(input.rejected, DESIGN_TEXT_CAP), impact: clip(input.impact, DESIGN_TEXT_CAP), at };
+}
+export function trimDesign(items, cap = DESIGN_CAP) {
+    return items.length <= cap ? items : items.slice(-cap);
+}
+/** 渲染设计决策：决策点在前，取舍与影响面在后（三者缺一就是没做完设计 pass）。 */
+export function renderDesign(items, limit = 8) {
+    if (items.length === 0)
+        return null;
+    const lines = items.slice(-limit).map((item, index) => {
+        const rejected = item.rejected ? `｜放弃：${item.rejected}` : "｜⚠ 没写被放弃的方案";
+        const impact = item.impact ? `｜影响面：${item.impact}` : "";
+        return `${index + 1}. ${item.point} → ${item.choice}${rejected}${impact}`;
+    });
+    return `〔设计决策｜本会话，跨轮跨压缩保留〕\n${lines.join("\n")}\n定下来的决策不要反复推翻；要改就写一条新的并说明为什么推翻上一条。`;
+}
+export function normalizeRequirement(input, at) {
+    const text = clip(input.text, REQUIREMENT_TEXT_CAP);
+    if (!text)
+        return null;
+    return { text, at };
+}
+/**
+ * 首条永远保留，**有结构的需求原文优先保留**（闲聊与评审粘贴先被挤掉）。
+ *
+ * 现场教训（2026-09-23）：需求原文在第 4 条，后面被 8 段评审粘贴挤出了表外 →
+ * 需求覆盖核对只能拿评审条目当需求逐条列，反而误导。只按时间挤旧是不够的，要按"是不是需求"分层。
+ */
+export function trimRequirements(items, cap = REQUIREMENT_CAP) {
+    if (items.length <= cap)
+        return items;
+    const [first, ...rest] = items;
+    const keep = rest.filter((item) => isRequirementStatement(item.text));
+    const others = rest.filter((item) => !isRequirementStatement(item.text));
+    const room = cap - 1;
+    if (keep.length >= room)
+        return [first, ...keep.slice(-room)];
+    return [first, ...keep, ...others.slice(-(room - keep.length))];
+}
+/**
+ * 渲染需求锚点。
+ *
+ * 为什么要逐字回显：现场实测（B2I 优惠视图与订单属性）模型用自己的转述工作，"新增字段" 被它转成
+ * "复用 create_id/modify_id"，随后几轮都在错误前提上推论；而契约工具它 14 次提示都没调用。
+ * 所以锚点由**插件自己写**，并在每轮把原话摆回它眼前。
+ */
+export function renderRequirements(items, limit = 6) {
+    if (items.length === 0)
+        return null;
+    const head = items[0];
+    const rest = items.slice(1).slice(-(limit - 1));
+    const lines = [`1.（原始需求，最重要）${head.text}`];
+    for (const [index, item] of rest.entries())
+        lines.push(`${index + 2}. ${item.text}`);
+    return `〔需求锚点｜用户原话，逐字保留〕\n${lines.join("\n")}\n你的理解与方案必须能追溯到上面这些句子；与它们冲突时改方案，不要改需求。`;
 }

package/lib/core/manifest.js

@@ -21,7 +21,9 @@ export function parseManifest(raw) {
             displayName: typeof entry.displayName === "string" ? entry.displayName : entry.name,
             description: typeof entry.description === "string" ? entry.description : "",
             defaultName: typeof entry.defaultName === "string" && entry.defaultName ? entry.defaultName : undefined,
-            signatureWords: Array.isArray(entry.signatureWords) ? entry.signatureWords.filter((w) => typeof w === "string" && w.length > 0) : undefined,
+            signatureWords: Array.isArray(entry.signatureWords)
+                ? entry.signatureWords.filter((w) => typeof w === "string" && w.length > 0)
+                : undefined,
             promptFile: typeof entry.promptFile === "string" ? entry.promptFile : `${entry.name}.txt`,
             corpusFile: typeof entry.corpusFile === "string" ? entry.corpusFile : `${entry.name}-corpus.jsonl`,
         });

package/lib/core/memory-id.js

@@ -0,0 +1,105 @@
+/**
+ * 记忆 ID：把「同一条知识」从**模糊文本比对**变成**内容寻址**。
+ *
+ * 为什么需要：原先去重靠 token Jaccard（中文二元组）——同义不同词就会漏（「列名必须用 PERMISSION_NAME」
+ * vs「权限人字段的列名固定为 PERMISSION_NAME」），而且每次落盘都要跟全部条目算一遍相似度。
+ *
+ * 做法：一条记忆的**身份**不是整句文本，而是它的**主题**：
+ *   ① 大写标识符 / 表名字段名（PERMISSION_NAME、WTPF_GOODS_PROPERTY_DEF）
+ *   ② 驼峰标识符（permissionName、busType）
+ *   ③ 文件名（去掉目录与扩展名）
+ *   ④ 命令名（mvn / gradle / npm / git / curl / psql …）
+ * 取这些实体排序后拼成 topicKey，再哈希成短 id（fnv1a32，与 projectKeyOf 同一套哈希）。
+ *
+ * 于是：**同主题 → 同 id → 精确去重 / 精确覆盖（O(1)，不再全表算相似度）**；
+ * 注入里显示编号（#n）与短 id，用户可以点名纠正（“#7 过时了”），模型也能引用。
+ *
+ * 取舍（不吹）：没有标识符的纯中文约定只能退化到关键词指纹 → 同义不同词仍可能漏，
+ * 所以**兜底仍保留 Jaccard**（低频路径），主路径走 id。
+ */
+import { fnv1a32 } from "./sampling.js";
+/** 命令名白名单：它们常出现在“这个仓库怎么跑”类知识里。 */
+const COMMANDS = [
+    "mvn",
+    "gradle",
+    "npm",
+    "pnpm",
+    "yarn",
+    "node",
+    "git",
+    "curl",
+    "curl.exe",
+    "psql",
+    "mysql",
+    "docker",
+    "kubectl",
+    "npx",
+    "tsc",
+    "vitest",
+    "jest",
+    "eslint",
+    "dotnet",
+    "python",
+    "pip",
+];
+const UPPER_RE = /[A-Z][A-Z0-9_]{2,}/g;
+const CAMEL_RE = /\b[a-z]+[A-Z][A-Za-z0-9]{2,}/g;
+const FILE_RE = /[\w.\u4e00-\u9fff-]+\.(?:java|xml|vue|ts|tsx|js|sql|md|yml|yaml|json|ps1|py|sh|properties|toml)/gi;
+/**
+ * 主题键：优先实体（标识符/文件/命令），退化到中文关键词指纹。
+ * 返回空串表示"完全无可提取的主题"（调用方应退回 Jaccard）。
+ */
+export function topicKey(text) {
+    const raw = String(text ?? "");
+    const upper = (raw.match(UPPER_RE) ?? []).map((item) => item.toLowerCase());
+    const camel = (raw.match(CAMEL_RE) ?? []).map((item) => item.toLowerCase());
+    const files = (raw.match(FILE_RE) ?? []).map((item) => (item.split(/[\\/]/).pop() ?? item).toLowerCase());
+    const lower = raw.toLowerCase();
+    const commands = COMMANDS.filter((command) => lower.includes(command));
+    const entities = [...new Set([...upper, ...camel, ...files, ...commands])].sort();
+    if (entities.length > 0)
+        return entities.slice(0, 5).join("+");
+    // 没有实体：退化到中文/英文关键词（去重后取前 6 个），仅供"同句重复"兜底
+    const cjk = (raw.match(/[\u4e00-\u9fff]{2,}/g) ?? []).flatMap((run) => {
+        const grams = [];
+        for (let i = 0; i < run.length - 1; i++)
+            grams.push(run.slice(i, i + 2));
+        return grams;
+    });
+    const words = lower.match(/[a-z0-9]{4,}/g) ?? [];
+    const picked = [...new Set([...words, ...cjk])].slice(0, 6);
+    return picked.join("+");
+}
+/** 记忆 id：kind 参与哈希（同一标识符的“构建”与“死路”是两条知识）。 */
+export function memoryId(kind, text) {
+    const key = topicKey(text);
+    if (!key)
+        return "";
+    return fnv1a32(`${kind}|${key}`).toString(16).padStart(8, "0").slice(0, 8);
+}
+/**
+ * 新版本是否比旧版本更"具体"：更长，且覆盖了旧文本里的标识符。
+ * 用于把「先到先得」改成「更精确的版本覆盖旧的」——否则后来更完整的表述会被丢掉。
+ */
+export function isMoreSpecific(next, previous) {
+    const before = topicKey(previous).split("+").filter(Boolean);
+    const after = topicKey(next).split("+").filter(Boolean);
+    if (after.length === 0)
+        return false;
+    // 旧主题必须被**完整覆盖**（新文本可能提到更多实体——那正是"更具体"）；
+    // 覆盖不到就说明讲的是另一件事，不许覆盖。
+    if (!before.every((part) => after.includes(part)))
+        return false;
+    return next.length > previous.length + 4;
+}
+/** 给记忆挂上 id（老数据缺 id 时按算法补，幂等）。 */
+export function withIds(facts) {
+    return facts.map((fact) => ({ ...fact, id: fact.id && fact.id.length > 0 ? fact.id : memoryId(fact.kind, fact.text) }));
+}
+/**
+ * 稳定编号：按时间升序的序号（1 起）。注入与 markdown 里都用它，用户可点名（“#7 过时了”）。
+ * 注意：条目被裁掉后编号会顺移，所以同时给出短 id（跨裁剪稳定）——引用时 id 更可靠。
+ */
+export function numberFacts(facts) {
+    return facts.map((item, index) => ({ item, n: index + 1 }));
+}

package/lib/core/metrics.js

@@ -0,0 +1,270 @@
+/**
+ * 运行时度量：把「Lume 到底有没有让它更聪明」从口头判断变成可统计的事实（0.8.x）。
+ *
+ * 为什么需要（2026-09-24 复盘）：此前整条链路里**没有任何外部信号进回路**——
+ * 路由判错率、触发器命中后行为是否真的变了、条款加权有没有用、用户纠正率，
+ * 一个都没测。反思日志打的是模型自评（5 个维度自评分），自评不是度量：
+ * 它既不能证明改对了，也不能指出改哪里。于是每加一条规则都只能靠「感觉这次好点」。
+ *
+ * 度量口径的三条纪律（照着写，别放宽）：
+ * 1. **只收机械可判的事实**：模式/命中规则/计数器/工具计数/用户纠正词，
+ *    一律不解释语义（`coverage.ts` 那句「语义正确性判不了，不装」同样适用）。
+ * 2. **外部信号优先**：用户纠正、重复请求、越权改动都是**用户给的**，
+ *    不与模型自评混在一起统计。
+ * 3. **测不了就说测不了**：触发器里只有一部分有机械可判的「预期行为变化」，
+ *    其余明确标 `none` 并排除在比例之外——宁可样本小，也不要假绿灯。
+ *
+ * 本模块是纯函数 + 纯类型（无 I/O），落盘与环形缓冲在 host/metrics-log.ts。
+ */
+/**
+ * 触发器的预期行为变化（机械可判）：
+ * - verify：窗口内出现一次「真验证命令」（`verify-run`；台账 verified 自动推进，不算证据）
+ * - contract / design / ledger / hypothesis：对应载具从无到有
+ * - none：**测不了**（判据漂移、知识采集这类没有机械口径），排除在比例外
+ */
+export const TRIGGER_EXPECT = {
+    "verify-as-you-go": "verify",
+    "dead-path": "verify",
+    "contract-missing": "contract",
+    "design-missing": "design",
+    // 决策分档：提醒是二选一（先做最便宜的核实 / 或落成假设），所以两条路都认。
+    // 只认「假设」会虚低——模型走了被鼓励的那条路（核实）反而记 0 改善（外部审核指出）。
+    "unfounded-change": "verify-or-hypothesis",
+    converge: "ledger",
+    "hypothesis-stale": "hypothesis",
+    "criteria-drift": "none",
+    "knowledge-capture": "none",
+};
+export function triggerExpect(id) {
+    return TRIGGER_EXPECT[id] ?? "none";
+}
+export function toMetricLine(record) {
+    return JSON.stringify(record);
+}
+/** 容错解析：坏行直接跳过（日志是诊断通道，一行坏不该让统计整体失败）。 */
+export function parseMetricLines(text) {
+    const out = [];
+    for (const line of text.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("{"))
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object" && typeof parsed.kind === "string")
+                out.push(parsed);
+        }
+        catch {
+            /* 半行/损坏行：跳过 */
+        }
+    }
+    return out;
+}
+/** 默认效能观察窗：命中后 3 轮内看行为是否变了（一多就归因不清）。 */
+export const EFFICACY_WINDOW_TURNS = 3;
+function bump(map, key) {
+    map[key] = (map[key] ?? 0) + 1;
+}
+/**
+ * 聚合。`sid` 给了就只看那条会话；不给则看全部记录。
+ * 效能判定只在**同一会话**内做（跨会话的轮次不可比），且只看命中之后的状态快照。
+ */
+export function summarizeMetrics(records, opts = {}) {
+    const sid = opts.sid;
+    const window = opts.efficacyWindow ?? EFFICACY_WINDOW_TURNS;
+    const scoped = sid ? records.filter((record) => record.sid === sid) : records;
+    const sessions = new Set(scoped.map((record) => record.sid));
+    // 单趟建 sid → 记录 索引：效能判定只扫同会话的记录。
+    // 原来每个命中都全量重扫（叠加 baselineAt 再来一遍），ring 800 时最坏几十万次比较，
+    // lume_metrics 频繁手调会有可见延迟（2026-09-24 审核指出）。
+    const bySid = new Map();
+    for (const record of scoped) {
+        const list = bySid.get(record.sid);
+        if (list)
+            list.push(record);
+        else
+            bySid.set(record.sid, [record]);
+    }
+    const routes = { total: 0, byMode: {}, byMatched: {}, bySource: {} };
+    const outcomes = { corrections: 0, repeats: 0, overreach: 0, noAction: 0, correctionsByMode: {} };
+    const blocks = { steps: 0, droppedSteps: 0, avgChars: 0, budget: 0, focusCounts: {} };
+    let charsTotal = 0;
+    for (const record of scoped) {
+        if (record.kind === "route") {
+            routes.total++;
+            bump(routes.byMode, record.mode);
+            bump(routes.byMatched, record.matched);
+            bump(routes.bySource, record.source);
+        }
+        else if (record.kind === "outcome") {
+            if (record.event === "user-correction") {
+                outcomes.corrections++;
+                bump(outcomes.correctionsByMode, record.mode);
+            }
+            else if (record.event === "repeat-request")
+                outcomes.repeats++;
+            else if (record.event === "overreach")
+                outcomes.overreach++;
+            else if (record.event === "no-action")
+                outcomes.noAction++;
+        }
+        else if (record.kind === "blocks") {
+            blocks.steps++;
+            charsTotal += record.chars;
+            blocks.budget = record.budget;
+            if (record.dropped > 0)
+                blocks.droppedSteps++;
+            for (const id of record.focus)
+                bump(blocks.focusCounts, id);
+        }
+    }
+    blocks.avgChars = blocks.steps > 0 ? Math.round(charsTotal / blocks.steps) : 0;
+    // 触发器效能：拿命中轮的状态快照当基线，看窗口内是否出现预期变化。
+    const byId = new Map();
+    for (const record of scoped) {
+        if (record.kind !== "trigger")
+            continue;
+        const expect = record.expect ?? triggerExpect(record.id);
+        const entry = byId.get(record.id) ?? { id: record.id, expect, fired: 0, improved: 0 };
+        entry.fired++;
+        if (expect !== "none" && improvedAfter(bySid.get(record.sid) ?? [record], { ...record, expect }, window))
+            entry.improved++;
+        byId.set(record.id, entry);
+    }
+    const triggers = [...byId.values()].sort((a, b) => b.fired - a.fired);
+    const measured = triggers.filter((entry) => entry.expect !== "none");
+    return {
+        sessions: sessions.size,
+        records: scoped.length,
+        routes,
+        outcomes,
+        blocks,
+        triggers,
+        measuredTriggers: measured.length,
+        improvedTriggers: measured.filter((entry) => entry.improved > 0).length,
+        measuredHits: measured.reduce((sum, entry) => sum + entry.fired, 0),
+        improvedHits: measured.reduce((sum, entry) => sum + entry.improved, 0),
+    };
+}
+/** 窗口内是否出现过「真验证命令」（机械可判，且不是台账自动推进的产物）。 */
+function hasVerifyRun(records, fire, window) {
+    for (const record of records) {
+        if (record.kind !== "outcome" || record.sid !== fire.sid || record.event !== "verify-run")
+            continue;
+        // 验证常常就发生在命中的**同一轮**里，所以允许同轮但必须在命中之后。
+        if (record.turn < fire.turn || record.turn > fire.turn + window)
+            continue;
+        if (record.at < fire.at)
+            continue;
+        return true;
+    }
+    return false;
+}
+/** 命中之后（窗口轮内）是否出现过预期变化。 */
+function improvedAfter(records, fire, window) {
+    // verify 类只认「真验证命令」：台账 verified 由自动推进产生，拿它当判据等于自我表扬。
+    if (fire.expect === "verify")
+        return hasVerifyRun(records, fire, window);
+    // 二选一的提醒：真验证命令与「假设从无到有」任一出现都算改善
+    if (fire.expect === "verify-or-hypothesis") {
+        if (hasVerifyRun(records, fire, window))
+            return true;
+    }
+    const base = baselineAt(records, fire);
+    if (!base)
+        return false;
+    for (const record of records) {
+        if (record.kind !== "state" || record.sid !== fire.sid)
+            continue;
+        // 允许**同轮**（但必须在命中之后）：快照已经按步记录了，如果再要求 turn 严格大于命中轮，
+        // 同一轮里新增的快照对效能判定就完全不可见——只有 verify-run 那条路吃到了新分辨率（审核指出）。
+        if (record.turn < fire.turn || record.turn > fire.turn + window)
+            continue;
+        if (record.at < fire.at)
+            continue;
+        switch (fire.expect) {
+            case "contract":
+                if (record.hasContract && !base.hasContract)
+                    return true;
+                break;
+            case "design":
+                if (record.designs > base.designs)
+                    return true;
+                break;
+            case "ledger":
+                if (record.changes > base.changes)
+                    return true;
+                break;
+            case "verify-or-hypothesis":
+            case "hypothesis":
+                if (record.hypotheses > base.hypotheses)
+                    return true;
+                break;
+            default:
+                break;
+        }
+    }
+    return false;
+}
+/** 命中轮（或之前最近一轮）的状态快照——命中发生在工具结果阶段，同轮快照可能还没写。 */
+function baselineAt(records, fire) {
+    let best = null;
+    for (const record of records) {
+        if (record.kind !== "state" || record.sid !== fire.sid)
+            continue;
+        if (record.turn > fire.turn)
+            continue;
+        if (record.at > fire.at)
+            continue;
+        if (!best || record.turn > best.turn || (record.turn === best.turn && record.at > best.at))
+            best = record;
+    }
+    return best;
+}
+function ratio(part, total) {
+    if (total <= 0)
+        return "—";
+    return `${part}/${total}（${Math.round((part / total) * 100)}%）`;
+}
+/**
+ * 人读格式。刻意把**口径**写在数字旁边：没有口径的漂亮数字比没有数字更坏
+ * （「改善率 80%」如果分母是 5 条且窗口是 3 轮，读者必须能看出来）。
+ */
+export function formatMetricsSummary(summary, opts = {}) {
+    const lines = [];
+    lines.push(`Lume 度量${opts.label ? `（${opts.label}）` : ""}：${summary.sessions} 个会话 / ${summary.records} 条记录`);
+    const routeTail = Object.entries(summary.routes.byMode)
+        .sort((a, b) => b[1] - a[1])
+        .map(([mode, count]) => `${mode} ${count}`)
+        .join(" · ");
+    lines.push(`- 路由判定 ${summary.routes.total} 次${routeTail ? `：${routeTail}` : ""}`);
+    const matchedTail = Object.entries(summary.routes.byMatched)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([key, count]) => `${key} ${count}`)
+        .join(" · ");
+    if (matchedTail)
+        lines.push(`  命中判据：${matchedTail}`);
+    const sourceTail = Object.entries(summary.routes.bySource)
+        .map(([key, count]) => `${key} ${count}`)
+        .join(" · ");
+    if (sourceTail)
+        lines.push(`  证据来源：${sourceTail}（text=只看这一句，trajectory/sticky=轨迹补证，correction=纠正后重算）`);
+    const o = summary.outcomes;
+    lines.push(`- 外部结果信号：用户纠正 ${o.corrections} · 重复请求 ${o.repeats} · 问答轮改动 ${o.overreach} · 执行轮零动作 ${o.noAction}`);
+    const wrongModes = Object.entries(o.correctionsByMode)
+        .sort((a, b) => b[1] - a[1])
+        .map(([mode, count]) => `${mode} ${count}`)
+        .join(" · ");
+    if (wrongModes)
+        lines.push(`  纠正落在：${wrongModes}（落在哪个模式上就是哪个模式在误判）`);
+    lines.push(`- 块装配：${summary.blocks.steps} 步，平均 ${summary.blocks.avgChars} 字符 / 预算 ${summary.blocks.budget || 4200}，超预算丢块 ${ratio(summary.blocks.droppedSteps, summary.blocks.steps)}`);
+    if (summary.triggers.length === 0)
+        lines.push("- 触发器：本区间没有命中记录");
+    else {
+        lines.push(`- 触发器效能（**观察性，不是因果**；窗口 ${EFFICACY_WINDOW_TURNS} 轮）：按命中次数 ${ratio(summary.improvedHits, summary.measuredHits)}；按类别 ${summary.improvedTriggers}/${summary.measuredTriggers} 类出现过改善`);
+        lines.push("  判据：窗口内出现「真验证命令」或对应载具（契约/设计/台账/假设）从无到有；没机械口径的类别标「未判定」、不计入分母。");
+        for (const entry of summary.triggers)
+            lines.push(`  · ${entry.id}：命中 ${entry.fired} 次，改善 ${entry.improved}${entry.expect === "none" ? "（无机械口径，未判定）" : ""}`);
+    }
+    return lines.join("\n");
+}

package/lib/core/persona-limits.js

@@ -0,0 +1,25 @@
+/** manifest 内置人设名 —— 自定义创建/删除不可触碰。 */
+export const BUILTIN_PERSONA_NAMES = new Set(["loli", "senpai", "butler", "tsundere", "none"]);
+export const CORPUS_CAP = 12;
+export const CORPUS_LINE_CAP = 240;
+export const MEMORY_CAP = 30;
+export const STYLE_CAP = 20;
+/** 语料净化：只保留 {user?, assistant} 形状的合法样本，超限截断。 */
+export function sanitizeCorpus(value) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        const assistant = item?.assistant;
+        const user = item?.user;
+        if (typeof assistant === "string" && assistant.trim()) {
+            out.push({
+                user: typeof user === "string" ? user.slice(0, CORPUS_LINE_CAP) : "",
+                assistant: assistant.slice(0, CORPUS_LINE_CAP),
+            });
+        }
+        if (out.length >= CORPUS_CAP)
+            break;
+    }
+    return out;
+}