lume-dsh-plugin 0.7.3 → 0.8.0

package/lib/host/prompt-blocks.js

@@ -0,0 +1,113 @@
+import { noticeOpen, noticeText, setNotice } from "./notices.js";
+import * as taskMemoryMod from "../core/task-memory.js";
+/**
+ * 当前步的易变段：路由 / 阶段 / 闲聊声明 / 长会话护栏 / 目标锚点 / 对齐 / 交付复核 /
+ * 压缩重锚 / 协议纠偏 / 反思提醒 + 载具与方法块。
+ *
+ * 顺序有讲究：把「此刻最该做的一件事」（触发器提醒）放在最后——尾部注意力最强。
+ * 超预算时先丢 `droppable` 块（见 methods.composeBlocks）。
+ */
+export function volatileBlocks(deps, input) {
+    const { st, query, mode } = input;
+    return [
+        { text: deps.buildInteractionDirective(mode) },
+        { text: deps.buildTaskPhaseDirective(st.taskPhase) },
+        // 条款预算：完整协议在系统提示里一条不少，这里只按本轮形态加权最相关的三条
+        { text: deps.buildFocusClauseDirective(input) },
+        { text: deps.buildCasualDirective(deps.taskSignalRe.test(query)) },
+        { text: deps.buildLongSessionGuard(st.turnIndex) },
+        { text: deps.buildSessionAnchor(st.turnIndex, mode, query, st.recentTurns) },
+        { text: noticeText(st, "align") },
+        { text: noticeText(st, "postTurn") },
+        { text: st.compaction ? deps.buildCompactionNotice(st.compaction, st.turnIndex) : null },
+        { text: noticeText(st, "protocol") },
+        { text: deps.reflectionFeedback(), droppable: true },
+        ...carrierBlocks(deps, input),
+    ];
+}
+/**
+ * 任务载具块：契约 / 改动台账 / 假设台账 / 设计决策 / 需求锚点 / 项目知识 + 方法块 + 触发器提醒。
+ *
+ * 全部落在尾部快照（易变层）——这正是「载具」现在才做得起的理由：0.6.2 之前每步注入一份
+ * 会变的状态等于每步作废整段前缀，而快照只在内容变化时才付费（实测 58 步只产生 9 条快照）。
+ */
+export function carrierBlocks(deps, input) {
+    if (!deps.projectMemoryOn)
+        return [];
+    const { sid, context, st, query, mode } = input;
+    // 第一轮装配时 cwd 还没到（宿主的运行时快照**晚于**系统提示装配，差 1 毫秒）→
+    // 用「会话目录名 → 工作目录」映射提前补上；否则依赖 cwd 的〔项目知识〕在**新会话第一轮**缺席
+    // （现场 14:15：模型答“我这轮没接上上下文，把方案文件发我”，而库里明明有 40 条知识）。
+    deps.ensureSessionWorkspace(sid, st);
+    const isTask = mode !== "question" || deps.taskSignalRe.test(query);
+    // 方法块只在**已定路由不是问答**时出现：路由说"直接回答、别调工具"，方法块说"先写契约"，
+    // 两者同时出现时模型只能赌（实测 13 轮 0 次契约调用）。问答轮保留事实回显（锚点/台账/知识）。
+    const taskMethods = mode !== "question";
+    // 契约是"动手前的产出"：讨论轮问的是取舍，塞"开工前先写任务契约"只会稀释它（实测噪音）。
+    const contractMethods = mode === "execute" || mode === "diagnosis";
+    const contract = deps.contractOf(sid);
+    const changes = deps.changesOf(sid);
+    const docDirective = deps.documentDirective(query, context);
+    // 需求覆盖核对：文档产物一写出来，就把「需求原句」与「交付物里的句子」并列，
+    // 替代模型的自证式「N 条全有落点」（2026-09-23 现场：自证全绿，实际藏着三处硬伤）。
+    if (!noticeText(st, "coverage") && noticeOpen(st, "coverage") && st.agent.artifactText.length > 200) {
+        // 只对着**需求原文**做覆盖核对：表里混着闲聊与评审粘贴，挑不出来就整段跳过（宁可不做也不做错）
+        const requirementText = deps.pickRequirementCorpus(deps.requirementsOf(sid));
+        const items = deps.splitRequirementItems(requirementText);
+        if (items.length >= 2) {
+            setNotice(st, "coverage", deps.buildRequirementCoverageDirective(deps.coverageRows(items, st.agent.artifactText), {
+                figures: deps.hasFigureRefs(requirementText) && !deps.hasFigureRefs(st.agent.artifactText),
+                danglingRefs: deps.danglingSectionRefs(st.assistantText, st.agent.artifactText),
+            }));
+        }
+    }
+    return [
+        // 契约：有就回显（交付轮切成对账口径），没有且是任务轮就先教它写一份。
+        { text: deps.renderContract(contract, st.taskPhase === "deliver") },
+        { text: !contract && contractMethods ? deps.buildContractMethodDirective() : null, droppable: true },
+        // 设计三问：设计型任务且还没写下设计时反复顶（实测一次提示会被忽略）
+        { text: deps.needsDesignPass(sid, st, query, mode) ? deps.buildDesignMethodDirective() : null, droppable: true },
+        // 需求解读三条硬规则：用户刚给/改了需求时顶
+        { text: st.requirementFresh ? deps.buildRequirementMethodDirective(taskMethods) : null, droppable: true },
+        // 台账与假设：存在就回显——让模型「看见」自己的计划，而不是记在脑子里。
+        { text: changes.length > 0 ? deps.renderChangeLedger(changes) : null },
+        { text: deps.renderHypotheses(deps.hypothesesOf(sid)) },
+        // 设计决策：跨轮/跨压缩回显，让「数据落在哪 / 接口 / 范式 / 取舍」不随上下文漂移
+        { text: deps.renderDesign(deps.designOf(sid)) },
+        // 需求锚点：逐字回显用户原话（非可丢块——它是最不该漂移的东西）
+        { text: deps.renderRequirements(deps.requirementsOf(sid)) },
+        // 需求覆盖核对：需求原句 vs 交付物句子（只在有文档产物时出现）
+        { text: noticeText(st, "coverage") },
+        // 会话记忆：只在**冷启动**（没有契约/台账/需求锚点）时顶上来。
+        // 这是「换个窗口接着干」的入口：上下文撑满时宿主压缩会失败，那个会话再也聊不动，
+        // 所以新会话必须能一眼看到上次的目标、已拍板、未决与关键定位。
+        {
+            text: deps.isColdStart({
+                hasContract: Boolean(deps.contractOf(sid)),
+                changes: deps.changesOf(sid).length,
+                requirements: deps.requirementsOf(sid).length,
+            })
+                ? deps.renderTaskMemory(st.taskMemories?.[0] ?? null, {
+                    recent: (st.taskMemories ?? [])
+                        .slice(0, 4)
+                        .map((item) => ({ title: String(item.title ?? ""), at: Number(item.at ?? 0) })),
+                })
+                : null,
+            droppable: true,
+        },
+        // 项目知识：**任何轮次都渲染**——它是事实（跨会话累积的约定/命令/死路），不是方法指引。
+        // 现场教训：曾只在非问答轮渲染，于是「新开会话先问一句『你知道 X 需求吗』」这种最自然的开场白
+        // 恰好看不到知识，用户会以为沉淀没生效。事实类回显与需求锚点同等处理（可丢块，成本可控）。
+        { text: deps.renderProjectFacts(deps.factsOf(sid, context), 14, st.sessionTitle), droppable: true },
+        // 方法块：按任务形态出现；文档方法论只在判定为文档任务时出现。
+        { text: isTask && mode !== "question" ? deps.buildImpactDirective() : null, droppable: true },
+        { text: docDirective ? deps.buildDocumentMethodDirective() : null },
+        { text: mode === "execute" || mode === "diagnosis" ? deps.buildStructureHint(deps.structureToolName(context)) : null, droppable: true },
+        { text: noticeText(st, "turn") },
+        { text: noticeText(st, "trigger") },
+        { text: noticeText(st, "drift") },
+        { text: noticeText(st, "citation") },
+        { text: noticeText(st, "claim") },
+        { text: noticeText(st, "question") },
+    ];
+}

