lume-dsh-plugin 0.7.2 → 0.7.4

package/lib/core/ledger.js

@@ -48,11 +48,18 @@ function asCount(value) {
     const n = typeof value === "number" ? value : Number.parseInt(String(value ?? ""), 10);
     return Number.isFinite(n) && n >= 0 ? Math.trunc(n) : null;
 }
-/** 项目键：跨会话共享的项目知识按工作目录归属（同一仓库的多个会话共用一份）。 */
+/**
+ * 项目键：跨会话共享的项目知识按工作目录归属（同一仓库的多个会话共用一份）。
+ *
+ * 拿不到工作目录时返回 **null**，不返回 "unknown"——实测踩过：写入口（工具 exec / 会话事件）
+ * 里的 session 视图不一定带 cwd，回落成 "unknown" 会把**所有项目**的知识塞进同一个桶，
+ * 跨会话隔离直接失效（现场取证：facts 表的键就是 "unknown"）。调用方拿到 null 必须
+ * 「不写跨会话表」，宁可不记也不要串味。
+ */
 export function projectKeyOf(cwd) {
     const normalized = clip(cwd, 240).replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
     if (!normalized)
-        return "unknown";
+        return null;
     return fnv1a32(normalized).toString(16).padStart(8, "0");
 }
 /** 从工具入参归一化契约（截断 + 去重 + 上限）。 */
