lume-dsh-plugin 0.4.4 → 0.4.5

package/README.md

@@ -201,6 +201,7 @@
 | `extractionProvider` / `extractionModel` | 回落主对话 | 提取专用模型档（可仅配置其一） |
 | `distillProvider` / `distillModel` | 回落主对话 | 蒸馏专用模型档（可仅配置其一） |
 | `reflectionEnabled` | `true` | 会话结束时运行 Codex 工作协议反思评估，写入 `lume_reflection` 域 |
+| `compactionTakeover` | `false` | 接管会话压缩（实验）：需同时在 profile 的 `cordis.patch.yml` 里禁用 `compaction-basic`，否则同名服务已被占用、接管不会生效 |
 
 ## 存储
 

package/lib/host/compaction.js

@@ -0,0 +1,219 @@
+/**
+ * Lume 压缩后端：把较早对话压缩成结构化检查点。
+ *
+ * 复用默认后端（dsh-compaction-basic）的触发策略、保留策略与重放安全逻辑，
+ * 只替换「摘要生成」这一个钩子。默认模板面向 coding 场景（Files and Code、
+ * Key Technical Concepts），对闲聊、人设对话和长任务状态不适用；Lume 模板
+ * 保留：当前目标、已完成、未完成、已确认事实、已排除方案、当前错误、下一步，
+ * 以及与人设相关的关系语气线索。
+ *
+ * 接管方式：cordis 的同名服务不可由两个 fiber 重复注册（provide 会抛
+ * `service "compaction" has been registered at <...>`）。因此用户需在 profile
+ * 的 cordis.patch.yml 里按 id 禁用 `compaction-basic` 行，Lume 引擎才能注册
+ * ctx.compaction；未禁用时注册被拒绝，这里捕获并提示，不影响 Lume 其他功能。
+ *
+ * 宿主不提供压缩包时（import 失败）静默跳过——压缩是增强能力，不是依赖。
+ */
+import { appendFileSync } from "node:fs";
+import { join } from "node:path";
+/** 摘要指令：七项状态结构 + 保留边界。空小节写「（无）」，禁止编造；强制短于原文。 */
+export const LUME_COMPACTION_INSTRUCTION = [
+    "请把上面的对话压缩成一份结构化检查点，让另一个模型在不读原始历史的情况下无缝接续。",
+    "",
+    "严格按下面的 Markdown 结构输出，保留每个小节与顺序；用小短句、每条一行：",
+    "",
+    "## 当前目标",
+    "- [用户当前真正想达成的结果；原话重要时逐字引用]",
+    "",
+    "## 已完成",
+    "- [已确认完成的事项；只写有结果证据的，不写「尝试过」]",
+    "",
+    "## 未完成",
+    "- [明确要求但尚未完成的工作]",
+    "",
+    "## 已确认事实",
+    "- [对话中确认的稳定信息：决定、偏好、约定、结论；区分用户陈述与模型推断]",
+    "",
+    "## 已排除方案",
+    "- [讨论过或尝试过但被否决、失败或放弃的方案，以及原因——避免重复走弯路]",
+    "",
+    "## 当前错误与阻塞",
+    "- [正在遇到的错误、失败或卡点；没有就写（无）]",
+    "",
+    "## 下一步",
+    "- [最直接的下一步动作；没有明确下一步就写（无）]",
+    "",
+    "## 关系与语气线索",
+    "- [仅在与人设/关系相关时保留：双方称呼、用户明确提出过的语气或风格要求、关系定位；没有就写（无）]",
+    "",
+    "硬性要求：",
+    "- 整份摘要必须明显短于被压缩的对话——它替代的是历史，不是复述历史；",
+    "- 每个小节最多 3 条，每条不超过 40 字；没有内容的小节只写「（无）」，不要展开；",
+    "- 不要逐轮复述，不要保留寒暄、重复确认和已被取代的中间过程；",
+    "- 只压缩对话里真实出现过的信息，不要评价、不要补充对话中没有的事实。",
+].join("\n");
+/**
+ * 解析摘要调用的模型路由：优先会话最近一次真实请求的路由（与默认后端一致，
+ * 保证摘要模型与对话模型同源），回退 agent 选项；都拿不到返回 null
+ * （调用方回退默认实现，让默认后端的错误路径处理）。
+ */
+export function resolveSummarizationTarget(agent) {
+    const a = agent;
+    const latest = a?.session?.requestHeader?.()?.config;
+    if (typeof latest?.provider === "string" && latest.provider && typeof latest?.model === "string" && latest.model) {
+        return { provider: latest.provider, model: latest.model };
+    }
+    const options = a?.options;
+    if (typeof options?.provider === "string" && options.provider && typeof options?.model === "string" && options.model) {
+        return { provider: options.provider, model: options.model };
+    }
+    return null;
+}
+/** 默认加载器：宿主包（dsh-compaction-basic / dsh-llm）由 DSH 模块图提供。
+ * 模块名走变量，避免本地静态解析——这些包只在 DSH 运行时存在，且 npm 上的
+ * 同名包与宿主内置版本的内容可能不同（例如 dsh-llm 的导出面差异）。 */
+async function loadHostCompactionBackend() {
+    const compactionId = "@deepseek-ai/dsh-compaction-basic";
+    const llmId = "@deepseek-ai/dsh-llm";
+    const [compactionMod, llmModule] = await Promise.all([import(compactionId), import(llmId)]);
+    return {
+        Base: compactionMod?.BasicCompactionEngine,
+        BlockAssembler: llmModule?.BlockAssembler,
+        createUserMessage: llmModule?.createUserMessage,
+    };
+}
+/**
+ * 压缩诊断通道：宿主 stderr 会被桌面外壳缓冲，排查「接管了但没生效」这类问题时
+ * 不可靠。压缩是静默功能（自动触发时用户无感），因此保留一个自己的追加日志：
+ * 每次接管、摘要调用、失败各一行，路径 `$DSH_HOME/lume-compaction.log`。
+ * 写失败一律忽略——诊断不能反过来影响功能。
+ */
+function appendCompactionLog(message) {
+    try {
+        const home = process.env.DSH_HOME;
+        if (!home)
+            return;
+        appendFileSync(join(home, "lume-compaction.log"), `${new Date().toISOString()} ${message}\n`, "utf8");
+    }
+    catch {
+        /* 诊断失败不阻断 */
+    }
+}
+/**
+ * 注册 Lume 压缩引擎。异步动态加载宿主包：宿主不提供压缩子系统时静默返回，
+ * 已由 compaction-basic 占用服务时记录一次可操作的提示。
+ *
+ * 宿主包只在 DSH 运行时由模块图解析（与 npm 上同名包内容可能不同，例如
+ * dsh-llm 的导出面差异），因此加载失败一律按「宿主不支持」处理而不是抛错。
+ *
+ * @param deps.resolveRoute - Lume 自己缓存的对话模型路由（request/context 事件）。
+ * agent 上取不到路由时用它兜底，避免摘要静默回退到宿主默认模板。
+ * @param deps.report - 诊断输出；默认同时写 stderr 与追加日志文件。
+ */
+export async function registerLumeCompaction(ctx, logger, deps) {
+    const report = deps?.report ??
+        ((message) => {
+            appendCompactionLog(message);
+            process.stderr.write(`${message}\n`);
+        });
+    const load = deps?.load ?? loadHostCompactionBackend;
+    let backend;
+    try {
+        backend = await load();
+    }
+    catch {
+        return; // 宿主没有压缩子系统：跳过接管，Lume 其余功能不受影响
+    }
+    const Base = backend?.Base;
+    const BlockAssembler = backend?.BlockAssembler;
+    const createUserMessage = backend?.createUserMessage;
+    if (typeof Base !== "function" || typeof BlockAssembler !== "function" || typeof createUserMessage !== "function")
+        return;
+    const fallbackRoute = deps?.resolveRoute;
+    class LumeCompactionEngine extends Base {
+        /** 手动 `/compact` 的入口追踪：确认命令是否到达 Lume 实例（而非宿主默认实现）。 */
+        async compactNow(agent, signal, sourceCommandId) {
+            report("[lume] compaction: compactNow 到达 Lume 实例（手动压缩）");
+            return super.compactNow(agent, signal, sourceCommandId);
+        }
+        /** 只替换摘要生成；触发、保留、重放与计量策略全部继承默认后端。 */
+        async summarize(input, agent, signal) {
+            const target = resolveSummarizationTarget(agent) ?? fallbackRoute?.() ?? null;
+            if (target === null) {
+                report("[lume] compaction: 摘要回退宿主默认实现（无法解析模型路由）");
+                return super.summarize(input, agent, signal);
+            }
+            const sessionId = agent?.session?.id;
+            const maxTokens = this.config?.maxTokens;
+            const messages = [
+                ...(input?.messages ?? []),
+                createUserMessage({
+                    content: [{ type: "text", text: LUME_COMPACTION_INSTRUCTION }],
+                    source: { kind: "plugin", plugin: "lume-dsh-plugin" },
+                }),
+            ];
+            const assembler = new BlockAssembler();
+            for await (const chunk of this.ctx.llm.stream({
+                provider: target.provider,
+                model: target.model,
+                messages,
+                ...(input?.system === undefined ? {} : { system: input.system }),
+                ...(input?.tools === undefined ? {} : { tools: [...input.tools] }),
+                ...(typeof maxTokens === "number" ? { maxTokens } : {}),
+                ...(typeof sessionId === "string" ? { sessionId } : {}),
+                purpose: "compaction",
+                ...(signal === undefined ? {} : { signal }),
+            })) {
+                assembler.push(chunk);
+            }
+            const finish = assembler.finish;
+            if (finish?.kind === "error") {
+                throw new Error(String(finish.failure?.message ?? "lume compaction: summarization stream failed"));
+            }
+            const blocks = assembler.blocks();
+            const summary = blocks.filter((block) => block?.type === "text" && typeof block.text === "string" && block.text.trim().length > 0);
+            if (summary.length === 0)
+                throw new Error("lume compaction: summarization produced no text summary content");
+            const usage = assembler.usage;
+            return {
+                summary,
+                rawOutput: blocks,
+                llmStreamCall: true,
+                provider: target.provider,
+                model: target.model,
+                ...(typeof maxTokens === "number" ? { maxTokens } : {}),
+                ...(usage === undefined ? {} : { usage }),
+            };
+        }
+    }
+    try {
+        // 注意：必须注册到 Lume 自己的 ctx——`ctx.inject` 回调收到的 scope 是
+        // 隔离子上下文，服务注册在那里对命令与其他插件不可见（表现为引擎构造
+        // 成功但 /compact 仍走默认实现）。inject 只用于等待依赖就绪。
+        ctx.inject(["llm", "tokenMeter", "sessions"], () => {
+            try {
+                const existing = (() => {
+                    try {
+                        return ctx.get("compaction", false) ?? null;
+                    }
+                    catch {
+                        return null;
+                    }
+                })();
+                report(`[lume] compaction: 注册前 compaction 服务${existing === null ? "不存在" : "已存在（将被接管尝试拒绝）"}`);
+                new LumeCompactionEngine(ctx, {});
+                logger?.info?.("lume: 已接管会话压缩（结构化检查点摘要）");
+                report("[lume] compaction: 已接管 ctx.compaction（结构化检查点摘要）");
+            }
+            catch (error) {
+                const message = "lume: 压缩后端未接管——compaction 服务已被占用；在 profile 的 cordis.patch.yml 里禁用 compaction-basic 行后重启即可启用 Lume 摘要";
+                logger?.warn?.(message, error);
+                report(`[lume] compaction: 接管失败，服务已被占用（${String(error?.message ?? error)}）——请在 profile 的 cordis.patch.yml 里禁用 compaction-basic 后重启`);
+            }
+        });
+    }
+    catch (error) {
+        logger?.warn?.("lume: 压缩后端注册失败（不影响其他功能）", error);
+        report(`[lume] compaction: 注册失败（${String(error?.message ?? error)}）`);
+    }
+}

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/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,54 +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";
 import { buildAlignmentCorrection, buildInteractionDirective, buildLongSessionGuard, buildSessionAnchor, buildTaskPhaseDirective, buildToolEvidenceDirective, classifyInteraction, taskPhaseForMode } from "./host/protocol.js";
