lume-dsh-plugin 0.6.2 → 0.7.0

package/lib/index.js

@@ -38,6 +38,11 @@ import { appendLumeLog } from "./host/diag.js";
 import { advancePhase, buildAlignmentCorrection, buildCasualDirective, buildCompactionNotice, buildInteractionDirective, buildLongSessionGuard, buildSessionAnchor, buildTaskPhaseDirective, buildToolFailureNotice, classifyInteraction, isUserAuthored, taskPhaseForMode } from "./host/protocol.js";
 import { buildDocumentDirective, probeDocumentCapabilities } from "./host/documents.js";
 import { REASONING_MODEL_RE, TASK_SIGNAL_RE, selectStableThinkingProtocol } from "./host/thinking.js";
+import { normalizeChange, normalizeContract, normalizeHypothesis, normalizeProjectFact, projectKeyOf, renderChangeLedger, renderContract, renderHypotheses, renderProjectFacts } from "./core/ledger.js";
+import { classifyTool, readResultSignals } from "./core/signals.js";
+import { buildContractMethodDirective, buildDocumentMethodDirective, buildImpactDirective, buildStructureHint, composeBlocks } from "./host/methods.js";
+import { LUME_PROJECT_SPEC, ProjectStore } from "./host/project.js";
+import { DEFAULT_TRIGGER_THRESHOLDS, applyToolSignal, applyVerifyOutcome, cooldownOk, evaluateToolTrigger, evaluateTurnTrigger } from "./host/triggers.js";
 /** schemastery → domainTable 形参的桥接（与 identity.ts 同款）。 */
 const recordSchema = zodLike;
 /** 会话人设选择的持久层（键 = sessionId）。 */
@@ -186,6 +191,35 @@ export function apply(ctx, config = {}) {
         }
     })();
     void reflectionReady.then((s) => { reflectionStore = s; });
+    // ── 项目域：任务契约 / 改动台账 / 假设台账 / 项目知识（失败降级为无载具功能）──
+    const projectMemoryOn = config.projectMemory ?? true;
+    const behaviorTriggersOn = config.behaviorTriggers ?? true;
+    const triggerThresholds = {
+        ...DEFAULT_TRIGGER_THRESHOLDS,
+        inspectStreak: config.triggerInspectStreak ?? DEFAULT_TRIGGER_THRESHOLDS.inspectStreak,
+        changeStreak: config.triggerChangeStreak ?? DEFAULT_TRIGGER_THRESHOLDS.changeStreak,
+        deadPathFails: config.triggerDeadPathFails ?? DEFAULT_TRIGGER_THRESHOLDS.deadPathFails,
+    };
+    let project = null;
+    const projectReady = (async () => {
+        if (!projectMemoryOn)
+            return null;
+        try {
+            const domain = await ctx.storageDomain.open(LUME_PROJECT_SPEC);
+            ctx.effect(() => async () => { await domain.close(); }, "lume: close project domain");
+            return new ProjectStore({
+                contract: domain.table("contract"),
+                ledger: domain.table("ledger"),
+                hypotheses: domain.table("hypotheses"),
+                facts: domain.table("facts"),
+            });
+        }
+        catch (error) {
+            ctx.logger?.warn?.("lume: 项目域不可用，任务契约/台账/项目知识降级", error);
+            return null;
+        }
+    })();
+    void projectReady.then((s) => { project = s; });
     const registry = new PersonaRegistry(builtins, () => identity);
     ctx.logger?.warn?.(`lume: 已加载（builtins=${Object.keys(builtins).join(",") || "空!"}，assets=${assetsDir}）`);
     ctx.logger?.warn?.(`lume: llmRoute 初始化策略：agentDefaultModel → settings → 回退`);
