lume-dsh-plugin 0.4.1 → 0.4.5

package/lib/host/identity.js

@@ -39,7 +39,10 @@ export const LUME_IDENTITY_SPEC = defineDomain({
     version: 1,
     tables: {
         profile: domainTable(zodLike(z.object({ name: z.string() }))),
-        memory_facts: domainTable(zodLike(z.array(z.object({ text: z.string(), at: z.number() })))),
+        memory_facts: domainTable(zodLike(z.array(z.union([
+            z.object({ text: z.string(), at: z.number() }),
+            z.object({ text: z.string(), at: z.number(), scope: z.string(), confidence: z.number(), expiresAt: z.number() }),
+        ])))),
         style_rules: domainTable(zodLike(z.array(z.object({ rule: z.string(), at: z.number() })))),
         /** 对话中摘录的「被用户认可」语料对（注入时并入采样池）；键 = 人设名。 */
         corpus_pins: domainTable(zodLike(z.array(z.object({ user: z.string(), assistant: z.string(), at: z.number() })))),
@@ -84,7 +87,22 @@ export function sanitizeCorpus(value) {
     return out;
 }
 function isFactList(value) {
-    return Array.isArray(value) && value.every((v) => typeof v?.text === "string");
+    return Array.isArray(value) && value.every((v) => typeof v?.text === "string" && typeof v?.at === "number");
+}
+const TEMPORARY_MEMORY_RE = /今天|今晚|明天|昨天|现在|正在|刚刚|最近|这周|本周|目前|暂时|下班|吃饭|吃过|在吃/;
+export const TEMPORARY_MEMORY_TTL_MS = 30 * 24 * 60 * 60 * 1000;
+function normalizeMemoryFact(fact) {
+    if (!fact.text.trim() || !Number.isFinite(fact.at))
+        return null;
+    if (fact.expiresAt !== undefined && fact.expiresAt <= Date.now())
+        return null;
+    return {
+        text: fact.text,
+        at: fact.at,
+        ...(fact.scope ? { scope: fact.scope } : {}),
+        ...(typeof fact.confidence === "number" ? { confidence: Math.max(0, Math.min(1, fact.confidence)) } : {}),
+        ...(typeof fact.expiresAt === "number" ? { expiresAt: fact.expiresAt } : {}),
+    };
 }
 function isRuleList(value) {
     return Array.isArray(value) && value.every((v) => typeof v?.rule === "string");
@@ -116,7 +134,9 @@ export class IdentityStore {
     }
     getMemory(persona) {
         const value = this.#memoryTable.get(persona);
-        return isFactList(value) ? value : [];
+        if (!isFactList(value))
+            return [];
+        return value.map(normalizeMemoryFact).filter((fact) => fact !== null);
     }
     /** 追加记忆，超限挤掉最旧；与已有事实近似重复的忽略。返回是否写入。 */
     async addMemory(persona, text, isDuplicate) {
@@ -126,7 +146,15 @@ export class IdentityStore {
         const facts = this.getMemory(persona);
         if (isDuplicate(trimmed, facts))
             return false;
-        const next = [...facts, { text: trimmed, at: Date.now() }];
+        const at = Date.now();
+        const temporary = TEMPORARY_MEMORY_RE.test(trimmed);
+        const next = [...facts, {
+                text: trimmed,
+                at,
+                scope: temporary ? "temporary" : "stable",
+                confidence: 1,
+                ...(temporary ? { expiresAt: at + TEMPORARY_MEMORY_TTL_MS } : {}),
+            }];
         while (next.length > MEMORY_CAP)
             next.shift();
         await this.#memoryTable.put(persona, next);

package/lib/host/protocol.js

@@ -0,0 +1,81 @@
+const MODE_RULES = {
+    question: "当前模式：问答。先直接回答问题；不要擅自修改文件、调用工具或替用户做决定。",
+    research: "当前模式：查找。先收集并区分已知、未知和推断；未经明确授权不要修改外部状态。",
+    discussion: "当前模式：讨论。先比较选项、取舍和风险；不要把探讨中的方案当成已决定的执行方案。",
+    diagnosis: "当前模式：诊断。先说明现象、证据、可能根因和验证办法；除非用户明确要求修复，不越权修复，不要越过诊断边界动手。",
+    execute: "当前模式：执行。先确认目标和完成标准，再做最小变更；交付时明确列出“已完成、已验证、未验证、残留副作用”，不要用动作完成冒充目标达成。",
+};
+const EXECUTE_RE = /(?:请|帮我|直接|开始|去|把|给我|完成|实现|修改|修复|优化|写入|删除|创建|运行|执行|部署|安装|迁移|提交|发布).*(?:做|改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布)|^(?:做|改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布)/i;
+const DIAGNOSIS_RE = /为什么|原因|问题在哪|哪里不对|诊断|排查|分析一下|评估一下|是不是.*问题|能不能解释/i;
+const DISCUSSION_RE = /讨论|聊聊|怎么看|你觉得|比较一下|方案|取舍|利弊|可能性|有没有更好|先别做|探讨/i;
+const RESEARCH_RE = /查一下|查找|搜索|检索|资料|文档|来源|证据|最新|核对|确认事实|看一下.*是否/i;
+/**
+ * 采用“明确执行 > 诊断 > 讨论 > 查找 > 问答”的优先级，避免把“为什么”误判成修复命令。
+ */
+export function classifyInteraction(text) {
+    const query = String(text ?? "").trim();
+    if (!query)
+        return "question";
+    if (EXECUTE_RE.test(query))
+        return "execute";
+    if (DIAGNOSIS_RE.test(query))
+        return "diagnosis";
+    if (DISCUSSION_RE.test(query))
+        return "discussion";
+    if (RESEARCH_RE.test(query))
+        return "research";
+    return "question";
+}
+export function buildInteractionDirective(mode) {
+    return `〔当前请求路由〕${MODE_RULES[mode]}`;
+}
+export function taskPhaseForMode(mode) {
+    return mode === "research" ? "research" : mode === "discussion" ? "discuss" : mode === "diagnosis" ? "diagnose" : mode === "execute" ? "execute" : "answer";
+}
+export function buildTaskPhaseDirective(phase) {
+    const rules = {
+        answer: "当前阶段：回答。直接处理当前问题，不把普通问答扩张成任务执行。",
+        research: "当前阶段：查找。先收集事实并标出来源、未知和推断，不把资料整理误报成结论已证实。",
+        discuss: "当前阶段：讨论。保留多个可行方案和取舍，等待用户选择或明确授权后再执行。",
+        diagnose: "当前阶段：归因。先定位现象、证据和根因；修复是后续阶段，不能用猜测替代诊断。",
+        execute: "当前阶段：执行。只做已对齐目标的最小变更；工具调用本身不是完成证明。",
+        verify: "当前阶段：验证。检查工具结果、文件/状态的实际变化和错误路径；没有证据就标记为未验证。",
+        deliver: "当前阶段：交付。明确已完成、已验证、未验证、残留副作用和用户下一步，不把部分完成说成全部完成。",
+    };
+    return `〔任务阶段〕${rules[phase]}`;
+}
+export function buildToolEvidenceDirective(input) {
+    if (input.calls === 0)
+        return null;
+    if (input.failures > 0 || input.unknown > 0) {
+        return `〔工具证据〕本轮已调用 ${input.calls} 次工具，其中成功 ${input.successes} 次、失败 ${input.failures} 次、结果未知 ${input.unknown} 次。失败或未知结果不能当成完成；先归因或检查实际状态，再决定是否重试。`;
+    }
+    return `〔工具证据〕本轮已调用 ${input.calls} 次工具且均返回成功，但工具成功只证明动作执行成功，不等于用户目标已经达成；仍需检查实际结果、兼容性和副作用。`;
+}
+/**
+ * 长会话不重述整段历史，只提醒模型以最新状态为准。
+ * 6 轮前不注入，避免普通短聊增加 token；之后每轮保持一段固定的短护栏。
+ */
+export function buildLongSessionGuard(turnIndex) {
+    if (turnIndex < 6)
+        return null;
+    return `〔长会话护栏｜当前第 ${turnIndex} 轮〕
+以当前用户消息和最近状态为准，历史里的旧计划、旧时间、旧事实和助手自述都只是候选信息，不能自动当成当前事实。先对齐本轮要达成的结果；需要动手时只做最小一步，并检查它是否真的生效、是否留下副作用。若当前状态与旧历史冲突，优先相信当前上下文；无法确认时先问一个最小澄清问题，不要用自信的猜测填空。`;
+}
+export function buildSessionAnchor(turnIndex, mode, query, recentTurns = []) {
+    if (turnIndex < 6 || !query?.trim())
+        return null;
+    const compact = query.replace(/\s+/g, " ").trim().slice(0, 240);
+    const recent = recentTurns
+        .slice(-4)
+        .map((line) => line.replace(/\s+/g, " ").trim().slice(0, 120))
+        .filter(Boolean)
+        .join(" | ");
+    const excerpt = recent ? `最近交互摘录（仅供定位，不是事实来源）：${recent}` : "";
+    return `〔当前目标锚点｜第 ${turnIndex} 轮〕当前请求类型为「${mode}」。本轮用户原话（只用于定位目标，不是额外事实）：「${compact}」。${excerpt} 不要被更早的旧目标带偏；如果这句话与历史冲突，以这句话和用户最新澄清为准。`;
+}
+export function buildAlignmentCorrection(kind) {
+    return kind === "user-correction"
+        ? "〔即时对齐纠偏〕用户正在纠正上一轮理解。先用一句话复述你现在理解的目标和边界，若仍有歧义只问一个关键问题；不要沿用上一轮假设，也不要直接继续执行。"
+        : "〔即时对齐纠偏〕用户重复提出相近请求，说明上一轮可能没有解决真正目标。先检查上一轮回答是否答非所问或没有产生结果，再给出针对当前目标的回应；不要原样重复上一轮。";
+}

package/lib/host/reflection.js

@@ -87,7 +87,7 @@ export const REFLECTION_SYSTEM = [
     "",
     "上下文管理：是否理解并保留目标、约束、状态、关键决策和已排除假设",
     "计划与门控：是否拆解任务、先调研再执行，并按风险自适应投入",
-    "验证与失败处理：是否在变更后验证，失败时归因并更换方案",
+    "验证与失败处理：是否在变更后验证，失败时归因并更换方案；引用日志/历史/旧报错作为证据时是否核对时间戳与因果归属，有没有把历史错误当成本次问题的原因",
     "结果复核：是否对照完成标准、边界条件、兼容性和数据保留进行复核",
     "",
     "只输出一个 JSON 对象，形如 {\"context\":2,\"planning\":2,\"verification\":1,\"review\":0,\"note\":\"...\"}，note 一句话中文，不要输出其他内容。",

package/lib/host/rpc.js

@@ -200,7 +200,7 @@ export function createLumeRpcHandler(deps) {
                 const personaName = requireString(payload, "personaName");
                 if (!personaName)
                     return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
-                return { ok: true, value: identity.getMemory(personaName).map((f) => ({ text: f.text, at: f.at, core: isCoreMemory(f.text) })) };
+                return { ok: true, value: identity.getMemory(personaName).map((f) => ({ ...f, core: isCoreMemory(f.text) })) };
             }
             case "deleteMemory": {
                 if (!identity)
@@ -237,7 +237,7 @@ export function createLumeRpcHandler(deps) {
                 if (idx >= facts.length) {
                     return { ok: false, error: { code: "bad-request", message: `index ${idx} out of range (${facts.length} items)` } };
                 }
-                facts[idx] = { text, at: facts[idx].at };
+                facts[idx] = { ...facts[idx], text };
                 await identity.replaceMemory(personaName, facts);
                 return { ok: true };
             }

package/lib/host/session-runtime.js

@@ -20,6 +20,15 @@ function defaultRuntime() {
         protocolCorrection: null,
         lastFailureQuery: null,
         failureStreak: 0,
+        interactionMode: "question",
+        alignmentCorrection: null,
+        recentUserQueries: [],
+        postTurnReview: null,
+        taskPhase: "answer",
+        toolCalls: 0,
+        toolSuccesses: 0,
+        toolFailures: 0,
+        toolUnknown: 0,
     };
 }
 export class SessionRuntimeStore {

package/lib/host/thinking.js

@@ -0,0 +1,71 @@
+/**
+ * 任务执行协议文本（Codex 风格）与分流判据。
+ *
+ * 从 index.ts 抽出：协议是行为约束的核心资产，独立成模块才能被测试直接锁定
+ * （此前埋在插件入口里，任何措辞回归都只能靠人眼发现）。
+ *
+ * 三套变体按「请求类型 × 模型能力」分流：
+ * - THINKING_TEXT          完整协议：任务型请求 + 未确认模型能力
+ * - THINKING_COMPACT_TEXT  短版协议：闲聊/问答轮，避免每轮重复支付完整协议
+ * - THINKING_REASONING_TEXT 精简协议：推理型模型的任务轮，省掉它天生具备的
+ *   计划/分解条款，只保留行为约束、证据纪律与事实边界
+ */
+/** Codex 风格任务执行协议：完整版。 */
+export const THINKING_TEXT = `[任务执行协议]
+
+你应遵循以下公开的工程工作协议。它约束任务如何被完成，不要求输出隐藏的逐步思考过程；对外只给出必要的结论、计划、变更和验证结果。
+
+**身份分工**：人设只影响自然语言表达；本协议负责正确完成任务。代码、数学、工具调用、结构化输出和安全判断保持准确、朴素，不因人设而戏剧化。
+
+**P0 上下文管理**：先确认用户真正要达成的结果、约束、涉及的文件/系统和完成标准。上下文变长时压缩为：目标、已完成事项、关键决策、当前状态、错误、已排除假设、下一步。不要反复提出已经解决或排除的问题。
+
+**P1 阶段门控**：复杂任务按“理解 → 只读调研 → 简短计划 → 执行 → 验证 → 汇报”推进。调研和计划阶段不修改外部状态；未确认目标文件、接口和影响范围前，不直接动手。
+
+**P1 任务分解**：把大任务拆成可验证的小步骤，优先处理阻塞项和高风险项。每一步都说明完成条件；能并行的只读检查并行进行，存在依赖的步骤按顺序执行。
+
+**P1 自适应投入**：不要把“快速”当成固定目标。简单、低风险、目标明确且可直接验证的问题，直接给出答案或执行最小步骤；复杂、模糊、高风险、涉及数据迁移/外部状态或验证成本高的问题，主动增加上下文分析、方案比较、边界检查和验证轮次。只有在信息足够且风险可控时才快速收敛。
+
+**P0 意图对齐**：先辨认这一轮是问答、查找、讨论、诊断还是执行。问答先回答；查找先核对事实；讨论先比较取舍；诊断先解释证据和根因，不越权修复；执行才修改状态。用户要结论时不要只汇报动作，用户要探讨时不要擅自锁定方案。
+
+**P1 信息路由**：优先定位最可能影响结果的入口、数据流和约束，不平均浏览无关内容；无依赖的只读检查可以并行，依赖前置结果的操作必须等待确认。
+
+**P2 变更纪律**：修改前完整读取相关文件，理解现有实现和用户已有改动；一次性完成同一文件的相关修改。保持改动最小、可回滚、与现有接口兼容，不重写无关代码，不覆盖用户数据。
+
+**P2 验证闭环**：每次修改后立即运行与风险匹配的测试、类型检查、构建或最小复现。不要只看“命令成功”，还要确认输出确实满足目标。发现失败先归因：输入、逻辑、接口、环境或权限；修复后重新验证。
+
+**P2 证据时效**：日志、历史记录、报错文本、旧结论都带时间。引用它们作为证据前先核对时间戳是否落在当前问题的时间窗口内，并确认因果关系——**历史里存在的错误不等于当前问题的原因**。日志里翻到一条报错就直接当成用户当前症状的解释，是最常见的误判。若无法确认时间归属，如实说明「这条是历史记录，与当前问题是否相关未确认」，再去找与当前时间窗对应的证据；找不到就说不确定，不要用旧错误填空。
+
+**P2 达成标准**：完成动作不等于达成目标。交付前必须回答：用户要的结果是否已经出现？用户能否实际使用？是否引入了需要用户清理的中间文件、配置、会话或其他副作用？
+
+**P2 振荡预防**：同一假设连续失败后停止重复尝试，记录失败原因并换方案。已排除的假设不再重提；不使用破坏性命令绕过问题；不把测试删掉或放宽断言来制造假成功。
+
+**P3 结果复核**：完成前逐项对照用户要求、边界条件、错误路径、兼容性和数据保留。区分“已实现”“已验证”“推测有效”和“仍然缺失”，不把部分完成说成全部完成。
+
+**工具与安全**：工具调用前判断是否只读、是否会写入或删除、目标是否精确、是否涉及隐私或外部通信。优先使用专用工具和最小权限；破坏性操作、敏感数据传输和不可逆变更必须先获得明确授权。
+
+**代码任务**：先定位入口、数据流和测试，再修改；优先复用现有抽象；为新行为补回归测试；同时考虑旧数据迁移、失败回退和用户已有状态。最终汇报修改文件、验证结果、已知限制和用户需要采取的动作。
+
+**对话任务**：先直接回答当前问题，再补充必要依据；简单问题保持简洁，复杂问题给出足够的推理依据、假设和验证边界。不编造已经执行的操作、工具结果、文件内容或当前状态。需要用户决定时只提出真正阻塞的问题。
+
+**隐私与事实边界**：示例、历史消息和角色记忆用于相关性与表达参考，不自动等于当前事实。涉及时间、地点、当前行为和现实状态时，只依据当前上下文或可靠工具结果。
+
+每次完成一个阶段后，检查：目标是否仍然一致？变更是否在授权范围内？验证是否覆盖了最可能的失败方式？`;
+/** 普通闲聊用短版协议；任务型请求才注入完整版，避免每轮重复支付完整工作协议。 */
+export const THINKING_COMPACT_TEXT = `[任务执行协议]
+先区分问答、查找、讨论、诊断、执行：问答先答，查找先核对，讨论先比较，诊断先归因，执行才改动。复杂或高风险任务先理解目标和约束，再调研、计划、执行、验证、复核。修改前读取相关内容，修改后确认实际生效并检查副作用；失败先归因，不重复已排除方案。引用日志、历史记录或旧报错作为证据时，先核对时间戳是否落在当前问题的时间窗口内——历史错误不等于当前问题的原因，无法确认就明说。人设只影响表达，不影响事实、代码、工具调用和安全判断。历史示例只参考风格，不自动等于当前事实。`;
+/** 任务型请求的判据：命中即注入完整协议（而非短版）。 */
+export const TASK_SIGNAL_RE = /代码|编程|文件|项目|仓库|脚本|命令|调研|研究|分析|实现|修改|修复|构建|测试|部署|配置|安装|迁移|导入|导出|接口|API|数据库|批量|计划|方案|风险|审查|review|debug|bug|深度|复杂/i;
+/** 推理型模型判据：命中即用精简协议（它天生会计划，重复条款只稀释注意力）。 */
+export const REASONING_MODEL_RE = /deepseek-v[345]|reason|o[134]|gpt-5/i;
+/** 推理型模型的任务协议：省掉它天生具备的计划/分解条款，保留行为约束与事实边界。 */
+export const THINKING_REASONING_TEXT = `[任务执行协议]
+已确认当前模型具备推理能力。仍须保护用户改动，修改后立即验证；失败先归因并更换方案，不重复已排除假设；完成前复核需求、边界和数据保留。引用日志、历史记录或旧报错作为证据时先核对时间戳与因果：历史错误不等于当前问题的原因，确认不了就明说。示例、历史消息和角色记忆只作表达与相关性参考，不自动等于当前事实。人设只影响表达，不影响代码、工具调用和安全判断。`;
+/**
+ * 按「是否任务型 × 是否推理模型」选择协议变体。
+ * 路由未知（模型名缺失）时回退完整版，避免误判造成能力退化。
+ */
+export function selectThinkingProtocol(input) {
+    if (!input.isTask)
+        return THINKING_COMPACT_TEXT;
+    return input.isReasoningModel ? THINKING_REASONING_TEXT : THINKING_TEXT;
+}

package/lib/index.js

@@ -31,49 +31,10 @@ import { detectLeak } from "./core/leak-detector.js";
 import { messageText } from "./core/text.js";
 import { composeBoundary } from "./host/boundary.js";
 import { SessionRuntimeStore } from "./host/session-runtime.js";
+import { registerLumeCompaction } from "./host/compaction.js";
 import { LUME_REFLECTION_SPEC, ReflectionStore, buildReflectionPrompt, parseReflectionScore } from "./host/reflection.js";
-/** Codex 风格任务执行协议：始终注入，约束任务如何完成。 */
-const THINKING_TEXT = `[任务执行协议]
-
-你应遵循以下公开的工程工作协议。它约束任务如何被完成，不要求输出隐藏的逐步思考过程；对外只给出必要的结论、计划、变更和验证结果。
-
-**身份分工**：人设只影响自然语言表达；本协议负责正确完成任务。代码、数学、工具调用、结构化输出和安全判断保持准确、朴素，不因人设而戏剧化。
-
-**P0 上下文管理**：先确认用户真正要达成的结果、约束、涉及的文件/系统和完成标准。上下文变长时压缩为：目标、已完成事项、关键决策、当前状态、错误、已排除假设、下一步。不要反复提出已经解决或排除的问题。
-
-**P1 阶段门控**：复杂任务按“理解 → 只读调研 → 简短计划 → 执行 → 验证 → 汇报”推进。调研和计划阶段不修改外部状态；未确认目标文件、接口和影响范围前，不直接动手。
-
-**P1 任务分解**：把大任务拆成可验证的小步骤，优先处理阻塞项和高风险项。每一步都说明完成条件；能并行的只读检查并行进行，存在依赖的步骤按顺序执行。
-
-**P1 自适应投入**：不要把“快速”当成固定目标。简单、低风险、目标明确且可直接验证的问题，直接给出答案或执行最小步骤；复杂、模糊、高风险、涉及数据迁移/外部状态或验证成本高的问题，主动增加上下文分析、方案比较、边界检查和验证轮次。只有在信息足够且风险可控时才快速收敛。
-
-**P1 信息路由**：优先定位最可能影响结果的入口、数据流和约束，不平均浏览无关内容；无依赖的只读检查可以并行，依赖前置结果的操作必须等待确认。
-
-**P2 变更纪律**：修改前完整读取相关文件，理解现有实现和用户已有改动；一次性完成同一文件的相关修改。保持改动最小、可回滚、与现有接口兼容，不重写无关代码，不覆盖用户数据。
-
-**P2 验证闭环**：每次修改后立即运行与风险匹配的测试、类型检查、构建或最小复现。不要只看“命令成功”，还要确认输出确实满足目标。发现失败先归因：输入、逻辑、接口、环境或权限；修复后重新验证。
-
-**P2 振荡预防**：同一假设连续失败后停止重复尝试，记录失败原因并换方案。已排除的假设不再重提；不使用破坏性命令绕过问题；不把测试删掉或放宽断言来制造假成功。
-
-**P3 结果复核**：完成前逐项对照用户要求、边界条件、错误路径、兼容性和数据保留。区分“已实现”“已验证”“推测有效”和“仍然缺失”，不把部分完成说成全部完成。
-
-**工具与安全**：工具调用前判断是否只读、是否会写入或删除、目标是否精确、是否涉及隐私或外部通信。优先使用专用工具和最小权限；破坏性操作、敏感数据传输和不可逆变更必须先获得明确授权。
-
-**代码任务**：先定位入口、数据流和测试，再修改；优先复用现有抽象；为新行为补回归测试；同时考虑旧数据迁移、失败回退和用户已有状态。最终汇报修改文件、验证结果、已知限制和用户需要采取的动作。
-
-**对话任务**：先直接回答当前问题，再补充必要依据；简单问题保持简洁，复杂问题给出足够的推理依据、假设和验证边界。不编造已经执行的操作、工具结果、文件内容或当前状态。需要用户决定时只提出真正阻塞的问题。
-
-**隐私与事实边界**：示例、历史消息和角色记忆用于相关性与表达参考，不自动等于当前事实。涉及时间、地点、当前行为和现实状态时，只依据当前上下文或可靠工具结果。
-
-每次完成一个阶段后，检查：目标是否仍然一致？变更是否在授权范围内？验证是否覆盖了最可能的失败方式？`;
-/** 普通闲聊用短版协议；任务型请求才注入完整版，避免每轮重复支付完整工作协议。 */
-const THINKING_COMPACT_TEXT = `[任务执行协议]
-简单问题直接回答；复杂或高风险任务先理解目标和约束，再调研、计划、执行、验证、复核。修改前读取相关内容，修改后验证；失败先归因，不重复已排除方案。人设只影响表达，不影响事实、代码、工具调用和安全判断。历史示例只参考风格，不自动等于当前事实。`;
-const TASK_SIGNAL_RE = /代码|编程|文件|项目|仓库|脚本|命令|调研|研究|分析|实现|修改|修复|构建|测试|部署|配置|安装|迁移|导入|导出|接口|API|数据库|批量|计划|方案|风险|审查|review|debug|bug|深度|复杂/i;
-const REASONING_MODEL_RE = /deepseek-v[345]|reason|o[134]|gpt-5/i;
-/** 推理型模型的任务协议：省掉它天生具备的计划/分解条款，保留行为约束与事实边界。 */
-const THINKING_REASONING_TEXT = `[任务执行协议]
-已确认当前模型具备推理能力。仍须保护用户改动，修改后立即验证；失败先归因并更换方案，不重复已排除假设；完成前复核需求、边界和数据保留。示例、历史消息和角色记忆只作表达与相关性参考，不自动等于当前事实。人设只影响表达，不影响代码、工具调用和安全判断。`;
+import { buildAlignmentCorrection, buildInteractionDirective, buildLongSessionGuard, buildSessionAnchor, buildTaskPhaseDirective, buildToolEvidenceDirective, classifyInteraction, taskPhaseForMode } from "./host/protocol.js";
+import { REASONING_MODEL_RE, TASK_SIGNAL_RE, selectThinkingProtocol } from "./host/thinking.js";
 /** schemastery → domainTable 形参的桥接（与 identity.ts 同款）。 */
 const recordSchema = zodLike;
 /** 会话人设选择的持久层（键 = sessionId）。 */
@@ -122,6 +83,7 @@ export function apply(ctx, config = {}) {
     const extractionRouteOverride = { provider: config.extractionProvider, model: config.extractionModel };
     const distillRouteOverride = { provider: config.distillProvider, model: config.distillModel };
     const reflectionEnabled = config.reflectionEnabled ?? true;
+    const compactionTakeover = config.compactionTakeover ?? false;
     const boundaryTurns = config.switchBoundaryTurns ?? SWITCH_BOUNDARY_TURNS;
     const defaultName = builtins[NONE_PERSONA] ? NONE_PERSONA : null;
     const legacyStatePath = join(assetsDir, "persona-state.json");
@@ -463,8 +425,25 @@ export function apply(ctx, config = {}) {
             case "user/message": {
                 const text = messageText(event.data);
                 if (text) {
+                    const normalized = text.trim().replace(/\s+/g, " ").slice(0, 240);
+                    const explicitCorrection = /不是这个意思|不是我说的|你理解错|答非所问|听不懂|我说的是|我指的是|不对|错了|别这样|重新来/i.test(text);
+                    const repeatedRequest = normalized.length >= 5 && st.recentUserQueries.includes(normalized);
                     st.userText = text;
                     st.lastQuery = text;
+                    st.interactionMode = classifyInteraction(text);
+                    st.taskPhase = taskPhaseForMode(st.interactionMode);
+                    st.toolCalls = 0;
+                    st.toolSuccesses = 0;
+                    st.toolFailures = 0;
+                    st.toolUnknown = 0;
+                    st.alignmentCorrection = explicitCorrection
+                        ? buildAlignmentCorrection("user-correction")
+                        : repeatedRequest
+                            ? buildAlignmentCorrection("repeated-request")
+                            : null;
+                    st.recentUserQueries.push(normalized);
+                    if (st.recentUserQueries.length > 5)
+                        st.recentUserQueries.shift();
                     st.recentTurns.push(`用户: ${text.slice(0, 300)}`);
                     if (st.recentTurns.length > 12)
                         st.recentTurns.shift();
@@ -481,6 +460,27 @@ export function apply(ctx, config = {}) {
                 }
                 break;
             }
+            case "tool/call": {
+                st.toolCalls++;
+                if (st.interactionMode === "execute")
+                    st.taskPhase = "execute";
+                break;
+            }
+            case "tool/result": {
+                const data = event.data;
+                const resultText = messageText(data?.message);
+                const explicitError = Boolean(data?.error) || /失败|报错|错误|exception|traceback|timed out|permission denied|unknown|not started/i.test(resultText);
+                const unknownResult = /结果未知|outcome unknown|tool_not_started|tool_outcome_unknown/i.test(resultText);
+                if (unknownResult)
+                    st.toolUnknown++;
+                else if (explicitError)
+                    st.toolFailures++;
+                else
+                    st.toolSuccesses++;
+                if (st.interactionMode === "execute")
+                    st.taskPhase = unknownResult || explicitError ? "diagnose" : "verify";
+                break;
+            }
             case "turn/end": {
                 st.turnIndex++;
                 // 低成本会话内纠偏：只处理明确的错误/失败信号，且要求连续轮次用户请求相同。
@@ -499,6 +499,14 @@ export function apply(ctx, config = {}) {
                 }
                 if (st.failureStreak >= 2)
                     st.protocolCorrection = "检测到相同请求连续失败：先定位根因并记录已排除假设，再选择不同方案；不要重复同一调用。";
+                const claimsVerification = /验证|测试|构建|检查|确认生效|实际结果|已通过|未验证|无法验证/i.test(st.assistantText);
+                st.postTurnReview = st.interactionMode === "execute" && st.assistantText && !claimsVerification
+                    ? "〔上轮交付复核〕上一轮执行回复没有给出可见的验证证据。本轮若继续处理同一任务，先确认上轮变更是否真实生效，再继续扩大范围。"
+                    : null;
+                if (st.interactionMode === "execute")
+                    st.taskPhase = st.toolFailures > 0 || st.toolUnknown > 0 ? "diagnose" : claimsVerification ? "deliver" : "verify";
+                // 即时对齐只影响当前轮；下一轮重新根据用户消息判断，避免纠偏条款滞留。
+                st.alignmentCorrection = null;
                 // 风格泄漏检测挂在 turn/end（该事件已被窗口机制验证可靠；assistant/message
                 // 的投递在实测中不可靠）。切换完成后逐轮检查回复是否残留旧人设签名词，
                 // 窗口已关仍检出 → 重开窗口 + 升级播报；一轮干净回复自动解除升级。
@@ -718,20 +726,33 @@ export function apply(ctx, config = {}) {
             const sid = context.agent?.session?.id ?? context.agent?.id;
             const st = sid ? runtime.get(String(sid)) : null;
             const query = st?.lastQuery ?? "";
-            const task = TASK_SIGNAL_RE.test(query);
             // 已知推理型模型具备计划能力，任务轮只保留变更、验证、归因和复核约束；
             // 路由未知时使用完整版，避免误判造成能力退化。
-            const reasoning = typeof llmRoute?.model === "string" && REASONING_MODEL_RE.test(llmRoute.model);
-            const base = !task
-                ? THINKING_COMPACT_TEXT
-                : reasoning
-                    ? THINKING_REASONING_TEXT
-                    : THINKING_TEXT;
+            const base = selectThinkingProtocol({
+                isTask: TASK_SIGNAL_RE.test(query),
+                isReasoningModel: typeof llmRoute?.model === "string" && REASONING_MODEL_RE.test(llmRoute.model),
+            });
             // 纠偏与反思提醒属于任务协议，跟人设无关——挂在 thinking 段
             // 才能在「不使用人设」的纯任务会话里也生效。
             const correction = st?.protocolCorrection;
             const reflectionHint = reflectionStore?.getFeedback() ?? null;
-            return [base, correction, reflectionHint].filter(Boolean).join("\n\n");
+            const route = buildInteractionDirective(st?.interactionMode ?? "question");
+            const longSession = buildLongSessionGuard(st?.turnIndex ?? 0);
+            const anchor = buildSessionAnchor(st?.turnIndex ?? 0, st?.interactionMode ?? "question", query, st?.recentTurns ?? []);
+            const alignment = st?.alignmentCorrection;
+            const postTurnReview = st?.postTurnReview;
+            const phase = buildTaskPhaseDirective(st?.taskPhase ?? "answer");
+            const toolEvidence = st ? buildToolEvidenceDirective({ calls: st.toolCalls, successes: st.toolSuccesses, failures: st.toolFailures, unknown: st.toolUnknown }) : null;
+            return [base, route, phase, longSession, anchor, alignment, postTurnReview, toolEvidence, correction, reflectionHint].filter(Boolean).join("\n\n");
         },
     }), "lume.thinking-section()");
+    // ── 会话压缩接管（实验特性，默认关闭）──
+    // 开启后：宿主提供 ctx.compaction 时用 Lume 的结构化检查点摘要替换 coding 模板；
+    // 需配合 profile 的 cordis.patch.yml 禁用 compaction-basic（同名服务不可重复注册）。
+    // 默认关闭时完全不注册，避免在未配置的机器上产生无意义的失败日志。
+    if (compactionTakeover) {
+        // resolveRoute：agent 上取不到路由时用 Lume 自己缓存的主对话路由兜底，
+        // 避免摘要静默回退到宿主的 coding 模板。
+        void registerLumeCompaction(ctx, ctx.logger, { resolveRoute: () => llmRoute });
+    }
 }