lume-dsh-plugin 0.7.3 → 0.8.0

package/lib/core/citations.js

@@ -0,0 +1,235 @@
+/**
+ * 引用-证据对齐（citation gate）：回答里引用的「文件:行」必须落在本会话**真正读到过**的范围里。
+ *
+ * 现场事故（2026-09-23 turn 18）：模型判「例外是 status（优惠状态）：它不是人工填的，
+ * 系统按生失效时间自动置无效（`WtpfGoodsPrepertyDefServiceImpl:159-160` 的注释）」，
+ * 并据此把「这一列接不接 Excel」丢给用户拍。用户反问后它回读代码，自己承认「我上轮说错，收回」：
+ * 159-160 是 **`if (resultCode.isEmpty())` 单条新增分支**的注释，Excel 导入路径的
+ * `setStatus(tmp.get("优惠状态"))` 在 **534 行**。
+ *
+ * 为什么加「要核实」的散文没用：它**引用了一个真实存在的行号**，它以为自己核实过了。
+ * 唯一能戳破的做法是把它"看过的范围"变成可对照的事实——所以这里维护证据索引，
+ * 只回答一个问题：**你引用的这行，你这次真的打开过吗？**
+ *
+ * 取舍：只对本会话**碰过的文件**生效（没碰过的文件可能来自用户消息或外部文档，不算错），
+ * 且只在回答里出现排除性/决策性措辞时才检查——不能变成每轮都响的噪音。
+ */
+/** 文件被完整读过（没有 offset/limit 的 read）时用的哨兵上限。 */
+export const FULLY_READ = Number.MAX_SAFE_INTEGER;
+/** 归一化路径：`b2i\a\B\Foo.java` 与 `Foo.java` 视为同一个文件。 */
+export function pathKey(file) {
+    const raw = String(file ?? "")
+        .trim()
+        .replace(/\\/g, "/");
+    const base = raw.split("/").filter(Boolean).pop() ?? "";
+    return base.toLowerCase();
+}
+export function newEvidenceIndex() {
+    return new Map();
+}
+function push(index, file, window) {
+    const key = pathKey(file);
+    if (!key)
+        return;
+    const list = index.get(key) ?? [];
+    list.push(window);
+    // 合并相邻/重叠窗口，避免"读过 1-100 两次"就撑出几十条清单（提示里要列给人看）。
+    list.sort((a, b) => a.from - b.from);
+    const merged = [];
+    for (const item of list) {
+        const last = merged[merged.length - 1];
+        if (last && item.from <= last.to + 1)
+            last.to = Math.max(last.to, item.to);
+        else
+            merged.push({ ...item });
+    }
+    index.set(key, merged.slice(-24));
+}
+/** 记录一次 read 类调用覆盖的范围；没有 offset/limit 视为整文件读过。 */
+export function recordReadArgs(index, args) {
+    if (!args || typeof args !== "object")
+        return;
+    const record = args;
+    let file = "";
+    for (const key of ["file_path", "filePath", "path", "file", "filename", "notebook_path"]) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim()) {
+            file = value.trim();
+            break;
+        }
+    }
+    if (!file)
+        return;
+    const rawOffset = Number(record.offset);
+    const rawLimit = Number(record.limit);
+    if (!Number.isFinite(rawOffset) && !Number.isFinite(rawLimit)) {
+        push(index, file, { from: 1, to: FULLY_READ });
+        return;
+    }
+    const from = Number.isFinite(rawOffset) && rawOffset > 0 ? Math.floor(rawOffset) : 1;
+    const to = Number.isFinite(rawLimit) && rawLimit > 0 ? from + Math.floor(rawLimit) - 1 : FULLY_READ;
+    push(index, file, { from, to });
+}
+/** 从工具结果文本里记录「路径:行」命中（grep 输出、带行号的清单）。 */
+export function recordResultText(index, text) {
+    const body = String(text ?? "");
+    if (!body)
+        return;
+    const re = /([A-Za-z0-9_./\\-]+\.[A-Za-z0-9]{1,8})[:：](\d{1,6})(?=[:\s)）]|$)/g;
+    for (const match of body.matchAll(re)) {
+        const line = Number(match[2]);
+        if (!Number.isFinite(line) || line <= 0)
+            continue;
+        push(index, match[1], { from: line, to: line });
+    }
+}
+/** 把引用里的文件名解析到索引里的 key：先精确 basename，再容忍 `Foo.java` ↔ `Foo` 这类简写。 */
+function resolveKey(index, file) {
+    const key = pathKey(file);
+    if (!key)
+        return null;
+    if (index.has(key))
+        return key;
+    for (const candidate of index.keys()) {
+        const dot = candidate.lastIndexOf(".");
+        if (dot > 0 && candidate.slice(0, dot) === key)
+            return candidate;
+    }
+    return null;
+}
+/** 抽取「文件:行」引用。刻意只用 ASCII 正则 + 事后过滤，避免中文标点字符类在编码上出岔子。 */
+export function extractCitations(index, text) {
+    const body = String(text ?? "");
+    if (!body)
+        return [];
+    const out = [];
+    const seen = new Set();
+    const push = (file, key, line) => {
+        const id = `${key}:${line}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        out.push({ file, key, line });
+    };
+    const scan = /([A-Za-z0-9_./\\-]+)[:：](\d{1,6})(?:\s*[-~]\s*(\d{1,6}))?/g;
+    for (const match of body.matchAll(scan)) {
+        const token = match[1];
+        if (!/^[A-Za-z]/.test(token))
+            continue; // 排除 12:34 这类时间/比例
+        const key = resolveKey(index, token);
+        if (!key)
+            continue;
+        const start = Number(match[2]);
+        push(token, key, start);
+        if (match[3])
+            push(token, key, Number(match[3]));
+    }
+    return out;
+}
+/**
+ * 只在回答里出现**排除性 / 决策性**措辞时才做引用核对：这类句子的错误代价最高
+ * （把用户带向错误方案、或让用户在假前提上做决定），而普通陈述句不值得每轮都查。
+ */
+export function shouldCheckCitations(text) {
+    return /例外|不能|不支持|无法|只能|一定要|要你定|你拍|需要你决定|建议不|不建议|风险|必须|没有理由/.test(String(text ?? ""));
+}
+/** 回答里引用过、但本会话从未读到过的行。 */
+export function unsupportedCitations(index, text) {
+    if (!shouldCheckCitations(text))
+        return [];
+    return extractCitations(index, text).filter((item) => !covers(index, item.key, item.line));
+}
+export function covers(index, key, line) {
+    const windows = index.get(key);
+    if (!windows)
+        return false;
+    return windows.some((window) => line >= window.from && line <= window.to);
+}
+/** 渲染某文件读到过的范围（给人看的一句事实，不是训话）。 */
+export function formatWindows(index, key, limit = 6) {
+    const windows = index.get(key) ?? [];
+    const shown = windows
+        .slice(-limit)
+        .map((window) => (window.to >= FULLY_READ ? "整文件" : window.from === window.to ? `${window.from}` : `${window.from}-${window.to}`));
+    return shown.join("、");
+}
+// ── 断言-证据对齐（claim gate）──────────────────────────────────────────────
+//
+// 现场事故（2026-09-23）：文档里写「列表查询的 resultMap 里 create_id/modify_id 都没映射，
+// 查不出来」——**事实是已映射**（DO result 第 12-15 行），而这条错误论据正是「必须另开一列」
+// 这个核心决策的依据。引用核对管不了"没有行号的否定断言"，这里补机械判据：
+//   · 否定断言指向的代码符号本会话从未在任何工具结果里出现过 → 根本没核实过（必顶）；
+//   · 出现过、但断言没给行号，且句子带排除/决策措辞 → 要求补行号。
+// 机械判不了"看过但仍判断错"（那要靠并列事实让人判），但能挡住"没看就断言"。
+/** 太泛的符号不算（出现在任何句子里都不构成"关于代码的断言"）。 */
+const SYMBOL_STOP = new Set([
+    "ok",
+    "true",
+    "false",
+    "null",
+    "undefined",
+    "number",
+    "string",
+    "boolean",
+    "result",
+    "status",
+    "message",
+    "error",
+]);
+/** 代码符号：下划线命名、驼峰命名，或反引号包裹的名字。 */
+export function symbolsIn(text) {
+    const raw = typeof text === "string" ? text : "";
+    if (!raw)
+        return [];
+    const out = new Set();
+    for (const match of raw.matchAll(/`([A-Za-z_][A-Za-z0-9_.]{2,})`/g))
+        out.add(match[1]);
+    for (const match of raw.matchAll(/\b[a-zA-Z][a-zA-Z0-9]*(?:_[a-zA-Z0-9]+)+\b/g))
+        out.add(match[0]);
+    for (const match of raw.matchAll(/\b[a-z][a-z0-9]*[A-Z][A-Za-z0-9]*\b/g))
+        out.add(match[0]);
+    return [...out].filter((symbol) => symbol.length >= 4 && !SYMBOL_STOP.has(symbol.toLowerCase()));
+}
+/** 否定词：断言"它不存在/没做/不支持"。 */
+const NEGATIVE_RE = /(不存在|没有|没映射|没注册|没实现|未映射|未注册|未定义|不支持|尚未|缺少|看不到|查不到|无映射|没做)/;
+/** 排除/决策措辞：这类否定断言直接支撑结论，要求给出处。 */
+const HARD_CLAIM_RE = /(例外|不能|不该|不支持|不存在|没映射|未映射|未注册|要你定|需要你拍)/;
+/** 记录「本会话在工具结果里真见过」的标识符（否定断言的核实底线；只记名字不记内容）。 */
+export function recordSymbols(store, text, cap = 4000) {
+    for (const symbol of symbolsIn(text)) {
+        if (store.size >= cap)
+            break;
+        store.add(symbol);
+    }
+}
+/** 挑出"没核实过就下的否定断言"（给了行号的交给引用核对）。 */
+export function unsupportedClaims(index, seen, text, limit = 3) {
+    const raw = typeof text === "string" ? text : "";
+    if (!raw)
+        return [];
+    const out = [];
+    const used = new Set();
+    for (const sentence of raw.split(/(?<=[。；;！？\n])/)) {
+        if (!NEGATIVE_RE.test(sentence))
+            continue;
+        if (extractCitations(index, sentence).length > 0)
+            continue;
+        const hard = HARD_CLAIM_RE.test(sentence);
+        for (const symbol of symbolsIn(sentence)) {
+            if (used.has(symbol))
+                continue;
+            const known = seen.has(symbol);
+            if (!known) {
+                used.add(symbol);
+                out.push({ symbol, sentence: sentence.trim().slice(0, 120), reason: "unseen" });
+            }
+            else if (hard) {
+                used.add(symbol);
+                out.push({ symbol, sentence: sentence.trim().slice(0, 120), reason: "no-line" });
+            }
+            if (out.length >= limit)
+                return out;
+        }
+    }
+    return out;
+}

package/lib/core/coverage.js

@@ -0,0 +1,149 @@
+/**
+ * 需求覆盖核对（机械部分）：把「交付物到底覆盖了需求的哪几条」从模型的自证，变成插件按**原文**做的外部对照。
+ *
+ * 为什么需要（2026-09-23 现场）：交付文档自称「覆盖需求三全部条目，8 条全有落点，已验证」，而那张对照表
+ * 是模型**自己切条目、自己填落点**——没有外部事实参与，等于自评。同一次交付里实际藏着三类问题：
+ *  ① 与需求原文矛盾（需求第 4 条说历史权限人「待运营梳理后提供」，文档写成「权限人由后端写入」→ 批量写错数据）；
+ *  ② 论据错（文档称 resultMap 没映射 create_id，实际已映射）；
+ *  ③ 落点错（把条件加到 whereSql，而列表查询在 _exp.xml 的 whereGoodsA → 静默失效）。
+ * 这三类都不是"少写一节"的显性缺失，只有把**需求原句**与**交付物里的句子**摆在一起才看得出来。
+ *
+ * 本模块只做机械能做的事：切条目、找提及、查图形引用、查悬空章节号。**语义正确性判不了**，不装。
+ */
+const TOP_ITEM_RE = /^\s*(\d{1,2})\s*[、.．]\s*(.*)$/;
+const SUB_ITEM_RE = /^\s*[（(]\s*(\d{1,2})\s*[)）]\s*(.*)$/;
+const SECTION_RE = /^\s*[一二三四五六七八九十]+\s*[、.．]/;
+/**
+ * 按用户原文的编号切条目——**条目由插件切，不用模型的总结**。
+ * 顶层用 `1、`，子项用 `（1）`；`（图一）` 这类不是条目（只作为图形引用信号）。
+ */
+export function splitRequirementItems(text) {
+    // 落账时换行会被压成空格（实测 lume_project.json 里就是「…新增权限人字段 （1）列表页…」），
+    // 所以先按**编号**把换行重建出来再切。「见 2.6」这类引用不会被误切（点号后接数字不算编号）。
+    const rebuilt = String(text ?? "")
+        .replace(/\s+(?=\d{1,2}\s*、)/g, "\n")
+        .replace(/\s+(?=[（(]\s*\d{1,2}\s*[)）])/g, "\n")
+        .replace(/\s+(?=\d{1,2}\s*[.．]\s*(?!\d))/g, "\n");
+    const lines = rebuilt.split(/\r?\n/);
+    const items = [];
+    let topLabel = "";
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line || /^[-—=*#>`|]+$/.test(line))
+            continue;
+        const sub = SUB_ITEM_RE.exec(line);
+        if (sub) {
+            const label = topLabel ? `${topLabel}(${sub[1]})` : sub[1];
+            if (sub[2].trim())
+                items.push({ index: items.length + 1, label, text: sub[2].trim() });
+            continue;
+        }
+        const top = TOP_ITEM_RE.exec(line);
+        if (top && !SECTION_RE.test(line)) {
+            topLabel = top[1];
+            if (top[2].trim())
+                items.push({ index: items.length + 1, label: topLabel, text: top[2].trim() });
+            continue;
+        }
+        // 无编号的续行：并到上一条（原文里常见的换行折行）
+        if (items.length > 0 && !SECTION_RE.test(line) && !/^[（(]?图/.test(line)) {
+            const last = items[items.length - 1];
+            if (last.text.length < 300)
+                last.text = `${last.text}${line}`;
+        }
+    }
+    return items;
+}
+/** 交付物里提到该条需求的句子（命中判据：与原文共享**未被泛化词污染的三元组**，中文无需分词）。 */
+const GENERIC_GRAM_RE = /[的了和与或、，。；：:?？!！"'"'（）()\s]|需求|本次|新增|调整|支持|可以|需要|具体|提供|之后|例如|当前|展示|进行|内容|要求|相关|直接|默认/;
+export function ngrams(text, n) {
+    const out = [];
+    for (let i = 0; i + n <= text.length; i++) {
+        const gram = text.slice(i, i + n);
+        if (GENERIC_GRAM_RE.test(gram))
+            continue; // 含虚词/标点/泛化词的片段不算
+        if (new Set(gram).size < n)
+            continue;
+        out.push(gram);
+    }
+    return [...new Set(out)];
+}
+function sentencesOf(artifact) {
+    return artifact
+        .split(/\r?\n|[。；;]/)
+        .filter((s) => !/^\s*#{1,6}\s/.test(s)) // 标题行不算"说法"
+        .map((s) => s.replace(/^\s*[|>-]*\s*/, "").trim())
+        .filter((s) => s.length >= 4);
+}
+/**
+ * 逐条找「交付物里提到这条的句子」。取不到就是取不到（如实说"未找到提及"），
+ * 不替模型判定"你漏了"——并列展示之后由它/用户判。
+ */
+export function coverageRows(items, artifact) {
+    const sentences = sentencesOf(artifact);
+    return items.map((item) => {
+        const gram3 = ngrams(item.text, 3);
+        const gram4 = ngrams(item.text, 4);
+        const scored = [];
+        for (const sentence of sentences) {
+            const hits4 = gram4.filter((gram) => sentence.includes(gram));
+            const hits = hits4.length > 0 ? hits4 : gram3.filter((gram) => sentence.includes(gram));
+            if (hits.length === 0)
+                continue;
+            hits.sort((a, b) => b.length - a.length);
+            scored.push({ text: sentence.slice(0, 110), gram: hits[0], tier: hits4.length > 0 ? 0 : 1 });
+        }
+        // 有强命中的条目就只用强命中（弱片段如「量数据」会把真正的句子挤掉）
+        const pool = scored.some((s) => s.tier === 0) ? scored.filter((s) => s.tier === 0) : scored;
+        pool.sort((a, b) => b.gram.length - a.gram.length);
+        return { label: item.label, text: item.text, mentions: pool.slice(0, 3).map(({ text, gram }) => ({ text, gram })) };
+    });
+}
+/** 需求里引用了图/附件（交互细节常在图里，最容易漏）。 */
+export function hasFigureRefs(text) {
+    return /图[一二三四五六七八九十\d]|如图|截图|附件/.test(String(text ?? ""));
+}
+/** 交付文案里引用的章节号是否真的存在于交付物里（落点编造/章节被删的机械判据）。 */
+export function danglingSectionRefs(deliveryText, artifact) {
+    const headings = new Set();
+    const headingRe = /^#{1,6}\s*(\d{1,2}(?:\.\d{1,2}){0,2})/gm;
+    let m;
+    while ((m = headingRe.exec(artifact)) !== null)
+        headings.add(m[1]);
+    if (headings.size < 3)
+        return []; // 交付物没有稳定编号体系 → 这条核对不成立
+    const refs = new Set();
+    const refRe = /\b(\d{1,2}\.\d{1,2}(?:\.\d{1,2})?)\b/g;
+    while ((m = refRe.exec(String(deliveryText ?? ""))) !== null)
+        refs.add(m[1]);
+    return [...refs].filter((ref) => !headings.has(ref) && ![...headings].some((h) => h.startsWith(`${ref}.`)));
+}
+/**
+ * 「评审意见」的判别：用户把评审（或自己写的评审）整段贴进来时，它不是需求原文。
+ * 现场：需求原文锚点被轮出表外，表里塞满评审粘贴 → 覆盖核对把评审条目当需求逐条列了（误导）。
+ */
+export function looksLikeReview(text) {
+    return /评审|必须处理|认同|反驳|优先级|开发文档|文档\s*\d|第\s*\d+\s*条|我核了|全文|核实结果|高优先级/.test(String(text ?? ""));
+}
+/** 「需求原文」的判别：有逐条编号结构，且不是评审。 */
+export function isRequirementStatement(text) {
+    const body = String(text ?? "");
+    if (looksLikeReview(body))
+        return false;
+    const numbered = (body.match(/\d{1,2}\s*[、.．]\s*(?!\d)/g) ?? []).length;
+    const subbed = (body.match(/[（(]\s*\d{1,2}\s*[)）]/g) ?? []).length;
+    if (numbered + subbed >= 2)
+        return true;
+    return body.length >= 200 && /需求[一二三四五六七八九十\d]|新增|调整为|验收|批量导入/.test(body);
+}
+/**
+ * 从锚点里挑出**需求原文语料**（覆盖核对只该对着它做）。
+ * 表里混着闲聊与评审粘贴，所以：过滤评审 → 取最长的需求陈述 → 都没有就返回空串（**宁可不做也不做错**）。
+ */
+export function pickRequirementCorpus(items) {
+    const candidates = items.map((i) => String(i.text ?? "")).filter((t) => isRequirementStatement(t));
+    if (candidates.length === 0)
+        return "";
+    candidates.sort((a, b) => b.length - a.length);
+    return candidates[0];
+}

package/lib/core/dialogue-mining.js

@@ -202,7 +202,9 @@ function cleanChatContent(lines) {
 }
 /** 聊天记录模式挖掘：目标说话人（hint 或最高频）为台词主源，其余归用户侧。 */
 export function mineChatLog(chat, hint) {
-    const target = hint?.trim() ? (chat.speakers.find((s) => s === hint.trim() || s.includes(hint.trim()) || hint.trim().includes(s)) ?? null) : null;
+    const target = hint?.trim()
+        ? (chat.speakers.find((s) => s === hint.trim() || s.includes(hint.trim()) || hint.trim().includes(s)) ?? null)
+        : null;
     const speaker = target ?? chat.speakers[0] ?? null;
     const targetLines = chat.messages.filter((m) => m.speaker === speaker).map((m) => m.text);
     const otherLines = chat.messages.filter((m) => m.speaker !== speaker).map((m) => m.text);
@@ -219,7 +221,7 @@ export function mineChatLog(chat, hint) {
     };
     for (const m of chat.messages) {
         if (m.speaker === speaker) {
-            const gap = pendingAt && m.timestamp ? (toMillis(m.timestamp) - toMillis(pendingAt)) : null;
+            const gap = pendingAt && m.timestamp ? toMillis(m.timestamp) - toMillis(pendingAt) : null;
             // 超过 6 小时视为新话题，不能把前一天的闲聊拼成当前回复的上下文。
             if (pendingUser.length > 0 && m.text.length <= 240 && (gap === null || (gap >= 0 && gap <= 6 * 60 * 60 * 1000))) {
                 pairs.push({ user: pendingUser.join(" ").slice(-240), assistant: m.text });
@@ -235,12 +237,15 @@ export function mineChatLog(chat, hint) {
     }
     // 契约不能只看目标单边台词：保留每条目标消息前后的小窗口，学习触发条件、
     // 关系距离和情绪转折。窗口只进蒸馏 prompt，不会污染最终 few-shot 语料。
-    const targetIndexes = chat.messages.map((m, i) => m.speaker === speaker ? i : -1).filter((i) => i >= 0);
+    const targetIndexes = chat.messages.map((m, i) => (m.speaker === speaker ? i : -1)).filter((i) => i >= 0);
     const contexts = [];
     for (const i of evenSample(targetIndexes, 16)) {
         const start = Math.max(0, i - 3);
         const end = Math.min(chat.messages.length, i + 2);
-        const window = chat.messages.slice(start, end).map((m) => `${m.speaker === speaker ? "目标" : "用户"}：${m.text}`).join("\n");
+        const window = chat.messages
+            .slice(start, end)
+            .map((m) => `${m.speaker === speaker ? "目标" : "用户"}：${m.text}`)
+            .join("\n");
         contexts.push(window.slice(0, 700));
     }
     const targetTexts = targetLines;
@@ -275,7 +280,12 @@ export function mineChatLog(chat, hint) {
         return null;
     };
     // 用户给目标的备注（如「老公」）= 用户如何称呼目标；目标消息里的称呼词（如「老婆」）= 目标如何称呼用户
-    const userToTarget = [...new Set([...RELATION_WORDS.filter((w) => speaker !== null && speaker.includes(w)), ...userLines.map(greetingOf).filter((w) => Boolean(w))])].slice(0, 6);
+    const userToTarget = [
+        ...new Set([
+            ...RELATION_WORDS.filter((w) => speaker !== null && speaker.includes(w)),
+            ...userLines.map(greetingOf).filter((w) => Boolean(w)),
+        ]),
+    ].slice(0, 6);
     const targetToUser = [...new Set(targetLinesAll.map(greetingOf).filter((w) => Boolean(w)))].slice(0, 6);
     const relationship = { userToTarget, targetToUser };
     return {
@@ -296,15 +306,43 @@ export function mineChatLog(chat, hint) {
 }
 /** 关系称呼词：出现在对话中即揭示双方关系定位。 */
 const RELATION_WORDS = [
-    "老公", "老婆", "媳妇", "弟妹", "宝宝", "宝贝", "亲爱的",
-    "爸爸", "妈妈", "爸", "妈", "爹", "娘",
-    "哥", "姐", "弟", "妹", "哥哥", "姐姐", "弟弟", "妹妹",
-    "师傅", "师父", "老板", "同事", "闺蜜", "兄弟", "哥们", "姐妹",
-    "女神", "男神", "前男/女友", "前男友", "前女友",
+    "老公",
+    "老婆",
+    "媳妇",
+    "弟妹",
+    "宝宝",
+    "宝贝",
+    "亲爱的",
+    "爸爸",
+    "妈妈",
+    "爸",
+    "妈",
+    "爹",
+    "娘",
+    "哥",
+    "姐",
+    "弟",
+    "妹",
+    "哥哥",
+    "姐姐",
+    "弟弟",
+    "妹妹",
+    "师傅",
+    "师父",
+    "老板",
+    "同事",
+    "闺蜜",
+    "兄弟",
+    "哥们",
+    "姐妹",
+    "女神",
+    "男神",
+    "前男/女友",
+    "前男友",
+    "前女友",
 ];
 /** 真实事件信号：生日/纪念/年份/岁数/共同经历/对方身份事实/约定。 */
 const MEMORY_EVENT_RE = /生日|纪念|周年|过完生日|周岁|去[^。，]{0,12}(过|去|玩|旅游)|第一次|那一年|去年|前年|过年|春节|中秋|国庆|跨年|毕业|结婚|认识[^。，]{0,10}年|领养|搬[^。，]{0,6}家|换工作|辞职|入职|生[了过][^。，]{0,8}(孩子|小孩|女儿|儿子)|考[上完研][^。，]{0,8}|我做|我是[^。，]{0,10}(医生|老师|老师|程序员|设计师)|我[在学过][^。，]{0,10}(编程|画画|钢琴|吉他)/;
-export const MEMORY_POINT_CAP = 12;
 /** 对话流单条消息字数上限（超限截断，保留开头）。 */
 const FLOW_LINE_CAP = 160;
 /** 对话流总字数预算：聊天记录可达 20 万字，记忆提炼 prompt 吃不下全文；

package/lib/core/knowledge.js

@@ -0,0 +1,165 @@
+/**
+ * 明面上要拒绝的内容：**带值的**密钥/密码/令牌/连接串，以及"某密钥可解"这类结论。
+ *
+ * 刻意区分「凭证名」与「凭证值」：`-Djasypt.encryptor.password` 只是参数名（正当约定，该留），
+ * 而 `password=ENC(…)`、`jdbc:postgresql://…`、`api_key` 这类才是要挡的。
+ * 第一版把前者也挡了——测试与现场清理都抓到了这个误杀。
+ */
+const SENSITIVE_RE = /(password|passwd|pwd|secret|token)\s*[:=]|ENC\(|BEGIN [A-Z ]*PRIVATE KEY|jdbc:[a-z]+:\/\/|connection\s*string|api[_-]?key|private[_-]?key|access[_-]?key|密钥|凭证|实测可解/i;
+export function looksSensitive(text) {
+    return SENSITIVE_RE.test(String(text ?? ""));
+}
+/**
+ * 证据锚点：没有这些东西的句子只是议论，不该进跨会话知识。
+ * 文件锚点刻意放宽到「任意非空白 token + 扩展名」——现场句子常是 `doc/<需求>/08-建表语句（表名）.sql`，
+ * 用 `\w` 匹配会把中文与括号挡掉（测试抓到的第一版漏洞）。
+ */
+const ANCHOR_RE = /([A-Za-z]:\\|\/[\w.-]+\/)|[^\s/\\|，。；]+\.(java|xml|sql|yml|yaml|json|md|ts|tsx|js|py|go|cs|kt|properties|sh|ps1)\b|\b[A-Z][A-Z0-9_]{4,}\b|\b(mvn|gradle|npm|pnpm|yarn|docker|kubectl|psql|mysql|redis-cli|python|pip|dotnet|go|cargo|make|git|icacls|chmod|rsync|systemctl|curl)\b/;
+/**
+ * 死路判据：谓词 + 对象/证据。
+ *
+ * 为什么加锚点（2026-09-24 审核指出误报）：原来只要有「不可用」就算死路，于是我们自己的诊断文案
+ * ——「落点不可用：宿主没提供 DSH_HOME…」——被记成死路，污染了最值钱的一类知识。
+ * 现在只认**明确的"怎么都不行"谓词**（行不通/跑不了/用不了/不可行/已经不行，以及带对象的"不支持"）。
+ *
+ * 为什么连「不可用」都删了（二审指出）：第一版用「负向断言豁免名单」挡自己的文案，看着像修好了，
+ * 其实「不可用」依旧单独立案——「身份域不可用」「载具不可用」照收不误，换个词同一个 bug 原样再来。
+ * 判据必须是**谓词 + 对象**，而不是「某个词 + 一张例外表」。
+ */
+const DEADEND_RE = /(?:行不通|跑不了|用不了|不可行|已经不行)[^。；\n]{0,40}|(?:不支持|不再维护|unsupported|not supported)[^。；\n]{0,40}(?:[A-Za-z0-9_./\\-]{3,}|版本|依赖|命令|报错|平台)/i;
+/** 四类机械可判的事实。刻意写窄：宁可漏掉，也不要把建议/议论灌进知识库。 */
+const KIND_RULES = [
+    // 构建/测试：必须出现"命令"语义（否则"构建通过"这种临时结果不值得跨会话留）
+    { kind: "build", re: /(构建|编译|打包|build)[^。；\n]{0,30}(命令|用\s*\S{2,30}\s*(执行|跑)|是\s*\S{2,30})/i },
+    { kind: "test", re: /(测试|用例|单测|test)[^。；\n]{0,30}(命令|用\s*\S{2,30}\s*(执行|跑)|入口是)/i },
+    // 死路：说清"行不通"，这是最值钱的一类（避免重复踩）。
+    // 判据 = 谓词 + 锚点（2026-09-24 审核指出误报）：
+    // 「不可用」太泛，我们自己的诊断文案就带它——「落点不可用：宿主没提供 DSH_HOME…」曾被记成死路，
+    // 直接污染了最值钱的一类。现在要么是明确的"跑不了/行不通"表述，要么「不支持」类必须带具体对象。
+    { kind: "deadend", re: DEADEND_RE },
+    // 约定：只认"项目/仓库/团队 + 一律/必须/统一"这种规范性表述
+    { kind: "convention", re: /(约定|规范|一律|统一|必须|禁止)[^。；\n]{0,60}/ },
+];
+/**
+ * 明确的"别记"特征：
+ * - 给人建议（我们只沉淀**事实**，不沉淀建议）；
+ * - 提问（问题不是知识）；
+ * - **宿主运行时快照**（它经 user/message 通道投递，里面全是 policy 文本与路径）。
+ */
+/** 工具输出里的脚手架行：不是事实，是检索/回显的格式（`63: …`、`Line 164: …`、`Found 3 of 9 matches`）。 */
+const SCAFFOLD_RE = /(Found \d+ of \d+ matches|^\s*Line\s*\d+\s*[:：]|^\s*L\d{2,}\s*[:：]|\b\d{1,5}\s*[:：]\s)/;
+/** 纯路径 / 纯标识符行：只有定位信息、没有事实内容（现场噪音最大的一类）。 */
+const PATH_ONLY_RE = /^[\w\\./:\-()（）<>@$\u4e00-\u9fa5]+$/;
+/** 去掉行首的编号/引用标记，让真句子上来参与判据与存储。 */
+function stripScaffold(line) {
+    return line
+        .replace(/^\s*(?:Line\s*\d+\s*[:：]|\d{1,5}\s*[:：]|>|#|\*|-)\s*/, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+const REJECT_RE = /(建议你|你可以|请把|请给|你应该|需要你|那条|这条|上述|前面那|刚才那)|Current runtime context|runtime context|file policy|workspace-write|approval policy|supersedes earlier|^\s*(#|【|一、|二、|三、)/;
+/**
+ * **形状**拒收：代码/测试产物/表格行/清单片段——它们不是句子，也不是事实。
+ *
+ * 为什么必须有（2026-09-24 真机数据，外部审核指出「它在往 DSH 嘴里塞垃圾」）：
+ * Lume 工作区 18 条知识里 11 条是本仓开发过程的产物——vitest 用例名（`✓ test/tools.test.ts > …`）、
+ * 源码注释（`/** 可省略：…`）、CHANGELOG 句子、markdown 表格行、测试代码（`expect(…)`）。
+ * 根因：这套形状过滤当时**只对非 tool 来源生效**，而噪音恰好全走 tool 通道（读文件/跑测试的输出）。
+ * 现在一律先过形状闸，再谈判据。
+ */
+const TEST_RUN_RE = /(?:^|\s)[✓✗×]\s|\b\d+\s*ms\s*$|test\/[\w./-]+\.test\.ts\s*[>›]/;
+const CODE_SHAPE_RE = /(expect\(|\.toBe\(|\.toHaveLength\(|=>|\/\*\*|\*\/|^\s*\/\/|\{\s*\"|^\s*\+\s*\w|^\s*const\s|^\s*let\s|\t|\u0060\u0060\u0060)/;
+/** 表格行（`| a | b |`）：文档片段不是事实。 */
+const TABLE_ROW_RE = /^\s*\|/;
+/**
+ * 复制粘贴的命令行（真机剩的那条噪音就是这个形状：`npm run lint   # 架构规则（…）`）。
+ * 形状清单永远补不全，所以这条按**类别**拦：命令行开头 + 注释符，或含 shell 的管道/重定向。
+ */
+const COMMAND_LINE_RE = /^\s*(?:npm|pnpm|npx|yarn|node|git|python|pip|mvn|gradle|go|cargo|make|tsc|vitest|jest|dotnet|docker|kubectl|psql|curl)\b[^\n]*#|2>&1|\|\s*(?:head|tail|grep|findstr|Select-String|Select-Object)\b/;
+/** 清单/引用/标题片段（`- x`、`* x`、`> x`、`# x`、`3. x`、`③ x`）：脱离上下文没有意义。 */
+const LIST_FRAGMENT_RE = /^\s*(?:[-*+>#]\s|\d+[.)]\s|[①-⑳])/;
+/** 问句不收：以问号收尾的句子是问题，不是可复用事实。 */
+const QUESTION_RE = /[?？]\s*$/;
+const MIN_LEN = 12;
+const MAX_LEN = 200;
+/**
+ * 从一段文本里挑出值得跨会话保留的项目事实。
+ *
+ * @param text 工具结果或助手可见文本
+ * @param options.userText 用户原话——与它高度重合的句子不回记（用户说过的不是"沉淀"）
+ * @param options.max 单次最多产出（默认 2；调用方还会按会话总上限再收一次）
+ */
+export function extractKnowledgeCandidates(text, options = {}) {
+    const raw = String(text ?? "");
+    if (!raw || raw.length < MIN_LEN)
+        return [];
+    const max = options.max ?? 2;
+    const source = options.source ?? "tool";
+    // 用户的规范陈述判据：比工具/助手更严——它会被当成权威跨会话复用，收错了代价最大
+    const USER_RULE_RE = /(必须|一律|统一|禁止|不要|别用|不能|唯一|按\s*\S{2,20}\s*(做|来|办)|约定|规范|标准是)/;
+    const userText = String(options.userText ?? "");
+    const out = [];
+    const seen = new Set();
+    // 按行/句切：保留带路径的行，去掉空行与纯装饰行
+    for (const piece of raw.split(/[\n。；;]+/)) {
+        if (out.length >= max)
+            break;
+        const sentence = stripScaffold(piece);
+        if (sentence.length < MIN_LEN || sentence.length > MAX_LEN)
+            continue;
+        // 现场噪音三类：检索脚手架、纯路径行、代码/文档的引用碎片
+        // 形状闸：对所有来源都生效（这一条就是上一版漏掉的那半扇门）
+        if (TEST_RUN_RE.test(sentence) || CODE_SHAPE_RE.test(sentence) || TABLE_ROW_RE.test(sentence) || COMMAND_LINE_RE.test(sentence))
+            continue;
+        if (SCAFFOLD_RE.test(piece) && !/[。，、]|必须|一致|不要|禁止/.test(sentence))
+            continue;
+        if (PATH_ONLY_RE.test(sentence))
+            continue;
+        if (REJECT_RE.test(sentence))
+            continue;
+        if (QUESTION_RE.test(sentence))
+            continue;
+        if (looksSensitive(sentence))
+            continue;
+        if (!ANCHOR_RE.test(sentence))
+            continue;
+        // 用户自己说过的话不算沉淀（那是锚点该管的）
+        if (userText && userText.includes(sentence.slice(0, 40)))
+            continue;
+        const rule = KIND_RULES.find((item) => item.re.test(sentence));
+        // 来源分流：用户来源只收「规范陈述」（否则会把需求描述当成项目知识）；
+        // 助手来源不采对话性句子（「我们/你要不要」那是交互，不是项目事实）。
+        if (source === "user" && !USER_RULE_RE.test(sentence))
+            continue;
+        if (source === "assistant" && /(我们|咱|你我|请问|要不要|这轮|这一轮|注入块|我前面|我刚才|上面我)/.test(sentence))
+            continue;
+        // 非工具来源额外降噪（真机精度循环结果：这两类最容易混进片段与"一次性动作"）：
+        // - 一次性动作（改成/补一句/过一遍/复核/同步到）是任务步骤，不是可复用知识；
+        // - 片段续写词（同理/另外/同时/还有）与引用符号（§、连续 →、✅、L\d+-\d+）说明它不是完整句子；
+        // - 表格行/清单行不是知识。
+        if (source !== "tool") {
+            if (/(改成|改为|补一句|补上|加一句|过一遍|复核|同步到|替换成|写成|落库到)/.test(sentence))
+                continue;
+            if (/^(同理|另外|同时|还有|以及|此外|且)/.test(sentence))
+                continue;
+            if (/(§|\u2705|L\d{2,}-\d{2,}|→.*→)/.test(sentence))
+                continue;
+        }
+        // 清单片段：工具/助手来源一律不收；**用户来源放行**（用户贴的规范条目就是一等公民）
+        if (source !== "user" && LIST_FRAGMENT_RE.test(sentence))
+            continue;
+        if (!rule)
+            continue;
+        // 助手来源的**死路**不收：那是对"能不能做"的判断，必须由真实执行结果或用户原话支撑。
+        // （真机里 5 条「死路」全是助手在讨论自己的判据——「一句话里没有任何行不通的语义…」。）
+        // 约定/构建/测试仍收：项目约定常常只在助手归纳时才成型，这是原设计的明文意图。
+        if (source === "assistant" && rule.kind === "deadend")
+            continue;
+        const key = sentence.slice(0, 60);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ kind: rule.kind, text: sentence.slice(0, MAX_LEN) });
+    }
+    return out;
+}

package/lib/core/leak-detector.js

@@ -10,9 +10,7 @@
  */
 /** 剥去 fenced 代码块与行内代码——代码内容不属于「说话方式」。 */
 export function stripCode(text) {
-    return text
-        .replace(/```[\s\S]*?```/g, " ")
-        .replace(/`[^`\n]*`/g, " ");
+    return text.replace(/```[\s\S]*?```/g, " ").replace(/`[^`\n]*`/g, " ");
 }
 export const DEFAULT_LEAK_THRESHOLD = { distinctWords: 2, singleWordCount: 3 };
 /**