@@ -511,6 +545,9 @@ export function apply(ctx, config = {}) {
                 st.toolCalls++;
                 if (st.interactionMode === "execute")
                     st.taskPhase = advancePhase(st.taskPhase, "execute");
+                // 行为类别在调用阶段记账（连击），成败到结果阶段才结算。
+                st.toolKind = classifyTool(event.data?.name);
+                applyToolSignal(st.triggerCounters, st.toolKind, null);
                 break;
             }
             case "tool/result": {
@@ -526,6 +563,30 @@ export function apply(ctx, config = {}) {
                     st.toolSuccesses++;
                 if (st.interactionMode === "execute")
                     st.taskPhase = advancePhase(st.taskPhase, unknownResult || explicitError ? "diagnose" : "verify");
+                // 行为信号 → 计数器 → 触发器提醒。提醒只在这一步之后可见（尾部快照），
+                // 且每类触发器有轮级冷却：提示一多就变噪音，模型会学会忽略。
+                const signals = readResultSignals(resultText, explicitError);
+                applyVerifyOutcome(st.triggerCounters, st.toolKind, signals);
+                if (behaviorTriggersOn) {
+                    const fire = evaluateToolTrigger(st.triggerCounters, {
+                        turnIndex: st.turnIndex,
+                        isTask: isTaskQuery(st),
+                        diagnosing: st.interactionMode === "diagnosis",
+                        hasContract: contractOf(sid) !== null,
+                        hasHypotheses: hypothesesOf(sid).length > 0,
+                        hypothesesTouched: st.hypothesesTouched,
+                    }, triggerThresholds);
+                    if (fire && cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
+                        st.triggerFiredAt[fire.id] = st.turnIndex;
+                        st.triggerNudge = fire.text;
+                        ctx.logger?.warn?.(`lume: [${sid}] 行为触发器 ${fire.id}（steps=${st.triggerCounters.steps}，inspect=${st.triggerCounters.inspectStreak}，mutate=${st.triggerCounters.mutateStreak}，verifyFail=${st.triggerCounters.verifyFailStreak}）`);
+                        // 环境性死路自动落成项目知识：下次会话不必重踩。
+                        if (fire.id === "dead-path" && signals.env && project) {
+                            const key = projectKeyFor(sid, session);
+                            void project.addFact(key, normalizeProjectFact({ kind: "deadend", text: `本环境验证受阻（${st.triggerCounters.verifyFailStreak} 次连续失败，环境/依赖类）：换降级阶梯，不要重复同一命令` }, Date.now()), (candidate, existing) => existing.some((fact) => fact.text === candidate));
+                        }
+                    }
+                }
                 break;
             }
             case "compaction/summary": {
@@ -546,6 +607,37 @@ export function apply(ctx, config = {}) {
                 st.switchGreetingPending = false;
                 if (st.switchTurn !== null && st.turnIndex - st.switchTurn >= boundaryTurns)
                     st.switchTurn = null;
+                // ── 行为触发器（轮边界）──
+                // 连击按轮清零：新一轮是新请求，上一轮的「撒网」不该继续累加；死路连击
+                // 跨轮保留（同一环境不可用是会话级事实）。上轮的提醒到这里失效。
+                st.triggerCounters.inspectStreak = 0;
+                st.triggerCounters.mutateStreak = 0;
+                st.triggerNudge = null;
+                st.turnNudge = null;
+                st.hypothesesTouched = false;
+                if (behaviorTriggersOn && project) {
+                    const fire = evaluateTurnTrigger({
+                        turnIndex: st.turnIndex,
+                        hasContract: contractOf(sid) !== null,
+                        compactionTurn: st.compaction?.turnIndex ?? null,
+                        lastDriftTurn: st.lastDriftTurn,
+                        counters: st.triggerCounters,
+                        knowledgePrompted: st.knowledgePrompted,
+                    }, triggerThresholds);
+                    if (fire && cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
+                        st.triggerFiredAt[fire.id] = st.turnIndex;
+                        if (fire.id === "criteria-drift") {
+                            // 契约对账用「交付口径」渲染原始判据：防判据随进展漂移。
+                            st.lastDriftTurn = st.turnIndex;
+                            st.turnNudge = renderContract(contractOf(sid), true);
+                        }
+                        else {
+                            st.knowledgePrompted = true;
+                            st.turnNudge = fire.text;
+                        }
+                        ctx.logger?.warn?.(`lume: [${sid}] 轮触发器 ${fire.id}（turn=${st.turnIndex}）`);
+                    }
+                }
                 // 低成本会话内纠偏：只处理明确的错误/失败信号，且要求连续轮次用户请求相同。
                 const failed = /失败|报错|错误|exception|traceback|cannot|unable|permission denied|timed out|找不到|不存在/i.test(st.assistantText);
                 const queryKey = st.userText.trim().replace(/\s+/g, " ").slice(0, 240);
@@ -602,6 +694,8 @@ export function apply(ctx, config = {}) {
         const st = runtime.get(sid);
         const turns = [...st.recentTurns];
         runtime.delete(sid);
+        // 任务载具是会话态：任务结束即无意义，清掉避免无界增长（项目知识在另一张表，不受影响）。
+        void projectReady.then((store) => store?.clearSession(sid));
         // 反思日志：会话结束后空闲时间跑一次小模型，零用户感知 token。
         // 历史不够长（< 4 条消息）或路由不可用时静默跳过。
         if (reflectionEnabled && turns.length >= 4) {
@@ -620,10 +714,89 @@ export function apply(ctx, config = {}) {
                 if (!score)
                     return;
                 await store.log(sid, score);
-                ctx.logger?.warn?.(`lume: 反思日志 ${sid} context=${score.context} planning=${score.planning} verification=${score.verification} review=${score.review}「${score.note}」`);
+                ctx.logger?.warn?.(`lume: 反思日志 ${sid} context=${score.context} planning=${score.planning} verification=${score.verification} review=${score.review} diagnosis=${score.diagnosis}「${score.note}」`);
             })();
         }
     }), "lume: session disposal");
