lume-dsh-plugin 0.7.4 → 0.8.0

package/lib/host/tools.js

@@ -0,0 +1,367 @@
+import { defineTool } from "@deepseek-ai/dsh-tools";
+import { pathKey } from "../core/citations.js";
+export function registerLumeTools(deps) {
+    // ── 模型可调用工具（主写入通道）──
+    // 工具 output schema 的 const 语义要求成功值恒为 { ok: true }；失败一律抛错交由框架呈现。
+    // as const 让 defineTool 从字面量推断 O，三个工具共用同一份成功形状。
+    const OK_OUTPUT_SCHEMA = {
+        type: "object",
+        additionalProperties: false,
+        properties: { ok: { type: "boolean", const: true, required: true } },
+    };
+    // 度量工具要把摘要回给模型（唯一一个「读」工具），所以 schema 里带一段文本。
+    const METRICS_OUTPUT_SCHEMA = {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+            ok: { type: "boolean", const: true, required: true },
+            text: { type: "string", required: true, description: "人读度量摘要" },
+        },
+    };
+    function dutyPersona(exec) {
+        const sid = exec?.agent?.session?.id;
+        const st = sid !== undefined ? deps.runtime.get(String(sid)) : undefined;
+        return st?.lastInjected ?? deps.defaultName;
+    }
+    deps.ctx.effect(() => {
+        deps.ctx.tools.register(defineTool({
+            name: "lume_remember",
+            description: "记住关于用户或你们关系的持久事实（偏好、习惯、背景、称呼）。仅当信息明确值得长期记住时调用；每次一条，40 字以内。不要记录工作内容、代码或项目机密。",
+            parameters: {
+                text: { type: "string", required: true, description: "要长期记住的事实，第三人称陈述句，≤40 字" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已保存" }] },
+            execute: async (args, exec) => {
+                if (!deps.identity)
+                    throw new Error("lume deps.identity store is unavailable");
+                const personaName = dutyPersona(exec);
+                if (!personaName)
+                    throw new Error("lume_remember requires an active persona (当前没有当值人设)");
+                await deps.identity.addMemory(personaName, String(args.text), deps.isDuplicateFact);
+                return { ok: true };
+            },
+        }));
+        deps.ctx.tools.register(defineTool({
+            name: "lume_update_style",
+            description: "把用户对你说话方式的新要求固化为长期风格约定（如「少用 emoji」「自称改成XX」）。仅当用户明确提出风格/语气要求时调用，每条一句话。",
+            parameters: {
+                rule: { type: "string", required: true, description: "风格约定，一句话祈使句" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已保存" }] },
+            execute: async (args, exec) => {
+                if (!deps.identity)
+                    throw new Error("lume deps.identity store is unavailable");
+                const personaName = dutyPersona(exec);
+                if (!personaName)
+                    throw new Error("lume_update_style requires an active persona (当前没有当值人设)");
+                await deps.identity.addStyleRule(personaName, String(args.rule), (a, b) => deps.jaccard(a, b) >= 0.6);
+                return { ok: true };
+            },
+        }));
+        deps.ctx.tools.register(defineTool({
+            name: "lume_create_persona",
+            description: "创建一个全新的自定义人设。仅当用户明确想新建人设时使用：先在对话中访谈收集（人设的名字、性格、说话方式、对用户的称呼），收集完整后再调用本工具保存，并告知用户保存成功。",
+            parameters: {
+                name: { type: "string", required: true, description: "人设英文键名，小写字母开头，≤32 字符（如 tsundere）" },
+                displayName: { type: "string", required: true, description: "界面显示名（如「傲娇」）" },
+                description: { type: "string", required: true, description: "一句话简介" },
+                promptText: { type: "string", required: true, description: "完整风格契约：称呼/emoji/语气词/节奏/立场，与内置契约同构" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已保存" }] },
+            execute: async (args) => {
+                if (!deps.identity)
+                    throw new Error("lume deps.identity store is unavailable");
+                await deps.identity.setCustomPersona(String(args.name), {
+                    displayName: String(args.displayName),
+                    description: String(args.description ?? ""),
+                    promptText: String(args.promptText),
+                    createdAt: Date.now(),
+                });
+                return { ok: true };
+            },
+        }));
+    }, "lume: persona tools");
+    // ── 任务载具工具（第二组写入通道）──
+    // 与人格工具一样是「模型主动调用、零额外 LLM 调用」，区别在写入对象：契约/台账/假设
+    // 属于当前任务（会话态），项目知识按工作目录跨会话累积。列表类参数统一用字符串
+    // 分隔（分号或换行），不引入数组 schema——省 schema token，也少一层校验风险。
+    const splitList = (value) => String(value ?? "")
+        .split(/[；;\n]/)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    deps.ctx.effect(() => {
+        deps.ctx.tools.register(defineTool({
+            name: "lume_contract",
+            description: "写下或更新本任务的任务契约（需求量化的落点）：目标、范围、数量、完成判据、非目标、待确认。任务型请求开工前调用一次；探索后回填实际数量；之后只传变化的字段即可（局部更新）。",
+            parameters: {
+                goal: { type: "string", description: "目标：一句话、可观察的结果" },
+                scope: { type: "string", description: "范围：路径/模块/章节，分号或换行分隔" },
+                expectCount: { type: "number", required: true, 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 (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() store is unavailable");
+                const sid = String(exec?.agent?.session?.id ?? "");
+                if (!sid)
+                    throw new Error("lume_contract requires an active session");
+                const st = deps.runtime.get(sid);
+                const normalized = deps.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 store = deps.projectStore();
+                const existing = store.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 store.patchContract(sid, patch);
+                }
+                else {
+                    if (!normalized.goal)
+                        throw new Error("lume_contract requires a goal on first write");
+                    await store.setContract(sid, normalized);
+                }
+                return { ok: true };
+            },
+        }));
+        deps.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 (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() 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 deps.projectStore().setChangeStatus(sid, target, allowed);
+                    if (!hit)
+                        throw new Error(`lume_change: no ledger entry for ${target}`);
+                    return { ok: true };
+                }
+                const item = deps.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 deps.projectStore().upsertChange(sid, item);
+                return { ok: true };
+            },
+        }));
+        deps.ctx.tools.register(defineTool({
+            name: "lume_hypothesis",
+            description: "假设台账：记录一条正在验证的假设及其证据与状态（open/testing/confirmed/excluded）。排查类任务里每验证一次就更新状态；已排除的假设不要再重复尝试。**下结论（confirmed/excluded）就是一次裁决**：证据、裁决方式、反例检查三项必填，缺一会被拒。",
+            parameters: {
+                text: { type: "string", required: true, description: "假设内容，一句话" },
+                evidence: { type: "string", description: "支持或推翻它的观察（含命令输出 / 文件行 / 时间戳）" },
+                status: { type: "string", description: "open | testing | confirmed | excluded" },
+                method: { type: "string", description: "裁决方式：用哪条命令 / 工具、看什么结果判定的（confirmed/excluded 必填）" },
+                counter: { type: "string", description: "反例检查：找过哪些反例，或「已尝试 X 未找到反例」（confirmed/excluded 必填）" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已更新假设台账" }] },
+            execute: async (args, exec) => {
+                if (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() store is unavailable");
+                const sid = String(exec?.agent?.session?.id ?? "");
+                if (!sid)
+                    throw new Error("lume_hypothesis requires an active session");
+                const st = deps.runtime.get(sid);
+                const status = String(args.status ?? "open").trim();
+                const evidence = String(args.evidence ?? "").trim();
+                const method = String(args.method ?? "").trim();
+                const counter = String(args.counter ?? "").trim();
+                // 结论级裁决门禁（机械可判，不比模型自评）：下结论 = 裁决，三样缺一不可。
+                // 为什么要硬拦：真机里「confirmed/excluded」曾经只带一句「已验证 / 无」，
+                // 那种结论无法复核，等于把猜测固化成跨轮次的事实。
+                let stored = evidence;
+                if (status === "confirmed" || status === "excluded") {
+                    if (evidence.length < 8)
+                        throw new Error("下结论必须带证据：evidence 写清观察（命令输出 / 文件行 / 时间戳），不要只写「已验证」");
+                    if (method.length < 6)
+                        throw new Error("下结论必须写裁决方式 method：用哪条命令 / 工具、看什么结果判定的（例：npm test 全绿 / grep 到 X）");
+                    if (counter.length < 8)
+                        throw new Error("下结论必须写反例检查 counter：找过哪些反例，或「已尝试 X 未找到反例」——只写「无」不算");
+                    // 证据里的文件引用必须真的看过（与引用核对同一套 pathKey 口径），否则就是编证据
+                    // 只把「像路径」的 token 当引用：含分隔符或带 :行号。否则 Node.js / e.g / i.e 都会被
+                    // 当成文件引用，写一句诚实的证据反而被拒（外部审核指出）。
+                    const refs = [...evidence.matchAll(/([A-Za-z0-9_./\\-]+\.[A-Za-z]{1,5})(:\d+)?/g)]
+                        .filter((m) => (m[0] ?? "").includes("/") || (m[0] ?? "").includes("\\") || Boolean(m[2]))
+                        .map((m) => m[1] ?? "")
+                        .filter(Boolean);
+                    const unseen = [...new Set(refs)].filter((ref) => !st.agent.evidence.has(pathKey(ref)));
+                    if (unseen.length > 0)
+                        throw new Error(`证据里有本会话没看过的引用：${unseen.join("、")}——先去看过再引用（引用必须能被核对）`);
+                    // 结构化保存三件套（早先折进 evidence 一行会让「多少结论带反例检查」没法机械统计，
+                    // 也会在改回 open/testing 时被新证据覆盖）
+                    stored = evidence;
+                }
+                const item = deps.normalizeHypothesis({ text: args.text, evidence: stored, status, method, counter }, Date.now());
+                if (!item)
+                    throw new Error("lume_hypothesis requires text");
+                await deps.projectStore().upsertHypothesis(sid, item);
+                deps.runtime.get(sid).hypothesesTouched = true;
+                return { ok: true };
+            },
+        }));
+        deps.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 (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() store is unavailable");
+                const sid = String(exec?.agent?.session?.id ?? "");
+                if (!sid)
+                    throw new Error("lume_project_note requires an active session");
+                const fact = deps.normalizeProjectFact({ kind: args.kind, text: args.text }, Date.now(), {
+                    taskTitle: deps.runtime.get(sid).sessionTitle,
+                    requirementHints: deps.requirementHintsOf(deps.runtime.get(sid).cwd),
+                });
+                if (!fact)
+                    throw new Error("lume_project_note requires text");
+                if (deps.looksSensitive(fact.text))
+                    throw new Error("lume_project_note 拒绝含密钥/连接串/凭证的内容：项目知识是**明文跨会话**存储；请改记「存在某类配置，细节见 <文件:行>」");
+                const projectKey = deps.projectKeyFor(sid, { agent: exec?.agent });
+                if (!projectKey) {
+                    // 拿不到工作目录时**暂存**而不是丢弃——现场代价：模型主动记的 3 条硬知识全丢了。
+                    // 仍然不写跨会话表：写一次就会把不同项目的知识串进同一个键（现场事故：facts 的键曾是 "unknown"）。
+                    const rt = deps.runtime.get(sid);
+                    rt.pendingFacts.push(fact);
+                    if (rt.pendingFacts.length > 8)
+                        rt.pendingFacts.shift();
+                    deps.ctx.logger?.warn?.(`lume: [${sid}] 项目知识已暂存（工作目录未知，共 ${rt.pendingFacts.length} 条），拿到 cwd 后补落盘`);
+                    return { ok: true };
+                }
+                await deps
+                    .projectStore()
+                    .addFact(projectKey, fact, (candidate, existing) => existing.some((entry) => deps.jaccard(entry.text, candidate) >= 0.7));
+                return { ok: true };
+            },
+        }));
+        deps.ctx.tools.register(defineTool({
+            name: "lume_project_forget",
+            description: "删掉一条已过时/记错的项目知识（注入块里的 #编号 或短 id）。旧结论被推翻时用它，别让错误知识继续跨会话传播。",
+            parameters: {
+                id: { type: "string", required: true, description: "要删的条目引用（#7 或 7 或短 id，见项目知识块里的 #编号·短id）" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已删除该条项目知识" }] },
+            execute: async (args, exec) => {
+                if (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() store is unavailable");
+                const sid = String(exec?.agent?.session?.id ?? "");
+                if (!sid)
+                    throw new Error("lume_project_forget requires an active session");
+                const ref = String(args.id ?? "").trim();
+                if (!ref)
+                    throw new Error("lume_project_forget requires id");
+                const projectKey = deps.projectKeyFor(sid, { agent: exec?.agent });
+                if (!projectKey)
+                    throw new Error("lume_project_forget 拿不到工作目录，无法定位知识库");
+                const removed = await deps.projectStore().deleteFactById(projectKey, ref);
+                if (!removed)
+                    throw new Error(`lume_project_forget 没找到 ${ref}（用项目知识块里的 #编号 或短 id）`);
+                return { ok: true };
+            },
+        }));
+        deps.ctx.tools.register(defineTool({
+            name: "lume_design",
+            description: "记一条设计决策（功能型任务的设计 pass）：决策点 → 选择 → 被放弃的方案与理由 → 影响面。新增字段/接口/页面这类需求，动手前先写；写下后会跨轮回显，交付时按它对账。",
+            parameters: {
+                point: { type: "string", required: true, description: "决策点：例如「权限人字段存在哪」" },
+                choice: { type: "string", required: true, description: "定下来的做法（一句话）" },
+                rejected: { type: "string", description: "被放弃的方案与理由（没有它就是没做取舍）" },
+                impact: { type: "string", description: "影响面：会经过哪些既有路径（其它 tab/导出/导入/报表/外部同步）" },
+            },
+            output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已记录设计决策" }] },
+            execute: async (args, exec) => {
+                if (!deps.projectOf())
+                    throw new Error("lume deps.projectOf() store is unavailable");
+                const sid = String(exec?.agent?.session?.id ?? "");
+                if (!sid)
+                    throw new Error("lume_design requires an active session");
+                const item = deps.normalizeDesign({ point: args.point, choice: args.choice, rejected: args.rejected, impact: args.impact }, Date.now());
+                if (!item)
+                    throw new Error("lume_design requires point and choice");
+                await deps.projectStore().upsertDesign(sid, item);
+                return { ok: true };
+            },
+        }));
+    }, "lume: carrier tools");
+    // ── 度量自读（0.8.x）──
+    // 让「是不是更聪明了」可以被查，而不是靠印象：只回机械事实（路由判定与命中判据、
+    // 用户纠正/重复请求/越权改动、块装配预算、触发器命中后行为是否变化），不做语义解释，
+    // 测不了的项目会注明「无机械口径」。
+    //
+    // **单开一个 effect，并且整段 try/catch**：它是本插件唯一一个自定义输出 schema 的工具
+    // （带 text 字段 + 动态 render）。注册期一旦抛错，会像 0.7.1 的 RPC 注册那样把整段
+    // apply 打断（那次界面上连人设都看不到）。度量是**观测设施**，缺了不该影响对话本身。
+    deps.ctx.effect(() => {
+        try {
+            deps.ctx.tools.register(defineTool({
+                name: "lume_metrics",
+                description: "读取 Lume 的运行时度量：最近的路由判定与命中的判据、用户纠正/重复请求/越权改动等外部结果信号、块装配预算、每个触发器命中后行为是否真的变了。用户问「最近效果如何」「为什么这轮判成问答」时用它回答，不要凭印象编。",
+                parameters: {
+                    scope: { type: "string", description: "session（默认）= 本会话；all = 本落点全部会话" },
+                },
+                output: {
+                    schema: METRICS_OUTPUT_SCHEMA,
+                    render: (_args, value) => [
+                        { type: "text", text: String(value?.text ?? "") },
+                    ],
+                },
+                execute: async (args, exec) => {
+                    const scope = String(args.scope ?? "session")
+                        .trim()
+                        .toLowerCase();
+                    const sid = String(exec?.agent?.session?.id ?? "");
+                    const text = scope === "all" ? deps.metricsSummary() : deps.metricsSummary(sid);
+                    return { ok: true, text };
+                },
+            }));
+        }
+        catch (error) {
+            // 注册失败只有一条后果：查不到度量。如实留痕，但不影响对话与其它工具。
+            deps.ctx.logger?.warn?.("lume: lume_metrics 注册失败（度量是观测设施，缺它不影响对话）", error);
+        }
+    }, "lume: metrics tool");
+}

package/lib/host/triggers.js

@@ -12,7 +12,16 @@
  */
 import { deadPathKind } from "../core/signals.js";
 export function newTriggerCounters() {
-    return { inspectStreak: 0, mutateStreak: 0, verifyFailStreak: 0, verifyEnvHits: 0, mutations: 0, steps: 0 };
+    return {
+        inspectStreak: 0,
+        mutateStreak: 0,
+        verifyFailStreak: 0,
+        verifyEnvHits: 0,
+        mutations: 0,
+        steps: 0,
+        codeInspects: 0,
+        unfoundedChanges: 0,
+    };
 }
 /** 计数器推进：语义是「行为模式」，因此只在类别切换或验证成败时重置。 */
 export function applyToolSignal(counters, kind, signals) {
@@ -61,6 +70,8 @@ export const DEFAULT_TRIGGER_THRESHOLDS = {
     changeStreak: 4,
     deadPathFails: 3,
     knowledgeSteps: 20,
+    // 6：实测这类型任务的轨迹是「grep/read 十几轮 → 直接动手」，6 次摸到代码就是该做设计的时点
+    designAfterInspects: 6,
 };
 /**
  * 工具事件触发的判定。一次只返回**一个**（按紧急度排序）：同时堆三条提醒会互相稀释。
@@ -82,6 +93,13 @@ export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_
             text: `〔死路提醒〕同一验证已连续失败 ${n} 次。先归因（输入 / 逻辑 / 接口 / 环境 / 权限），把结论写进假设台账：证实的标 confirmed、排除的标 excluded（用 lume_hypothesis）——已排除的假设不要再试。换一个方案再动手。`,
         };
     }
+    // 决策分档：正在拿推测当依据改东西。排在「改多了要验证」之前——因为这一步的**依据**有问题。
+    if (counters.unfoundedChanges > 0 && ctx.blindTarget) {
+        return {
+            id: "unfounded-change",
+            text: `〔决策分档〕这一步在改一个**本会话没读过**的目标：${ctx.blindTarget}。二选一：① 先做最便宜的核实（读一次 / 跑一次 / 查一次引用），拿到事实再改；② 确实要带着不确定动手 → 用 lume_hypothesis 把它落成假设（写清证据与「怎么验证」，并说明「如果这条不成立会怎样」）。不要拿推测当依据直接改。`,
+        };
+    }
     if (counters.mutateStreak >= thresholds.changeStreak || ctx.unverifiedChanges >= thresholds.changeStreak) {
         return {
             id: "verify-as-you-go",
@@ -94,6 +112,12 @@ export function evaluateToolTrigger(counters, ctx, thresholds = DEFAULT_TRIGGER_
             text: "〔载具缺失〕你已经动手改动，但还没写下任务契约。花一次调用写清：目标（可观察的结果）、范围（精确到路径/模块/章节）、预计数量、完成判据（可执行）、非目标（明确不动什么）、待确认（≤2 个）。之后每步以契约为准，交付时按它逐项对账——用 lume_contract。",
         };
     }
+    if (ctx.isTask && ctx.designSignal && !ctx.hasDesign && counters.codeInspects >= thresholds.designAfterInspects) {
+        return {
+            id: "design-missing",
+            text: `〔设计缺失〕你已经读了 ${counters.codeInspects} 处代码，但还没有一条设计决策。功能型任务最容易在这里翻车：直接照需求改代码，把「数据落在哪 / 接口长什么样 / 照哪个既有范式」留给临场发挥。现在花一次调用写进 lume_design（point / choice / rejected / impact 各一行），写完再动手。`,
+        };
+    }
     if (ctx.isTask && counters.inspectStreak >= thresholds.inspectStreak) {
         return {
             id: "converge",

package/lib/host/turn-boundary.js

@@ -0,0 +1,116 @@
+import { claimsVerification, looksLikeFailure } from "../core/signals.js";
+export function handleTurnEnd(deps, sid, st, session) {
+    st.turnIndex++;
+    // 轮边界补一次项目知识落盘：此时 cwd 通常已经从提示词上下文拿到
+    deps.flushPendingFacts(sid, session);
+    // 切换窗口的消耗只发生在轮边界（渲染函数只读状态，不再就地清零）：
+    // 同一步里 prompt 会被构建多次，若在渲染里消耗窗口，第二次构建就会
+    // 丢掉接班招呼——那是「注入随构建次数漂移」，正是本版要消灭的东西。
+    st.switchGreetingPending = false;
+    if (st.switchTurn !== null && st.turnIndex - st.switchTurn >= deps.boundaryTurns)
+        st.switchTurn = null;
+    // ── 行为触发器（轮边界）──
+    // 连击按轮清零：新一轮是新请求，上一轮的「撒网」不该继续累加；死路连击
+    // 跨轮保留（同一环境不可用是会话级事实）。上轮的提醒到这里失效。
+    st.triggerCounters.inspectStreak = 0;
+    st.triggerCounters.mutateStreak = 0;
+    deps.clearNotice(st, "trigger");
+    deps.forceNotice(st, "turn", null);
+    st.hypothesesTouched = false;
+    if (deps.behaviorTriggersOn && deps.projectOf()) {
+        const fire = deps.evaluateTurnTrigger({
+            turnIndex: st.turnIndex,
+            hasContract: deps.contractOf(sid) !== null,
+            compactionTurn: st.compaction?.turnIndex ?? null,
+            lastDriftTurn: st.lastDriftTurn,
+            counters: st.triggerCounters,
+            knowledgePrompted: st.knowledgePrompted,
+        }, deps.triggerThresholds);
+        if (fire && deps.cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
+            st.triggerFiredAt[fire.id] = st.turnIndex;
+            deps.recordMetric({
+                kind: "trigger",
+                at: Date.now(),
+                sid,
+                turn: st.turnIndex,
+                id: fire.id,
+                counters: { ...st.triggerCounters },
+            });
+            if (fire.id === "criteria-drift") {
+                // 契约对账用「交付口径」渲染原始判据：防判据随进展漂移。
+                st.lastDriftTurn = st.turnIndex;
+                deps.forceNotice(st, "turn", deps.renderContract(deps.contractOf(sid), true));
+            }
+            else {
+                st.knowledgePrompted = true;
+                deps.forceNotice(st, "turn", fire.text);
+            }
+            deps.ctx.logger?.warn?.(`lume: [${sid}] 轮触发器 ${fire.id}（turn=${st.turnIndex}）`);
+        }
+    }
+    // 低成本会话内纠偏：只处理明确的错误/失败信号，且要求连续轮次用户请求相同。
+    const failed = looksLikeFailure(st.assistantText);
+    const queryKey = st.userText.trim().replace(/\s+/g, " ").slice(0, 240);
+    if (failed && queryKey && queryKey === st.lastFailureQuery)
+        st.failureStreak++;
+    else if (failed && queryKey) {
+        st.lastFailureQuery = queryKey;
+        st.failureStreak = 1;
+    }
+    else if (!failed) {
+        st.failureStreak = 0;
+        st.lastFailureQuery = null;
+        deps.forceNotice(st, "protocol", null);
+    }
+    if (st.failureStreak >= 2)
+        deps.forceNotice(st, "protocol", "检测到相同请求连续失败：先定位根因并记录已排除假设，再选择不同方案；不要重复同一调用。");
+    // 空转信号：判成执行/诊断，但这一轮一次工具都没调——要么在纸上谈兵，要么就是路由判错了。
+    // 与「越权改动」凑成一对：一个抓「该动没动」，一个抓「不该动却动了」。
+    if ((st.interactionMode === "execute" || st.interactionMode === "diagnosis") && (st.toolCalls ?? 0) === 0)
+        deps.recordMetric({
+            kind: "outcome",
+            at: Date.now(),
+            sid,
+            turn: st.turnIndex,
+            event: "no-action",
+            mode: st.interactionMode,
+            detail: st.intent?.text?.slice(0, 120) ?? "",
+        });
+    const claimsVerificationNow = claimsVerification(st.assistantText);
+    // 交付对账（C4）：台账里还有"已改未验"就**列出具体条目**——泛泛提醒"要有验证证据"
+    // 实测没用，摆出未验证的具体项才有可执行性。
+    const deliveryNotice = st.interactionMode === "execute" || st.triggerCounters.mutations > 0 ? deps.buildUnverifiedDeliveryNotice(deps.changesOf(sid)) : null;
+    // 载具缺口：动了代码但契约/设计都空 → 交付时如实说（触发器喊过没用，只能靠事实）
+    const carrierGap = deps.noticeOpen(st, "carrierGap")
+        ? deps.buildCarrierGapNotice({
+            mutations: st.triggerCounters.mutations,
+            hasContract: deps.contractOf(sid) !== null,
+            hasDesign: deps.designOf(sid).length > 0,
+        })
+        : null;
+    deps.setNotice(st, "carrierGap", carrierGap);
+    deps.forceNotice(st, "postTurn", [deliveryNotice, carrierGap].filter(Boolean).join("\n\n") ||
+        (st.interactionMode === "execute" && st.assistantText && !claimsVerificationNow
+            ? "〔上轮交付复核〕上一轮执行回复没有给出可见的验证证据。本轮若继续处理同一任务，先确认上轮变更是否真实生效，再继续扩大范围。"
+            : null));
+    if (st.interactionMode === "execute")
+        st.taskPhase = deps.advancePhase(st.taskPhase, st.toolFailures > 0 || st.toolUnknown > 0 ? "diagnose" : claimsVerificationNow ? "deliver" : "verify");
+    // 即时对齐只影响当前轮；下一轮重新根据用户消息判断，避免纠偏条款滞留。
+    deps.clearNotice(st, "align");
+    // 风格泄漏检测挂在 turn/end（该事件已被窗口机制验证可靠；assistant/message
+    // 的投递在实测中不可靠）。切换完成后逐轮检查回复是否残留旧人设签名词，
+    // 窗口已关仍检出 → 重开窗口 + 升级播报；一轮干净回复自动解除升级。
+    if (st.prevSignatures.length > 0 && st.lastInjected !== undefined && st.assistantText) {
+        const report = deps.detectLeak(st.assistantText, st.prevSignatures);
+        const inWindow = st.switchTurn !== null && st.turnIndex - st.switchTurn < deps.boundaryTurns;
+        if (report.leaked && !inWindow) {
+            st.switchTurn = st.turnIndex;
+            st.leakEscalated = true;
+            deps.ctx.logger?.warn?.(`lume: [${sid}] 检测到旧人设风格泄漏（${report.hits.map((h) => `${h.word}×${h.count}`).join("、")}），重新注入升级版切换播报`);
+        }
+        else if (!report.leaked) {
+            st.leakEscalated = false;
+        }
+    }
+    deps.scheduleExtraction(sid, st);
+}