package/lib/host/protocol.js

@@ -1,6 +1,6 @@
 const MODE_RULES = {
-    question: "当前模式：问答。先直接回答问题；不要擅自修改文件、调用工具或替用户做决定。",
-    research: "当前模式：查找。先收集并区分已知、未知和推断；未经明确授权不要修改外部状态。",
+    question: "当前模式：问答。先直接回答；**只读核实该做就做**（read / grep / glob / git log 这类只读工具允许用）——答案依赖仓库事实时，不许用「我不确定」「这是新会话」作答；但不要改动文件、不要替用户做决定。",
+    research: "当前模式：查找。先收集并区分已知、未知和推断；**该查就查**（只读工具随便用），但未经明确授权不要修改外部状态（文件 / 提交 / 远端 / 数据库）。",
     discussion: "当前模式：讨论。先比较选项、取舍和风险；不要把探讨中的方案当成已决定的执行方案。",
     diagnosis: "当前模式：诊断。先说明现象、证据、可能根因和验证办法；除非用户明确要求修复，不越权修复，不要越过诊断边界动手。",
     execute: "当前模式：执行。先确认目标和完成标准，再做最小变更；交付时明确列出“已完成、已验证、未验证、残留副作用”，不要用动作完成冒充目标达成。",
@@ -8,6 +8,12 @@ const MODE_RULES = {
 // 显式请求标记后必须紧跟一个动作动词，且限制在同一小句内（旧版用 `.*` 贪婪跨越
 // 整句，导致「是什么驱动你去这么做的」也被判成执行）。句首祈使不再放行「做」：
 // 「做一件事…」这类名词化表述是讨论而非执行。
+/**
+ * 设计信号（0.7.5）：命中说明这条需求要动**数据或接口**，值得走一次设计 pass。
+ * 现场样本（B2I 优惠视图与订单属性）：新增字段 + 模糊搜索 + 分页改造 + 历史数据刷 + 外部同步，
+ * 全是设计型动作，但会话里没有任何设计决策。这条正则只用于「该不该顶设计三问」，不参与模式路由。
+ */
+export const DESIGN_SIGNAL_RE = /新增|添加|加个|加一个|字段|属性|接口|表结构|建表|改表|页面|分页|导出|导入|批量|视图|列表|搜索|筛选|下拉|同步|对接|联调|迁移|兼容|需求|功能|模块|组件|设计/;
 const EXECUTE_RE = new RegExp([
     "(?:请|帮我|帮忙|直接|把|给我|替我|麻烦|需要你)\\s*[^，。！？；\\n]{0,24}?(?:做|改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布|检查|核对|补|替换|重命名|合并|回滚|加上)",
     "^(?:改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布|检查|补|替换|重命名|合并|回滚)",
@@ -19,19 +25,138 @@ const RESEARCH_RE = /查一下|查找|搜索|检索|资料|文档|来源|证据|
 /**
  * 采用“明确执行 > 诊断 > 讨论 > 查找 > 问答”的优先级，避免把“为什么”误判成修复命令。
  */
-export function classifyInteraction(text) {
+/**
+ * 执行动词的补充表（0.7.4 起，0.8.x 扩表）。
+ *
+ * 现场实测：`EXECUTE_RE` 不含「重构 / 梳理 / 删掉 / 合并 / 迁移」等常见动词，于是
+ * 「帮我重构订单退费链路」被判成**问答**——方法层（影响面清单）与阶段门控都不生效，
+ * 而那次会话确实改了 11 个文件。这里只补「对产物动手」的动作，**不含诊断类动词**
+ * （分析/诊断/排查属于 diagnosis，混进来会把讨论与排查误判成执行）。
+ *
+ * 扩表理由（2026-09-24 复盘）：词表永远补不完（「把这部分整理一下」曾整句落空），
+ * 所以本表只当**第一层证据**，真正的兜底是 classifyWithTrajectory 的轨迹证据。
+ */
+const EXECUTE_EXTRA_RE = /重构|重写|梳理|清理|删掉|删除|去掉|移除|合并|合入|迁移|替换|收口|落地|接入|适配|升级|降级|补上|补齐|加上|改成|改为|换成|拆开|拆出|整理|归置|收拾|精简|瘦身|补全|抽出来|挪到|调整一下|改一下|优化一下|重排/;
+/**
+ * 「在问怎么做 / 能不能做」的语用标记：命中说明这一句要的是**判断与办法**，不是让人动手。
+ * 为什么必须有这道闸（2026-09-24 复盘）：动词表与语用层是两件事——「怎么整理这段数据比较好」
+ * 含执行动词「整理」，但它要的是方案；旧版靠动词命中即判执行，于是讨论被当成命令。
+ */
+const HOWTO_RE = /^\s*(怎么|怎样|如何|为什么|为啥|是否|能否|能不能|可不可以|该不该|要不要)|比较好|更好一点|哪种更/;
+/** 变更对象：软性请求（能不能/可否）必须真的指向一个可改动的东西，否则只是普通疑问句。 */
+const CHANGE_OBJECT_RE = /优化|重构|重写|整理|清理|拆分|合并|迁移|替换|升级|调整|改进|简化|精简|改造|重排|补全/;
+/** 能力/可行性询问：「看看这块能不能优化」→ 先给判断与办法（诊断），不是让人直接动手。 */
+const SOFT_CHANGE_RE = /能不能|能否|可不可以|是否可以|有没有办法|有没有可能|可否/;
+/**
+ * 复核既有改动：再/重新/再次 + 「看/查/评价」一族动词 + 代码/改动/实现/方案。
+ *
+ * 覆盖要够宽（二审指出：原来只枚举六个动词，「再次评价一下刚才的改动」就漏了，靠默认落回问答蒙对）：
+ * 检查/核对/检验/验证/确认/评价/评估/评审/审阅/审一遍/过一遍/看一遍/看看/看一下 都算；前缀可省。
+ */
+const RECHECK_RE = /(?:(?:再|重新|从头|再次|复核|复检|复审|复查|回顾)[^。；\n]{0,8})?(?:检查|核对|检验|验证|确认|评价|评估|评审|审阅|审一遍|审一下|过一遍|看一遍|看看|看一下)[^。；\n]{0,12}(?:代码|改动|修改|实现|产物|结果|逻辑|方案|思路)/;
+/**
+ * 路由纠正语用：用户在说「你刚才理解错了这一轮要什么」。
+ * 与 session-events 的通用纠偏词分开——那条管语气与表达，这条只管**模式判错**，
+ * 因为它要做的事不同：拿被纠正前的那句话重算路由（见 classifyWithTrajectory）。
+ */
+export const ROUTE_CORRECTION_RE = /不是让你|我没让你|谁说让你|我只是问|我只是想|我问的是|我是问|不是要你改|不是让你改|你理解错|答非所问|我说的是|我指的是|先别改|别改|不要动|你改错|搞错方向/;
+/**
+ * 当前句自带「新问题」特征：疑问代词/疑问语气/显式换话题。
+ *
+ * 为什么需要（2026-09-24 审核指出）：中文常不带问号，轨迹抬档只看「非 ? 结尾 + ≤120 字 + 近三轮任务型」，
+ * 于是「顺便说下 git 怎么配」会被抬成执行。带上这条反向条件：明显在问，就一律不抬档——
+ * 宁可少一次加权，也不要把「问一句」判成「动手」。
+ */
+const NEW_QUESTION_RE = /怎么|如何|为什么|为啥|什么|哪些|哪个|是否|吗\s*$|呢\s*$|换个话题|另一个问题|另外问|顺便问|新问题/;
+/** 承接式追问：没有新动词，但明显在上一件事上往下走。 */
+const FOLLOW_UP_RE = /^\s*(继续|接着|然后|还有|再|那|所以|顺便|下一步|再来|往下|then|接着来|继续吧|那这个|这样的话|那它)/i;
+/**
+ * 采用“明确执行 > 诊断 > 讨论 > 查找 > 问答”的优先级，避免把“为什么”误判成修复命令。
+ *
+ * 返回值带命中判据与来源（0.8.x）：路由是**唯一一处「判错就全盘错」**的决策，
+ * 而它此前不可观测——判错了没人知道，也没法统计哪条正则在误判。详细版让每次判定
+ * 都能落进度量（见 core/metrics.ts 与 tools 的 lume_metrics）。
+ */
+export function classifyInteractionDetailed(text) {
     const query = String(text ?? "").trim();
     if (!query)
-        return "question";
-    if (EXECUTE_RE.test(query))
-        return "execute";
+        return { mode: "question", matched: "empty", source: "text" };
+    const howto = HOWTO_RE.test(query);
+    // 复核既有改动要**先于**执行判定：这类句子的宾语本身就是「改动/修改/实现」，
+    // 若让动词表先跑，「帮我看一遍刚才的修改」会被抢成 execute（二审的同一个洞）。
+    // 但**明确命令优先**：宾语里有动作（改成/删掉/替换/重写…）就还是执行——
+    // 「检查一下这段代码，有问题就改成对的」要的是动手，不是诊断（二审指出的代价）。
+    if (!howto && !EXECUTE_EXTRA_RE.test(query) && RECHECK_RE.test(query))
+        return { mode: "diagnosis", matched: "recheck", source: "text" };
+    if (!howto && EXECUTE_RE.test(query))
+        return { mode: "execute", matched: "execute-request", source: "text" };
+    if (!howto && EXECUTE_EXTRA_RE.test(query))
+        return { mode: "execute", matched: "execute-verb", source: "text" };
+    // 可行性询问放在执行之后：显式命令（把 X 改一下）仍然优先判执行，
+    // 只有「没下命令、只在问能不能」的句子才落到诊断——诊断模式不改文件，但会给办法。
+    if (!howto && SOFT_CHANGE_RE.test(query) && CHANGE_OBJECT_RE.test(query))
+        return { mode: "diagnosis", matched: "capability-ask", source: "text" };
+    // 复核既有改动（真机实测：「做了修改，你再重新检查一下代码」被判成 research）：
+    // 「再/重新 + 检查/复核 + 代码/改动」要的是判断与结论，不是检索资料 → 诊断。
     if (DIAGNOSIS_RE.test(query))
-        return "diagnosis";
+        return { mode: "diagnosis", matched: "diagnosis", source: "text" };
     if (DISCUSSION_RE.test(query))
-        return "discussion";
+        return { mode: "discussion", matched: "discussion", source: "text" };
     if (RESEARCH_RE.test(query))
-        return "research";
-    return "question";
+        return { mode: "research", matched: "research", source: "text" };
+    return { mode: "question", matched: "fallback", source: "text" };
+}
+export function classifyInteraction(text) {
+    return classifyInteractionDetailed(text).mode;
+}
+/**
+ * 轨迹路由（0.8.x）：单句正则只看「这一句话的词」，中文是发散的——「把这部分整理一下」
+ * 里换了动词就落空，而**判错的代价是后面全部条款都指向错的方向**（现场：执行轮被当成
+ * 问答，方法层与阶段门控整轮不生效，而那次会话改了 11 个文件）。
+ *
+ * 这里补的不是更多词，是三类**轨迹证据**：
+ * ① 纠正：用户说「不是让你改 / 我问的是」→ 拿被纠正前那句重算，而不是在纠正句上再猜一次；
+ * ② 粘性：在途任务（阶段已推进或已动过文件）上的承接式追问 → 保持任务模式，
+ *    不因为「那继续吧」这种没有动词的句子掉回问答；
+ * ③ 一致：最近几轮用户都在做任务、当前这句又没有疑问特征 → 按轨迹取任务模式。
+ * 证据不足时**一律回落到单句结果**——轨迹只用来补，不用来猜。
+ */
+export function classifyWithTrajectory(input) {
+    const base = classifyInteractionDetailed(input.text);
+    const query = String(input.text ?? "").trim();
+    const recent = input.recentUserTexts ?? [];
+    const correction = input.correction ?? ROUTE_CORRECTION_RE.test(query);
+    // ① 纠正：从最近往前找第一句「本来是任务」的发言，用它重算。
+    if (correction) {
+        for (let i = recent.length - 1; i >= 0; i--) {
+            const prior = classifyInteractionDetailed(recent[i]);
+            if (prior.mode === "execute" || prior.mode === "diagnosis")
+                return { mode: prior.mode, matched: prior.matched, source: "correction", evidence: recent[i] };
+        }
+        return { mode: base.mode, matched: base.matched, source: "correction", evidence: query };
+    }
+    const followUp = FOLLOW_UP_RE.test(query) && query.length <= 120;
+    // 自带疑问特征 → 不参与抬档（粘性也一样：追问可以，问新问题不行）
+    const asksNewQuestion = NEW_QUESTION_RE.test(query);
+    // ② 粘性：任务在途 + 承接式追问 + 单句判成问答（明显掉档）→ 保持上一轮模式。
+    // 只认「阶段已推进 / 已动过文件」的在途任务：否则一次误判会被无限继承。
+    const inFlight = input.hadMutations || input.prevPhase === "execute" || input.prevPhase === "verify" || input.prevPhase === "deliver";
+    if (followUp && !asksNewQuestion && base.mode === "question" && inFlight && input.prevMode !== "question")
+        return { mode: input.prevMode, matched: `sticky:${base.matched}`, source: "sticky", evidence: query };
+    // ③ 一致：最近三轮用户话里至少两轮是任务型，当前这句既没有疑问特征也不是新话题 → 按轨迹判任务。
+    if (base.mode === "question" && !followUp && !asksNewQuestion && query.length <= 120 && !/[?？]\s*$/.test(query)) {
+        const taskish = recent
+            .slice(-3)
+            .map((turn) => classifyInteractionDetailed(turn))
+            .filter((decision) => decision.mode === "execute" || decision.mode === "diagnosis");
+        if (taskish.length >= 2) {
+            // 延续**最近一轮**的任务模式：比「按词猜这一句是要分析还是要动手」可靠——
+            // 轨迹是证据，词表只是提示。判错也只是少一次加权，不会白动手（执行前仍有阶段门控）。
+            const mode = taskish[taskish.length - 1].mode;
+            return { mode, matched: `trajectory:${base.matched}`, source: "trajectory", evidence: query };
+        }
+    }
+    return base;
 }
 /**
  * 判定一条消息是否出自真实用户。
@@ -65,7 +190,15 @@ export function buildCasualDirective(isTask) {
     return "〔本轮类型〕闲聊轮：协议里的任务条款（任务分解、阶段门控、验证清单、交付复核）本轮不适用——直接回答，不要输出执行计划，也不要为简单问题增加调研与验证步骤。";
 }
 export function taskPhaseForMode(mode) {
-    return mode === "research" ? "research" : mode === "discussion" ? "discuss" : mode === "diagnosis" ? "diagnose" : mode === "execute" ? "execute" : "answer";
+    return mode === "research"
+        ? "research"
+        : mode === "discussion"
+            ? "discuss"
+            : mode === "diagnosis"
+                ? "diagnose"
+                : mode === "execute"
+                    ? "execute"
+                    : "answer";
 }
 /**
  * 阶段只前进，不回退到初始的「回答」。

package/lib/host/reflection.js

@@ -8,15 +8,30 @@
 import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
 import z from "@deepseek-ai/schemastery";
 import { zodLike } from "./identity.js";
-import { extractBalancedAt } from "./distill.js";
+import { extractBalancedAt } from "./distill-prompt.js";
 export const LUME_REFLECTION_SPEC = defineDomain({
     name: "lume_reflection",
     version: 1,
     tables: {
         logs: domainTable(zodLike(z.union([
-            z.object({ at: z.number(), context: z.number(), planning: z.number(), verification: z.number(), review: z.number(), diagnosis: z.number(), note: z.string() }),
+            z.object({
+                at: z.number(),
+                context: z.number(),
+                planning: z.number(),
+                verification: z.number(),
+                review: z.number(),
+                diagnosis: z.number(),
+                note: z.string(),
+            }),
             // v0.7.0 之前的四维日志
-            z.object({ at: z.number(), context: z.number(), planning: z.number(), verification: z.number(), review: z.number(), note: z.string() }),
+            z.object({
+                at: z.number(),
+                context: z.number(),
+                planning: z.number(),
+                verification: z.number(),
+                review: z.number(),
+                note: z.string(),
+            }),
             // v0.4.0 之前的存量日志；仅用于打开域并在启动时迁移。
             z.object({ at: z.number(), p0: z.number(), p1: z.number(), p2: z.number(), p3: z.number(), note: z.string() }),
         ]))),
@@ -69,7 +84,11 @@ export class ReflectionStore {
         return value;
     }
     #computeFeedback() {
-        const entries = [...this.#table.keys()].map((key) => this.#table.get(key)).filter((e) => typeof e?.context === "number").sort((a, b) => b.at - a.at).slice(0, 5);
+        const entries = [...this.#table.keys()]
+            .map((key) => this.#table.get(key))
+            .filter((e) => typeof e?.context === "number")
+            .sort((a, b) => b.at - a.at)
+            .slice(0, 5);
         if (entries.length < 3)
             return null;
         const dims = ["context", "planning", "verification", "review", "diagnosis"];
@@ -117,7 +136,11 @@ export function buildReflectionPrompt(turns) {
     };
 }
 export function parseReflectionScore(output) {
-    const trimmed = output.trim().replace(/^```(?:json)?/i, "").replace(/```$/, "").trim();
+    const trimmed = output
+        .trim()
+        .replace(/^```(?:json)?/i, "")
+        .replace(/```$/, "")
+        .trim();
     let parsed;
     try {
         parsed = JSON.parse(trimmed);

package/lib/host/registry.js

@@ -56,7 +56,3 @@ export class PersonaRegistry {
         return out;
     }
 }
-/** 自定义人设记录 → Persona 形状的转换（供工具/RPC 校验复用）。 */
-export function customToRecord(name, custom) {
-    return { name, displayName: custom.displayName, description: custom.description, promptText: custom.promptText, corpus: [] };
-}

package/lib/host/requirements-scan.js

@@ -0,0 +1,108 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+const MAX_DOC_FILES = 12;
+const MAX_KEYWORDS = 60;
+/** 只认"像项目标识符"的大写词：含下划线且够长，或纯大写且 ≥8 字（表名/常量/字段名）。 */
+const IDENTIFIER_RE = /\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b|\b[A-Z][A-Z0-9_]{7,}\b/g;
+/** 常见技术词：不是"某需求的标识符"，命中它们会把知识误归到别的需求。 */
+const IDENTIFIER_STOPLIST = new Set([
+    "POSTGRESQL",
+    "MYSQL",
+    "ORACLE",
+    "MARIADB",
+    "SQLSERVER",
+    "JAVASCRIPT",
+    "TYPESCRIPT",
+    "HTTP",
+    "HTTPS",
+    "JSON",
+    "XML",
+    "YAML",
+    "UUID",
+    "URL",
+    "URI",
+    "API",
+    "APIS",
+    "DDL",
+    "DML",
+    "SQL",
+    "HTML",
+    "CSS",
+    "README",
+    "TODO",
+    "FIXME",
+    "NULL",
+    "TRUE",
+    "FALSE",
+    "SELECT",
+    "INSERT",
+    "UPDATE",
+    "DELETE",
+    "WHERE",
+]);
+/** 不是需求目录的常见子目录（`doc/` 下混着这些）。 */
+const NON_REQUIREMENT_DIRS = new Set(["GOOSE", "记忆", "项目理解", "需求模板", "模板", "参考", "归档", "TEMP", "_LUME", "DOCS", "ASSETS"]);
+function looksLikeIdentifier(token) {
+    if (IDENTIFIER_STOPLIST.has(token))
+        return false;
+    if (/^\d+$/.test(token))
+        return false;
+    return token.includes("_") || token.length >= 8;
+}
+const cache = new Map();
+function collectKeywords(dir) {
+    const found = new Set();
+    let entries = [];
+    try {
+        entries = readdirSync(dir, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && /\.(md|sql|txt|json)$/i.test(entry.name))
+            .map((entry) => entry.name)
+            .slice(0, MAX_DOC_FILES);
+    }
+    catch {
+        return [];
+    }
+    for (const name of entries) {
+        try {
+            const text = readFileSync(join(dir, name), "utf8");
+            for (const hit of text.matchAll(IDENTIFIER_RE))
+                if (looksLikeIdentifier(hit[0]))
+                    found.add(hit[0]);
+            if (found.size >= MAX_KEYWORDS)
+                break;
+        }
+        catch {
+            /* 单个文件读不了就跳过 */
+        }
+    }
+    return [...found].slice(0, MAX_KEYWORDS);
+}
+export function requirementHintsOf(cwd) {
+    const key = String(cwd ?? "").trim();
+    if (!key)
+        return [];
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    let hints = [];
+    try {
+        const docRoot = join(key, "doc");
+        hints = readdirSync(docRoot, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() &&
+            entry.name.length > 0 &&
+            entry.name.length <= 60 &&
+            !entry.name.startsWith("_") &&
+            !entry.name.startsWith(".") &&
+            !NON_REQUIREMENT_DIRS.has(entry.name.toUpperCase()))
+            .map((entry) => ({ name: entry.name, keywords: collectKeywords(join(docRoot, entry.name)) }));
+    }
+    catch {
+        hints = []; // 没有 doc 目录：退化成"没有线索"，判定回到会话标题
+    }
+    cache.set(key, hints);
+    return hints;
+}
+/** 测试/扫描用：清缓存。 */
+export function clearRequirementHintsCache() {
+    cache.clear();
+}

package/lib/host/rpc-bridge.js

@@ -61,12 +61,31 @@ export function parseClientRequest(channel, request) {
         return { kind: "respond", status: 400, body: "body is not JSON", contentType: "text/plain" };
     }
     const envelope = body;
-    if (!envelope || typeof envelope !== "object" || envelope.type !== "client-request" || typeof envelope.rpcId !== "string" || typeof envelope.method !== "string") {
-        const rpcId = typeof envelope?.rpcId === "string" ? String(envelope.rpcId) : "invalid-request";
-        return { kind: "respond", status: 200, body: connectionResponse(rpcId, { ok: false, error: { code: "gateway/bad-request", message: "invalid client-request message" } }), contentType: "application/json" };
+    if (!envelope ||
+        typeof envelope !== "object" ||
+        envelope.type !== "client-request" ||
+        typeof envelope.rpcId !== "string" ||
+        typeof envelope.method !== "string") {
+        const rpcId = typeof envelope?.rpcId === "string"
+            ? String(envelope.rpcId)
+            : "invalid-request";
+        return {
+            kind: "respond",
+            status: 200,
+            body: connectionResponse(rpcId, { ok: false, error: { code: "gateway/bad-request", message: "invalid client-request message" } }),
+            contentType: "application/json",
+        };
     }
     if (envelope.method !== endpoint) {
-        return { kind: "respond", status: 200, body: connectionResponse(envelope.rpcId, { ok: false, error: { code: "gateway/bad-request", message: `endpoint mismatch: ${envelope.method} vs ${endpoint}` } }), contentType: "application/json" };
+        return {
+            kind: "respond",
+            status: 200,
+            body: connectionResponse(envelope.rpcId, {
+                ok: false,
+                error: { code: "gateway/bad-request", message: `endpoint mismatch: ${envelope.method} vs ${endpoint}` },
+            }),
+            contentType: "application/json",
+        };
     }
     return { kind: "dispatch", rpcId: envelope.rpcId, endpoint, payload: envelope.payload };
 }

package/lib/host/rpc.js

@@ -1,4 +1,4 @@
-import { settleMemoryText, STORY_MEMORY_CAP } from "./distill.js";
+import { settleMemoryText, STORY_MEMORY_CAP } from "./distill-prompt.js";
 import { normalizeCard, parseCard } from "../core/card.js";
 import { isCoreMemory } from "./injection.js";
 function requireString(payload, field) {

package/lib/host/sections.js

@@ -0,0 +1,48 @@
+export function installPromptSections(deps) {
+    const { ctx } = deps;
+    ctx.effect(() => ctx.systemPrompt.section({
+        name: deps.personaSection,
+        order: deps.personaOrder,
+        text: (context) => {
+            const sid = context.agent?.session?.id ?? context.agent?.id;
+            return sid ? deps.systemSectionText(String(sid), context, "persona") : "";
+        },
+    }), "lume.persona-section()");
+    if (deps.layeredOn) {
+        for (const entry of deps.contexts) {
+            ctx.effect(() => ctx.systemPrompt.context({
+                name: entry.name,
+                order: entry.order,
+                text: (context) => {
+                    const sid = context.agent?.session?.id ?? context.agent?.id;
+                    return sid ? deps.runtimeContextText(String(sid), context, entry.part) : "";
+                },
+            }), `lume.runtime-context(${entry.name})`);
+        }
+    }
+    ctx.effect(() => ctx.systemPrompt.section({
+        name: deps.thinkingSection,
+        order: deps.thinkingOrder,
+        text: (context) => {
+            const sid = context.agent?.session?.id ?? context.agent?.id;
+            return sid ? deps.systemSectionText(String(sid), context, "thinking") : "";
+        },
+    }), "lume.thinking-section()");
+    ctx.effect(() => {
+        if (typeof ctx.systemPrompt?.context !== "function") {
+            ctx.logger?.warn?.("lume: 当前宿主不支持 systemPrompt.context，工具失败提示已跳过（不影响其余功能）");
+            return;
+        }
+        return ctx.systemPrompt.context({
+            name: deps.toolNoticeContext.name,
+            order: deps.toolNoticeContext.order,
+            text: (context) => {
+                const sid = context.agent?.session?.id ?? context.agent?.id;
+                const st = sid ? deps.runtime.get(String(sid)) : null;
+                if (!st)
+                    return "";
+                return deps.buildToolFailureNotice({ failures: st.toolFailures, unknown: st.toolUnknown }) ?? "";
+            },
+        });
+    }, "lume.tool-notice-context()");
+}

package/lib/host/session-deps.js

@@ -0,0 +1,27 @@
+/**
+ * 会话事件处理链路的**依赖契约**（架构整理 ①⑤：边界类型化 + 契约独立成模块）。
+ *
+ * 为什么单独成文件：事件分发（session-events）、轮边界（turn-boundary）、disposed 收尾共用同一份
+ * 依赖；契约放在使用方之一里会让另一个反向依赖它（成环）。这里只有类型，没有运行时依赖。
+ *
+ * 分组按**域**（env / notice / carrier / signal / prompt / tool / agent），组合用 extends；
+ * 访问保持扁平（deps.contractOf），所以分组不增加调用点噪音。
+ */
+import * as citationsMod from "../core/citations.js";
+import * as leakMod from "../core/leak-detector.js";
+import * as ledgerMod from "../core/ledger.js";
+import * as signalsMod from "../core/signals.js";
+import * as textMod from "../core/text.js";
+import * as knowledgeMod from "../core/knowledge.js";
+import * as compactionMod from "./compaction.js";
+import * as diagMod from "./diag.js";
+import * as extractionMod from "./extraction.js";
+import * as hostEventsMod from "./host-events.js";
+import * as methodsMod from "./methods.js";
+import * as noticesMod from "./notices.js";
+import * as taskMemoryMod from "../core/task-memory.js";
+import * as protocolMod from "./protocol.js";
+import * as reflectionMod from "./reflection.js";
+import * as thinkingMod from "./thinking.js";
+import * as triggersMod from "./triggers.js";
+import { handleTurnEnd } from "./turn-boundary.js";