lume-dsh-plugin 0.7.3 → 0.8.0

package/lib/host/session-events.js

@@ -0,0 +1,371 @@
+import { existsSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+import { pathKey } from "../core/citations.js";
+import { claimsVerification, looksLikeFailure } from "../core/signals.js";
+import { handleTurnEnd } from "./turn-boundary.js";
+import { AUTO_FACT_CAP, anchorRequirement, applyAlignNotice, checkContextPressure, checkEvidenceNotices, checkRequirementDrift, collectAssistantFacts, collectUserRuleFacts, handleCompactionCheckpoint, learnWorkspaceFromSnapshot, } from "./inbound.js";
+/** 每会话自动沉淀的项目知识上限：宁可少记，也不要让知识库变垃圾桶。 */
+/**
+ * 「本会话看过这个目标吗」的**唯一**判据：证据索引（pathKey 归一）+ 摸过的目标。
+ * 首改定位门槛与决策分档共用它——同一种问题只能有一个真值来源（两处各用一种键会得出两种结论）。
+ */
+function inspectedTarget(st, target) {
+    const key = pathKey(target);
+    if (st.agent.evidence.has(key))
+        return true;
+    for (const seen of st.agent.inspectedTargets)
+        if (pathKey(seen) === key)
+            return true;
+    return false;
+}
+/**
+ * 只对**已存在**的文件判「没读过就改」：新建文件天然没读过，对它喊「先读一次」是错话。
+ * 相对路径按会话 cwd 解析；解析不了（cwd 未知）就当新建处理——宁可漏，不喊错话。
+ */
+function existingTarget(st, target) {
+    const raw = String(target ?? "").trim();
+    if (!raw)
+        return null;
+    const resolved = isAbsolute(raw) ? raw : st.cwd ? join(st.cwd, raw) : raw;
+    return existsSync(resolved) ? raw : null;
+}
+export function createSessionEventHandler(deps) {
+    return (session, event) => {
+        const sid = String(session.id);
+        const st = deps.runtime.get(sid);
+        switch (event.type) {
+            case "request/context": {
+                // 路由缓存的真正来源：agent-loop 在路由变化时 append 的 request/context
+                // （{provider, model, contextWindow}）。request/header 的载荷是 {header,
+                // reason}，拿不到 provider/model——v0.3.0 一直监听错了事件，提取从未跑通。
+                const data = event.data;
+                // 上下文窗口：预警要用（0/未知就不预警）
+                st.contextWindow = Number(data?.contextWindow) || st.contextWindow;
+                if (typeof data?.provider === "string" && typeof data?.model === "string") {
+                    deps.llmRoute.current = { provider: data.provider, model: data.model };
+                    deps.ctx.logger?.warn?.(`lume: request/context 更新 deps.llmRoute → ${deps.llmRoute.current?.provider}/${deps.llmRoute.current?.model}`);
+                }
+                else {
+                    deps.ctx.logger?.warn?.("lume: request/context 未携带 provider/model，保留 deps.llmRoute", data);
+                }
+                break;
+            }
+            case "session/title": {
+                // 会话标题：会话记忆的标识 + 新会话的「继续 X」指令依赖它。
+                st.sessionTitle = String(event.data?.title ?? "").slice(0, 60);
+                break;
+            }
+            case "user/message": {
+                if (handleCompactionCheckpoint(sid, st, deps, event.data))
+                    break;
+                learnWorkspaceFromSnapshot(sid, st, deps, event.data);
+                if (!deps.isUserAuthored(event.data))
+                    break;
+                const text = deps.messageText(event.data);
+                if (!text)
+                    break;
+                const normalized = text.trim().replace(/\s+/g, " ").slice(0, 240);
+                const explicitCorrection = /不是这个意思|不是我说的|你理解错|答非所问|听不懂|我说的是|我指的是|不对|错了|别这样|重新来/i.test(text);
+                const repeatedRequest = normalized.length >= 5 && st.recentUserQueries.includes(normalized);
+                st.userText = text;
+                anchorRequirement(sid, st, deps, text);
+                collectUserRuleFacts(sid, st, deps, text, event.data);
+                applyAlignNotice(st, deps, explicitCorrection, repeatedRequest);
+                // 外部结果信号（**用户给的**，不是模型自评）：用户纠正与重复请求是「上一轮判错 /
+                // 没做到」最直接的证据。带上当时生效的模式——落在哪个模式上，就是哪个模式在误判。
+                if (explicitCorrection || repeatedRequest)
+                    deps.recordMetric({
+                        kind: "outcome",
+                        at: Date.now(),
+                        sid,
+                        turn: st.turnIndex,
+                        event: explicitCorrection ? "user-correction" : "repeat-request",
+                        mode: st.interactionMode,
+                        detail: normalized.slice(0, 120),
+                    });
+                st.recentUserQueries.push(normalized);
+                if (st.recentUserQueries.length > 5)
+                    st.recentUserQueries.shift();
+                st.recentTurns.push(`用户: ${text.slice(0, 300)}`);
+                if (st.recentTurns.length > 12)
+                    st.recentTurns.shift();
+                // 模式/阶段的冻结统一由 resolveIntent（组装时读会话权威历史）负责；这里只记账。
+                break;
+            }
+            case "assistant/message": {
+                const text = deps.visibleText(event.data?.message);
+                if (!text)
+                    break;
+                st.assistantText = text;
+                collectAssistantFacts(sid, st, deps, text, event.data);
+                checkRequirementDrift(sid, st, deps, text);
+                checkContextPressure(sid, st, deps, event.data);
+                checkEvidenceNotices(st, deps, text);
+                st.recentTurns.push(`助手: ${text.slice(0, 300)}`);
+                if (st.recentTurns.length > 12)
+                    st.recentTurns.shift();
+                break;
+            }
+            case "tool/call": {
+                st.toolCalls++;
+                if (st.interactionMode === "execute")
+                    st.taskPhase = deps.advancePhase(st.taskPhase, "execute");
+                // 行为类别在调用阶段记账（连击），成败到结果阶段才结算。
+                st.toolKind = deps.classifyTool(deps.toolNameOf(event.data));
+                deps.applyToolSignal(st.triggerCounters, st.toolKind, null);
+                // 自动改动台账：mutate 类工具一被调用就先记一条——实测模型几乎不会主动调 lume_change
+                // （4 个会话里 0 次），而 edit/write 每次会话几十次。载具必须由插件自己落账，
+                // 否则「改动台账」永远空着（这正是上一版没生效的地方）。
+                if (st.toolKind === "inspect" && deps.toolTargetOf(event.data))
+                    st.triggerCounters.codeInspects++;
+                // 越权改动：判成问答却动了文件——「路由判错」的机械证据，比用户抱怨出现得更早。
+                // 决策分档的机械判据：**已存在的文件**在本会话没看过就改 = 拿推测当依据。
+                // - 只管已存在的目标：新建文件天然「没读过」，对它喊「先读一次」是错话（外部审核指出）；
+                // - 看过的判据只走 inspectedTarget（证据索引 + 摸过的目标，同一套 pathKey），
+                //   不再让两处各问一次、各用一种键。
+                if (st.toolKind === "mutate") {
+                    const target = existingTarget(st, deps.toolTargetOf(event.data));
+                    if (target && !inspectedTarget(st, target)) {
+                        st.triggerCounters.unfoundedChanges++;
+                        st.agent.lastBlindTarget = target;
+                    }
+                    else
+                        st.agent.lastBlindTarget = null;
+                }
+                if (st.toolKind === "mutate" && st.interactionMode === "question")
+                    deps.recordMetric({
+                        kind: "outcome",
+                        at: Date.now(),
+                        sid,
+                        turn: st.turnIndex,
+                        event: "overreach",
+                        mode: "question",
+                        detail: deps.toolNameOf(event.data),
+                    });
+                // 引用-证据对齐与定位门槛的输入：read 的窗口、摸过的目标、最近一次调用的命令文本。
+                // 只把 read/view 这类**读文件**的工具记成窗口——grep 的 path 可能只是目录或模式，
+                // 记成"整文件读过"会把没看的行洗白（宁可少记，也不要给假证据）。
+                const callName = deps.toolNameOf(event.data);
+                const callArgs = deps.toolArgsOf(event.data);
+                st.agent.lastToolName = callName || null;
+                st.agent.lastToolArgs = callArgs ? JSON.stringify(callArgs) : null;
+                st.agent.lastToolTarget = deps.toolTargetOf(event.data);
+                if (st.toolKind === "inspect") {
+                    if (/read|view|cat|open|head|tail/i.test(callName))
+                        deps.recordReadArgs(st.agent.evidence, callArgs);
+                    if (st.agent.lastToolTarget)
+                        st.agent.inspectedTargets.add(st.agent.lastToolTarget);
+                }
+                if (deps.projectMemoryOn && st.toolKind === "mutate") {
+                    const target = deps.toolTargetOf(event.data);
+                    if (target) {
+                        const toolName = deps.toolNameOf(event.data);
+                        // 台账条目要能当交付依据用，所以带上内容摘要（原来只有「由 edit 修改」，对模型零信息）
+                        const args = deps.toolArgsOf(event.data);
+                        const summary = deps.summarizeToolChange(args, toolName);
+                        // 文档类产物留正文：覆盖核对要把「需求原句」与「交付物里的句子」并列（这是查矛盾的机械手段）
+                        if (deps.DOC_ARTIFACT_RE.test(target)) {
+                            const content = deps.toolArtifactText(args);
+                            if (content) {
+                                st.agent.artifactText = (st.agent.artifactText + "\n" + content).slice(-60000);
+                                deps.clearNotice(st, "coverage"); // 换了新产物 → 重新核一次
+                            }
+                        }
+                        deps.projectTask(sid, "自动改动入账", (store) => store.upsertChange(sid, {
+                            target,
+                            change: `（自动）${toolName}：${summary}`,
+                            why: "",
+                            verify: "",
+                            status: "done",
+                            at: Date.now(),
+                        }));
+                    }
+                    // 首改前的定位门槛：要改的文件本会话从没被读过就动手 → 顶一次（不改代码，只补定位）
+                    if (st.triggerCounters.mutations === 1 && target && !inspectedTarget(st, target)) {
+                        const seen = [...st.agent.inspectedTargets].slice(-3).join("、") || "（本会话还没读过任何文件）";
+                        if (!deps.noticeText(st, "trigger"))
+                            deps.forceNotice(st, "trigger", `〔先定位〕你要改 ${target}，但本会话还没有读过它——已经摸过的是：${seen}。先打开要改的那段（含调用方与配置/SQL 绑定），确认现有实现再动手；改完立刻回读或跑最小验证。`);
+                        deps.ctx.logger?.warn?.(`lume: [${sid}] 首改未定位：${target}`);
+                    }
+                }
+                break;
+            }
+            case "tool/result": {
+                const data = event.data;
+                const resultText = deps.messageText(data?.message);
+                const explicitError = Boolean(data?.error) || looksLikeFailure(resultText);
+                const unknownResult = /结果未知|outcome unknown|tool_not_started|tool_outcome_unknown/i.test(resultText);
+                if (unknownResult)
+                    st.toolUnknown++;
+                else if (explicitError)
+                    st.toolFailures++;
+                else
+                    st.toolSuccesses++;
+                if (st.interactionMode === "execute")
+                    st.taskPhase = deps.advancePhase(st.taskPhase, unknownResult || explicitError ? "diagnose" : "verify");
+                // 行为信号 → 计数器 → 触发器提醒。提醒只在这一步之后可见（尾部快照），
+                // 且每类触发器有轮级冷却：提示一多就变噪音，模型会学会忽略。
+                const signals = deps.readResultSignals(resultText, explicitError);
+                deps.applyVerifyOutcome(st.triggerCounters, st.toolKind, signals);
+                // 引用-证据对齐：结果里出现过的「路径:行」也算"看到过"（grep 命中即证据）
+                if (st.toolKind === "inspect" && resultText)
+                    deps.recordResultText(st.agent.evidence, resultText);
+                // 所有工具结果都算「见过」：否定断言只能用见过的东西支撑
+                if (resultText)
+                    deps.recordSymbols(st.agent.seenSymbols, resultText);
+                // 验证结算：成功的真验证自动推进台账 / 失败立刻顶一句先修红——都不等模型调工具
+                if (deps.projectMemoryOn)
+                    deps.settleVerification(sid, st, resultText, signals);
+                // 度量：出现一次「真验证命令」就记一条。它是 verify 类触发器效能判定的判据——
+                // **不能**用「台账 verified 增加」：那是 settleVerification 自动推进的产物，会自我表扬。
+                if (st.toolKind === "verify" && deps.isRealVerifyCommand(st.agent.lastToolArgs ?? ""))
+                    deps.recordMetric({
+                        kind: "outcome",
+                        at: Date.now(),
+                        sid,
+                        turn: st.turnIndex,
+                        event: "verify-run",
+                        mode: st.interactionMode,
+                    });
+                // 自动沉淀项目知识：**不依赖模型自觉调工具**（实测 3 次 lume_project_note 全丢）。判据在
+                // core/knowledge.ts（宁窄勿宽 + 敏感词硬拦），每会话有上限，落盘统一走 pendingFacts → flush。
+                if (deps.projectMemoryOn && resultText && st.agent.autoFacts < AUTO_FACT_CAP) {
+                    for (const candidate of deps.extractKnowledgeCandidates(resultText, { source: "tool", userText: st.userText ?? "" })) {
+                        if (st.agent.autoFacts >= AUTO_FACT_CAP)
+                            break;
+                        const fact = deps.normalizeProjectFact({ kind: candidate.kind, text: candidate.text }, Date.now(), {
+                            taskTitle: st.sessionTitle,
+                        });
+                        if (!fact || deps.looksSensitive(fact.text))
+                            continue;
+                        st.pendingFacts.push(fact);
+                        if (st.pendingFacts.length > 8)
+                            st.pendingFacts.shift();
+                        st.agent.autoFacts++;
+                        deps.ctx.logger?.warn?.(`lume: [${sid}] 自动沉淀候选（${fact.kind}）：${fact.text.slice(0, 60)}`);
+                    }
+                    deps.flushPendingFacts(sid, event.data);
+                }
+                if (deps.behaviorTriggersOn) {
+                    const fire = deps.evaluateToolTrigger(st.triggerCounters, {
+                        turnIndex: st.turnIndex,
+                        isTask: deps.isTaskQuery(st),
+                        diagnosing: st.interactionMode === "diagnosis",
+                        hasContract: deps.contractOf(sid) !== null,
+                        unverifiedChanges: deps.changesOf(sid).filter((item) => item.status !== "verified" && item.status !== "skipped").length,
+                        hasDesign: deps.designOf(sid).length > 0,
+                        designSignal: deps.DESIGN_SIGNAL_RE.test(st.intent?.text ?? st.userText ?? ""),
+                        hypothesesTouched: st.hypothesesTouched,
+                        blindTarget: st.agent.lastBlindTarget ?? null,
+                    }, 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 },
+                        });
+                        deps.forceNotice(st, "trigger", fire.text);
+                        deps.ctx.logger?.warn?.(`lume: [${sid}] 行为触发器 ${fire.id}（steps=${st.triggerCounters.steps}，inspect=${st.triggerCounters.inspectStreak}，mutate=${st.triggerCounters.mutateStreak}，verifyFail=${st.triggerCounters.verifyFailStreak}）`);
+                        // 死路落成项目知识：句柄取一次再收窄（可空），后台写失败留痕
+                        const store = deps.projectOf();
+                        if (fire.id === "dead-path" && signals.env && store) {
+                            const key = deps.projectKeyFor(sid, session);
+                            if (key) {
+                                const fact = deps.normalizeProjectFact({
+                                    kind: "deadend",
+                                    text: `本环境验证受阻（${st.triggerCounters.verifyFailStreak} 次连续失败，环境/依赖类）：换降级阶梯，不要重复同一命令`,
+                                }, Date.now());
+                                if (fact) {
+                                    void store
+                                        .addFact(key, fact, (candidate, existing) => existing.some((f) => f.text === candidate))
+                                        .catch((error) => deps.ctx.logger?.warn?.(`lume: [${sid}] 死路知识落盘失败`, error));
+                                }
+                            }
+                        }
+                    }
+                }
+                break;
+            }
+            case "compaction/summary": {
+                // 压缩由宿主 preset 在隔离域执行（Lume 无法接管该服务），但事件在
+                // 会话总线上可见。记录规模，供下一轮注入「摘要不是完整历史」的重锚。
+                const data = event.data;
+                const shadowedItems = Array.isArray(data?.shadowedSeqs) ? data.shadowedSeqs.length : 0;
+                const tokens = typeof data?.shadowedTokenCount === "number" ? data.shadowedTokenCount : 0;
+                st.compaction = { turnIndex: st.turnIndex, shadowedItems, tokens };
+                deps.appendLumeLog(`[${sid}] 压缩完成：替换 ${shadowedItems} 项历史（~${tokens} tokens），下一轮注入状态重锚`);
+                break;
+            }
+            case "turn/end": {
+                // 每轮把会话记忆搬出来（零 token、机械）：上下文不能当记忆载体——
+                // 它撑满时宿主压缩会失败（现场：context overflow），之后会话再也产不出事件。
+                void deps.saveSessionMemory(sid);
+                handleTurnEnd(deps, sid, st, session);
+                break;
+            }
+            default:
+                // 诊断：压缩事件是否经由 session/event 总线投递（宿主按 session
+                // 所属上下文收集监听者，隔离域里发出的日志事件可能不经过这里）。
+                if (typeof event.type === "string" && /compact/i.test(event.type)) {
+                    deps.appendLumeLog(`[${sid}] 收到未处理的压缩事件类型 ${event.type}`);
+                }
+                break;
+        }
+    };
+}
+/**
+ * 会话结束：先最后试一次项目知识补落盘（此时 session 自带 cwd），再归档反思、清运行时。
+ * 与事件处理器共用同一批依赖（sessionEventDeps）。
+ */
+export function createSessionDisposedHandler(deps) {
+    return (session) => {
+        const sid = String(session.id);
+        const st = deps.runtime.get(sid);
+        const turns = [...st.recentTurns];
+        // 会话结束前最后试一次补落盘（session 自带 cwd）；仍然落不了就如实报数，不再静默丢弃。
+        deps.flushPendingFacts(sid, session);
+        if (st.pendingFacts.length > 0)
+            deps.ctx.logger?.warn?.(`lume: [${sid}] 项目知识未落盘（无法确定工作目录）：${st.pendingFacts.length} 条`);
+        deps.runtime.delete(sid);
+        // 任务载具是会话态：任务结束即无意义，清掉避免无界增长（项目知识在另一张表，不受影响）。
+        deps.projectTask(sid, "清空会话台账", (store) => store.clearSession(sid));
+        // 反思日志：会话结束后空闲时间跑一次小模型，零用户感知 token。
+        // 历史不够长（< 4 条消息）或路由不可用时静默跳过。
+        if (deps.reflectionEnabled && turns.length < 4)
+            deps.ctx.logger?.warn?.(`lume: 反思跳过（${sid}）历史不足：${turns.length} < 4 条消息`);
+        if (deps.reflectionEnabled && turns.length >= 4) {
+            void (async () => {
+                const store = await deps.reflectionReady;
+                if (!store) {
+                    deps.ctx.logger?.warn?.(`lume: 反思跳过（${sid}）reflection 域不可用`);
+                    return;
+                }
+                if (!store)
+                    return;
+                const route = deps.resolveAuxRoute({}, deps.llmRoute.current);
+                if (!route) {
+                    deps.ctx.logger?.warn?.(`lume: 反思跳过（${sid}）无可用小模型路由`);
+                    return;
+                }
+                if (!route)
+                    return;
+                const prompt = deps.buildReflectionPrompt(turns);
+                const output = await deps.callLlm(route, prompt.system, prompt.userText, 800);
+                if (output === null)
+                    return;
+                const score = deps.parseReflectionScore(output);
+                if (!score) {
+                    deps.ctx.logger?.warn?.(`lume: 反思跳过（${sid}）评分解析失败`);
+                    return;
+                }
+                await store.log(sid, score);
+                deps.ctx.logger?.warn?.(`lume: 反思日志 ${sid} context=${score.context} planning=${score.planning} verification=${score.verification} review=${score.review} diagnosis=${score.diagnosis}「${score.note}」`);
+            })();
+        }
+    };
+}