+    // ── 载具与项目知识的读取入口（事件处理器 / 工具 / 注入三处共用）──
+    /** 项目键：优先取会话工作目录（跨会话共享同一仓库的知识）。 */
+    function projectKeyFor(sid, source) {
+        const st = runtime.get(sid);
+        if (st.projectKey)
+            return st.projectKey;
+        // 三种调用来源：提示词 context（{agent:{session}}）、工具 exec（{agent:{session}}）、
+        // 会话事件（session 本身）。统一取到 session 再读 cwd。
+        const session = source?.agent?.session ?? source?.session ?? source;
+        const cwd = session?.cwd ?? "";
+        const key = projectKeyOf(cwd);
+        // 只有拿到真实工作目录才缓存：否则一次无 cwd 的调用会把 "unknown" 固化下来。
+        if (cwd)
+            st.projectKey = key;
+        return key;
+    }
+    function isTaskQuery(st) {
+        return TASK_SIGNAL_RE.test(st.intent?.text ?? st.userText ?? "");
+    }
+    function contractOf(sid) {
+        return project?.getContract(sid) ?? null;
+    }
+    function changesOf(sid) {
+        return project?.getChanges(sid) ?? [];
+    }
+    function hypothesesOf(sid) {
+        return project?.getHypotheses(sid) ?? [];
+    }
+    function factsOf(sid, context) {
+        return project ? project.getFacts(projectKeyFor(sid, context)) : [];
+    }
+    /** 环境里是否有符号级结构分析工具：有就让模型用它替代通篇 read。 */
+    function structureToolName(context) {
+        try {
+            const schemas = ctx.get("tools")?.schemas?.(context?.agent);
+            if (!Array.isArray(schemas))
+                return null;
+            for (const schema of schemas) {
+                const name = String(schema?.name ?? "");
+                if (/analy|tree|symbol|lsp|reference|code_map|outline/i.test(name))
+                    return name;
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 任务载具块：契约 / 改动台账 / 假设台账 / 项目知识 + 方法块 + 触发器提醒。
+     *
+     * 全部落在尾部快照（易变层）——这正是「载具」现在才做得起的原因：0.6.2 之前每步
+     * 注入一份会变的状态等于每步作废整段前缀，而快照只在内容变化时才付费（实测 58 步
+     * 只产生 9 条快照）。顺序上把「此刻最该做的一件事」（触发器提醒）放在最后。
+     */
+    function carrierBlocks(sid, context, st, query, mode) {
+        if (!projectMemoryOn)
+            return [];
+        const isTask = TASK_SIGNAL_RE.test(query);
+        const contract = contractOf(sid);
+        const changes = changesOf(sid);
+        const docDirective = buildDocumentDirective({ query, capabilities: probeDocumentCapabilities(ctx.get("tools"), context?.agent) });
+        return [
+            // 契约：有就回显（交付轮切成对账口径），没有且是任务轮就先教它写一份。
+            { text: renderContract(contract, st.taskPhase === "deliver") },
+            { text: !contract && isTask ? buildContractMethodDirective() : null, droppable: true },
+            // 台账与假设：存在就回显——让模型「看见」自己的计划，而不是记在脑子里。
+            { text: changes.length > 0 ? renderChangeLedger(changes) : null },
+            { text: renderHypotheses(hypothesesOf(sid)) },
+            // 项目知识：只在与项目相关的轮次出现（闲聊不该背仓库事实）。
+            { text: isTask ? renderProjectFacts(factsOf(sid, context)) : null, droppable: true },
+            // 方法块：按任务形态出现；文档方法论只在判定为文档任务时出现。
+            { text: isTask && mode !== "question" ? buildImpactDirective() : null, droppable: true },
+            { text: docDirective ? buildDocumentMethodDirective() : null },
+            { text: mode === "execute" || mode === "diagnosis" ? buildStructureHint(structureToolName(context)) : null, droppable: true },
+            { text: st.turnNudge },
+            { text: st.triggerNudge },
+        ];
+    }
     // ── 模型可调用工具（主写入通道）──
     // 工具 output schema 的 const 语义要求成功值恒为 { ok: true }；失败一律抛错交由框架呈现。
     // as const 让 defineTool 从字面量推断 O，三个工具共用同一份成功形状。
@@ -694,6 +867,152 @@ export function apply(ctx, config = {}) {
                 return { ok: true };
             },
         }));
