lume-dsh-plugin 0.7.4 → 0.8.0

package/lib/host/metrics-log.js

@@ -0,0 +1,169 @@
+/**
+ * 度量的落地与读取（0.8.x）：一份 JSONL + 一个进程内环形缓冲。
+ *
+ * 为什么不用数据库/存储域：度量是**诊断通道**，不是用户资产。它要满足三条：
+ * ① 宿主没提供落点（没有 DSH_HOME）时静默跳过、不影响功能；
+ * ② 单行追加、永不回读失败（用户随时可以 `type` 出来看，也可以直接删）；
+ * ③ 写失败绝不阻断对话（与 diag.ts 同一套纪律）。
+ * 存储域那边表名/事务/迁移的代价，对「一行一条事实」的用法全是负担。
+ *
+ * 环形缓冲的意义：模型要用度量做自校（lume_metrics 工具、纠正率过高时顶一句提醒），
+ * 而每次读文件太贵——缓冲保最近 N 条，聚合在内存里做（core/metrics.ts 是纯函数）。
+ */
+import { closeSync, existsSync, openSync, readSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { EFFICACY_WINDOW_TURNS, formatMetricsSummary, parseMetricLines, summarizeMetrics, toMetricLine, triggerExpect, } from "../core/metrics.js";
+import { appendLumeLineAt, lumeLogHome } from "./diag.js";
+export const LUME_METRICS_FILE = "lume-metrics.jsonl";
+/** 环形缓冲上限：一次会话的步数远小于它，跨几个会话也够看趋势。 */
+export const METRIC_RING = 800;
+/** 回读上限（字节）：只读文件尾部，避免长年累积把启动拖慢。 */
+const READ_TAIL_BYTES = 512 * 1024;
+/**
+ * 攒够多少条就强制刷盘。
+ *
+ * 为什么必须攒批（2026-09-24 实测）：块装配记录是**每次构建提示词**都会写的，
+ * 一步里可能构建好几次；原来是每条一次同步 appendFileSync，热路径上非常贵——
+ * 本仓最重的 apply-carriers 用例因此从 3.0s 涨到超过 5s 超时。改成缓冲 + 批量写。
+ */
+const FLUSH_AT = 24;
+export function createMetricsLog(opts = {}) {
+    const enabled = opts.enabled ?? true;
+    const ringSize = opts.ring ?? METRIC_RING;
+    const ring = [];
+    // 落点：生产走自动探测；测试/自检可以显式指定（否则测试数据会混进真实指标文件）。
+    const home = opts.home ?? lumeLogHome();
+    const path = home ? join(home, LUME_METRICS_FILE) : null;
+    let healthCache = null;
+    /** 待落盘的 JSONL 行（攒批写；进程若中途死掉最多丢一轮）。 */
+    let pending = [];
+    /** 真正落盘：一次 append 写多行。失败静默（诊断通道纪律）。 */
+    const flush = () => {
+        if (!enabled || !home || pending.length === 0) {
+            pending = [];
+            return;
+        }
+        const lines = pending.join("\n");
+        pending = [];
+        appendLumeLineAt(home, LUME_METRICS_FILE, lines);
+    };
+    const record = (incoming) => {
+        if (!enabled)
+            return;
+        // 归一（写入侧唯一一处）：
+        // ① 触发器记录补 expect——调用点只报「谁命中了」，预期行为变化由 TRIGGER_EXPECT 定义；
+        // ② 同轮同类的结果信号（越权改动在一步里能连触发十几次）只留第一条，否则计数被灌水。
+        const entry = incoming.kind === "trigger" && !incoming.expect ? { ...incoming, expect: triggerExpect(incoming.id) } : incoming;
+        const last = ring[ring.length - 1];
+        if (entry.kind === "outcome" && last?.kind === "outcome") {
+            if (last.sid === entry.sid && last.turn === entry.turn && last.event === entry.event)
+                return;
+        }
+        // 块装配同样去重：一步里提示词会被构建多次，逐次落盘会把环形缓冲冲淡——
+        // 缓冲里最该留住的是状态快照与路由判定（效能判定与误判率都靠它们）。
+        if (entry.kind === "blocks" && last?.kind === "blocks") {
+            const same = last.sid === entry.sid &&
+                last.turn === entry.turn &&
+                last.kept === entry.kept &&
+                last.dropped === entry.dropped &&
+                last.chars === entry.chars &&
+                last.focus.join(",") === entry.focus.join(",");
+            if (same)
+                return;
+        }
+        ring.push(entry);
+        if (ring.length > ringSize)
+            ring.shift();
+        healthCache = null;
+        pending.push(toMetricLine(entry));
+        // 每轮的状态快照必然出现一次 —— 用它当"本轮结束"的落盘点，避免新增依赖接线；
+        // 长轮次（一步里构建多次提示词）则由条数上限兜住。
+        if (entry.kind === "state" || pending.length >= FLUSH_AT)
+            flush();
+    };
+    const records = (sid) => (sid ? ring.filter((entry) => entry.sid === sid) : ring);
+    const health = (sid) => {
+        if (healthCache && healthCache.sid === sid && healthCache.count === ring.length)
+            return healthCache.value;
+        const value = {
+            routes: 0,
+            corrections: 0,
+            overreach: 0,
+            noAction: 0,
+            correctionsByMode: {},
+            lastCorrectionTurnByMode: {},
+        };
+        for (const entry of ring) {
+            if (entry.sid !== sid)
+                continue;
+            if (entry.kind === "route")
+                value.routes++;
+            else if (entry.kind === "outcome") {
+                if (entry.event === "user-correction") {
+                    value.corrections++;
+                    value.correctionsByMode[entry.mode] = (value.correctionsByMode[entry.mode] ?? 0) + 1;
+                    value.lastCorrectionTurnByMode[entry.mode] = Math.max(value.lastCorrectionTurnByMode[entry.mode] ?? -1, entry.turn);
+                }
+                else if (entry.event === "overreach")
+                    value.overreach++;
+                else if (entry.event === "no-action")
+                    value.noAction++;
+            }
+        }
+        healthCache = { sid, count: ring.length, value };
+        return value;
+    };
+    const loadFromDisk = () => {
+        if (!enabled || !path)
+            return 0;
+        try {
+            if (!existsSync(path))
+                return 0;
+            const size = statSync(path).size;
+            // 只读文件尾部：长年累积的度量不该拖慢启动，也不该把内存吃满。
+            const length = Math.min(size, READ_TAIL_BYTES);
+            const handle = openSync(path, "r");
+            let text = "";
+            try {
+                const buffer = Buffer.alloc(length);
+                readSync(handle, buffer, 0, length, size - length);
+                text = buffer.toString("utf8");
+            }
+            finally {
+                closeSync(handle);
+            }
+            const parsed = parseMetricLines(text);
+            const recent = parsed.slice(-ringSize);
+            ring.length = 0;
+            ring.push(...recent);
+            healthCache = null;
+            return recent.length;
+        }
+        catch {
+            /* 回读失败不影响本轮记录 */
+            return 0;
+        }
+    };
+    const summaryTo = (sid) => summarizeMetrics(records(), sid ? { sid } : {});
+    return {
+        record,
+        flush,
+        records,
+        summary: summaryTo,
+        summaryText: (scope) => {
+            if (!enabled)
+                return "Lume 度量已关闭（config.metrics = false）：本次运行没有记录任何事实。";
+            const label = scope ? "本会话" : "全部会话（内存中保留的最近记录）";
+            const head = formatMetricsSummary(summaryTo(scope), { label });
+            const where = path
+                ? "落点：" + path + "（一行一条 JSON，可直接看/可删）"
+                : "落点不可用：宿主没提供 DSH_HOME / APPDATA，本次只有内存记录（重启即丢）。";
+            // 口径自证：样本多大、窗口多长都写清楚——没有口径的数字比没有数字更坏。
+            return (head + "\n" + where + "；效能窗口 " + EFFICACY_WINDOW_TURNS + " 轮，纠正率是**代理指标**（用户纠正次数 / 判定次数），不是真值。");
+        },
+        health,
+        loadFromDisk,
+        path,
+        enabled,
+    };
+}

package/lib/host/notices.js

@@ -0,0 +1,62 @@
+/** 各机制的每会话上限（要加机制只改这张表）。 */
+export const NOTICE_CAPS = {
+    /** 需求漂移：反复顶会让模型开始躲词而不是解决问题（实测） */
+    drift: 2,
+    /** 引用-证据对齐 */
+    citation: 3,
+    /** 断言-证据对齐（没核实就下的否定断言） */
+    claim: 2,
+    /** 提问核对 */
+    question: 2,
+    /** 需求覆盖核对 */
+    coverage: 2,
+    // 上下文预警：warn/critical 各一次就够（反复催会变噪音）
+    pressure: 3,
+    /** 载具缺口（动了代码但契约/设计都空） */
+    carrierGap: 2,
+    /** 度量自校：本会话路由被反复纠正时顶一次（上限 2，防噪音） */
+    metrics: 2,
+    // 以下无上限（靠场景与冷却控制）
+    trigger: Number.POSITIVE_INFINITY,
+    turn: Number.POSITIVE_INFINITY,
+    verifyFail: Number.POSITIVE_INFINITY,
+    postTurn: Number.POSITIVE_INFINITY,
+    align: Number.POSITIVE_INFINITY,
+    protocol: Number.POSITIVE_INFINITY,
+    /** 外部（人设/记忆/压缩等）一次性提示 */
+    extra: Number.POSITIVE_INFINITY,
+};
+export function noticeSlot(st, id) {
+    st.notices[id] ??= { text: null, used: 0 };
+    return st.notices[id];
+}
+/** 还能不能顶（上限没到）。 */
+export function noticeOpen(st, id) {
+    return noticeSlot(st, id).used < (NOTICE_CAPS[id] ?? Number.POSITIVE_INFINITY);
+}
+export function noticeText(st, id) {
+    return st.notices[id]?.text ?? null;
+}
+/** 写入：text 为空 → 清空该槽且不计数；超上限 → 不写（返回 false）。 */
+export function setNotice(st, id, text) {
+    const slot = noticeSlot(st, id);
+    if (!text) {
+        slot.text = null;
+        return false;
+    }
+    if (!noticeOpen(st, id))
+        return false;
+    slot.text = text;
+    slot.used += 1;
+    return true;
+}
+/** 不经上限的强制写入（首改定位、验证失败这类一次性提示）。 */
+export function forceNotice(st, id, text) {
+    const slot = noticeSlot(st, id);
+    slot.text = text ?? null;
+}
+export function clearNotice(st, id) {
+    const slot = st.notices[id];
+    if (slot)
+        slot.text = null;
+}

package/lib/host/project-access.js

@@ -0,0 +1,210 @@
+import { DESIGN_SIGNAL_RE } from "./protocol.js";
+import { forceNotice, noticeText } from "./notices.js";
+import { buildTaskMemory } from "../core/task-memory.js";
+export function createProjectAccess(deps) {
+    /** 项目键：优先取会话工作目录（跨会话共享同一仓库的知识）。 */
+    function projectKeyFor(sid, source) {
+        const st = deps.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 = String(session?.cwd || st.cwd || "");
+        const key = deps.projectKeyOf(cwd);
+        // 只有拿到真实工作目录才缓存：否则一次无 cwd 的调用会把 "unknown" 固化下来。
+        if (cwd && key)
+            st.projectKey = key;
+        return st.projectKey ?? key;
+    }
+    /** 命令摘要：验证证据要写进台账，太长的命令只留前 120 字。 */
+    function commandSummary(raw) {
+        if (!raw)
+            return "(未记录命令行)";
+        try {
+            const parsed = JSON.parse(raw);
+            const command = parsed?.command ?? parsed?.cmd ?? parsed?.script;
+            if (typeof command === "string" && command.trim())
+                return command.trim().replace(/\s+/g, " ").slice(0, 120);
+        }
+        catch {
+            /* 不是 JSON：按原文处理 */
+        }
+        return raw.replace(/\s+/g, " ").slice(0, 120);
+    }
+    /**
+     * 项目知识补落盘：事件流里拿不到 cwd 时先暂存，等提示词上下文给出 cwd 再补写。
+     *
+     * 现场代价（0.7.4）：模型主动调了 3 次 lume_project_note，全部因为"当时还不知道工作目录"
+     * 被丢弃——facts 表里一条都没有。cwd 在同一轮稍后就能拿到，所以丢弃太早、太永久。
+     */
+    function flushPendingFacts(sid, source) {
+        const st = deps.runtime.get(sid);
+        if (st.pendingFacts.length === 0)
+            return;
+        const key = projectKeyFor(sid, source);
+        if (!key)
+            return;
+        const pending = st.pendingFacts.splice(0, st.pendingFacts.length);
+        void deps.stores.projectReady
+            .then(async (store) => {
+            if (!store)
+                return;
+            let saved = 0;
+            for (const fact of pending) {
+                const ok = await store.addFact(key, fact, (candidate, existing) => existing.some((entry) => deps.jaccard(entry.text, candidate) >= 0.7));
+                if (ok)
+                    saved++;
+            }
+            deps.ctx.logger?.warn?.(`lume: [${sid}] 项目知识补落盘 ${saved}/${pending.length} 条 → ${key}`);
+        })
+            .catch((error) => deps.ctx.logger?.warn?.(`lume: [${sid}] 项目知识补落盘失败：${String(error)}`));
+    }
+    /**
+     * 验证结算（插件侧的「改一处验一处」）：成功的**真验证**自动把台账推进到 verified，
+     * 真验证失败立刻顶一句先修红。
+     *
+     * 为什么必须插件做：实测模型 4 个会话 0 次调用 lume_change、0 次推进状态，台账里的
+     * 「未验证」于是永远是未验证。判据取**宁窄勿宽**（`git grep` 不算验证），并把证据
+     * （命令 + 结果首行）写进 verify 字段，让真假一眼可辨。
+     */
+    function settleVerification(sid, st, resultText, signals) {
+        if (st.toolKind !== "verify" && st.toolKind !== "inspect")
+            return;
+        const realVerify = st.toolKind === "verify" && deps.isRealVerifyCommand(st.agent.lastToolArgs ?? "");
+        const readbackTarget = st.toolKind === "inspect" ? st.agent.lastToolTarget : null;
+        if (!realVerify && !readbackTarget)
+            return;
+        if (signals.failure || signals.unknown) {
+            if (realVerify) {
+                if (!noticeText(st, "trigger"))
+                    forceNotice(st, "trigger", `〔验证失败〕刚才那条验证没过（${commandSummary(st.agent.lastToolArgs)}）。先定位并修红：看第一条错误属于输入 / 逻辑 / 接口 / 环境哪一类，修完重新验；不要在这个状态上继续扩大改动范围，也不要把动作完成当成验证通过。`);
+                deps.ctx.logger?.warn?.(`lume: [${sid}] 真验证失败：${commandSummary(st.agent.lastToolArgs)}`);
+            }
+            return;
+        }
+        const changed = changesOf(sid);
+        const targets = realVerify ? undefined : [readbackTarget];
+        if (!realVerify && !changed.some((item) => item.target === readbackTarget))
+            return;
+        const firstLine = resultText
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean)[0] ?? "";
+        const evidence = realVerify
+            ? `自动：${commandSummary(st.agent.lastToolArgs)} → ${firstLine.slice(0, 80)}`
+            : `自动：回读 ${readbackTarget} → ${firstLine.slice(0, 60)}`;
+        void deps.stores.projectReady
+            .then(async (store) => {
+            const count = (await store?.verifyChanges(sid, { before: Date.now(), evidence, targets })) ?? 0;
+            if (count > 0)
+                deps.ctx.logger?.warn?.(`lume: [${sid}] 自动推进台账 ${count} 条 → verified（${evidence.slice(0, 60)}）`);
+        })
+            .catch((error) => deps.ctx.logger?.warn?.(`lume: [${sid}] 自动推进台账失败：${String(error)}`));
+    }
+    function contractOf(sid) {
+        return deps.stores.project()?.getContract(sid) ?? null;
+    }
+    function changesOf(sid) {
+        return deps.stores.project()?.getChanges(sid) ?? [];
+    }
+    function hypothesesOf(sid) {
+        return deps.stores.project()?.getHypotheses(sid) ?? [];
+    }
+    function factsOf(sid, context) {
+        const projectKey = projectKeyFor(sid, context);
+        const store = deps.stores.project();
+        return store && projectKey ? store.getFacts(projectKey) : [];
+    }
+    /** 本会话的设计决策（设计 pass 产出）。 */
+    /** 本会话的需求锚点（用户原话，逐字）。 */
+    function requirementsOf(sid) {
+        return deps.stores.project()?.getRequirements(sid) ?? [];
+    }
+    function designOf(sid) {
+        return deps.stores.project()?.getDesign(sid) ?? [];
+    }
+    /** 该不该顶〔设计三问〕：要动数据/接口 + 还没写下设计 + 不是纯问答。 */
+    function needsDesignPass(sid, st, query, mode) {
+        return mode !== "question" && DESIGN_SIGNAL_RE.test(query) && designOf(sid).length === 0;
+    }
+    function structureToolName(context) {
+        try {
+            const schemas = deps.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;
+        }
+    }
+    // ── 人设五段式注入 + 切换播报 ──
+    /**
+     * 导出**会话记忆**（零 token、机械）：把会话的结构化状态（目标/需求原话/已拍板/改动/未决/死路/定位）
+     * 落成可跨会话续接的一份记忆。上下文撑满时宿主的压缩会失败（现场：context overflow），
+     * 会话再也聊不动——**上下文不能当记忆载体**，所以每轮都得把记忆搬出来。
+     */
+    async function saveSessionMemory(sid) {
+        try {
+            const store = await deps.stores.projectReady;
+            const key = projectKeyFor(sid, {});
+            if (!store || !key)
+                return false;
+            const st = deps.runtime.get(sid);
+            const memory = buildTaskMemory({
+                sid,
+                title: st?.sessionTitle ?? "",
+                turn: st?.turnIndex ?? 0,
+                goal: contractOf(sid)?.goal ?? "",
+                requirement: requirementsOf(sid),
+                design: designOf(sid),
+                changes: changesOf(sid),
+                hypotheses: hypothesesOf(sid),
+                deadends: factsOf(sid, {}).filter((fact) => fact.kind === "deadend"),
+                locate: [...(st?.agent.inspectedTargets ?? [])].slice(-5),
+            });
+            if (!memory)
+                return false;
+            return await store.saveTaskMemory(key, memory);
+        }
+        catch (error) {
+            deps.ctx.logger?.warn?.(`lume: [${sid}] 会话记忆导出失败：${String(error).slice(0, 80)}`);
+            return false;
+        }
+    }
+    /** 本项目键下最近的会话记忆（新的在前）；新会话开局用它接上上一个会话。 */
+    async function taskMemoriesOf(sid, limit = 3) {
+        try {
+            const store = await deps.stores.projectReady;
+            const key = projectKeyFor(sid, {});
+            if (!store || !key)
+                return [];
+            return store.getTaskMemories(key, limit);
+        }
+        catch {
+            return [];
+        }
+    }
+    return {
+        projectKeyFor,
+        commandSummary,
+        flushPendingFacts,
+        settleVerification,
+        contractOf,
+        saveSessionMemory,
+        taskMemoriesOf,
+        changesOf,
+        hypothesesOf,
+        factsOf,
+        requirementsOf,
+        designOf,
+        needsDesignPass,
+        structureToolName,
+    };
+}

