lume-dsh-plugin 0.6.2 → 0.7.0

package/lib/host/project.js

@@ -0,0 +1,222 @@
+/**
+ * 项目域：任务契约 / 改动台账 / 假设台账 / 项目知识。
+ *
+ * 四张表，两类归属：
+ * - **会话内**（键 = sessionId）：contract、ledger、hypotheses —— 它们描述「这次任务」，
+ *   任务结束即无意义；
+ * - **跨会话**（键 = projectKey，由工作目录派生）：facts —— 它们描述「这个仓库/这个
+ *   文档集合」，正是「越用越强」要积累的东西。放在会话键上会让换会话就失忆；
+ *   放在人设键上会让换人设就失忆（这是现有记忆的一个真实盲区）。
+ *
+ * 为什么项目知识不与人格记忆混用一张表：代码路径、构建命令、仓库约定属于**工作
+ * 事实**，不具备人格语义，也不该被人设卡的导出/分享带出去。
+ *
+ * 存储容错：与身份域同款——域不可用时整体降级为 null，功能缺失但不影响其余部分。
+ */
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+import z from "@deepseek-ai/schemastery";
+import { CHANGE_CAP, HYPOTHESIS_CAP, PROJECT_FACT_CAP, normalizeChange, normalizeProjectFact, trimChanges, trimFacts, } from "../core/ledger.js";
+import { zodLike } from "./identity.js";
+/** 存储里用 -1 表示「未估/未回填」：schemastery 的 number 不接受 null，避免为它引入联合类型。 */
+const UNSET = -1;
+export const LUME_PROJECT_SPEC = defineDomain({
+    name: "lume_project",
+    version: 1,
+    tables: {
+        /** 任务契约（键 = sessionId）。 */
+        contract: domainTable(zodLike(z.object({
+            goal: z.string(),
+            scope: z.array(z.string()),
+            expectCount: z.number(),
+            actualCount: z.number(),
+            criteria: z.array(z.string()),
+            nonGoals: z.array(z.string()),
+            open: z.array(z.string()),
+            at: z.number(),
+            turn: z.number(),
+        }))),
+        /** 改动台账（键 = sessionId）。 */
+        ledger: domainTable(zodLike(z.array(z.object({ target: z.string(), change: z.string(), why: z.string(), verify: z.string(), status: z.string(), at: z.number() })))),
+        /** 假设台账（键 = sessionId）。 */
+        hypotheses: domainTable(zodLike(z.array(z.object({ text: z.string(), evidence: z.string(), status: z.string(), at: z.number() })))),
+        /** 项目知识（键 = projectKey，跨会话共享）。 */
+        facts: domainTable(zodLike(z.array(z.object({ kind: z.string(), text: z.string(), at: z.number() })))),
+    },
+});
+function toContract(stored) {
+    const raw = stored;
+    if (!raw || typeof raw.goal !== "string" || !raw.goal)
+        return null;
+    const list = (value) => (Array.isArray(value) ? value.filter((item) => typeof item === "string") : []);
+    return {
+        goal: raw.goal,
+        scope: list(raw.scope),
+        expectCount: typeof raw.expectCount === "number" && raw.expectCount >= 0 ? raw.expectCount : null,
+        actualCount: typeof raw.actualCount === "number" && raw.actualCount >= 0 ? raw.actualCount : null,
+        criteria: list(raw.criteria),
+        nonGoals: list(raw.nonGoals),
+        open: list(raw.open),
+        at: typeof raw.at === "number" ? raw.at : 0,
+        turn: typeof raw.turn === "number" ? raw.turn : 0,
+    };
+}
+function fromContract(contract) {
+    return {
+        goal: contract.goal,
+        scope: contract.scope,
+        expectCount: contract.expectCount ?? UNSET,
+        actualCount: contract.actualCount ?? UNSET,
+        criteria: contract.criteria,
+        nonGoals: contract.nonGoals,
+        open: contract.open,
+        at: contract.at,
+        turn: contract.turn,
+    };
+}
+export class ProjectStore {
+    #contractTable;
+    #ledgerTable;
+    #hypothesisTable;
+    #factTable;
+    constructor(tables) {
+        this.#contractTable = tables.contract;
+        this.#ledgerTable = tables.ledger;
+        this.#hypothesisTable = tables.hypotheses;
+        this.#factTable = tables.facts;
+    }
+    // ── 契约 ──
+    getContract(sid) {
+        return toContract(this.#contractTable.get(sid));
+    }
+    async setContract(sid, contract) {
+        await this.#contractTable.put(sid, fromContract(contract));
+    }
+    /** 局部更新（回填数量、补判据、清待确认）。返回更新后的契约。 */
+    async patchContract(sid, patch) {
+        const current = this.getContract(sid);
+        if (!current)
+            return null;
+        const merged = {
+            ...current,
+            ...patch,
+            // 局部更新时 undefined 表示「不动这一项」；显式空数组视为清空。
+            scope: patch.scope ?? current.scope,
+            criteria: patch.criteria ?? current.criteria,
+            nonGoals: patch.nonGoals ?? current.nonGoals,
+            open: patch.open ?? current.open,
+        };
+        await this.setContract(sid, merged);
+        return merged;
+    }
+    // ── 改动台账 ──
+    getChanges(sid) {
+        const value = this.#ledgerTable.get(sid);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            const raw = entry;
+            const normalized = normalizeChange({ target: raw?.target, change: raw?.change, why: raw?.why, verify: raw?.verify, status: raw?.status }, typeof raw?.at === "number" ? raw.at : 0);
+            return normalized;
+        })
+            .filter((item) => item !== null);
+    }
+    /** 写入一条改动；同 target + 同 change 视为更新（状态推进），不重复建条目。 */
+    async upsertChange(sid, item) {
+        const items = this.getChanges(sid);
+        const index = items.findIndex((entry) => entry.target === item.target && entry.change === item.change);
+        if (index >= 0)
+            items[index] = { ...items[index], ...item };
+        else
+            items.push(item);
+        await this.#ledgerTable.put(sid, trimChanges(items, CHANGE_CAP));
+    }
+    /** 按 target 推进状态：模型常只报"改成 verified 了"，不必重述 change 文本。 */
+    async setChangeStatus(sid, target, status) {
+        const items = this.getChanges(sid);
+        let hit = false;
+        for (const item of items) {
+            if (item.target !== target)
+                continue;
+            item.status = status;
+            hit = true;
+        }
+        if (hit)
+            await this.#ledgerTable.put(sid, trimChanges(items, CHANGE_CAP));
+        return hit;
+    }
+    // ── 假设台账 ──
+    getHypotheses(sid) {
+        const value = this.#hypothesisTable.get(sid);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            const raw = entry;
+            const text = typeof raw?.text === "string" ? raw.text : "";
+            if (!text)
+                return null;
+            const status = raw?.status;
+            return {
+                text,
+                evidence: typeof raw?.evidence === "string" ? raw.evidence : "",
+                status: (status === "testing" || status === "confirmed" || status === "excluded" ? status : "open"),
+                at: typeof raw?.at === "number" ? raw.at : 0,
+            };
+        })
+            .filter((item) => item !== null);
+    }
+    async upsertHypothesis(sid, item) {
+        const list = this.getHypotheses(sid);
+        const index = list.findIndex((entry) => entry.text === item.text);
+        if (index >= 0)
+            list[index] = { ...list[index], ...item };
+        else
+            list.push(item);
+        await this.#hypothesisTable.put(sid, list.slice(-HYPOTHESIS_CAP));
+    }
+    /** 一轮内至少更新过假设状态——触发器据此判断「有没有在维护假设」。 */
+    lastHypothesisAt(sid) {
+        return this.getHypotheses(sid).reduce((max, item) => Math.max(max, item.at), 0);
+    }
+    // ── 项目知识（跨会话）──
+    getFacts(projectKey) {
+        const value = this.#factTable.get(projectKey);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            const raw = entry;
+            return normalizeProjectFact({ kind: raw?.kind, text: raw?.text }, typeof raw?.at === "number" ? raw.at : 0);
+        })
+            .filter((item) => item !== null);
+    }
+    /** 追加项目事实；近似重复的忽略。返回是否写入。 */
+    async addFact(projectKey, fact, isDuplicate) {
+        const facts = this.getFacts(projectKey);
+        if (isDuplicate(fact.text, facts))
+            return false;
+        facts.push(fact);
+        await this.#factTable.put(projectKey, trimFacts(facts, PROJECT_FACT_CAP));
+        return true;
+    }
+    async deleteFact(projectKey, index) {
+        const facts = this.getFacts(projectKey);
+        if (index < 0 || index >= facts.length)
+            return false;
+        facts.splice(index, 1);
+        await this.#factTable.put(projectKey, facts);
+        return true;
+    }
+    async clearFacts(projectKey) {
+        await this.#factTable.delete(projectKey);
+    }
+    /** 会话结束清理：任务态数据不跨会话保留（项目知识是另一张表，不受影响）。 */
+    async clearSession(sid) {
+        await Promise.all([this.#contractTable.delete(sid), this.#ledgerTable.delete(sid), this.#hypothesisTable.delete(sid)]);
+    }
+    /** 诊断用：当前项目键下的事实条数。 */
+    factCount(projectKey) {
+        return this.getFacts(projectKey).length;
+    }
+}

package/lib/host/reflection.js

@@ -14,6 +14,8 @@ export const LUME_REFLECTION_SPEC = defineDomain({
     version: 1,
     tables: {
         logs: domainTable(zodLike(z.union([
+            z.object({ at: z.number(), context: z.number(), planning: z.number(), verification: z.number(), review: z.number(), diagnosis: z.number(), note: z.string() }),
+            // v0.7.0 之前的四维日志
             z.object({ at: z.number(), context: z.number(), planning: z.number(), verification: z.number(), review: z.number(), note: z.string() }),
             // v0.4.0 之前的存量日志；仅用于打开域并在启动时迁移。
             z.object({ at: z.number(), p0: z.number(), p1: z.number(), p2: z.number(), p3: z.number(), note: z.string() }),
@@ -46,6 +48,8 @@ export class ReflectionStore {
                 planning: raw.p1,
                 verification: raw.p2,
                 review: raw.p3,
+                // 旧日志没有第五维：记 -1，统计时跳过（不当作 0 分）。
+                diagnosis: -1,
                 note: typeof raw.note === "string" ? raw.note : "",
             });
             migrated++;
@@ -68,17 +72,30 @@ export class ReflectionStore {
         const entries = [...this.#table.keys()].map((key) => this.#table.get(key)).filter((e) => typeof e?.context === "number").sort((a, b) => b.at - a.at).slice(0, 5);
         if (entries.length < 3)
             return null;
-        const avg = (key) => entries.reduce((n, e) => n + e[key], 0) / entries.length;
-        const weakest = ["context", "planning", "verification", "review"].slice().sort((a, b) => avg(a) - avg(b))[0];
-        if (avg(weakest) > 1.15)
+        const dims = ["context", "planning", "verification", "review", "diagnosis"];
+        // 逐维在「评过这一维」的条目上取平均：老日志没有 diagnosis（-1），不参与该维统计，
+        // 否则会被当成 0 分，把一个从未评过的维度误报成最弱项。
+        const avg = (key) => {
+            const scored = entries.filter((e) => typeof e[key] === "number" && e[key] >= 0);
+            if (scored.length === 0)
+                return null;
+            return scored.reduce((n, e) => n + (e[key] ?? 0), 0) / scored.length;
+        };
+        const ranked = dims
+            .map((key) => ({ key, value: avg(key) }))
+            .filter((item) => item.value !== null)
+            .sort((a, b) => a.value - b.value);
+        const weakest = ranked[0];
+        if (!weakest || weakest.value > 1.15)
             return null;
         const text = {
             context: "请先确认目标、约束和当前状态，避免遗漏已知信息。",
             planning: "请按任务复杂度先做必要调研和计划，不要过早执行。",
             verification: "本轮修改或执行后请立即做最小验证，不要只看命令是否结束。",
             review: "完成前请对照需求、边界条件和数据保留做一次结果复核。",
+            diagnosis: "排查时先立假设再动手：写下每条假设的证据与状态，把已排除的标出来，不要重复验证同一个假设。",
         };
-        return text[weakest];
+        return text[weakest.key];
     }
 }
 export const REFLECTION_SYSTEM = [
@@ -89,8 +106,9 @@ export const REFLECTION_SYSTEM = [
     "计划与门控：是否拆解任务、先调研再执行，并按风险自适应投入",
     "验证与失败处理：是否在变更后验证，失败时归因并更换方案；引用日志/历史/旧报错作为证据时是否核对时间戳与因果归属，有没有把历史错误当成本次问题的原因",
     "结果复核：是否对照完成标准、边界条件、兼容性和数据保留进行复核",
+    "诊断深度与假设管理：是否在排查时建立并维护假设（证据、状态、已排除项），是否避免重复验证同一个假设、避免撒网式浏览代替链路定位",
     "",
-    "只输出一个 JSON 对象，形如 {\"context\":2,\"planning\":2,\"verification\":1,\"review\":0,\"note\":\"...\"}，note 一句话中文，不要输出其他内容。",
+    '只输出一个 JSON 对象，形如 {"context":2,"planning":2,"verification":1,"review":0,"diagnosis":1,"note":"..."}，note 一句话中文，不要输出其他内容。',
 ].join("\n");
 export function buildReflectionPrompt(turns) {
     return {
@@ -137,10 +155,13 @@ export function parseReflectionScore(output) {
     const planning = clampScore(r.planning ?? r.p1);
     const verification = clampScore(r.verification ?? r.p2);
     const review = clampScore(r.review ?? r.p3);
+    // 第五维「诊断深度与假设管理」：模型没给这一维时记 -1（统计时跳过该维，不当作 0 分）。
+    const rawDiagnosis = clampScore(r.diagnosis ?? r.p4);
+    const diagnosis = Number.isNaN(rawDiagnosis) ? -1 : rawDiagnosis;
     const note = typeof r.note === "string" ? r.note.trim().slice(0, 200) : "";
     if (Number.isNaN(context) || Number.isNaN(planning) || Number.isNaN(verification) || Number.isNaN(review))
         return null;
-    return { at: Date.now(), context, planning, verification, review, note };
+    return { at: Date.now(), context, planning, verification, review, diagnosis, note };
 }
 function clampScore(value) {
     const n = Number(value);

package/lib/host/rpc.js

@@ -20,6 +20,21 @@ export function createLumeRpcHandler(deps) {
             case "list": {
                 return { ok: true, value: registry.list() };
             }
+            case "getProjectState": {
+                // 任务载具 + 项目知识的只读视图（诊断/排查用；未接线时返回 null）。
+                const sessionId = requireString(payload, "sessionId");
+                if (!sessionId)
+                    return { ok: false, error: { code: "bad-request", message: "sessionId is required" } };
+                return { ok: true, value: deps.getProjectState?.(sessionId) ?? null };
+            }
+            case "clearProjectFacts": {
+                // 清空当前项目的知识积累（不可逆）。项目知识是工作事实，用户有权一键忘掉。
+                const sessionId = requireString(payload, "sessionId");
+                if (!sessionId)
+                    return { ok: false, error: { code: "bad-request", message: "sessionId is required" } };
+                const cleared = (await deps.clearProjectFacts?.(sessionId)) ?? false;
+                return { ok: true, value: { cleared } };
+            }
             case "select": {
                 const sessionId = requireString(payload, "sessionId");
                 const personaName = requireString(payload, "personaName");

package/lib/host/session-runtime.js

@@ -1,3 +1,4 @@
+import { newTriggerCounters } from "./triggers.js";
 /** 运行时状态上限：与 PersonaStore 的 maxSessions 对齐，超限淘汰最旧。 */
 const MAX_RUNTIME_SESSIONS = 200;
 function defaultRuntime() {
@@ -22,6 +23,15 @@ function defaultRuntime() {
         interactionMode: "question",
         intent: null,
         stableDigest: null,
+        projectKey: null,
+        toolKind: "other",
+        triggerCounters: newTriggerCounters(),
+        triggerNudge: null,
+        triggerFiredAt: {},
+        turnNudge: null,
+        lastDriftTurn: null,
+        knowledgePrompted: false,
+        hypothesesTouched: false,
         alignmentCorrection: null,
         recentUserQueries: [],
         postTurnReview: null,

package/lib/host/triggers.js

@@ -0,0 +1,133 @@
+/**
+ * 行为触发器：把「元决策」从用户手里接过来。
+ *
+ * 实测的症状不是模型不知道规矩，而是**在压力下不执行**：连续 34 次广度探查不收敛、
+ * 连续 18 次改动不验证、在同一个不可用的构建环境上撞 17 次、交付前不自审——每一次
+ * 都是用户亲自下令才纠正。协议文本管不了这种，因为文本是静态的，而症状是**轨迹**的。
+ *
+ * 所以这里只在**行为模式成立**时注入一句针对性的提醒，并且：
+ * - 每类触发器每轮最多一次、且有轮级冷却（提示一多就变噪音，模型会学会忽略）；
+ * - 文本带具体数字（"已连续 14 次只读探查"），让提醒可被核对而不是空洞训话；
+ * - 纯函数：计数器由调用方持有（SessionRuntime），判定与措辞在这里可单测。
+ */
+import { deadPathKind } from "../core/signals.js";
+export function newTriggerCounters() {
+    return { inspectStreak: 0, mutateStreak: 0, verifyFailStreak: 0, verifyEnvHits: 0, mutations: 0, steps: 0 };
+}
+/** 计数器推进：语义是「行为模式」，因此只在类别切换或验证成败时重置。 */
+export function applyToolSignal(counters, kind, signals) {
+    counters.steps++;
+    if (kind === "inspect") {
+        counters.inspectStreak++;
+        return;
+    }
+    if (kind === "mutate") {
+        counters.mutateStreak++;
+        counters.mutations++;
+        counters.inspectStreak = 0;
+        return;
+    }
+    if (kind === "verify") {
+        counters.inspectStreak = 0;
+        counters.mutateStreak = 0;
+        return;
+    }
+    if (kind === "plan") {
+        // 写载具本身就是「收敛」动作：两个连击都清零。
+        counters.inspectStreak = 0;
+        counters.mutateStreak = 0;
+    }
+}
+/**
+ * 验证结果的成败记账（在 tool/result 阶段调用，与 applyToolSignal 配对）。
+ * 失败连击只被**成功的验证**清零——普通探查不该让「死路」计数归零，
+ * 否则在死路上反复穿插读文件就能把提醒刷掉。
+ */
+export function applyVerifyOutcome(counters, kind, signals) {
+    if (kind !== "verify" || signals.unknown)
+        return;
+    if (signals.failure) {
+        counters.verifyFailStreak++;
+        if (signals.env)
+            counters.verifyEnvHits++;
+    }
+    else {
+        counters.verifyFailStreak = 0;
+        counters.verifyEnvHits = 0;
+    }
+}
+export const DEFAULT_TRIGGER_THRESHOLDS = {
+    inspectStreak: 12,
+    changeStreak: 6,
+    deadPathFails: 3,
+    knowledgeSteps: 20,
+};
+/**
+ * 工具事件触发的判定。一次只返回**一个**（按紧急度排序）：同时堆三条提醒会互相稀释。
+ * 调用方负责「每类每轮最多一次」的冷却。
+ */
+export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_THRESHOLDS) {
+    const dead = deadPathKind(counters.verifyEnvHits, counters.verifyFailStreak);
+    if (dead !== null && counters.verifyFailStreak >= thresholds.deadPathFails) {
+        const n = counters.verifyFailStreak;
+        const m = counters.verifyEnvHits;
+        if (dead === "env") {
+            return {
+                id: "dead-path",
+                text: `〔验证降级〕同一环境已连续 ${n} 次验证失败，其中 ${m} 次是环境或依赖不可用（不是代码问题）。停止重复同一条命令，换降级阶梯：① 能用的编译器/测试 → ② 语法检查（parser / typecheck）→ ③ 静态交叉引用（谁调用它、它调用谁、配置与 SQL 绑定）→ ④ 手工走读并列出风险点。交付时明确写「本环境无法完成构建验证」。`,
+            };
+        }
+        return {
+            id: "dead-path",
+            text: `〔死路提醒〕同一验证已连续失败 ${n} 次。先归因（输入 / 逻辑 / 接口 / 环境 / 权限），把结论写进假设台账：证实的标 confirmed、排除的标 excluded（用 lume_hypothesis）——已排除的假设不要再试。换一个方案再动手。`,
+        };
+    }
+    if (counters.mutateStreak >= thresholds.changeStreak) {
+        return {
+            id: "verify-as-you-go",
+            text: `〔增量验证〕已连续 ${counters.mutateStreak} 次改动，中间没有任何验证动作。改一处验一处：现在先跑一次最小验证（编译 / 语法检查 / 回读改动区域），确认前一批改动真的生效，再继续下一批。一大批改完再验，失败时无法定位是哪一处的问题。`,
+        };
+    }
+    if (!ctx.hasContract && ctx.isTask && counters.mutations > 0) {
+        return {
+            id: "contract-missing",
+            text: "〔载具缺失〕你已经动手改动，但还没写下任务契约。花一次调用写清：目标（可观察的结果）、范围（精确到路径/模块/章节）、预计数量、完成判据（可执行）、非目标（明确不动什么）、待确认（≤2 个）。之后每步以契约为准，交付时按它逐项对账——用 lume_contract。",
+        };
+    }
+    if (ctx.isTask && counters.inspectStreak >= thresholds.inspectStreak) {
+        return {
+            id: "converge",
+            text: `〔收敛提醒〕已连续 ${counters.inspectStreak} 次只读探查，还没有产出契约或改动台账。停止撒网式通读，先把链路复述出来——入口 → 数据流 → 影响面（谁调用、被谁调用、配置与 SQL 绑定）——写成改动台账（lume_change）并回填实际数量，然后带着这份清单回去读缺口。`,
+        };
+    }
+    if (counters.verifyFailStreak > 0 && ctx.diagnosing && ctx.hasHypotheses && !ctx.hypothesesTouched) {
+        return {
+            id: "hypothesis-stale",
+            text: "〔假设台账〕本轮出现了验证失败，但假设状态没有更新。把这次失败归因写进 lume_hypothesis（证实 / 排除 / 新假设），并标出下一步要验的是哪一条——否则同一个假设会被反复试。",
+        };
+    }
+    return null;
+}
+/** 轮边界触发的判定：契约对账（防判据漂移）与项目知识采集。 */
+export function evaluateTurnTrigger(ctx, thresholds = DEFAULT_TRIGGER_THRESHOLDS) {
+    if (ctx.hasContract) {
+        const afterCompaction = ctx.compactionTurn !== null && ctx.turnIndex - ctx.compactionTurn <= 1;
+        const periodic = ctx.turnIndex >= 3 && (ctx.lastDriftTurn === null || ctx.turnIndex - ctx.lastDriftTurn >= 3);
+        if (afterCompaction || periodic)
+            return { id: "criteria-drift", text: "" }; // 文本由调用方按契约渲染
+        return null;
+    }
+    if (!ctx.knowledgePrompted && ctx.counters.steps >= thresholds.knowledgeSteps) {
+        return {
+            id: "knowledge-capture",
+            text: `〔项目知识〕本会话已执行 ${ctx.counters.steps} 步工具。若这轮确认了**稳定的**项目事实——构建/测试命令、模块数据流、仓库约定、或一条死路——用 lume_project_note 记下来（按当前工作目录跨会话累积，下次直接可用）。没有就忽略这句。`,
+        };
+    }
+    return null;
+}
+/** 冷却判定：同一触发器在 N 轮内不再重复（提示变噪音就失效）。 */
+export function cooldownOk(lastFiredTurn, turnIndex, cooldownTurns = 2) {
+    if (lastFiredTurn === null || lastFiredTurn === undefined)
+        return true;
+    return turnIndex - lastFiredTurn >= cooldownTurns;
+}