lume-dsh-plugin 0.7.3 → 0.8.0

package/lib/core/scope.js

@@ -0,0 +1,124 @@
+/**
+ * 知识作用域：把「这个仓库怎么干活」和「这个需求特有的结论」分开。
+ *
+ * 为什么需要：知识按**工作目录**共享（同一仓库的所有需求共用一份）。好处是通用约定一次学会处处可用；
+ * 坏处是**需求特有的结论会污染别的需求**——「优惠视图的列名用 PERMISSION_NAME」对退费需求毫无意义，
+ * 却会出现在它的注入里，既占额度又误导。
+ *
+ * 判定全部机械（零 token、可测）：
+ * - 命中任务指代词（本次/这个需求/该需求/本需求…）→ task；
+ * - 命中**需求标题的显著词**（标题里 ≥2 字、且不在通用词表里的词）→ task（并记下归属哪个需求）；
+ * - 其余 → repo（构建/测试/模块链路/通用约定/环境坑，这些对同仓库所有需求都成立）。
+ *
+ * 保守取向：拿不准就归 repo —— 少给一条通用知识比多给一条无关知识代价大。
+ */
+/** 任务指代：出现这些词说明句子在讲"当前这个需求"。 */
+const TASK_POINTER_RE = /(本次|这次|当前需求|这个需求|该需求|本需求|此需求|这条需求|本方案|这个方案)/;
+/** 通用词表：太常见，不能作为"需求特有词"（否则任何句子都会被判成 task）。 */
+const GENERIC_WORDS = new Set([
+    "新增",
+    "修改",
+    "删除",
+    "字段",
+    "接口",
+    "页面",
+    "列表",
+    "导入",
+    "导出",
+    "查询",
+    "数据",
+    "脚本",
+    "文档",
+    "需求",
+    "功能",
+    "问题",
+    "方案",
+    "代码",
+    "配置",
+    "权限",
+    "用户",
+    "订单",
+    "系统",
+    "平台",
+    "管理",
+    "服务",
+    "数据库",
+    "表结构",
+    "测试",
+    "构建",
+    "部署",
+    "上线",
+    "回滚",
+    "迁移",
+    "校验",
+    "统计",
+    "报表",
+    "通知",
+]);
+/**
+ * 需求标题的显著词：切出 ≥2 字的中文片段与 ≥3 字的英文词，去掉通用词。
+ * 例：「B2I 优惠视图新增字段」→ [b2i, 优惠视图]（"新增/字段"是通用词，丢掉）。
+ */
+export function taskKeywords(title) {
+    const raw = String(title ?? "").toLowerCase();
+    const english = (raw.match(/[a-z][a-z0-9]{2,}/g) ?? []).filter((word) => !GENERIC_WORDS.has(word));
+    const chinese = (raw.match(/[\u4e00-\u9fff]{2,}/g) ?? []).flatMap((run) => {
+        // 长片段再切 2~4 字滑窗，让"优惠视图新增字段"里的"优惠视图"能被单独识别
+        if (run.length <= 4)
+            return [run];
+        const out = [];
+        for (let size = 4; size >= 2; size--)
+            for (let i = 0; i + size <= run.length; i++)
+                out.push(run.slice(i, i + size));
+        return out;
+    });
+    return [...new Set([...english, ...chinese])].filter((word) => !GENERIC_WORDS.has(word));
+}
+/**
+ * 判定一条知识的作用域。
+ *
+ * 现场问题（2026-09-24）：判据原先只用**会话标题**，而标题常是"接着优惠视图的任务干活"这种临时话 →
+ * 判不出归属 → 40 条知识全归 repo → 任何需求都能看到全部知识 → 模型从"退费 / 优惠视图 / 通用约定"
+ * 三条线索里读出了**三个需求**（实际只有两个；WTPF_GOODS_PROPERTY_DEF 就是优惠视图那张表）。
+ *
+ * 现在优先按**仓库里真实存在的需求名**归属（来自 `<cwd>/doc/*`）：命中多个取最长的（更具体）。
+ * `taskTitle` 只作为兜底。
+ */
+export function classifyScope(text, input) {
+    const options = typeof input === "string" || input == null ? { taskTitle: input ?? null } : input;
+    const body = String(text ?? "").toLowerCase();
+    let best = null;
+    for (const hint of options.requirementHints ?? []) {
+        const name = String(hint?.name ?? "").trim();
+        if (!name)
+            continue;
+        // 需求名切词（中文 2~4 字窗口）+ 文档里抽到的标识符（表名/常量/字段名）
+        for (const keyword of [...taskKeywords(name), ...(hint.keywords ?? [])]) {
+            const token = String(keyword).toLowerCase();
+            if (token.length < 2 || !body.includes(token))
+                continue;
+            if (!best || token.length > best.score)
+                best = { name, score: token.length };
+        }
+    }
+    if (best)
+        return { scope: "task", task: best.name };
+    const title = String(options.taskTitle ?? "").trim();
+    // 标题可能是"首条用户消息"被截断的样子（含方括号/换行/过长）——那种**不是需求名**，
+    // 拿它当 task 标签会造出 `[系统背景与诊断事实] 你是 DSH…` 这种垃圾归属（现场见过）。
+    if (!title || title.length > 30 || /[[\]\n\r]/.test(title))
+        return { scope: "repo" };
+    if (TASK_POINTER_RE.test(body))
+        return { scope: "task", task: title };
+    const hit = taskKeywords(title).some((keyword) => keyword.length >= 2 && body.includes(keyword));
+    return hit ? { scope: "task", task: title } : { scope: "repo" };
+}
+/** 这条知识能不能给"当前需求"看：通用知识人人可见，需求知识只给同一需求。 */
+export function visibleForTask(fact, currentTask) {
+    if (fact.scope !== "task")
+        return true;
+    const current = String(currentTask ?? "").trim();
+    if (!current)
+        return false; // 冷启动/无标题：需求级知识先不给，避免误导
+    return fact.task === current;
+}