package/lib/host/project.js

@@ -15,10 +15,13 @@
  */
 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 { CHANGE_CAP, DESIGN_CAP, HYPOTHESIS_CAP, REQUIREMENT_CAP, PROJECT_FACT_CAP, normalizeChange, normalizeDesign, normalizeProjectFact, normalizeRequirement, trimDesign, trimRequirements, trimChanges, trimFacts, } from "../core/ledger.js";
+import { isMoreSpecific } from "../core/memory-id.js";
 import { zodLike } from "./identity.js";
 /** 存储里用 -1 表示「未估/未回填」：schemastery 的 number 不接受 null，避免为它引入联合类型。 */
 const UNSET = -1;
+/** 每个项目键保留的会话记忆条数（够了；只用于「接着上次干」）。 */
+const TASK_MEMORY_CAP = 10;
 export const LUME_PROJECT_SPEC = defineDomain({
     name: "lume_project",
     version: 1,
@@ -40,6 +43,24 @@ export const LUME_PROJECT_SPEC = defineDomain({
         /** 假设台账（键 = sessionId）。 */
         hypotheses: domainTable(zodLike(z.array(z.object({ text: z.string(), evidence: z.string(), status: z.string(), at: z.number() })))),
         /** 项目知识（键 = projectKey，跨会话共享）。 */
+        /** 设计决策（键 = sessionId）：功能型任务的设计 pass 产出，跨轮/跨压缩保留。 */
+        /** 需求锚点（键 = sessionId）：用户原话逐字保留，每轮回显——治「用自己的转述替代需求」。 */
+        /** 会话记忆（键 = projectKey）：结构化导出会话状态，供下次开新会话续接——上下文不能当记忆载体。 */
+        task_memory: domainTable(zodLike(z.array(z.object({
+            sid: z.string(),
+            title: z.string(),
+            turn: z.number(),
+            goal: z.string(),
+            requirement: z.array(z.string()),
+            decided: z.array(z.string()),
+            changed: z.array(z.string()),
+            open: z.array(z.string()),
+            deadends: z.array(z.string()),
+            locate: z.array(z.string()),
+            at: z.number(),
+        })))),
+        requirements: domainTable(zodLike(z.array(z.object({ text: z.string(), at: z.number() })))),
+        design: domainTable(zodLike(z.array(z.object({ point: z.string(), choice: z.string(), rejected: z.string(), impact: z.string(), at: z.number() })))),
         facts: domainTable(zodLike(z.array(z.object({ kind: z.string(), text: z.string(), at: z.number() })))),
     },
 });
@@ -78,11 +99,17 @@ export class ProjectStore {
     #ledgerTable;
     #hypothesisTable;
     #factTable;
+    #designTable;
+    #requirementTable;
+    #taskMemoryTable;
     constructor(tables) {
         this.#contractTable = tables.contract;
         this.#ledgerTable = tables.ledger;
         this.#hypothesisTable = tables.hypotheses;
         this.#factTable = tables.facts;
+        this.#designTable = tables.design;
+        this.#requirementTable = tables.requirements;
+        this.#taskMemoryTable = tables.taskMemory;
     }
     // ── 契约 ──
     getContract(sid) {
@@ -145,6 +172,31 @@ export class ProjectStore {
             await this.#ledgerTable.put(sid, trimChanges(items, CHANGE_CAP));
         return hit;
     }
+    /**
+     * 插件自己推进台账：一次**成功且真实**的验证，把此前「已改未验」的条目推进成 verified。
+     *
+     * 为什么必须由插件做：实测模型几乎不会主动调 lume_change（4 个会话 0 次），所以台账里的
+     * 「未验证」永远是未验证——而"改完必须有验证"正是这一版要保证的东西。证据写进 verify 字段
+     * （命令 + 结果首行），让用户一眼能看出是真验还是假验。
+     */
+    async verifyChanges(sid, input) {
+        const items = this.getChanges(sid);
+        let count = 0;
+        for (const item of items) {
+            if (item.status !== "done")
+                continue;
+            if (item.at > input.before)
+                continue;
+            if (input.targets && !input.targets.includes(item.target))
+                continue;
+            item.status = "verified";
+            item.verify = item.verify ? `${item.verify}｜${input.evidence}` : input.evidence;
+            count++;
+        }
+        if (count > 0)
+            await this.#ledgerTable.put(sid, trimChanges(items, CHANGE_CAP));
+        return count;
+    }
     // ── 假设台账 ──
     getHypotheses(sid) {
         const value = this.#hypothesisTable.get(sid);
@@ -179,6 +231,21 @@ export class ProjectStore {
     lastHypothesisAt(sid) {
         return this.getHypotheses(sid).reduce((max, item) => Math.max(max, item.at), 0);
     }
+    // ── 会话记忆（按项目键，跨会话续接）──
+    /** 读最近的会话记忆（新的在前）。 */
+    getTaskMemories(projectKey, limit = 5) {
+        const value = this.#taskMemoryTable.get(projectKey);
+        if (!Array.isArray(value))
+            return [];
+        return value.slice(-limit).reverse();
+    }
+    /** 写会话记忆：同 sid 覆盖，保留最近 10 条（免得桶里全是陈年会话）。 */
+    async saveTaskMemory(projectKey, memory) {
+        const list = this.getTaskMemories(projectKey, TASK_MEMORY_CAP).filter((item) => item.sid !== memory.sid);
+        list.push(memory);
+        await this.#taskMemoryTable.put(projectKey, list.slice(-TASK_MEMORY_CAP));
+        return true;
+    }
     // ── 项目知识（跨会话）──
     getFacts(projectKey) {
         const value = this.#factTable.get(projectKey);
@@ -194,12 +261,47 @@ export class ProjectStore {
     /** 追加项目事实；近似重复的忽略。返回是否写入。 */
     async addFact(projectKey, fact, isDuplicate) {
         const facts = this.getFacts(projectKey);
+        // 内容寻址（见 core/memory-id.ts）：同主题就是同一条知识 → 精确命中，不再全表算相似度。
+        const same = fact.id ? facts.findIndex((item) => item.id === fact.id) : -1;
+        if (same >= 0) {
+            const current = facts[same];
+            // 先到先得会让后来更完整的表述被丢掉；只有"更具体"（更长且主题一致）才覆盖。
+            if (isMoreSpecific(fact.text, current.text)) {
+                facts[same] = { ...fact, at: current.at };
+                await this.#factTable.put(projectKey, trimFacts(facts, PROJECT_FACT_CAP));
+                return true;
+            }
+            // 唯一例外：作用域修正（老数据没有 scope，补扫时能把它纠正成"本需求"）——这让老库自愈。
+            // ⚠️ 只在**新判定是 task**（也就是这次真的拿到了需求线索）时才改：否则一旦某轮没有线索
+            // （比如没预热到 cwd、`doc/` 下没有需求目录），就会把已经归好的 task 标签**改回 repo**——
+            // 我在 2026-09-24 的存量重归属里真踩过（22 条标签被冲掉，从备份才救回来）。
+            if (fact.scope === "task" && current.scope !== "task") {
+                facts[same] = { ...current, scope: fact.scope, task: fact.task };
+                await this.#factTable.put(projectKey, trimFacts(facts, PROJECT_FACT_CAP));
+                return true;
+            }
+            return false;
+        }
         if (isDuplicate(fact.text, facts))
             return false;
         facts.push(fact);
         await this.#factTable.put(projectKey, trimFacts(facts, PROJECT_FACT_CAP));
         return true;
     }
+    /** 按 id 或编号删除一条项目知识（编号 = 注入块里的 #n，会随裁剪顺移；id 稳定）。 */
+    async deleteFactById(projectKey, ref) {
+        const facts = this.getFacts(projectKey);
+        const wanted = ref.trim().replace(/^#/, "");
+        if (!wanted)
+            return false;
+        const byId = facts.findIndex((item) => item.id === wanted || (item.id ?? "").startsWith(wanted));
+        const index = byId >= 0 ? byId : Number(wanted) - 1;
+        if (index < 0 || index >= facts.length)
+            return false;
+        facts.splice(index, 1);
+        await this.#factTable.put(projectKey, facts);
+        return true;
+    }
     async deleteFact(projectKey, index) {
         const facts = this.getFacts(projectKey);
         if (index < 0 || index >= facts.length)
@@ -213,9 +315,58 @@ export class ProjectStore {
     }
     /** 会话结束清理：任务态数据不跨会话保留（项目知识是另一张表，不受影响）。 */
     async clearSession(sid) {
-        await Promise.all([this.#contractTable.delete(sid), this.#ledgerTable.delete(sid), this.#hypothesisTable.delete(sid)]);
+        await Promise.all([
+            this.#contractTable.delete(sid),
+            this.#ledgerTable.delete(sid),
+            this.#hypothesisTable.delete(sid),
+            this.#designTable.delete(sid),
+            this.#requirementTable.delete(sid),
+        ]);
     }
     /** 诊断用：当前项目键下的事实条数。 */
+    // ── 设计决策（会话态，跨轮跨压缩保留）──
+    getDesign(sid) {
+        const value = this.#designTable.get(sid);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            const raw = entry;
+            return normalizeDesign({ point: raw?.point, choice: raw?.choice, rejected: raw?.rejected, impact: raw?.impact }, typeof raw?.at === "number" ? raw.at : 0);
+        })
+            .filter((item) => item !== null);
+    }
+    /** 同一决策点视为更新（改主意就覆盖，保留新的理由）。 */
+    async upsertDesign(sid, item) {
+        const items = this.getDesign(sid);
+        const index = items.findIndex((entry) => entry.point === item.point);
+        if (index >= 0)
+            items[index] = { ...items[index], ...item };
+        else
+            items.push(item);
+        await this.#designTable.put(sid, trimDesign(items, DESIGN_CAP));
+    }
+    // ── 需求锚点（会话态）──
+    getRequirements(sid) {
+        const value = this.#requirementTable.get(sid);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((entry) => {
+            const raw = entry;
+            return normalizeRequirement({ text: raw?.text }, typeof raw?.at === "number" ? raw.at : 0);
+        })
+            .filter((item) => item !== null);
+    }
+    /** 逐字追加一条用户原话（近似重复的忽略，避免同一句被记两次）。 */
+    async appendRequirement(sid, item) {
+        const items = this.getRequirements(sid);
+        if (items.some((entry) => entry.text === item.text))
+            return false;
+        items.push(item);
+        await this.#requirementTable.put(sid, trimRequirements(items, REQUIREMENT_CAP));
+        return true;
+    }
     factCount(projectKey) {
         return this.getFacts(projectKey).length;
     }