package/lib/host/session-runtime.js

@@ -17,24 +17,37 @@ function defaultRuntime() {
         lastExtractionAt: undefined,
         lastExchange: null,
         recentTurns: [],
-        protocolCorrection: null,
+        sessionTitle: "",
+        taskMemories: null,
+        contextWindow: 0,
         lastFailureQuery: null,
         failureStreak: 0,
         interactionMode: "question",
         intent: null,
         stableDigest: null,
+        cwd: null,
+        requirementFresh: false,
+        driftWordsReported: [],
+        notices: {},
+        agent: {
+            evidence: new Map(),
+            artifactText: "",
+            inspectedTargets: new Set(),
+            seenSymbols: new Set(),
+            lastToolName: null,
+            lastToolArgs: null,
+            lastToolTarget: null,
+            autoFacts: 0,
+        },
+        pendingFacts: [],
         projectKey: null,
         toolKind: "other",
         triggerCounters: newTriggerCounters(),
-        triggerNudge: null,
         triggerFiredAt: {},
-        turnNudge: null,
         lastDriftTurn: null,
         knowledgePrompted: false,
         hypothesesTouched: false,
-        alignmentCorrection: null,
         recentUserQueries: [],
-        postTurnReview: null,
         taskPhase: "answer",
         toolCalls: 0,
         toolSuccesses: 0,

package/lib/host/thinking.js

@@ -35,6 +35,14 @@ export const THINKING_TEXT = `[任务执行协议]
 
 **P2 证据时效**：日志、历史记录、报错文本、旧结论都带时间。引用它们作为证据前先核对时间戳是否落在当前问题的时间窗口内，并确认因果关系——**历史里存在的错误不等于当前问题的原因**。日志里翻到一条报错就直接当成用户当前症状的解释，是最常见的误判。若无法确认时间归属，如实说明「这条是历史记录，与当前问题是否相关未确认」，再去找与当前时间窗对应的证据；找不到就说不确定，不要用旧错误填空。
 
+**P1 独立判断**：用户给的是需求，不是技术结论。用户说的做法要先独立评估：同意要说清为什么成立，不同意要给具体失败场景和更安全的替代。允许「有条件同意」（前提对、但要加限定），不要把用户的判断直接当成自己的结论，也不要用复述他的话代替评估。
+
+**P1 证据来源纪律**：判断「现状」以**当前代码和当前运行结果**为准；git 历史、旧日志只用于回答"何时引入/当时有没有配套脚本"这类时间问题，且要在回答里写明为什么用历史。你写下的每一处「文件:行」都应该是你**这次真的打开过**的那一段——同一符号在不同路径（新增/导入/导出/定时任务）里的处理常常不一样，不要用一条路径的代码去断定另一条路径的行为。
+
+**P0 事实优先**：答案依赖仓库事实（提交历史、文件内容、接口定义、表结构）时，**先用只读工具核实再回答**。禁止用「我不确定」「我这轮没接上上下文」「这是新会话」当答案——那不是回答，是把核实工作退回给用户。确实查不到（要账号 / 要看生产库 / 需要用户提供）才说查不到，并写明查到哪一步。
+
+**P1 提问纪律**：把决定权交回用户之前，先核实这条问题的**前提**——一次 grep/read 就能确认的，先自己确认，不要拿它当问题问用户；能按现有证据定下的，直接定下并写明默认假设（"我按 X 做，除非你反对"），不要挂在"待你定"里。每轮抛回给用户的"待确认"不超过 2 条（默认 0 条），且**不许把"我没查环境/我没登录/我猜"的推断列成待你定**。**已核实的事实不要再挂"待确认"**：你读过的代码已经能定的就定下来（写明依据）——把能定的事标成待确认，等于把工作退回给用户。用户问"方案清楚了吗"时要给清单，但清单里的每一项要么已定（写明依据），要么是真阻塞（写清你查到哪一步）。
+
 **P2 达成标准**：完成动作不等于达成目标。交付前必须回答：用户要的结果是否已经出现？用户能否实际使用？是否引入了需要用户清理的中间文件、配置、会话或其他副作用？
 
 **P2 振荡预防**：同一假设连续失败后停止重复尝试，记录失败原因并换方案。已排除的假设不再重提；不使用破坏性命令绕过问题；不把测试删掉或放宽断言来制造假成功。
@@ -59,7 +67,8 @@ export const TASK_SIGNAL_RE = /代码|编程|文件|项目|仓库|脚本|命令|
 export const REASONING_MODEL_RE = /deepseek-v[345]|reason|o[134]|gpt-5/i;
 /** 推理型模型的任务协议：省掉它天生具备的计划/分解条款，保留行为约束与事实边界。 */
 export const THINKING_REASONING_TEXT = `[任务执行协议]
-已确认当前模型具备推理能力。仍须保护用户改动，修改后立即验证；失败先归因并更换方案，不重复已排除假设；完成前复核需求、边界和数据保留。引用日志、历史记录或旧报错作为证据时先核对时间戳与因果：历史错误不等于当前问题的原因，确认不了就明说。示例、历史消息和角色记忆只作表达与相关性参考，不自动等于当前事实。人设只影响表达，不影响代码、工具调用和安全判断。`;
+已确认当前模型具备推理能力。仍须保护用户改动，修改后立即验证；失败先归因并更换方案，不重复已排除假设；完成前复核需求、边界和数据保留。引用日志、历史记录或旧报错作为证据时先核对时间戳与因果：历史错误不等于当前问题的原因，确认不了就明说。示例、历史消息和角色记忆只作表达与相关性参考，不自动等于当前事实。人设只影响表达，不影响代码、工具调用和安全判断。
+独立判断：用户给的是需求，不是技术结论——同意要说清为什么成立，不同意要给具体失败场景，允许"有条件同意"。证据来源纪律：判断现状以当前代码为准，历史只用于时间问题；写下的「文件:行」必须是你这次真的打开过的那段，同一符号在不同路径（新增/导入/导出/定时任务）的处理常常不同，不要用一条路径的代码断定另一条路径的行为。提问纪律：把决定权交回用户前先核实问题前提（一次 grep/read 能确认的先自己确认），能定的就定下并写明默认假设，"待确认"不超过 2 条，不许把"我没查环境/我猜"的推断列成待你定。`;
 /**
  * 按「是否任务型 × 是否推理模型」选择协议变体。
  * 路由未知（模型名缺失）时回退完整版，避免误判造成能力退化。