package/lib/core/signals.js

@@ -1,12 +1,90 @@
 const PLAN_TOKENS = new Set(["todo", "plan", "contract", "change", "ledger", "hypothesis", "note"]);
 const LUME_TOKENS = new Set(["lume"]);
 const VERIFY_TOKENS = new Set([
-    "bash", "shell", "pwsh", "powershell", "cmd", "terminal", "run", "exec", "job", "make", "mvn", "gradle",
-    "npm", "pnpm", "yarn", "bun", "deno", "node", "tsc", "tsdown", "vite", "vitest", "jest", "pytest", "cargo",
-    "go", "dotnet", "msbuild", "compile", "build", "test", "lint", "typecheck", "check", "verify",
+    "bash",
+    "shell",
+    "pwsh",
+    "powershell",
+    "cmd",
+    "terminal",
+    "run",
+    "exec",
+    "job",
+    "make",
+    "mvn",
+    "gradle",
+    "npm",
+    "pnpm",
+    "yarn",
+    "bun",
+    "deno",
+    "node",
+    "tsc",
+    "tsdown",
+    "vite",
+    "vitest",
+    "jest",
+    "pytest",
+    "cargo",
+    "go",
+    "dotnet",
+    "msbuild",
+    "compile",
+    "build",
+    "test",
+    "lint",
+    "typecheck",
+    "check",
+    "verify",
+]);
+const MUTATE_TOKENS = new Set([
+    "edit",
+    "write",
+    "multiedit",
+    "patch",
+    "apply",
+    "replace",
+    "create",
+    "delete",
+    "remove",
+    "rename",
+    "move",
+    "append",
+    "insert",
+    "mkdir",
+    "apply_patch",
+]);
+const INSPECT_TOKENS = new Set([
+    "read",
+    "view",
+    "cat",
+    "grep",
+    "search",
+    "glob",
+    "find",
+    "ls",
+    "list",
+    "tree",
+    "analyze",
+    "symbol",
+    "reference",
+    "web",
+    "fetch",
+    "browser",
+    "screenshot",
+    "image",
+    "git",
+    "status",
+    "diff",
+    "log",
+    "show",
+    "stat",
+    "head",
+    "tail",
+    "query",
+    "sql",
+    "map",
 ]);