+        // ── 任务载具工具（第二组写入通道）──
+        // 与人格工具一样是「模型主动调用、零额外 LLM 调用」，区别在写入对象：契约/台账/假设
+        // 属于当前任务（会话态），项目知识按工作目录跨会话累积。列表类参数统一用字符串
+        // 分隔（分号或换行），不引入数组 schema——省 schema token，也少一层校验风险。
+        const splitList = (value) => String(value ?? "")
+            .split(/[；;\n]/)
+            .map((item) => item.trim())
+            .filter(Boolean);
+        ctx.effect(() => {
+            ctx.tools.register(defineTool({
+                name: "lume_contract",
+                description: "写下或更新本任务的任务契约（需求量化的落点）：目标、范围、数量、完成判据、非目标、待确认。任务型请求开工前调用一次；探索后回填实际数量；之后只传变化的字段即可（局部更新）。",
+                parameters: {
+                    goal: { type: "string", description: "目标：一句话、可观察的结果" },
+                    scope: { type: "string", description: "范围：路径/模块/章节，分号或换行分隔" },
+                    expectCount: { type: "number", description: "预计数量（探索前先估）" },
+                    actualCount: { type: "number", description: "实际数量（探索后回填）" },
+                    criteria: { type: "string", description: "完成判据：可执行、可核对，分号或换行分隔" },
+                    nonGoals: { type: "string", description: "非目标：明确不动的东西，分号分隔" },
+                    open: { type: "string", description: "待确认：只列真正阻塞的（≤2 个），分号分隔" },
+                },
+                output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已记录任务契约" }] },
+                execute: async (args, exec) => {
+                    if (!project)
+                        throw new Error("lume project store is unavailable");
+                    const sid = String(exec?.agent?.session?.id ?? "");
+                    if (!sid)
+                        throw new Error("lume_contract requires an active session");
+                    const st = runtime.get(sid);
+                    const normalized = normalizeContract({
+                        goal: args.goal,
+                        scope: splitList(args.scope),
+                        expectCount: args.expectCount,
+                        actualCount: args.actualCount,
+                        criteria: splitList(args.criteria),
+                        nonGoals: splitList(args.nonGoals),
+                        open: splitList(args.open),
+                    }, Date.now(), st.turnIndex);
+                    const existing = project.getContract(sid);
+                    if (existing) {
+                        // 局部更新：未传的字段保持原值（回填数量时不该把判据清空）。
+                        const patch = {};
+                        if (args.goal !== undefined)
+                            patch.goal = normalized.goal;
+                        if (args.scope !== undefined)
+                            patch.scope = normalized.scope;
+                        if (args.expectCount !== undefined)
+                            patch.expectCount = normalized.expectCount;
+                        if (args.actualCount !== undefined)
+                            patch.actualCount = normalized.actualCount;
+                        if (args.criteria !== undefined)
+                            patch.criteria = normalized.criteria;
+                        if (args.nonGoals !== undefined)
+                            patch.nonGoals = normalized.nonGoals;
+                        if (args.open !== undefined)
+                            patch.open = normalized.open;
+                        await project.patchContract(sid, patch);
+                    }
+                    else {
+                        if (!normalized.goal)
+                            throw new Error("lume_contract requires a goal on first write");
+                        await project.setContract(sid, normalized);
+                    }
+                    return { ok: true };
+                },
+            }));
+            ctx.tools.register(defineTool({
+                name: "lume_change",
+                description: "改动台账：记录/更新一处将要改或已改的位置（文件/符号/文档章节 → 改什么 → 怎么验 → 状态）。动手前先列计划项，改完推进状态；只推进状态时可只传 target + status。文档任务用章节名当 target，形成分节记账。",
+                parameters: {
+                    target: { type: "string", required: true, description: "目标位置：文件路径 / 符号 / 文档章节" },
+                    change: { type: "string", description: "改什么（一句话）" },
+                    why: { type: "string", description: "为什么改（对齐契约的哪一条）" },
+                    verify: { type: "string", description: "怎么验（命令 / 回读 / 对照）" },
+                    status: { type: "string", description: "planned | done | verified | skipped" },
+                },
+                output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已更新改动台账" }] },
+                execute: async (args, exec) => {
+                    if (!project)
+                        throw new Error("lume project store is unavailable");
+                    const sid = String(exec?.agent?.session?.id ?? "");
+                    if (!sid)
+                        throw new Error("lume_change requires an active session");
+                    const target = String(args.target ?? "").trim();
+                    if (!target)
+                        throw new Error("lume_change requires a target");
+                    const status = args.status;
+                    const allowed = status === "planned" || status === "done" || status === "verified" || status === "skipped" ? status : undefined;
+                    if (args.change === undefined && allowed !== undefined) {
+                        const hit = await project.setChangeStatus(sid, target, allowed);
+                        if (!hit)
+                            throw new Error(`lume_change: no ledger entry for ${target}`);
+                        return { ok: true };
+                    }
+                    const item = normalizeChange({ target, change: args.change, why: args.why, verify: args.verify, status: allowed }, Date.now());
+                    if (!item)
+                        throw new Error("lume_change requires target and change");
+                    await project.upsertChange(sid, item);
+                    return { ok: true };
+                },
+            }));
+            ctx.tools.register(defineTool({
+                name: "lume_hypothesis",
+                description: "假设台账：记录一条正在验证的假设及其证据与状态（open/testing/confirmed/excluded）。排查类任务里每验证一次就更新状态；已排除的假设不要再重复尝试。",
+                parameters: {
+                    text: { type: "string", required: true, description: "假设内容，一句话" },
+                    evidence: { type: "string", description: "支持或推翻它的观察（含命令输出/时间戳摘要）" },
+                    status: { type: "string", description: "open | testing | confirmed | excluded" },
+                },
+                output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已更新假设台账" }] },
+                execute: async (args, exec) => {
+                    if (!project)
+                        throw new Error("lume project store is unavailable");
+                    const sid = String(exec?.agent?.session?.id ?? "");
+                    if (!sid)
+                        throw new Error("lume_hypothesis requires an active session");
+                    const item = normalizeHypothesis({ text: args.text, evidence: args.evidence, status: args.status }, Date.now());
+                    if (!item)
+                        throw new Error("lume_hypothesis requires text");
+                    await project.upsertHypothesis(sid, item);
+                    runtime.get(sid).hypothesesTouched = true;
+                    return { ok: true };
+                },
+            }));
+            ctx.tools.register(defineTool({
+                name: "lume_project_note",
+                description: "记录一条**稳定的项目事实**（按工作目录跨会话累积）：构建/测试命令、模块数据流、仓库约定、或一条死路（试过但行不通的做法）。只记可复用、已验证的事实，不要记一次性进展。",
+                parameters: {
+                    kind: { type: "string", required: true, description: "build | test | module | convention | deadend" },
+                    text: { type: "string", required: true, description: "事实本身，一句话，≤200 字" },
+                },
+                output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已记入项目知识" }] },
+                execute: async (args, exec) => {
+                    if (!project)
+                        throw new Error("lume project store is unavailable");
+                    const sid = String(exec?.agent?.session?.id ?? "");
+                    if (!sid)
+                        throw new Error("lume_project_note requires an active session");
+                    const fact = normalizeProjectFact({ kind: args.kind, text: args.text }, Date.now());
+                    if (!fact)
+                        throw new Error("lume_project_note requires text");
+                    await project.addFact(projectKeyFor(sid, { agent: exec?.agent }), fact, (candidate, existing) => existing.some((entry) => jaccard(entry.text, candidate) >= 0.7));
+                    return { ok: true };
+                },
+            }));
+        }, "lume: carrier tools");
     }, "lume: persona tools");
     // ── 人设五段式注入 + 切换播报 ──
     /**
@@ -751,21 +1070,21 @@ export function apply(ctx, config = {}) {
         }).trim();
         // 易变的任务指令：路由、阶段、闲聊声明、长会话护栏、目标锚点、即时对齐、
         // 交付复核、压缩重锚、文档能力指引、失败纠偏、反思提醒——全部每步可变。
-        const thinkingRuntime = [
-            buildInteractionDirective(mode),
-            buildTaskPhaseDirective(st.taskPhase),
-            buildCasualDirective(TASK_SIGNAL_RE.test(query)),
-            buildLongSessionGuard(st.turnIndex),
-            buildSessionAnchor(st.turnIndex, mode, query, st.recentTurns),
-            st.alignmentCorrection,
-            st.postTurnReview,
-            st.compaction ? buildCompactionNotice(st.compaction, st.turnIndex) : null,
-            buildDocumentDirective({ query, capabilities: probeDocumentCapabilities(ctx.get("tools"), context?.agent) }),
-            st.protocolCorrection,
-            reflectionStore?.getFeedback() ?? null,
-        ]
-            .filter(Boolean)
-            .join("\n\n");
+        // 载具与方法块（契约/台账/假设/项目知识/影响面/文档方法/触发器提醒）排在最后：
+        // 它们是「此刻最该看的」，紧贴尾部注意力最强位；超预算时先丢可丢块（composeBlocks）。
+        const thinkingRuntime = composeBlocks([
+            { text: buildInteractionDirective(mode) },
+            { text: buildTaskPhaseDirective(st.taskPhase) },
+            { text: buildCasualDirective(TASK_SIGNAL_RE.test(query)) },
+            { text: buildLongSessionGuard(st.turnIndex) },
+            { text: buildSessionAnchor(st.turnIndex, mode, query, st.recentTurns) },
+            { text: st.alignmentCorrection },
+            { text: st.postTurnReview },
+            { text: st.compaction ? buildCompactionNotice(st.compaction, st.turnIndex) : null },
+            { text: st.protocolCorrection },
+            { text: reflectionStore?.getFeedback() ?? null, droppable: true },
+            ...carrierBlocks(sid, context, st, query, mode),
+        ]);
         // 会话选择尚未就绪（启动竞态）：只出任务协议，人设段留空——与旧实现一致，
         // 也避免把「尚未选择」误记成一次人设切换。
         if (!currentStore)
@@ -853,6 +1172,29 @@ export function apply(ctx, config = {}) {
         get distill() {
             return distillRunner;
         },
+        getProjectState(sessionId) {
+            // 诊断视图：任务载具 + 项目知识（供排查"模型到底看到了什么"）。
+            if (!project)
+                return null;
+            const st = runtime.get(sessionId);
+            return {
+                projectKey: st.projectKey,
+                contract: project.getContract(sessionId),
+                changes: project.getChanges(sessionId),
+                hypotheses: project.getHypotheses(sessionId),
+                facts: st.projectKey ? project.getFacts(st.projectKey) : [],
+                triggers: { ...st.triggerCounters, fired: st.triggerFiredAt },
+            };
+        },
+        async clearProjectFacts(sessionId) {
+            if (!project)
+                return false;
+            const st = runtime.get(sessionId);
+            if (!st.projectKey)
+                return false;
+            await project.clearFacts(st.projectKey);
+            return true;
+        },
     });
     ctx.effect(() => ctx.connection.rpc.handle(LUME_CHANNEL, async (endpoint, payload) => {
         currentStore ??= await storesReady;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lume-dsh-plugin",
-  "description": "微光 (Lume) — DSH Desktop 增强插件：给会话装上工程纪律与真实关系。纪律层约束「如何正确完成任务」——意图路由、阶段门控、真实工具证据、交付前复核、文档能力感知；人设层塑造「以何种风格表达」——从聊天记录、小说、剧本、设定文档蒸馏具名角色，长期记忆与风格随对话演进。约束按需注入，闲聊不额外付 token。",
-  "version": "0.6.2",
+  "description": "微光 (Lume) — DSH Desktop 增强插件：给会话装上工程纪律与真实关系。纪律层约束「如何正确完成任务」——意图路由、阶段门控、真实工具证据、交付前复核、文档能力感知；方法层把量化需求、改动台账、假设台账与项目知识变成可检查的产出，并用行为触发器在轨迹上纠偏（撒网不收敛 / 连写不验 / 死路重撞）；人设层塑造「以何种风格表达」——从聊天记录、小说、剧本、设定文档蒸馏具名角色，长期记忆与风格随对话演进。约束按需注入，闲聊不额外付 token。",
+  "version": "0.7.0",
   "type": "module",
   "main": "lib/index.js",
   "exports": {