-/** Codex 风格任务执行协议：始终注入，约束任务如何完成。 */
-const THINKING_TEXT = `[任务执行协议]
-
-你应遵循以下公开的工程工作协议。它约束任务如何被完成，不要求输出隐藏的逐步思考过程；对外只给出必要的结论、计划、变更和验证结果。
-
-**身份分工**：人设只影响自然语言表达；本协议负责正确完成任务。代码、数学、工具调用、结构化输出和安全判断保持准确、朴素，不因人设而戏剧化。
-
-**P0 上下文管理**：先确认用户真正要达成的结果、约束、涉及的文件/系统和完成标准。上下文变长时压缩为：目标、已完成事项、关键决策、当前状态、错误、已排除假设、下一步。不要反复提出已经解决或排除的问题。
-
-**P1 阶段门控**：复杂任务按“理解 → 只读调研 → 简短计划 → 执行 → 验证 → 汇报”推进。调研和计划阶段不修改外部状态；未确认目标文件、接口和影响范围前，不直接动手。
-
-**P1 任务分解**：把大任务拆成可验证的小步骤，优先处理阻塞项和高风险项。每一步都说明完成条件；能并行的只读检查并行进行，存在依赖的步骤按顺序执行。
-
-**P1 自适应投入**：不要把“快速”当成固定目标。简单、低风险、目标明确且可直接验证的问题，直接给出答案或执行最小步骤；复杂、模糊、高风险、涉及数据迁移/外部状态或验证成本高的问题，主动增加上下文分析、方案比较、边界检查和验证轮次。只有在信息足够且风险可控时才快速收敛。
-
-**P0 意图对齐**：先辨认这一轮是问答、查找、讨论、诊断还是执行。问答先回答；查找先核对事实；讨论先比较取舍；诊断先解释证据和根因，不越权修复；执行才修改状态。用户要结论时不要只汇报动作，用户要探讨时不要擅自锁定方案。
-
-**P1 信息路由**：优先定位最可能影响结果的入口、数据流和约束，不平均浏览无关内容；无依赖的只读检查可以并行，依赖前置结果的操作必须等待确认。
-
-**P2 变更纪律**：修改前完整读取相关文件，理解现有实现和用户已有改动；一次性完成同一文件的相关修改。保持改动最小、可回滚、与现有接口兼容，不重写无关代码，不覆盖用户数据。
-
-**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 { REASONING_MODEL_RE, TASK_SIGNAL_RE, selectThinkingProtocol } from "./host/thinking.js";
 /** schemastery → domainTable 形参的桥接（与 identity.ts 同款）。 */
 const recordSchema = zodLike;
 /** 会话人设选择的持久层（键 = sessionId）。 */
@@ -127,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");
@@ -769,15 +726,12 @@ 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;
@@ -792,4 +746,13 @@ export function apply(ctx, config = {}) {
             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 });
+    }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lume-dsh-plugin",
   "description": "微光 (Lume) — DSH Desktop 增强插件：Codex 风格自适应任务执行协议 + 人设系统（聊天记录蒸馏具名角色、长期记忆、风格纠偏自动捕获）",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -51,17 +51,12 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-connection": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-locale": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-runtime": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-invariants": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-storage-domain": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-system-prompt": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-tools": "^0.0.1-rc.1",
-    "@deepseek-ai/dsh-typert-protocol": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "*",
+    "@deepseek-ai/dsh-llm": "*",
+    "@deepseek-ai/dsh-storage-domain": "*",
+    "@deepseek-ai/dsh-tools": "*",
+    "@deepseek-ai/dsh-compaction": "*",
+    "@deepseek-ai/dsh-compaction-basic": "*",
     "@deepseek-ai/schemastery": "^3.18.1"
   },
   "scripts": {
@@ -95,5 +90,31 @@
     "assets/personalities.json",
     "assets/personalities/*.txt",
     "assets/personalities/*.jsonl"
-  ]
+  ],
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-client-ui-primitives": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-storage-domain": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-tools": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-compaction-basic": {
+      "optional": true
+    },
+    "@deepseek-ai/schemastery": {
+      "optional": true
+    }
+  }
 }