-const MUTATE_TOKENS = new Set(["edit", "write", "multiedit", "patch", "apply", "replace", "create", "delete", "remove", "rename", "move", "append", "insert", "mkdir", "apply_patch"]);
-const INSPECT_TOKENS = new Set(["read", "view", "cat", "grep", "search", "glob", "find", "ls", "list", "tree", "analyze", "symbol", "reference", "web", "fetch", "browser", "screenshot", "image", "git", "status", "diff", "log", "show", "stat", "head", "tail", "query", "sql", "map"]);
 /** 把工具名切成小写词元：`lume_contract` → [lume, contract]；`mcp__fs__read_file` → [mcp, fs, read, file]。 */
 function tokens(name) {
     return String(name ?? "")
@@ -14,6 +92,140 @@ function tokens(name) {
         .split(/[^a-z0-9]+/)
         .filter(Boolean);
 }
+/**
+ * 「真验证」判据（C1 自动推进台账用）：命令文本真的在跑编译/测试/检查，
+ * 而不是 `git grep`、`ls` 这类同样归入 verify 类的通用命令。
+ *
+ * 为什么需要它：把 `git grep` 当成一次验证，会把"未验证"洗白——那比不做更糟。
+ * 所以取**宁窄勿宽**：宁可少自动推进几条，也不能让台账撒谎。
+ */
+export const REAL_VERIFY_RE = /(?:^|[\s&|;"'])(?:tsc|tsdown|vitest|jest|mocha|pytest|mvn|gradle|gradlew|npm|pnpm|yarn|bun|deno|go|dotnet|cargo|make)\s[^&|]*\b(?:test|build|lint|typecheck|check|verify|compile|package|vitest|tsc)\b|node_modules[\\/]\.bin[\\/]|--noEmit|\btsc\b|\bvitest\b|\btsdown\b/i;
+export function isRealVerifyCommand(args) {
+    const body = typeof args === "string" ? args : JSON.stringify(args ?? "");
+    return REAL_VERIFY_RE.test(body);
+}
+/**
+ * 把一次改动工具的入参压成一句可读摘要（自动台账用）。
+ *
+ * 为什么需要：自动台账原来只写「（自动）由 edit 修改」——交付对账要靠它列条目，
+ * 而这种文案对模型没有任何信息量（它不知道改了哪一行、改成了什么），对账就沦为形式。
+ */
+/** 交付物正文（覆盖核对要用全文，不是首行摘要）。 */
+export function toolArtifactText(args) {
+    const record = (args && typeof args === "object" ? args : null);
+    if (!record)
+        return "";
+    const parts = [record.content, record.new_string, record.newString, record.new_str, record.text, record.new_text];
+    const edits = Array.isArray(record.edits) ? record.edits : [];
+    for (const edit of edits) {
+        if (edit && typeof edit === "object")
+            parts.push(edit.new_string, edit.content);
+    }
+    return parts.filter((p) => typeof p === "string" && p.trim().length > 0).join("\n");
+}
+export function summarizeToolChange(args, toolName) {
+    const record = (args && typeof args === "object" ? args : null);
+    if (!record)
+        return `由 ${toolName} 修改`;
+    const candidates = [
+        record.new_string,
+        record.newString,
+        record.new_str,
+        record.content,
+        record.text,
+        record.new_text,
+        record.contents,
+    ];
+    const edits = Array.isArray(record.edits) ? record.edits : [];
+    for (const edit of edits) {
+        if (edit && typeof edit === "object")
+            candidates.push(edit.new_string, edit.content);
+    }
+    for (const candidate of candidates) {
+        if (typeof candidate !== "string" || !candidate.trim())
+            continue;
+        const firstLine = candidate
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .find((line) => line.length > 0) ?? "";
+        if (!firstLine)
+            continue;
+        return firstLine.replace(/\s+/g, " ").slice(0, 70);
+    }
+    const path = record.path ?? record.file_path ?? record.filePath;
+    return path ? `${toolName} 改了 ${String(path)}（未取到内容摘要）` : `由 ${toolName} 修改`;
+}
+/**
+ * 数「抛回给用户的待确认清单」有几项（提问纪律的结构化核对）。
+ *
+ * 现场（2026-09-23 turn 20）：用户只问「现在方案是不是都清楚了？」，模型回了 4 条"待你定"
+ * （生产库类型 / status 口径 / 权限人下拉来源 / 分页 total），用户直接反问「分页还能有疑问？
+ * 不就是改前端的吗」，模型下一轮自己承认「三个是我自己造的，撤」——而那一轮的上下文里
+ * **没有**「提问前提必须已核实」这条（它当时只挂在〔需求解读〕上，而需求解读只在"用户给了
+ * 新需求"的轮次出现）。规则在不在场，决定它会不会自查。
+ *
+ * 判据只做**结构计数**，不做语义猜测：出现"待定/待确认/还没定/不确定"这类小节标题后，
+ * 紧跟的列表项数量。目的不是判断问题对不对，而是把"你抛了几个问题"这个事实摆出来。
+ */
+export const MAX_OPEN_QUESTIONS = 2;
+const OPEN_QUESTION_HEADING_RE = /待定|待确认|还没定|未定|不确定|需要你|要你定|请你确认/;
+const LIST_ITEM_RE = /^\s*(?:(?:[-*•](?!\*))|\d+\s*[.、)]|[一二三四五六七八九十]+\s*[、.])/;
+const QUESTION_ITEM_RE = /待你定|待定|待确认|要你定|你定|请你确认|需要你确认/;
+const ITEM_EVIDENCE_RE = /[:：]\s*\d{1,6}/;
+const ITEM_UNANSWERABLE_RE = /查不到|没有代码|代码库里没有|不在仓库|登录不了|无法访问|环境限制|需要你提供|只有你能|配置中心/;
+/** 抽出「要用户拍板的条目」原文：小节标题下的列表项 + 行内含「待确认/待你定」的句子。 */
+function openQuestionItems(text) {
+    const lines = String(text ?? "").split(/\r?\n/);
+    const items = [];
+    const headingLines = new Set();
+    const push = (line) => {
+        const trimmed = line.trim();
+        if (trimmed && !items.includes(trimmed))
+            items.push(trimmed);
+    };
+    // 「小节标题」才是标题（短、无句读）；长句里出现「待定」是条目本身，不能当标题排掉
+    const isHeadingLike = (line) => line.trim().length <= 24 && !/[。！？；，,;]/.test(line);
+    for (let i = 0; i < lines.length; i++) {
+        if (!OPEN_QUESTION_HEADING_RE.test(lines[i]))
+            continue;
+        if (isHeadingLike(lines[i]))
+            headingLines.add(i);
+        for (let j = i + 1; j < lines.length && j <= i + 16; j++) {
+            const line = lines[j];
+            if (!line.trim())
+                continue; // 列表项之间允许空行
+            if (LIST_ITEM_RE.test(line)) {
+                push(line);
+                continue;
+            }
+            break; // 遇到非列表内容即认为小节结束
+        }
+    }
+    // 行内条目（"文档里要标一条待定：status 口径"这种单句也常见）；标题行本身不算条目
+    for (let i = 0; i < lines.length; i++) {
+        if (headingLines.has(i))
+            continue;
+        if (QUESTION_ITEM_RE.test(lines[i]))
+            push(lines[i]);
+    }
+    return items;
+}
+export function countOpenQuestions(text) {
+    return openQuestionItems(text).length;
+}
+/**
+ * 提问质量核对（比数量核对更准，因为真实事故常常只有**一条**假问题）。
+ *
+ * 现场（2026-09-23 turn 22）：模型把「status 口径」挂成待确认要用户拍板——而它自己 turn 19
+ * 就读过 526-534（导入路径直写 Excel 值），结论早已在手。数量核对（>2 条）抓不到这种一条就
+ * 命中的情况，所以这里按**证据**判：条目里有没有行号？没行号又没说明"代码答不了"的，就是
+ * 应该自己先核实的那类。
+ */
+export function auditOpenQuestions(text) {
+    const items = openQuestionItems(text);
+    const unsupported = items.filter((item) => !ITEM_EVIDENCE_RE.test(item) && !ITEM_UNANSWERABLE_RE.test(item));
+    return { count: items.length, unsupported: unsupported.slice(0, 3) };
+}
 export function classifyTool(name) {
     const parts = tokens(name);
     if (parts.length === 0)
@@ -43,6 +255,20 @@ const UNKNOWN_RE = /结果未知|outcome unknown|tool_not_started|tool_outcome_u
  * 网络/权限受阻。命中它才给「验证降级阶梯」——普通编译错误该归因到代码，
  * 给环境阶梯反而会误导。
  */
+/**
+ * 失败判据（唯一实现）。
+ *
+ * 现场（2026-09-24 评审）：这条正则原先在 host/turn-boundary.ts 与 host/session-events.ts 各抄一份，
+ * 两处都没单测、改一处漏一处——而它决定「红了要不要立刻闭环」。判据属于 core（纯函数 + 单测），不该漏在 host。
+ */
+export function looksLikeFailure(text) {
+    return FAILURE_RE.test(String(text ?? "")) || /timed out|not started/i.test(String(text ?? ""));
+}
+/** 助手这轮是否声称「验证过」（交付对账与阶段推进共用）。 */
+const CLAIMS_VERIFICATION_RE = /验证|测试|构建|检查|确认生效|实际结果|已通过|未验证|无法验证/i;
+export function claimsVerification(text) {
+    return CLAIMS_VERIFICATION_RE.test(String(text ?? ""));
+}
 const ENV_FAILURE_RE = /could not resolve dependencies|could not find artifact|cannot find module|module_not_found|command not found|not recognized as an internal|不是内部或外部命令|系统找不到指定的路径|no such file or directory|enoent|offline mode|cannot access .* in offline|本地仓库|repository.*(?:empty|missing)|network is unreachable|econnrefused|etimedout|proxy|self-signed certificate|eacces/i;
 /** 从工具结果文本判定成败。`explicitError` 为宿主上报的错误字段。 */
 export function readResultSignals(text, explicitError = false) {
@@ -62,3 +288,57 @@ export function deadPathKind(envHits, failStreak) {
         return null;
     return envHits >= 2 ? "env" : "retry";
 }
+/**
+ * 需求漂移检测（词法级、零成本）：模型的输出里出现了**需求原话里没有**的变更类型词。
+ *
+ * 现场样本：需求写「业务类型下拉新增三个选项」，模型却推论出「删除/割接」——用户当场纠正。
+ * 这类脑补完全可以用词法检出：动词在模型侧出现、在用户侧从未出现。
+ */
+const CHANGE_TYPE_WORDS = ["删除", "删掉", "下线", "停用", "替换", "割接", "回滚", "重构", "改名", "重命名", "迁移", "拆分", "合并"];
+export function unrequestedChangeWords(requirementText, candidateText, skipWords = []) {
+    const requirement = String(requirementText ?? "");
+    const candidate = String(candidateText ?? "");
+    if (!candidate)
+        return [];
+    return CHANGE_TYPE_WORDS.filter((word) => {
+        if (!candidate.includes(word) || requirement.includes(word))
+            return false;
+        if (skipWords.includes(word))
+            return false;
+        return isDriftProposal(candidate, word);
+    });
+}
+/**
+ * 命中词到底算不算「漂移」：只有当模型把这件事说成**自己要做的变更**时才算。
+ *
+ * 事故（2026-09-23 现场，b2i-all 会话）：旧实现只做词表匹配，于是
+ * ① 用户自己问「业务类型删了旧值，旧数据是不是涉及割接」→ 模型的回答被顶「收回」；
+ * ② 模型陈述事实「该字段 2025-03-17 引入时没做数据迁移」→ 被顶；
+ * ③ 风险分析里的「回滚」「影响面」→ 被顶（最近 5 轮里 3 轮命中，全是误报）。
+ * 代价写在模型的推理里：它开始**躲词**（「不提割接/迁移/替换」「为了安全我换措辞」）
+ * ——把注意力花在词表上而不是问题上，这才是「变笨」的真实来源。
+ *
+ * 所以判定分两步：附近有否定/疑问/风险语境 → 不计；变更词前有计划线索 → 才算提议。
+ * 取舍：**宁漏报不误报**——漏一次脑补的代价，远小于天天冤枉它、把它训成不敢用词。
+ */
+function isDriftProposal(candidate, word) {
+    let from = 0;
+    for (;;) {
+        const at = candidate.indexOf(word, from);
+        if (at < 0)
+            return false;
+        const before = candidate.slice(Math.max(0, at - DRIFT_BEFORE), at);
+        const after = candidate.slice(at + word.length, at + word.length + DRIFT_AFTER);
+        if (!DRIFT_EXEMPT_RE.test(before + after) && DRIFT_PLAN_RE.test(before))
+            return true;
+        from = at + word.length;
+    }
+}
+/** 豁免语境：否定、疑问、风险与讨论——出现这些说明它在讨论，不是在动手。 */
+const DRIFT_EXEMPT_RE = /不|没|别|避免|无需|不用|是否|会不会|风险|影响|回滚|留痕|降级|万一|如果|若|讨论|方案|选项|历史|曾经|之前|已经|吗|？|\?/;
+/** 计划线索：变更词之前出现这些，才是在说「我要做的变更」。 */
+const DRIFT_PLAN_RE = /要|会|将|建议|应该|打算|计划|准备|必须|改为|改成|直接|需要/;
+const DRIFT_BEFORE = 24;
+const DRIFT_AFTER = 8;
+/** 每会话最多顶几次〔需求漂移〕：同一条提醒反复出现 = 噪音，模型会学会忽略它。 */
+export const DRIFT_NOTICE_MAX = 2;

package/lib/core/task-memory.js

@@ -0,0 +1,143 @@
+const CAP = { requirement: 3, decided: 5, changed: 6, open: 4, deadends: 3, locate: 5 };
+const text = (value, max = 120) => String(value ?? "")
+    .replace(/\s+/g, " ")
+    .trim()
+    .slice(0, max);
+/** 台账条目的状态标记：未验证的要显眼——那是接手时最该先做的事。 */
+const STATUS_MARK = { verified: "[已验证]", done: "[已改未验]", planned: "[计划]", skipped: "[跳过]" };
+/**
+ * 从结构化状态构建会话记忆。**空白会话返回 null**（不写空记忆，避免把桶塞满"什么都没做"的记录）。
+ */
+export function buildTaskMemory(input) {
+    const goal = text(input.goal, 200);
+    const requirement = (input.requirement ?? [])
+        .map((item) => text(item.text, 200))
+        .filter(Boolean)
+        .slice(0, CAP.requirement);
+    const decided = (input.design ?? [])
+        .map((item) => text(`${item.point} → ${item.choice}`, 160))
+        .filter(Boolean)
+        .slice(-CAP.decided);
+    const changed = (input.changes ?? [])
+        .slice(-CAP.changed)
+        .map((item) => `${STATUS_MARK[item.status] ?? ""}${text(item.target, 70)}：${text(item.change, 80)}`.trim())
+        .filter(Boolean);
+    const open = [
+        ...(input.hypotheses ?? [])
+            .filter((item) => item.status === "open" || item.status === "unconfirmed")
+            .map((item) => text(item.text, 140)),
+    ]
+        .filter(Boolean)
+        .slice(0, CAP.open);
+    const deadends = (input.deadends ?? [])
+        .map((item) => text(item.text, 140))
+        .filter(Boolean)
+        .slice(0, CAP.deadends);
+    const locate = (input.locate ?? [])
+        .map((item) => text(item, 100))
+        .filter(Boolean)
+        .slice(-CAP.locate);
+    if (!goal && requirement.length === 0 && decided.length === 0 && changed.length === 0 && open.length === 0 && deadends.length === 0)
+        return null;
+    return {
+        sid: input.sid,
+        title: text(input.title, 60) || "（未命名会话）",
+        turn: input.turn,
+        goal,
+        requirement,
+        decided,
+        changed,
+        open,
+        deadends,
+        locate,
+        at: input.now ?? Date.now(),
+    };
+}
+/** 记忆是不是"值得写/值得注入"：至少有两类内容，避免只有一句目标的空壳记忆。 */
+export function memoryWeight(memory) {
+    return [
+        memory.goal,
+        memory.requirement.length,
+        memory.decided.length,
+        memory.changed.length,
+        memory.open.length,
+        memory.deadends.length,
+        memory.locate.length,
+    ].filter((value) => (typeof value === "number" ? value > 0 : Boolean(value))).length;
+}
+const ageLabel = (at, now) => {
+    const minutes = (now - at) / 60_000;
+    if (!Number.isFinite(minutes) || minutes < 0)
+        return "";
+    if (minutes < 90)
+        return `约 ${Math.max(1, Math.round(minutes))} 分钟前`;
+    if (minutes < 48 * 60)
+        return `约 ${Math.round(minutes / 60)} 小时前`;
+    return `约 ${Math.round(minutes / 1440)} 天前`;
+};
+/**
+ * 注入文本：新会话开局用它"接着上一个会话干"。
+ *
+ * `recent` 是同一工作目录下的其它会话标题——用户可以直接说「继续 X」，
+ * 不必自己回忆"上次那个窗口叫什么"。
+ */
+export function renderTaskMemory(memory, options = {}) {
+    if (!memory || memoryWeight(memory) < 2)
+        return null;
+    const now = options.now ?? Date.now();
+    const lines = [`〔上次会话记忆｜${memory.title}（${ageLabel(memory.at, now)}，第 ${memory.turn} 轮）〕`];
+    if (memory.goal)
+        lines.push(`目标：${memory.goal}`);
+    if (memory.requirement.length > 0)
+        lines.push(`需求原话：${memory.requirement.map((item) => `「${item}」`).join(" ")}`);
+    if (memory.decided.length > 0)
+        lines.push(`已拍板：${memory.decided.map((item) => `- ${item}`).join(" ")}`);
+    if (memory.changed.length > 0)
+        lines.push(`改动：${memory.changed.join(" ")}`);
+    if (memory.open.length > 0)
+        lines.push(`未决：${memory.open.join(" ")}`);
+    if (memory.deadends.length > 0)
+        lines.push(`死路（别再试）：${memory.deadends.join(" ")}`);
+    if (memory.locate.length > 0)
+        lines.push(`关键定位：${memory.locate.join(" ")}`);
+    lines.push(`要继续就说「继续 ${memory.title}」；未验证的改动优先补验证，别从头重做。`);
+    const others = (options.recent ?? []).filter((item) => item.title !== memory.title).slice(0, 3);
+    if (others.length > 0)
+        lines.push(`同目录其它会话：${others.map((item) => `${item.title}（${ageLabel(item.at, now)}）`).join(" / ")}`);
+    return lines.join("\n");
+}
+/** markdown 版本：落到工作区给人看（等价于"手写会话记忆"的自动版）。 */
+export function renderTaskMemoryMarkdown(memory, options = {}) {
+    const now = options.now ?? Date.now();
+    const section = (title, items) => items.length === 0 ? "" : `\n## ${title}\n\n${items.map((item) => `- ${item}`).join("\n")}\n`;
+    return [
+        `# 会话记忆 · ${memory.title}`,
+        "",
+        `> 自动生成（Lume）· 更新于 ${new Date(memory.at).toISOString()}（${ageLabel(memory.at, now)}）· 第 ${memory.turn} 轮 · session \`${memory.sid}\``,
+        memory.goal ? `\n## 目标\n\n${memory.goal}\n` : "",
+        section("需求原话（逐字）", memory.requirement.map((item) => `「${item}」`)),
+        section("已拍板", memory.decided),
+        section("改动（未验证的优先补验证）", memory.changed),
+        section("未决", memory.open),
+        section("死路（别再试）", memory.deadends),
+        section("关键定位", memory.locate),
+    ].join("\n");
+}
+/** 会话起点：没有契约、没有台账 —— 这种时候才需要把"上次会话记忆"顶上去。 */
+export function isColdStart(state) {
+    return !state.hasContract && state.changes === 0 && state.requirements === 0;
+}
+/** 上下文压力：宿主给了 contextWindow，我们按最近一次用量估占用率。 */
+export function contextPressure(usedTokens, contextWindow) {
+    if (!Number.isFinite(usedTokens) || !Number.isFinite(contextWindow) || contextWindow <= 0)
+        return { level: "ok", ratio: 0 };
+    const ratio = usedTokens / contextWindow;
+    return { level: ratio >= 0.9 ? "critical" : ratio >= 0.75 ? "warn" : "ok", ratio };
+}
+/** 上下文预警文案：告诉用户"该换窗口了"，并说清记忆不会丢。 */
+export function buildContextPressureDirective(level, ratio, memorySaved) {
+    const percent = Math.round(ratio * 100);
+    const head = level === "critical" ? `〔上下文接近上限：约 ${percent}%〕` : `〔上下文已用约 ${percent}%〕`;
+    const advice = "收尾当前这一步，然后**开一个新会话**继续——同工作目录的新会话会直接带上「上次会话记忆」（目标/已拍板/未决/关键定位）。";
+    return `${head}${memorySaved ? "会话记忆已保存：" : ""}${advice}不要再展开新话题，也不要把已有结论重述一遍占额度。`;
+}

package/lib/core/text.js

@@ -2,16 +2,58 @@
  * 消息文本提取（纯函数）：从 Cordis 消息对象中提取纯文本。
  *
  * user/message 的 data 即消息内容；assistant/message 的 data.message 即消息内容。
+ *
+ * **真机形状（2026-09-24 现场取证）**：`tool/result` 的文本比消息本体**深一层**——
+ *   `data.message.content = [{ type: "tool-result", content: [{ type: "text", text: "…" }] }]`
+ * 早期实现只看第一层 `block.text`，于是**工具结果文本永远是空串**：一条 bug 同时打死
+ * 自动沉淀（0 候选）、失败识别（信号永远"无失败"）、grep 命中的证据记账、否定断言的证据底账。
+ * 所以这里统一**递归收集**（限深 3 层，防环）。
  */
+function collectText(blocks, out, depth = 0) {
+    if (!Array.isArray(blocks) || depth > 3)
+        return;
+    for (const block of blocks) {
+        if (!block || typeof block !== "object")
+            continue;
+        const record = block;
+        if (typeof record.text === "string")
+            out.push(record.text);
+        if (record.content !== undefined)
+            collectText(record.content, out, depth + 1);
+    }
+}
 export function messageText(message) {
+    const content = message?.content;
+    const parts = [];
+    collectText(content, parts);
+    return parts.join(" ").trim();
+}
+/** 内部推理块类型：这些不是「用户看到的话」，不参与漂移/交付类判定。 */
+const NON_VISIBLE_BLOCK_TYPES = new Set(["reasoning", "thinking", "analysis", "chain_of_thought"]);
+/** 工具收发的块：属于「工具说了什么」，不是「助手说了什么」——可见正文里要整块排除。 */
+const TOOL_BLOCK_TYPES = new Set(["tool-call", "tool-result"]);
+/**
+ * 只取「用户可见的正文」——排除 reasoning / thinking 这类内部推理块，以及工具收发块。
+ *
+ * 为什么要分开：漂移检测的现场事故正是**扫到了推理文本**。模型在推理里权衡「要不要删、
+ * 会不会割接」，被当成「它要删」并顶了一句「收回」，于是它开始在推理里躲词（实测原文：
+ * 「不提割接/迁移/替换」「为了安全我换措辞」）。判断「它打算做什么」看可见回答；
+ * 「它想了什么」不归插件管；「工具输出」由 messageText 负责。
+ */
+export function visibleText(message) {
     const content = message?.content;
     if (!Array.isArray(content))
         return "";
     const parts = [];
     for (const block of content) {
-        const text = block?.text;
-        if (typeof text === "string")
-            parts.push(text);
+        if (!block || typeof block !== "object")
+            continue;
+        const record = block;
+        const type = typeof record.type === "string" ? record.type : "";
+        if (NON_VISIBLE_BLOCK_TYPES.has(type) || TOOL_BLOCK_TYPES.has(type))
+            continue;
+        if (typeof record.text === "string")
+            parts.push(record.text);
     }
     return parts.join(" ").trim();
 }