@@ -143,8 +150,8 @@ export function renderContract(contract, delivery = false) {
     lines.push(`目标：${contract.goal}`);
     if (contract.scope.length > 0)
         lines.push(`范围：${contract.scope.join("；")}`);
-    if (contract.expectCount !== null || contract.actualCount !== null) {
-        const expect = contract.expectCount === null ? "?" : contract.expectCount;
+    if (true) {
+        const expect = contract.expectCount === null ? "未估" : contract.expectCount;
         const actual = contract.actualCount === null ? "未回填" : contract.actualCount;
         lines.push(`数量：预计 ${expect} → 实际 ${actual}`);
     }

package/lib/host/methods.js

@@ -15,7 +15,7 @@ export function buildContractMethodDirective() {
         "〔先量化后动手〕本轮是任务型请求。开工前先写任务契约（lume_contract）：",
         "- 目标：一句话，可观察的结果（不是「优化一下」这种动词）",
         "- 范围：精确到路径 / 模块 / 章节 / 表",
-        "- 数量：先估一个数，探索后回填实际值——交付时要用实际数量对账",
+        "- 数量：必填，先估一个数，探索后回填实际值（实在无法估时传 0 并说明理由）——交付时要用实际数量对账",
         "- 完成判据：可执行、可核对（命令 / 回读 / 对照），不是「改完」",
         "- 非目标：明确不动什么，防止范围蔓延",
         "- 待确认：只列真正阻塞的（≤2 个）；不阻塞的按默认假设前进并写明假设",
@@ -36,6 +36,7 @@ export function buildImpactDirective() {
     return [
         "〔改动影响面〕动手前列出：要改的符号 → 谁调用它、它实现或被实现于谁、配置或 SQL 映射、前端/模板引用；并标出「不打算改但需一并确认」的位置。",
         "每处改动写明验证方式；同一文件的相关改动一次做完，不要反复回来改同一个文件。",
+        "每改完一处就用 lume_change 记一条（target=文件/符号、change=改了什么、verify=怎么验、status=done），验完推进到 verified；台账积着未验证项时会有提醒。",
     ].join("\n");
 }
 /** 环境里有结构分析/符号工具时的一句提示：用符号级定位替代通篇 read。 */

package/lib/host/protocol.js

@@ -8,6 +8,15 @@ const MODE_RULES = {
 // 显式请求标记后必须紧跟一个动作动词，且限制在同一小句内（旧版用 `.*` 贪婪跨越
 // 整句，导致「是什么驱动你去这么做的」也被判成执行）。句首祈使不再放行「做」：
 // 「做一件事…」这类名词化表述是讨论而非执行。
+/**
+ * 执行动词的补充表（0.7.4）。
+ *
+ * 现场实测：`EXECUTE_RE` 不含「重构 / 梳理 / 删掉 / 合并 / 迁移」等常见动词，于是
+ * 「帮我重构订单退费链路」被判成**问答**——方法层（影响面清单）与阶段门控都不生效，
+ * 而那次会话确实改了 11 个文件。这里只补「对产物动手」的动作，**不含诊断类动词**
+ * （分析/诊断/排查属于 diagnosis，混进来会把讨论与排查误判成执行）。
+ */
+const EXECUTE_EXTRA_RE = /重构|重写|梳理|清理|删掉|删除|去掉|移除|合并|合入|迁移|替换|收口|落地|接入|适配|升级|降级|补上|补齐|加上|改成|改为|换成|拆开|拆出/;
 const EXECUTE_RE = new RegExp([
     "(?:请|帮我|帮忙|直接|把|给我|替我|麻烦|需要你)\\s*[^，。！？；\\n]{0,24}?(?:做|改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布|检查|核对|补|替换|重命名|合并|回滚|加上)",
     "^(?:改|修|写|加|删|建|跑|执行|完成|实现|优化|更新|部署|安装|迁移|提交|发布|检查|补|替换|重命名|合并|回滚)",
@@ -23,7 +32,7 @@ export function classifyInteraction(text) {
     const query = String(text ?? "").trim();
     if (!query)
         return "question";
-    if (EXECUTE_RE.test(query))
+    if ((EXECUTE_RE.test(query) || EXECUTE_EXTRA_RE.test(query)))
         return "execute";
     if (DIAGNOSIS_RE.test(query))
         return "diagnosis";

package/lib/host/rpc-bridge.js

@@ -0,0 +1,122 @@
+/**
+ * Connection RPC 的**桥接协议**实现（纯函数 + 一个路由工厂）。
+ *
+ * 为什么需要它：宿主 `connection.rpc.handle(channel, handler)` 内部要求
+ * 「频道注册属于**调用方 fiber**」（见 dsh-client-connection 的 `register(owner, …)` →
+ * `owner.effect(() => owner.webServer.register(route))`），在 DSH Desktop 0.9.1 上我们的
+ * 入口 fiber 解析不到 `webServer` → 抛 `cannot get property "webServer" without inject`。
+ * 于是准备一条**不依赖 connection.rpc 的回退路径**：照宿主自己的写法把 HTTP 路由挂到
+ * `webServer` 上（宿主自带的 dsh-ppt 就是这么做的），报文与客户端 `conn.rpc.call` 完全一致：
+ *
+ *   请求  POST {channel}/{endpoint}   content-type: application/json
+ *         { type: "client-request", rpcId, method: endpoint, payload }
+ *   响应  200 { type: "server-response", rpcId, result: { ok, value|error } }
+ *
+ * 纯函数部分（解析/组装）可单测，路由工厂只做 Node req/res 的胶水。
+ */
+/** 端点段白名单，与宿主 ENDPOINT_SEGMENT_PATTERN 一致。 */
+const ENDPOINT_SEGMENT_PATTERN = /^[A-Za-z0-9_$.-]+$/;
+/** 组装一条回信（含 rpcId 与错误信封补全）。 */
+export function connectionResponse(rpcId, result) {
+    return JSON.stringify({ type: "server-response", rpcId, result: withErrorDetails(result) });
+}
+/**
+ * 补全错误信封：客户端的 `parseConnectionResponse` 要求失败时
+ * `error.details` 是对象，缺失会直接抛 "invalid server-response failure"。
+ * （这是 0.7.2 之前一直存在的隐患：任何错误路径都会让客户端调用炸掉。）
+ */
+export function withErrorDetails(result) {
+    const envelope = result;
+    if (!envelope || typeof envelope !== "object" || envelope.ok !== false)
+        return result;
+    const error = envelope.error ?? {};
+    return {
+        ok: false,
+        error: {
+            code: typeof error.code === "string" ? error.code : "bad-request",
+            message: typeof error.message === "string" ? error.message : "unknown error",
+            details: error.details && typeof error.details === "object" ? error.details : {},
+        },
+    };
+}
+/** 解析客户端请求。与宿主的 rpcFetchHandler 语义对齐（404/415/400 + 信封校验）。 */
+export function parseClientRequest(channel, request) {
+    if ((request.method ?? "GET").toUpperCase() !== "POST")
+        return { kind: "respond", status: 404, body: "not found", contentType: "text/plain" };
+    const pathname = (request.url ?? "/").split("?")[0] ?? "/";
+    if (!pathname.startsWith(`${channel}/`))
+        return { kind: "respond", status: 404, body: "not found", contentType: "text/plain" };
+    const endpoint = pathname.slice(channel.length + 1);
+    if (endpoint.split("/").some((segment) => segment === "" || segment === "." || segment === ".." || !ENDPOINT_SEGMENT_PATTERN.test(segment))) {
+        return { kind: "respond", status: 404, body: "not found", contentType: "text/plain" };
+    }
+    const mime = (request.contentType ?? "").split(";")[0]?.trim().toLowerCase();
+    if (mime !== "application/json")
+        return { kind: "respond", status: 415, body: "content type must be application/json", contentType: "text/plain" };
+    let body;
+    try {
+        body = JSON.parse(request.rawBody);
+    }
+    catch {
+        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.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: "dispatch", rpcId: envelope.rpcId, endpoint, payload: envelope.payload };
+}
+/**
+ * 组装可交给 `webServer.register()` 的路由（宿主自带 dsh-ppt 同形：
+ * `{ kind: "prefix", path: channel, handler(req, res) }`）。
+ *
+ * @param channel - RPC 频道（须匹配 /^\/[A-Za-z0-9._~-]+$/，且不得为 /api）
+ * @param dispatch - 业务分发（endpoint + payload → lume 信封）
+ * @param guard - 可选的浏览器信任闸（宿主 connection.requestRejection），返回状态码即拒绝
+ */
+export function makeRpcRoute(channel, dispatch, guard) {
+    return {
+        kind: "prefix",
+        path: channel,
+        handler: async (req, res) => {
+            const rejection = guard?.(req);
+            if (rejection !== undefined) {
+                res.writeHead(rejection);
+                res.end(rejection === 401 ? "unauthorized" : "forbidden");
+                return;
+            }
+            let rawBody = "";
+            try {
+                for await (const chunk of req)
+                    rawBody += typeof chunk === "string" ? chunk : String(chunk);
+            }
+            catch {
+                /* 客户端断开：下面按空 body 处理并回 400 */
+            }
+            const parsed = parseClientRequest(channel, {
+                method: req?.method,
+                url: req?.url,
+                contentType: req?.headers?.["content-type"] ?? null,
+                rawBody,
+            });
+            if (parsed.kind === "respond") {
+                res.writeHead(parsed.status, { "content-type": parsed.contentType });
+                res.end(parsed.body);
+                return;
+            }
+            let result;
+            try {
+                result = await dispatch(parsed.endpoint, parsed.payload);
+            }
+            catch (error) {
+                result = { ok: false, error: { code: "internal", message: String(error?.message ?? error) } };
+            }
+            res.writeHead(200, { "content-type": "application/json" });
+            res.end(connectionResponse(parsed.rpcId, result));
+        },
+    };
+}

package/lib/host/session-runtime.js

@@ -23,6 +23,7 @@ function defaultRuntime() {
         interactionMode: "question",
         intent: null,
         stableDigest: null,
+        cwd: null,
         projectKey: null,
         toolKind: "other",
         triggerCounters: newTriggerCounters(),

package/lib/host/triggers.js

@@ -58,7 +58,7 @@ export function applyVerifyOutcome(counters, kind, signals) {
 }
 export const DEFAULT_TRIGGER_THRESHOLDS = {
     inspectStreak: 12,
-    changeStreak: 6,
+    changeStreak: 4,
     deadPathFails: 3,
     knowledgeSteps: 20,
 };
@@ -74,7 +74,7 @@ export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_
         if (dead === "env") {
             return {
                 id: "dead-path",
-                text: `〔验证降级〕同一环境已连续 ${n} 次验证失败，其中 ${m} 次是环境或依赖不可用（不是代码问题）。停止重复同一条命令，换降级阶梯：① 能用的编译器/测试 → ② 语法检查（parser / typecheck）→ ③ 静态交叉引用（谁调用它、它调用谁、配置与 SQL 绑定）→ ④ 手工走读并列出风险点。交付时明确写「本环境无法完成构建验证」。`,
+                text: `〔验证降级〕同一环境已连续 ${n} 次验证失败，其中 ${m} 次是环境或依赖不可用（不是代码问题）。停止重复同一条命令，换降级阶梯：① 能用的编译器/测试 → ② 语法检查（parser / typecheck）→ ③ 静态交叉引用（谁调用它、它调用谁、配置与 SQL 绑定）→ ④ 手工走读并列出风险点。同时用 lume_project_note（kind=deadend）把这条环境死路记进项目知识——下次会话不必重踩。交付时明确写「本环境无法完成构建验证」。`,
             };
         }
         return {
@@ -82,10 +82,10 @@ export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_
             text: `〔死路提醒〕同一验证已连续失败 ${n} 次。先归因（输入 / 逻辑 / 接口 / 环境 / 权限），把结论写进假设台账：证实的标 confirmed、排除的标 excluded（用 lume_hypothesis）——已排除的假设不要再试。换一个方案再动手。`,
         };
     }
-    if (counters.mutateStreak >= thresholds.changeStreak) {
+    if (counters.mutateStreak >= thresholds.changeStreak || ctx.unverifiedChanges >= thresholds.changeStreak) {
         return {
             id: "verify-as-you-go",
-            text: `〔增量验证〕已连续 ${counters.mutateStreak} 次改动，中间没有任何验证动作。改一处验一处：现在先跑一次最小验证（编译 / 语法检查 / 回读改动区域），确认前一批改动真的生效，再继续下一批。一大批改完再验，失败时无法定位是哪一处的问题。`,
+            text: `〔增量验证〕已连续 ${counters.mutateStreak} 次改动、台账里还有 ${ctx.unverifiedChanges} 项未验证。改一处验一处：现在先跑一次最小验证（编译 / 语法检查 / 回读改动区域），确认前一批改动真的生效；验完用 lume_change 把对应条目推进到 verified（只传 target + status 即可）。一大批改完再验，失败时无法定位是哪一处的问题。`,
         };
     }
     if (!ctx.hasContract && ctx.isTask && counters.mutations > 0) {
@@ -100,7 +100,7 @@ export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_
             text: `〔收敛提醒〕已连续 ${counters.inspectStreak} 次只读探查，还没有产出契约或改动台账。停止撒网式通读，先把链路复述出来——入口 → 数据流 → 影响面（谁调用、被谁调用、配置与 SQL 绑定）——写成改动台账（lume_change）并回填实际数量，然后带着这份清单回去读缺口。`,
         };
     }
-    if (counters.verifyFailStreak > 0 && ctx.diagnosing && ctx.hasHypotheses && !ctx.hypothesesTouched) {
+    if (counters.verifyFailStreak > 0 && ctx.diagnosing && !ctx.hypothesesTouched) {
         return {
             id: "hypothesis-stale",
             text: "〔假设台账〕本轮出现了验证失败，但假设状态没有更新。把这次失败归因写进 lume_hypothesis（证实 / 排除 / 新假设），并标出下一步要验的是哪一条——否则同一个假设会被反复试。",

package/lib/index.js

@@ -21,6 +21,7 @@ import z from "@deepseek-ai/schemastery";
 import { buildPersonaContractSection, buildPersonaRuntimeSection } from "./host/injection.js";
 import { loadPersonalities, NONE_PERSONA } from "./host/personalities.js";
 import { createLumeRpcHandler } from "./host/rpc.js";
+import { makeRpcRoute } from "./host/rpc-bridge.js";
 import { FilePersonaStore, migrateLegacyState, PersonaStore } from "./host/store.js";
 import { IdentityStore, LUME_IDENTITY_SPEC, zodLike } from "./host/identity.js";
 import { PersonaRegistry } from "./host/registry.js";
@@ -433,8 +434,10 @@ function applyInner(ctx, config = {}) {
                 return;
             const prompt = buildExtractionPrompt(userText, assistantText, existing.map((f) => f.text));
             const output = await callLlm(resolveAuxRoute(extractionRouteOverride, llmRoute), prompt.system, prompt.userText, 800);
-            if (output === null)
+            if (output === null) {
+                ctx.logger?.warn?.(`lume: 反思跳过（${sid}）模型无输出`);
                 return;
+            }
             st.lastExtractionAt = Date.now();
             const fresh = mergeNewFacts(parseFacts(output), identity.getMemory(personaName));
             for (const fact of fresh) {
@@ -565,6 +568,16 @@ function applyInner(ctx, config = {}) {
                 // 行为类别在调用阶段记账（连击），成败到结果阶段才结算。
                 st.toolKind = classifyTool(event.data?.name);
                 applyToolSignal(st.triggerCounters, st.toolKind, null);
+                // 自动改动台账：mutate 类工具一被调用就先记一条——实测模型几乎不会主动调 lume_change
+                // （4 个会话里 0 次），而 edit/write 每次会话几十次。载具必须由插件自己落账，
+                // 否则「改动台账」永远空着（这正是上一版没生效的地方）。
+                if (projectMemoryOn && st.toolKind === "mutate") {
+                    const target = targetPathFromToolEvent(event.data);
+                    if (target) {
+                        const toolName = String(event.data?.name ?? "tool");
+                        void projectReady.then((store) => store?.upsertChange(sid, { target, change: `（自动）由 ${toolName} 修改`, why: "", verify: "", status: "done", at: Date.now() }));
+                    }
+                }
                 break;
             }
             case "tool/result": {
@@ -590,7 +603,7 @@ function applyInner(ctx, config = {}) {
                         isTask: isTaskQuery(st),
                         diagnosing: st.interactionMode === "diagnosis",
                         hasContract: contractOf(sid) !== null,
-                        hasHypotheses: hypothesesOf(sid).length > 0,
+                        unverifiedChanges: changesOf(sid).filter((item) => item.status !== "verified" && item.status !== "skipped").length,
                         hypothesesTouched: st.hypothesesTouched,
                     }, triggerThresholds);
                     if (fire && cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
@@ -600,7 +613,8 @@ function applyInner(ctx, config = {}) {
                         // 环境性死路自动落成项目知识：下次会话不必重踩。
                         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));
+                            if (key)
+                                void project.addFact(key, normalizeProjectFact({ kind: "deadend", text: `本环境验证受阻（${st.triggerCounters.verifyFailStreak} 次连续失败，环境/依赖类）：换降级阶梯，不要重复同一命令` }, Date.now()), (candidate, existing) => existing.some((fact) => fact.text === candidate));
                         }
                     }
                 }
@@ -715,12 +729,22 @@ function applyInner(ctx, config = {}) {
         void projectReady.then((store) => store?.clearSession(sid));
         // 反思日志：会话结束后空闲时间跑一次小模型，零用户感知 token。
         // 历史不够长（< 4 条消息）或路由不可用时静默跳过。
+        if (reflectionEnabled && turns.length < 4)
+            ctx.logger?.warn?.(`lume: 反思跳过（${sid}）历史不足：${turns.length} < 4 条消息`);
         if (reflectionEnabled && turns.length >= 4) {
             void (async () => {
                 const store = await reflectionReady;
+                if (!store) {
+                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）reflection 域不可用`);
+                    return;
+                }
                 if (!store)
                     return;
                 const route = resolveAuxRoute({}, llmRoute);
+                if (!route) {
+                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）无可用小模型路由`);
+                    return;
+                }
                 if (!route)
                     return;
                 const prompt = buildReflectionPrompt(turns);
@@ -728,8 +752,10 @@ function applyInner(ctx, config = {}) {
                 if (output === null)
                     return;
                 const score = parseReflectionScore(output);
-                if (!score)
+                if (!score) {
+                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）评分解析失败`);
                     return;
+                }
                 await store.log(sid, score);
                 ctx.logger?.warn?.(`lume: 反思日志 ${sid} context=${score.context} planning=${score.planning} verification=${score.verification} review=${score.review} diagnosis=${score.diagnosis}「${score.note}」`);
             })();
@@ -744,12 +770,24 @@ function applyInner(ctx, config = {}) {
         // 三种调用来源：提示词 context（{agent:{session}}）、工具 exec（{agent:{session}}）、
         // 会话事件（session 本身）。统一取到 session 再读 cwd。
         const session = source?.agent?.session ?? source?.session ?? source;
-        const cwd = session?.cwd ?? "";
+        const cwd = String(session?.cwd || st.cwd || "");
         const key = projectKeyOf(cwd);
         // 只有拿到真实工作目录才缓存：否则一次无 cwd 的调用会把 "unknown" 固化下来。
-        if (cwd)
+        if (cwd && key)
             st.projectKey = key;
-        return key;
+        return st.projectKey ?? key;
+    }
+    /** 从工具入参里取目标路径（自动改动台账用）：兼容常见字段名，取不到返回 null——宁可少记，不要记错。 */
+    function targetPathFromToolEvent(data) {
+        const args = data?.args ?? data?.input ?? data?.parameters ?? data?.arguments;
+        if (!args || typeof args !== "object")
+            return null;
+        for (const key of ["path", "file_path", "filePath", "file", "filename", "target", "notebook_path"]) {
+            const value = args[key];
+            if (typeof value === "string" && value.trim())
+                return value.trim().slice(0, 120);
+        }
+        return null;
     }
     function isTaskQuery(st) {
         return TASK_SIGNAL_RE.test(st.intent?.text ?? st.userText ?? "");
@@ -764,7 +802,8 @@ function applyInner(ctx, config = {}) {
         return project?.getHypotheses(sid) ?? [];
     }
     function factsOf(sid, context) {
-        return project ? project.getFacts(projectKeyFor(sid, context)) : [];
+        const projectKey = projectKeyFor(sid, context);
+        return project && projectKey ? project.getFacts(projectKey) : [];
     }
     /** 环境里是否有符号级结构分析工具：有就让模型用它替代通篇 read。 */
     function structureToolName(context) {
@@ -793,7 +832,7 @@ function applyInner(ctx, config = {}) {
     function carrierBlocks(sid, context, st, query, mode) {
         if (!projectMemoryOn)
             return [];
-        const isTask = TASK_SIGNAL_RE.test(query);
+        const isTask = mode !== "question" || TASK_SIGNAL_RE.test(query);
         const contract = contractOf(sid);
         const changes = changesOf(sid);
         const docDirective = buildDocumentDirective({ query, capabilities: probeDocumentCapabilities(ctx.get("tools"), context?.agent) });
@@ -899,7 +938,7 @@ function applyInner(ctx, config = {}) {
                 parameters: {
                     goal: { type: "string", description: "目标：一句话、可观察的结果" },
                     scope: { type: "string", description: "范围：路径/模块/章节，分号或换行分隔" },
-                    expectCount: { type: "number", description: "预计数量（探索前先估）" },
+                    expectCount: { type: "number", required: true, description: "预计数量（探索前先估）" },
                     actualCount: { type: "number", description: "实际数量（探索后回填）" },
                     criteria: { type: "string", description: "完成判据：可执行、可核对，分号或换行分隔" },
                     nonGoals: { type: "string", description: "非目标：明确不动的东西，分号分隔" },
@@ -1025,7 +1064,13 @@ function applyInner(ctx, config = {}) {
                     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));
+                    const projectKey = projectKeyFor(sid, { agent: exec?.agent });
+                    if (!projectKey) {
+                        // 拿不到工作目录：不写跨会话表——写一次就会把不同项目的知识串进同一个键（现场事故：facts 的键曾是 "unknown"）
+                        ctx.logger?.warn?.(`lume: [${sid}] 项目知识未落盘（无法确定工作目录）`);
+                        return { ok: true };
+                    }
+                    await project.addFact(projectKey, fact, (candidate, existing) => existing.some((entry) => jaccard(entry.text, candidate) >= 0.7));
                     return { ok: true };
                 },
             }));
@@ -1042,6 +1087,8 @@ function applyInner(ctx, config = {}) {
      */
     function resolveIntent(context, st) {
         const session = context?.agent?.session;
+        if (typeof session?.cwd === "string" && session.cwd)
+            st.cwd = session.cwd;
         const messages = typeof session?.deriveMessages === "function" ? session.deriveMessages() : [];
         let text = null;
         let messageId = "";
@@ -1089,6 +1136,9 @@ function applyInner(ctx, config = {}) {
         // 交付复核、压缩重锚、文档能力指引、失败纠偏、反思提醒——全部每步可变。
         // 载具与方法块（契约/台账/假设/项目知识/影响面/文档方法/触发器提醒）排在最后：
         // 它们是「此刻最该看的」，紧贴尾部注意力最强位；超预算时先丢可丢块（composeBlocks）。
+        // 记录工作目录：工具 exec / 会话事件里可能拿不到 cwd，项目键靠这里缓存兜住（实测项目知识曾落到 unknown）
+        if (typeof context?.agent?.session?.cwd === "string" && context.agent.session.cwd)
+            st.cwd = context.agent.session.cwd;
         const thinkingRuntime = composeBlocks([
             { text: buildInteractionDirective(mode) },
             { text: buildTaskPhaseDirective(st.taskPhase) },
@@ -1290,22 +1340,57 @@ function applyInner(ctx, config = {}) {
      * inject 回调里调用（不包 effect）。没有 web 载体的宿主（headless）只是没有 RPC 通道。
      */
     function registerRpcChannel(scope) {
-        scope.inject(["webServer"], (webCtx) => {
+        const dispatch = async (endpoint, payload) => {
+            currentStore ??= await storesReady;
+            identity ??= await identityReady;
+            return handleEndpoint(endpoint, payload);
+        };
+        // 依赖组合与宿主自带 dsh-api-gateway 一致（["connection", "webServer"]）。
+        scope.inject(["connection", "webServer"], (webCtx) => {
+            const notes = [];
             try {
+                // ── 主路径：宿主公开 API。频道注册归属**调用方 fiber**，所以必须在注入作用域里调用。
                 webCtx.connection.rpc.handle(LUME_CHANNEL, async (endpoint, payload) => {
-                    currentStore ??= await storesReady;
-                    identity ??= await identityReady;
-                    const result = await handleEndpoint(endpoint, payload);
+                    const result = await dispatch(endpoint, payload);
                     if (endpoint !== "list" && endpoint !== "getSessionPersona") {
-                        webCtx.logger?.warn?.(`lume: rpc ${endpoint} ${JSON.stringify(payload ?? {})} → ok=${result.ok}${result.ok ? "" : ` code=${result.error.code}`}`);
+                        webCtx.logger?.warn?.(`lume: rpc ${endpoint} → ok=${result.ok}${result.ok ? "" : ` code=${result.error.code}`}`);
                     }
                     return result;
                 }, { authority: "trusted-host" });
+                notes.push("connection.rpc.handle");
             }
             catch (error) {
-                // 局部兜底：RPC 通道起不来只是菜单不可用，人设注入与工具必须照常。
-                webCtx.logger?.error?.("lume: RPC 通道注册失败（仅客户端菜单不可用，其余功能不受影响）", error);
+                notes.push(`rpc.handle 失败(${describeError(error)})`);
+                // ── 回退：自己往 webServer 注册 HTTP 路由（宿主自带 dsh-ppt 的写法）。
+                // 报文与客户端 conn.rpc.call 完全一致，见 host/rpc-bridge.ts。
+                try {
+                    const guard = typeof webCtx.connection?.requestRejection === "function"
+                        ? (req) => webCtx.connection.requestRejection(req)
+                        : undefined;
+                    webCtx.webServer.register(makeRpcRoute(LUME_CHANNEL, dispatch, guard));
+                    notes.push("webServer.register(自注册路由)");
+                }
+                catch (fallbackError) {
+                    notes.push(`webServer.register 失败(${describeError(fallbackError)})`);
+                }
+            }
+            // 两条都失败时补上环境形状，便于下一轮定位（宿主 API 变更时这行就是证据）。
+            if (!notes.some((note) => !note.includes("失败"))) {
+                notes.push(`shapes: connection=${typeof webCtx.connection} rpc=${typeof webCtx.connection?.rpc} handle=${typeof webCtx.connection?.rpc?.handle} webServer=${typeof webCtx.webServer} get=${typeof webCtx.get}`);
             }
+            webCtx.logger?.warn?.(`lume: RPC 通道 ${LUME_CHANNEL} = ${notes.join(" | ")}`);
         });
     }
+    /** 把任意抛出物变成可读的一行（宿主 logger 直接打对象会变成 `{}`，所以要自己转字符串）。 */
+    function describeError(error) {
+        if (error instanceof Error)
+            return error.message;
+        try {
+            const text = JSON.stringify(error);
+            return text && text !== "{}" ? text : String(error);
+        }
+        catch {
+            return String(error);
+        }
+    }
 }

package/package.json

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