lume-dsh-plugin 0.7.4 → 0.8.0

package/lib/index.js

@@ -25,26 +25,50 @@ import { makeRpcRoute } from "./host/rpc-bridge.js";
 import { FilePersonaStore, migrateLegacyState, PersonaStore } from "./host/store.js";
 import { IdentityStore, LUME_IDENTITY_SPEC, zodLike } from "./host/identity.js";
 import { PersonaRegistry } from "./host/registry.js";
-import { buildCorrectionPrompt, buildExtractionPrompt, extractNaming, isCoolingDown, isDuplicateFact, mergeNewFacts, parseCorrectionRule, parseFacts, resolveAuxRoute, shouldCaptureCorpus, shouldConsider, shouldConsiderCorrection } from "./host/extraction.js";
+import { buildCorrectionPrompt, buildExtractionPrompt, extractNaming, isCoolingDown, isDuplicateFact, mergeNewFacts, parseCorrectionRule, parseFacts, resolveAuxRoute, shouldCaptureCorpus, shouldConsider, shouldConsiderCorrection, } from "./host/extraction.js";
 import { DistillJobRunner, DISTILL_ALGORITHM_VERSION, runDistill } from "./host/distill.js";
 import { jaccard } from "./core/retrieval.js";
 import { fnv1a32 } from "./core/sampling.js";
 import { detectLeak } from "./core/leak-detector.js";
-import { messageText } from "./core/text.js";
+import { messageText, visibleText } from "./core/text.js";
+import { formatWindows, recordReadArgs, recordResultText, unsupportedCitations } from "./core/citations.js";
 import { composeBoundary } from "./host/boundary.js";
 import { SessionRuntimeStore } from "./host/session-runtime.js";
 import { isCompactionCheckpoint } from "./host/compaction.js";
 import { LUME_REFLECTION_SPEC, ReflectionStore, buildReflectionPrompt, parseReflectionScore } from "./host/reflection.js";
 import { appendLumeLog } from "./host/diag.js";
-import { advancePhase, buildAlignmentCorrection, buildCasualDirective, buildCompactionNotice, buildInteractionDirective, buildLongSessionGuard, buildSessionAnchor, buildTaskPhaseDirective, buildToolFailureNotice, classifyInteraction, isUserAuthored, taskPhaseForMode } from "./host/protocol.js";
+import { clearNotice, forceNotice, noticeOpen, noticeText, setNotice } from "./host/notices.js";
+import { toolArgsOf, toolNameOf, toolTargetOf } from "./host/host-events.js";
+import { advancePhase, buildAlignmentCorrection, buildCasualDirective, buildCompactionNotice, buildInteractionDirective, buildLongSessionGuard, buildSessionAnchor, buildTaskPhaseDirective, buildToolFailureNotice, classifyWithTrajectory, isUserAuthored, taskPhaseForMode, } from "./host/protocol.js";
+import { DESIGN_SIGNAL_RE } from "./host/protocol.js";
 import { buildDocumentDirective, probeDocumentCapabilities } from "./host/documents.js";
 import { REASONING_MODEL_RE, TASK_SIGNAL_RE, selectStableThinkingProtocol } from "./host/thinking.js";
-import { normalizeChange, normalizeContract, normalizeHypothesis, normalizeProjectFact, projectKeyOf, renderChangeLedger, renderContract, renderHypotheses, renderProjectFacts } from "./core/ledger.js";
+import { normalizeChange, normalizeContract, normalizeHypothesis, normalizeProjectFact, projectKeyOf, renderChangeLedger, renderContract, renderHypotheses, renderProjectFacts, } from "./core/ledger.js";
+import { normalizeDesign, renderDesign, renderRequirements } from "./core/ledger.js";
 import { classifyTool, readResultSignals } from "./core/signals.js";
-import { buildContractMethodDirective, buildDocumentMethodDirective, buildImpactDirective, buildStructureHint, composeBlocks } from "./host/methods.js";
+import { auditOpenQuestions, isRealVerifyCommand, summarizeToolChange, toolArtifactText, unrequestedChangeWords, } from "./core/signals.js";
+import { recordSymbols, unsupportedClaims } from "./core/citations.js";
+import { coverageRows, danglingSectionRefs, hasFigureRefs, pickRequirementCorpus, splitRequirementItems } from "./core/coverage.js";
+/** 〔提问核对〕每会话上限（提问纪律的纠偏；比引用核对更敏感，限得更死）。 */
+const QUESTION_AUDIT_MAX = 2;
+/** 只把「文档类产物」当交付物收进覆盖核对（源码改动进去只会制造噪音）。 */
+const DOC_ARTIFACT_RE = /\.(md|markdown|txt)$/i;
+import { buildCarrierGapNotice, buildCitationDirective, buildClaimDirective, buildContractMethodDirective, buildDocumentMethodDirective, buildImpactDirective, buildQuestionAuditDirective, buildRequirementCoverageDirective, buildStructureHint, buildUnverifiedDeliveryNotice, composeBlocksDetailed, } from "./host/methods.js";
+import { buildDesignMethodDirective, buildRequirementMethodDirective, buildDriftDirective } from "./host/methods.js";
 import { LUME_PROJECT_SPEC, ProjectStore } from "./host/project.js";
-import { DEFAULT_TRIGGER_THRESHOLDS, applyToolSignal, applyVerifyOutcome, cooldownOk, evaluateToolTrigger, evaluateTurnTrigger } from "./host/triggers.js";
-/** schemastery → domainTable 形参的桥接（与 identity.ts 同款）。 */
+import { volatileBlocks } from "./host/prompt-blocks.js";
+import { initStores } from "./host/bootstrap.js";
+import { focusIdsFor } from "./host/clauses.js";
+import { createMetricsLog } from "./host/metrics-log.js";
+import { createAuxLlm } from "./host/llm-aux.js";
+import { createLlmRouteCell } from "./host/llm-route.js";
+import { createProjectAccess } from "./host/project-access.js";
+import { installPromptSections } from "./host/sections.js";
+import { registerLumeTools } from "./host/tools.js";
+import { assembleBlockDeps, assembleSessionEventDeps, assembleToolDeps, startSessionBackfill } from "./host/wiring.js";
+import { createSessionDisposedHandler, createSessionEventHandler } from "./host/session-events.js";
+import { DEFAULT_TRIGGER_THRESHOLDS, applyToolSignal, applyVerifyOutcome, cooldownOk, evaluateToolTrigger, evaluateTurnTrigger, } from "./host/triggers.js";
+/** schemastery → domainTable 形参的桥接（与 stores.identity().ts 同款）。 */
 const recordSchema = zodLike;
 /** 会话人设选择的持久层（键 = sessionId）。 */
 export const LUME_DOMAIN_SPEC = defineDomain({
@@ -146,105 +170,46 @@ function applyInner(ctx, config = {}) {
     }
     const defaultName = builtins[NONE_PERSONA] ? NONE_PERSONA : null;
     const legacyStatePath = join(assetsDir, "persona-state.json");
-    // ── 存储就绪：会话选择域（必有）+ 身份域（失败降级为无档案功能）──
-    let currentStore = null;
-    let identity = null;
-    const storesReady = (async () => {
-        try {
-            const domain = await ctx.storageDomain.open(LUME_DOMAIN_SPEC);
-            ctx.effect(() => async () => {
-                await domain.close();
-            }, "lume: close state domain");
-            const store = new PersonaStore(domain.table(SESSION_PERSONA_TABLE), { maxSessions: MAX_SESSIONS });
-            const migrated = await migrateLegacyState(store, legacyStatePath);
-            if (migrated)
-                ctx.logger?.warn?.("lume: 已从 assets/persona-state.json 迁移旧的人设记忆");
-            return store;
-        }
-        catch (error) {
-            ctx.logger?.warn?.("lume: storageDomain 不可用，降级为 assets 文件存储", error);
-            return new FilePersonaStore(legacyStatePath, { maxSessions: MAX_SESSIONS });
-        }
-    })();
-    const identityReady = (async () => {
-        try {
-            const domain = await ctx.storageDomain.open(LUME_IDENTITY_SPEC);
-            ctx.effect(() => async () => {
-                await domain.close();
-            }, "lume: close identity domain");
-            return new IdentityStore({
-                profile: domain.table("profile"),
-                memory_facts: domain.table("memory_facts"),
-                style_rules: domain.table("style_rules"),
-                corpus_pins: domain.table("corpus_pins"),
-                custom_personas: domain.table("custom_personas"),
-            });
-        }
-        catch (error) {
-            ctx.logger?.warn?.("lume: 身份域不可用，档案/记忆/自定义人设功能降级", error);
-            return null;
-        }
-    })();
-    void storesReady.then((store) => {
-        currentStore = store;
-    });
-    void identityReady.then((store) => {
-        identity = store;
+    // ── 存储与生命周期（会话/身份/反思/项目四域）── 实现见 host/bootstrap.ts
+    const stores = initStores({
+        ctx,
+        legacyStatePath,
+        maxSessions: MAX_SESSIONS,
+        projectMemoryOn: config.projectMemory ?? true,
+        migrateLegacyState,
+        personaDomainSpec: LUME_DOMAIN_SPEC,
+        sessionPersonaTable: SESSION_PERSONA_TABLE,
+        describeError,
     });
-    // ── 反思域（会话结束后打分，失败降级为无反思功能）──
-    let reflectionStore = null;
-    const reflectionReady = (async () => {
-        try {
-            const domain = await ctx.storageDomain.open(LUME_REFLECTION_SPEC);
-            ctx.effect(() => async () => { await domain.close(); }, "lume: close reflection domain");
-            const store = new ReflectionStore(domain.table("logs"));
-            const migrated = await store.migrateLegacy();
-            if (migrated > 0)
-                ctx.logger?.warn?.(`lume: 已迁移 ${migrated} 条旧版反思日志`);
-            return store;
-        }
-        catch (error) {
-            ctx.logger?.warn?.("lume: 反思域不可用，反思日志降级", error);
-            return null;
-        }
-    })();
-    void reflectionReady.then((s) => { reflectionStore = s; });
     // ── 项目域：任务契约 / 改动台账 / 假设台账 / 项目知识（失败降级为无载具功能）──
     const projectMemoryOn = config.projectMemory ?? true;
     const behaviorTriggersOn = config.behaviorTriggers ?? true;
+    /** 运行时度量开关（默认开）：关掉只是不记录，不改变任何行为。 */
+    const metricsEnabled = config.metrics !== false;
     const triggerThresholds = {
         ...DEFAULT_TRIGGER_THRESHOLDS,
         inspectStreak: config.triggerInspectStreak ?? DEFAULT_TRIGGER_THRESHOLDS.inspectStreak,
         changeStreak: config.triggerChangeStreak ?? DEFAULT_TRIGGER_THRESHOLDS.changeStreak,
         deadPathFails: config.triggerDeadPathFails ?? DEFAULT_TRIGGER_THRESHOLDS.deadPathFails,
     };
-    let project = null;
-    const projectReady = (async () => {
-        if (!projectMemoryOn)
-            return null;
-        try {
-            const domain = await ctx.storageDomain.open(LUME_PROJECT_SPEC);
-            ctx.effect(() => async () => { await domain.close(); }, "lume: close project domain");
-            return new ProjectStore({
-                contract: domain.table("contract"),
-                ledger: domain.table("ledger"),
-                hypotheses: domain.table("hypotheses"),
-                facts: domain.table("facts"),
-            });
-        }
-        catch (error) {
-            ctx.logger?.warn?.("lume: 项目域不可用，任务契约/台账/项目知识降级", error);
-            return null;
-        }
-    })();
-    void projectReady.then((s) => { project = s; });
-    const registry = new PersonaRegistry(builtins, () => identity);
-    ctx.logger?.warn?.(`lume: 已加载（builtins=${Object.keys(builtins).join(",") || "空!"}，assets=${assetsDir}）`);
+    /** 请求是不是任务型（按形态决定方法块；提示装配与事件处理共用）。 */
+    function isTaskQuery(st) {
+        return TASK_SIGNAL_RE.test(st.intent?.text ?? st.userText ?? "");
+    }
+    /**
+     * fire-and-forget 的持久化：**失败必须留痕**。
+     *
+     * 现场教训（2026-09-23）：一整批写入路径用 `void stores.projectReady.then(...)` 且没有 catch，
+     * 出问题时不报错也不入账（ledger 一直 undefined），六个功能静默失效很久才被发现。
+     */
+    const registry = new PersonaRegistry(builtins, () => stores.identity());
+    ctx.logger?.warn?.(`lume: 已加载（builtins=${Object.keys(builtins).join(",") || "空!"}，assets=${assetsDir}，能力=载具+触发器+设计pass+需求锚点）`);
     ctx.logger?.warn?.(`lume: llmRoute 初始化策略：agentDefaultModel → settings → 回退`);
     // ── 每会话运行时状态（内存，重启即弃，LRU 上限兜底）──
     const runtime = new SessionRuntimeStore();
     // ── 模型路由缓存（request/context，会话过程中由 agent-loop 更新）──
-    let llmRoute = null;
+    // 共享可变单元（不是快照）：会话事件在 request/context 里写它，读方都拿 .current
+    const llmRoute = createLlmRouteCell();
     // ── 主动解析默认模型：会话开始前蒸馏/提取也要能用 ──
     // request/context 事件只在对话路由变化时触发（delta event），静默状态下 llmRoute 恒为 null，
     // 导致蒸馏一开即报「模型路由不可用」。这里初始化即解析默认模型，后续仍被 request/context 覆盖。
@@ -258,8 +223,8 @@ function applyInner(ctx, config = {}) {
             if (agentDefaultModel) {
                 const selection = agentDefaultModel.currentSelection?.();
                 if (typeof selection?.provider === "string" && typeof selection?.model === "string") {
-                    llmRoute = { provider: selection.provider, model: selection.model };
-                    ctx.logger?.warn?.(`lume: llmRoute 从 agentDefaultModel 初始化 → ${llmRoute.provider}/${llmRoute.model}`);
+                    llmRoute.current = { provider: selection.provider, model: selection.model };
+                    ctx.logger?.warn?.(`lume: llmRoute 从 agentDefaultModel 初始化 → ${llmRoute.current.provider}/${llmRoute.current.model}`);
                     return;
                 }
             }
@@ -273,8 +238,8 @@ function applyInner(ctx, config = {}) {
             if (settings) {
                 const raw = settings.get("agent-default-model");
                 if (raw && typeof raw.provider === "string" && typeof raw.model === "string") {
-                    llmRoute = { provider: raw.provider, model: raw.model };
-                    ctx.logger?.warn?.(`lume: llmRoute 从 settings 初始化 → ${llmRoute.provider}/${llmRoute.model}`);
+                    llmRoute.current = { provider: raw.provider, model: raw.model };
+                    ctx.logger?.warn?.(`lume: llmRoute 从 settings 初始化 → ${llmRoute.current.provider}/${llmRoute.current.model}`);
                     return;
                 }
             }
@@ -284,98 +249,21 @@ function applyInner(ctx, config = {}) {
         }
         ctx.logger?.warn?.("lume: llmRoute 初始化失败 — 蒸馏/提取在对话前不可用");
     })();
-    /** 小模型单次调用（提取/蒸馏等辅助功能用）；路由由调用方解析后传入，不可用时返回 null。signal 中止时抛错。
-     * 组装时保留全部块（text + reasoning），蒸馏解析需要完整的模型输出——
-     * 推理型模型可能把 JSON 拆在 reasoning 块尾部，只取 text 会拿到半成品。
-     * 蒸馏类调用传完整控制参数：reasoningEffort=low（复述风模型常吃 4000+ token 复述指令，低推理显著缩短）、
-     * temperature=0（稳定）。模型不支持低推理时会抛 UNSUPPORTED_REASONING_EFFORT，捕获降级重试（去掉 effort 重发）。 */
-    async function callLlm(route, system, userText, maxTokens, signal) {
-        if (!route)
-            return null;
-        const llm = ctx.get("llm");
-        if (!llm)
-            return null;
-        try {
-            const messages = [
-                createUserMessage({
-                    content: [{ type: "text", text: userText }],
-                    source: { kind: "plugin", plugin: "lume" },
-                }),
-            ];
-            const assembler = new BlockAssembler();
-            try {
-                for await (const chunk of llm.stream({ provider: route.provider, model: route.model, messages, system, maxTokens, reasoningEffort: ReasoningEffortId("low"), temperature: 0, ...(signal ? { signal } : {}) })) {
-                    assembler.push(chunk);
-                }
-                // 错误经流内 finish chunk 传输（不 throw）——检查 finish.kind === "error"
-                if (assembler.finish.kind === "error") {
-                    const code = assembler.finish.failure?.code;
-                    if (code !== "UNSUPPORTED_REASONING_EFFORT")
-                        throw new Error(String(assembler.finish.failure?.message ?? "unnamed stream error"));
-                    // 不支持 effort：降级无 effort 重发
-                    const assembler2 = new BlockAssembler();
-                    for await (const chunk of llm.stream({ provider: route.provider, model: route.model, messages, system, maxTokens, temperature: 0, ...(signal ? { signal } : {}) })) {
-                        assembler2.push(chunk);
-                    }
-                    if (assembler2.finish.kind === "error") {
-                        throw new Error(String(assembler2.finish.failure?.message ?? "unnamed stream error"));
-                    }
-                    return assembler2
-                        .blocks()
-                        .map((block) => {
-                        const text = block?.text;
-                        return typeof text === "string" ? text : "";
-                    })
-                        .filter((text) => text.length > 0)
-                        .join(" ")
-                        .trim();
-                }
-            }
-            catch (error) {
-                // throw 形态的错误：非 UNSUPPORTED 直接抛；是则降级重试
-                if (error?.code !== "UNSUPPORTED_REASONING_EFFORT")
-                    throw error;
-                const assembler2 = new BlockAssembler();
-                for await (const chunk of llm.stream({ provider: route.provider, model: route.model, messages, system, maxTokens, temperature: 0, ...(signal ? { signal } : {}) })) {
-                    assembler2.push(chunk);
-                }
-                if (assembler2.finish.kind === "error") {
-                    throw new Error(String(assembler2.finish.failure?.message ?? "unnamed stream error"));
-                }
-                return assembler2
-                    .blocks()
-                    .map((block) => {
-                    const text = block?.text;
-                    return typeof text === "string" ? text : "";
-                })
-                    .filter((text) => text.length > 0)
-                    .join(" ")
-                    .trim();
-            }
-            const allBlocks = assembler
-                .blocks()
-                .map((block) => {
-                const text = block?.text;
-                return typeof text === "string" ? text : "";
-            })
-                .filter((text) => text.length > 0);
-            // 诊断探针：完整输出落盘（含 max-tokens 截断标记；追加，一次失败可看全程）
-            try {
-                const existing = readFileSync(LLM_DUMP_PATH, "utf8");
-                const dumps = existing ? JSON.parse(existing) : [];
-                dumps.push({ ts: Date.now(), route: `${route.provider}/${route.model}`, maxTokens, finish: assembler.finish, blocks: allBlocks.map((t) => t.slice(0, 6000)) });
-                writeFileSync(LLM_DUMP_PATH, JSON.stringify(dumps, null, 2), "utf8");
-            }
-            catch { /* 诊断失败不阻断 */ }
-            return allBlocks.join(" ").trim();
-        }
-        catch (error) {
-            if (signal?.aborted)
-                throw error; // 用户取消：向上抛，任务状态走 cancelled
-            ctx.logger?.warn?.("lume: 小模型调用失败，本轮跳过", error);
-            return null;
-        }
-    }
+    // ── 辅助模型调用（实现见 host/llm-aux.ts）──
+    const { callLlm } = createAuxLlm({ ctx, llmRoute: () => llmRoute.current, llmDumpPath: LLM_DUMP_PATH });
+    // ── 载具与项目知识的读取入口（实现见 host/project-access.ts）──
+    const projectAccess = createProjectAccess({
+        ctx,
+        config,
+        runtime,
+        stores,
+        projectTask: stores.projectTask,
+        normalizeProjectFact,
+        isRealVerifyCommand,
+        jaccard,
+        projectKeyOf,
+    });
+    const { projectKeyFor, commandSummary, flushPendingFacts, settleVerification, saveSessionMemory, taskMemoriesOf, contractOf, changesOf, hypothesesOf, factsOf, requirementsOf, designOf, needsDesignPass, structureToolName, } = projectAccess;
     /** 被动提取：三道门 → 小模型 → 合并落盘。按会话串行，失败静默。 */
     function scheduleExtraction(sid, st) {
         if (st.extracting) {
@@ -396,7 +284,7 @@ function applyInner(ctx, config = {}) {
         st.userText = "";
         st.assistantText = "";
         try {
-            if (!extractionEnabled || !identity)
+            if (!extractionEnabled || !stores.identity())
                 return;
             const personaName = st.lastInjected;
             if (!personaName || !userText)
@@ -405,14 +293,17 @@ function applyInner(ctx, config = {}) {
             // 一条风格约定写回 style_rules（Jaccard 相似自动替换，不堆叠）。冷却与
             // 记忆提取共用，避免同一轮双模型调用。
             if (shouldConsiderCorrection(userText) && !isCoolingDown(st.lastExtractionAt, Date.now(), cooldownMs)) {
-                const route = resolveAuxRoute(extractionRouteOverride, llmRoute);
+                const route = resolveAuxRoute(extractionRouteOverride, llmRoute.current);
                 if (route) {
-                    const prompt = buildCorrectionPrompt(userText, assistantText, identity.getStyleRules(personaName).map((r) => r.rule));
+                    const prompt = buildCorrectionPrompt(userText, assistantText, stores
+                        .identity()
+                        .getStyleRules(personaName)
+                        .map((r) => r.rule));
                     const output = await callLlm(route, prompt.system, prompt.userText, 400);
                     const rule = output === null ? null : parseCorrectionRule(output);
                     if (rule) {
                         st.lastExtractionAt = Date.now();
-                        await identity.addStyleRule(personaName, rule, (a, b) => jaccard(a, b) >= 0.6);
+                        await stores.identity().addStyleRule(personaName, rule, (a, b) => jaccard(a, b) >= 0.6);
                         ctx.logger?.warn?.(`lume: 纠偏捕获 → ${personaName}: ${rule}`);
                     }
                 }
@@ -420,7 +311,9 @@ function applyInner(ctx, config = {}) {
             // 通道 B：语料摘录——用户认可上一轮回复「像本人」时，把真实对话对
             // 摘录进 corpus_pins（注入时并入采样池，让语气随真实使用收敛）。
             if (shouldCaptureCorpus(userText) && pinCandidate && pinCandidate.assistant) {
-                const written = await identity.addCorpusPin(personaName, { user: pinCandidate.user, assistant: pinCandidate.assistant, at: Date.now() }, (a, b) => jaccard(a, b) >= 0.8);
+                const written = await stores
+                    .identity()
+                    .addCorpusPin(personaName, { user: pinCandidate.user, assistant: pinCandidate.assistant, at: Date.now() }, (a, b) => jaccard(a, b) >= 0.8);
                 if (written)
                     ctx.logger?.warn?.(`lume: 语料摘录 → ${personaName}: ${pinCandidate.assistant.slice(0, 40)}`);
             }
@@ -429,26 +322,26 @@ function applyInner(ctx, config = {}) {
                 return;
             if (isCoolingDown(st.lastExtractionAt, Date.now(), cooldownMs))
                 return;
-            const existing = identity.getMemory(personaName);
+            const existing = stores.identity().getMemory(personaName);
             if (isDuplicateFact(userText, existing))
                 return;
             const prompt = buildExtractionPrompt(userText, assistantText, existing.map((f) => f.text));
-            const output = await callLlm(resolveAuxRoute(extractionRouteOverride, llmRoute), prompt.system, prompt.userText, 800);
+            const output = await callLlm(resolveAuxRoute(extractionRouteOverride, llmRoute.current), prompt.system, prompt.userText, 800);
             if (output === null) {
                 ctx.logger?.warn?.(`lume: 反思跳过（${sid}）模型无输出`);
                 return;
             }
             st.lastExtractionAt = Date.now();
-            const fresh = mergeNewFacts(parseFacts(output), identity.getMemory(personaName));
+            const fresh = mergeNewFacts(parseFacts(output), stores.identity().getMemory(personaName));
             for (const fact of fresh) {
-                const written = await identity.addMemory(personaName, fact, (candidate, all) => isDuplicateFact(candidate, all));
+                const written = await stores.identity().addMemory(personaName, fact, (candidate, all) => isDuplicateFact(candidate, all));
                 if (written)
                     ctx.logger?.warn?.(`lume: 提取记忆 → ${personaName}: ${fact}`);
             }
             // 取名类事实同步身份档案：下拉显示档案名 + 【你是谁】段生效
             const named = extractNaming(fresh);
             if (named) {
-                await identity.setProfileName(personaName, named);
+                await stores.identity().setProfileName(personaName, named);
                 ctx.logger?.warn?.(`lume: 人设 ${personaName} 被命名为「${named}」`);
             }
         }
@@ -458,13 +351,14 @@ function applyInner(ctx, config = {}) {
     }
     /** 蒸馏任务 Runner：素材文本 → 角色卡（契约+语料）。路由可配专用档（distillProvider/Model），默认跟随主对话。 */
     const distillRunner = new DistillJobRunner({
-        route: () => resolveAuxRoute(distillRouteOverride, llmRoute),
+        route: () => resolveAuxRoute(distillRouteOverride, llmRoute.current),
         call: (route, system, userText, maxTokens, signal) => callLlm(route, system, userText, maxTokens, signal),
         logger: ctx.logger,
     });
     // 版本迁移：有本地原始素材的旧角色在后台自动重蒸馏；只替换基础契约/语料，
     // 身份名、记忆、习得风格与 corpus pins 均留在独立表中，不参与覆盖。
-    void identityReady.then(async (store) => {
+    void stores.identityReady
+        .then(async (store) => {
         if (!store)
             return;
         for (const [personaName, oldCard] of Object.entries(store.listCustomPersonas())) {
@@ -472,7 +366,7 @@ function applyInner(ctx, config = {}) {
                 continue;
             try {
                 const upgraded = await runDistill({
-                    route: () => resolveAuxRoute(distillRouteOverride, llmRoute),
+                    route: () => resolveAuxRoute(distillRouteOverride, llmRoute.current),
                     call: (route, system, userText, maxTokens, signal) => callLlm(route, system, userText, maxTokens, signal),
                     logger: ctx.logger,
                 }, { text: oldCard.distillSource, hint: oldCard.distillHint });
@@ -492,591 +386,12 @@ function applyInner(ctx, config = {}) {
                 ctx.logger?.warn?.(`lume: 角色卡 ${personaName} 后台升级失败，保留旧卡`, error);
             }
         }
-    });
+    })
+        .catch((error) => ctx.logger?.warn?.(`lume: 旧角色后台重蒸馏失败：${describeError(error)}`));
     // ── 会话事件：路由缓存 + 轮次缓冲 + 提取调度 + 清理 ──
-    ctx.effect(() => ctx.on("session/event", (session, event) => {
-        const sid = String(session.id);
-        const st = 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;
-                if (typeof data?.provider === "string" && typeof data?.model === "string") {
-                    llmRoute = { provider: data.provider, model: data.model };
-                    ctx.logger?.warn?.(`lume: request/context 更新 llmRoute → ${llmRoute.provider}/${llmRoute.model}`);
-                }
-                else {
-                    ctx.logger?.warn?.("lume: request/context 未携带 provider/model，保留 llmRoute", data);
-                }
-                break;
-            }
-            case "user/message": {
-                // 压缩检查点：宿主把被压缩的历史替换成一条摘要消息，必须与真实
-                // 用户消息区分——否则摘要会被当成「用户当前说的话」，污染协议
-                // 路由所依赖的 lastQuery 与对话缓冲。这是兜底识别：同一轮里
-                // compaction/summary 通常先到且带规模，不要把那条覆盖成无规模的。
-                if (isCompactionCheckpoint(event.data)) {
-                    if (!st.compaction || st.compaction.turnIndex !== st.turnIndex) {
-                        st.compaction = { turnIndex: st.turnIndex, shadowedItems: 0, tokens: 0 };
-                    }
-                    appendLumeLog(`[${sid}] 检测到上下文压缩检查点（第 ${st.turnIndex} 轮）`);
-                    break;
-                }
-                // 只有真实用户消息能定义本轮意图。宿主快照（@deepseek-ai/dsh-system-prompt）、
-                // 工作区指令（agent-instructions）、技能目录（skill-catalog）都经这条通道投递，
-                // 曾被当成用户发言：覆盖真实请求，并把模式从「执行」冲成「问答」。
-                if (!isUserAuthored(event.data))
-                    break;
-                const text = messageText(event.data);
-                if (text) {
-                    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;
-                    st.alignmentCorrection = explicitCorrection
-                        ? buildAlignmentCorrection("user-correction")
-                        : repeatedRequest
-                            ? buildAlignmentCorrection("repeated-request")
-                            : null;
-                    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 = messageText(event.data?.message);
-                if (text) {
-                    st.assistantText = 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 = advancePhase(st.taskPhase, "execute");
-                // 行为类别在调用阶段记账（连击），成败到结果阶段才结算。
-                st.toolKind = classifyTool(event.data?.name);
-                applyToolSignal(st.triggerCounters, st.toolKind, null);
-                // 自动改动台账：mutate 类工具一被调用就先记一条——实测模型几乎不会主动调 lume_change
-                // （4 个会话里 0 次），而 edit/write 每次会话几十次。载具必须由插件自己落账，
-                // 否则「改动台账」永远空着（这正是上一版没生效的地方）。
-                if (projectMemoryOn && st.toolKind === "mutate") {
-                    const target = targetPathFromToolEvent(event.data);
-                    if (target) {
-                        const toolName = String(event.data?.name ?? "tool");
-                        void projectReady.then((store) => store?.upsertChange(sid, { target, change: `（自动）由 ${toolName} 修改`, why: "", verify: "", status: "done", at: Date.now() }));
-                    }
-                }
-                break;
-            }
-            case "tool/result": {
-                const data = event.data;
-                const resultText = messageText(data?.message);
-                const explicitError = Boolean(data?.error) || /失败|报错|错误|exception|traceback|timed out|permission denied|unknown|not started/i.test(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 = advancePhase(st.taskPhase, unknownResult || explicitError ? "diagnose" : "verify");
-                // 行为信号 → 计数器 → 触发器提醒。提醒只在这一步之后可见（尾部快照），
-                // 且每类触发器有轮级冷却：提示一多就变噪音，模型会学会忽略。
-                const signals = readResultSignals(resultText, explicitError);
-                applyVerifyOutcome(st.triggerCounters, st.toolKind, signals);
-                if (behaviorTriggersOn) {
-                    const fire = evaluateToolTrigger(st.triggerCounters, {
-                        turnIndex: st.turnIndex,
-                        isTask: isTaskQuery(st),
-                        diagnosing: st.interactionMode === "diagnosis",
-                        hasContract: contractOf(sid) !== null,
-                        unverifiedChanges: changesOf(sid).filter((item) => item.status !== "verified" && item.status !== "skipped").length,
-                        hypothesesTouched: st.hypothesesTouched,
-                    }, triggerThresholds);
-                    if (fire && cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
-                        st.triggerFiredAt[fire.id] = st.turnIndex;
-                        st.triggerNudge = fire.text;
-                        ctx.logger?.warn?.(`lume: [${sid}] 行为触发器 ${fire.id}（steps=${st.triggerCounters.steps}，inspect=${st.triggerCounters.inspectStreak}，mutate=${st.triggerCounters.mutateStreak}，verifyFail=${st.triggerCounters.verifyFailStreak}）`);
-                        // 环境性死路自动落成项目知识：下次会话不必重踩。
-                        if (fire.id === "dead-path" && signals.env && project) {
-                            const key = projectKeyFor(sid, session);
-                            if (key)
-                                void project.addFact(key, normalizeProjectFact({ kind: "deadend", text: `本环境验证受阻（${st.triggerCounters.verifyFailStreak} 次连续失败，环境/依赖类）：换降级阶梯，不要重复同一命令` }, Date.now()), (candidate, existing) => existing.some((fact) => fact.text === candidate));
-                        }
-                    }
-                }
-                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 };
-                appendLumeLog(`[${sid}] 压缩完成：替换 ${shadowedItems} 项历史（~${tokens} tokens），下一轮注入状态重锚`);
-                break;
-            }
-            case "turn/end": {
-                st.turnIndex++;
-                // 切换窗口的消耗只发生在轮边界（渲染函数只读状态，不再就地清零）：
-                // 同一步里 prompt 会被构建多次，若在渲染里消耗窗口，第二次构建就会
-                // 丢掉接班招呼——那是「注入随构建次数漂移」，正是本版要消灭的东西。
-                st.switchGreetingPending = false;
-                if (st.switchTurn !== null && st.turnIndex - st.switchTurn >= boundaryTurns)
-                    st.switchTurn = null;
-                // ── 行为触发器（轮边界）──
-                // 连击按轮清零：新一轮是新请求，上一轮的「撒网」不该继续累加；死路连击
-                // 跨轮保留（同一环境不可用是会话级事实）。上轮的提醒到这里失效。
-                st.triggerCounters.inspectStreak = 0;
-                st.triggerCounters.mutateStreak = 0;
-                st.triggerNudge = null;
-                st.turnNudge = null;
-                st.hypothesesTouched = false;
-                if (behaviorTriggersOn && project) {
-                    const fire = evaluateTurnTrigger({
-                        turnIndex: st.turnIndex,
-                        hasContract: contractOf(sid) !== null,
-                        compactionTurn: st.compaction?.turnIndex ?? null,
-                        lastDriftTurn: st.lastDriftTurn,
-                        counters: st.triggerCounters,
-                        knowledgePrompted: st.knowledgePrompted,
-                    }, triggerThresholds);
-                    if (fire && cooldownOk(st.triggerFiredAt[fire.id], st.turnIndex)) {
-                        st.triggerFiredAt[fire.id] = st.turnIndex;
-                        if (fire.id === "criteria-drift") {
-                            // 契约对账用「交付口径」渲染原始判据：防判据随进展漂移。
-                            st.lastDriftTurn = st.turnIndex;
-                            st.turnNudge = renderContract(contractOf(sid), true);
-                        }
-                        else {
-                            st.knowledgePrompted = true;
-                            st.turnNudge = fire.text;
-                        }
-                        ctx.logger?.warn?.(`lume: [${sid}] 轮触发器 ${fire.id}（turn=${st.turnIndex}）`);
-                    }
-                }
-                // 低成本会话内纠偏：只处理明确的错误/失败信号，且要求连续轮次用户请求相同。
-                const failed = /失败|报错|错误|exception|traceback|cannot|unable|permission denied|timed out|找不到|不存在/i.test(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;
-                    st.protocolCorrection = null;
-                }
-                if (st.failureStreak >= 2)
-                    st.protocolCorrection = "检测到相同请求连续失败：先定位根因并记录已排除假设，再选择不同方案；不要重复同一调用。";
-                const claimsVerification = /验证|测试|构建|检查|确认生效|实际结果|已通过|未验证|无法验证/i.test(st.assistantText);
-                st.postTurnReview = st.interactionMode === "execute" && st.assistantText && !claimsVerification
-                    ? "〔上轮交付复核〕上一轮执行回复没有给出可见的验证证据。本轮若继续处理同一任务，先确认上轮变更是否真实生效，再继续扩大范围。"
-                    : null;
-                if (st.interactionMode === "execute")
-                    st.taskPhase = advancePhase(st.taskPhase, st.toolFailures > 0 || st.toolUnknown > 0 ? "diagnose" : claimsVerification ? "deliver" : "verify");
-                // 即时对齐只影响当前轮；下一轮重新根据用户消息判断，避免纠偏条款滞留。
-                st.alignmentCorrection = null;
-                // 风格泄漏检测挂在 turn/end（该事件已被窗口机制验证可靠；assistant/message
-                // 的投递在实测中不可靠）。切换完成后逐轮检查回复是否残留旧人设签名词，
-                // 窗口已关仍检出 → 重开窗口 + 升级播报；一轮干净回复自动解除升级。
-                if (st.prevSignatures.length > 0 && st.lastInjected !== undefined && st.assistantText) {
-                    const report = detectLeak(st.assistantText, st.prevSignatures);
-                    const inWindow = st.switchTurn !== null && st.turnIndex - st.switchTurn < boundaryTurns;
-                    if (report.leaked && !inWindow) {
-                        st.switchTurn = st.turnIndex;
-                        st.leakEscalated = true;
-                        ctx.logger?.warn?.(`lume: [${sid}] 检测到旧人设风格泄漏（${report.hits.map((h) => `${h.word}×${h.count}`).join("、")}），重新注入升级版切换播报`);
-                    }
-                    else if (!report.leaked) {
-                        st.leakEscalated = false;
-                    }
-                }
-                scheduleExtraction(sid, st);
-                break;
-            }
-            default:
-                // 诊断：压缩事件是否经由 session/event 总线投递（宿主按 session
-                // 所属上下文收集监听者，隔离域里发出的日志事件可能不经过这里）。
-                if (typeof event.type === "string" && /compact/i.test(event.type)) {
-                    appendLumeLog(`[${sid}] 收到未处理的压缩事件类型 ${event.type}`);
-                }
-                break;
-        }
-    }), "lume: session events");
-    ctx.effect(() => ctx.on("session/disposed", (session) => {
-        const sid = String(session.id);
-        const st = runtime.get(sid);
-        const turns = [...st.recentTurns];
-        runtime.delete(sid);
-        // 任务载具是会话态：任务结束即无意义，清掉避免无界增长（项目知识在另一张表，不受影响）。
-        void projectReady.then((store) => store?.clearSession(sid));
-        // 反思日志：会话结束后空闲时间跑一次小模型，零用户感知 token。
-        // 历史不够长（< 4 条消息）或路由不可用时静默跳过。
-        if (reflectionEnabled && turns.length < 4)
-            ctx.logger?.warn?.(`lume: 反思跳过（${sid}）历史不足：${turns.length} < 4 条消息`);
-        if (reflectionEnabled && turns.length >= 4) {
-            void (async () => {
-                const store = await reflectionReady;
-                if (!store) {
-                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）reflection 域不可用`);
-                    return;
-                }
-                if (!store)
-                    return;
-                const route = resolveAuxRoute({}, llmRoute);
-                if (!route) {
-                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）无可用小模型路由`);
-                    return;
-                }
-                if (!route)
-                    return;
-                const prompt = buildReflectionPrompt(turns);
-                const output = await callLlm(route, prompt.system, prompt.userText, 800);
-                if (output === null)
-                    return;
-                const score = parseReflectionScore(output);
-                if (!score) {
-                    ctx.logger?.warn?.(`lume: 反思跳过（${sid}）评分解析失败`);
-                    return;
-                }
-                await store.log(sid, score);
-                ctx.logger?.warn?.(`lume: 反思日志 ${sid} context=${score.context} planning=${score.planning} verification=${score.verification} review=${score.review} diagnosis=${score.diagnosis}「${score.note}」`);
-            })();
-        }
-    }), "lume: session disposal");
+    ctx.effect(() => ctx.on("session/event", (session, event) => sessionEventHandler(session, event)), "lume: session events");
+    ctx.effect(() => ctx.on("session/disposed", (session) => sessionDisposedHandler(session)), "lume: session disposal");
     // ── 载具与项目知识的读取入口（事件处理器 / 工具 / 注入三处共用）──
-    /** 项目键：优先取会话工作目录（跨会话共享同一仓库的知识）。 */
-    function projectKeyFor(sid, source) {
-        const st = 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 = projectKeyOf(cwd);
-        // 只有拿到真实工作目录才缓存：否则一次无 cwd 的调用会把 "unknown" 固化下来。
-        if (cwd && key)
-            st.projectKey = key;
-        return st.projectKey ?? key;
-    }
-    /** 从工具入参里取目标路径（自动改动台账用）：兼容常见字段名，取不到返回 null——宁可少记，不要记错。 */
-    function targetPathFromToolEvent(data) {
-        const args = data?.args ?? data?.input ?? data?.parameters ?? data?.arguments;
-        if (!args || typeof args !== "object")
-            return null;
-        for (const key of ["path", "file_path", "filePath", "file", "filename", "target", "notebook_path"]) {
-            const value = args[key];
-            if (typeof value === "string" && value.trim())
-                return value.trim().slice(0, 120);
-        }
-        return null;
-    }
-    function isTaskQuery(st) {
-        return TASK_SIGNAL_RE.test(st.intent?.text ?? st.userText ?? "");
-    }
-    function contractOf(sid) {
-        return project?.getContract(sid) ?? null;
-    }
-    function changesOf(sid) {
-        return project?.getChanges(sid) ?? [];
-    }
-    function hypothesesOf(sid) {
-        return project?.getHypotheses(sid) ?? [];
-    }
-    function factsOf(sid, context) {
-        const projectKey = projectKeyFor(sid, context);
-        return project && projectKey ? project.getFacts(projectKey) : [];
-    }
-    /** 环境里是否有符号级结构分析工具：有就让模型用它替代通篇 read。 */
-    function structureToolName(context) {
-        try {
-            const schemas = 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;
-        }
-    }
-    /**
-     * 任务载具块：契约 / 改动台账 / 假设台账 / 项目知识 + 方法块 + 触发器提醒。
-     *
-     * 全部落在尾部快照（易变层）——这正是「载具」现在才做得起的原因：0.6.2 之前每步
-     * 注入一份会变的状态等于每步作废整段前缀，而快照只在内容变化时才付费（实测 58 步
-     * 只产生 9 条快照）。顺序上把「此刻最该做的一件事」（触发器提醒）放在最后。
-     */
-    function carrierBlocks(sid, context, st, query, mode) {
-        if (!projectMemoryOn)
-            return [];
-        const isTask = mode !== "question" || TASK_SIGNAL_RE.test(query);
-        const contract = contractOf(sid);
-        const changes = changesOf(sid);
-        const docDirective = buildDocumentDirective({ query, capabilities: probeDocumentCapabilities(ctx.get("tools"), context?.agent) });
-        return [
-            // 契约：有就回显（交付轮切成对账口径），没有且是任务轮就先教它写一份。
-            { text: renderContract(contract, st.taskPhase === "deliver") },
-            { text: !contract && isTask ? buildContractMethodDirective() : null, droppable: true },
-            // 台账与假设：存在就回显——让模型「看见」自己的计划，而不是记在脑子里。
-            { text: changes.length > 0 ? renderChangeLedger(changes) : null },
-            { text: renderHypotheses(hypothesesOf(sid)) },
-            // 项目知识：只在与项目相关的轮次出现（闲聊不该背仓库事实）。
-            { text: isTask ? renderProjectFacts(factsOf(sid, context)) : null, droppable: true },
-            // 方法块：按任务形态出现；文档方法论只在判定为文档任务时出现。
-            { text: isTask && mode !== "question" ? buildImpactDirective() : null, droppable: true },
-            { text: docDirective ? buildDocumentMethodDirective() : null },
-            { text: mode === "execute" || mode === "diagnosis" ? buildStructureHint(structureToolName(context)) : null, droppable: true },
-            { text: st.turnNudge },
-            { text: st.triggerNudge },
-        ];
-    }
-    // ── 模型可调用工具（主写入通道）──
-    // 工具 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 } },
-    };
-    function dutyPersona(exec) {
-        const sid = exec?.agent?.session?.id;
-        const st = sid !== undefined ? runtime.get(String(sid)) : undefined;
-        return st?.lastInjected ?? defaultName;
-    }
-    ctx.effect(() => {
-        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 (!identity)
-                    throw new Error("lume identity store is unavailable");
-                const personaName = dutyPersona(exec);
-                if (!personaName)
-                    throw new Error("lume_remember requires an active persona (当前没有当值人设)");
-                await identity.addMemory(personaName, String(args.text), isDuplicateFact);
-                return { ok: true };
-            },
-        }));
-        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 (!identity)
-                    throw new Error("lume identity store is unavailable");
-                const personaName = dutyPersona(exec);
-                if (!personaName)
-                    throw new Error("lume_update_style requires an active persona (当前没有当值人设)");
-                await identity.addStyleRule(personaName, String(args.rule), (a, b) => jaccard(a, b) >= 0.6);
-                return { ok: true };
-            },
-        }));
-        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 (!identity)
-                    throw new Error("lume identity store is unavailable");
-                await identity.setCustomPersona(String(args.name), {
-                    displayName: String(args.displayName),
-                    description: String(args.description ?? ""),
-                    promptText: String(args.promptText),
-                    createdAt: Date.now(),
-                });
-                return { ok: true };
-            },
-        }));
-        // ── 任务载具工具（第二组写入通道）──
-        // 与人格工具一样是「模型主动调用、零额外 LLM 调用」，区别在写入对象：契约/台账/假设
-        // 属于当前任务（会话态），项目知识按工作目录跨会话累积。列表类参数统一用字符串
-        // 分隔（分号或换行），不引入数组 schema——省 schema token，也少一层校验风险。
-        const splitList = (value) => String(value ?? "")
-            .split(/[；;\n]/)
-            .map((item) => item.trim())
-            .filter(Boolean);
-        ctx.effect(() => {
-            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 (!project)
-                        throw new Error("lume project store is unavailable");
-                    const sid = String(exec?.agent?.session?.id ?? "");
-                    if (!sid)
-                        throw new Error("lume_contract requires an active session");
-                    const st = runtime.get(sid);
-                    const normalized = 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 existing = project.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 project.patchContract(sid, patch);
-                    }
-                    else {
-                        if (!normalized.goal)
-                            throw new Error("lume_contract requires a goal on first write");
-                        await project.setContract(sid, normalized);
-                    }
-                    return { ok: true };
-                },
-            }));
-            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 (!project)
-                        throw new Error("lume project 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 project.setChangeStatus(sid, target, allowed);
-                        if (!hit)
-                            throw new Error(`lume_change: no ledger entry for ${target}`);
-                        return { ok: true };
-                    }
-                    const item = 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 project.upsertChange(sid, item);
-                    return { ok: true };
-                },
-            }));
-            ctx.tools.register(defineTool({
-                name: "lume_hypothesis",
-                description: "假设台账：记录一条正在验证的假设及其证据与状态（open/testing/confirmed/excluded）。排查类任务里每验证一次就更新状态；已排除的假设不要再重复尝试。",
-                parameters: {
-                    text: { type: "string", required: true, description: "假设内容，一句话" },
-                    evidence: { type: "string", description: "支持或推翻它的观察（含命令输出/时间戳摘要）" },
-                    status: { type: "string", description: "open | testing | confirmed | excluded" },
-                },
-                output: { schema: OK_OUTPUT_SCHEMA, render: () => [{ type: "text", text: "已更新假设台账" }] },
-                execute: async (args, exec) => {
-                    if (!project)
-                        throw new Error("lume project store is unavailable");
-                    const sid = String(exec?.agent?.session?.id ?? "");
-                    if (!sid)
-                        throw new Error("lume_hypothesis requires an active session");
-                    const item = normalizeHypothesis({ text: args.text, evidence: args.evidence, status: args.status }, Date.now());
-                    if (!item)
-                        throw new Error("lume_hypothesis requires text");
-                    await project.upsertHypothesis(sid, item);
-                    runtime.get(sid).hypothesesTouched = true;
-                    return { ok: true };
-                },
-            }));
-            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 (!project)
-                        throw new Error("lume project store is unavailable");
-                    const sid = String(exec?.agent?.session?.id ?? "");
-                    if (!sid)
-                        throw new Error("lume_project_note requires an active session");
-                    const fact = normalizeProjectFact({ kind: args.kind, text: args.text }, Date.now());
-                    if (!fact)
-                        throw new Error("lume_project_note requires text");
-                    const projectKey = projectKeyFor(sid, { agent: exec?.agent });
-                    if (!projectKey) {
-                        // 拿不到工作目录：不写跨会话表——写一次就会把不同项目的知识串进同一个键（现场事故：facts 的键曾是 "unknown"）
-                        ctx.logger?.warn?.(`lume: [${sid}] 项目知识未落盘（无法确定工作目录）`);
-                        return { ok: true };
-                    }
-                    await project.addFact(projectKey, fact, (candidate, existing) => existing.some((entry) => jaccard(entry.text, candidate) >= 0.7));
-                    return { ok: true };
-                },
-            }));
-        }, "lume: carrier tools");
-    }, "lume: persona tools");
-    // ── 人设五段式注入 + 切换播报 ──
     /**
      * 权威意图解析：与宿主会话历史对账，而不是只信事件缓存。
      *
@@ -1085,7 +400,7 @@ function applyInner(ctx, config = {}) {
      * 读会话投影出的消息（`deriveMessages`，宿主侧带增量缓存），取最后一条真实用户
      * 消息作为本轮意图；messageId 未变时零成本短路，保证一轮内只冻结一次。
      */
-    function resolveIntent(context, st) {
+    function resolveIntent(sid, context, st) {
         const session = context?.agent?.session;
         if (typeof session?.cwd === "string" && session.cwd)
             st.cwd = session.cwd;
@@ -1110,7 +425,20 @@ function applyInner(ctx, config = {}) {
             messageId = `text:${st.userText.slice(0, 120)}`;
         }
         if (text !== null && (st.intent === null || st.intent.messageId !== messageId)) {
-            const mode = classifyInteraction(text);
+            // 路由从「这一句话的词」升到「最近几轮轨迹的证据」（0.8.x）：纠正当场按被纠正前那句话重算、
+            // 在途任务对承接式追问有粘性、任务型轨迹上不因一句没有动词的话掉回问答。
+            // 路由是唯一「判错就全盘错」的决策，所以判定结论（模式 + 命中判据 + 证据来源）一并落进度量。
+            // recentUserQueries 里**已经包含这一句**（user/message 事件先到）：轨迹证据必须把它剔掉，
+            // 否则「最近三轮有两轮任务型」会被当前句自己凑够——那是自证，不是证据。
+            const normalizedQuery = text.trim().replace(/\s+/g, " ").slice(0, 240);
+            const decision = classifyWithTrajectory({
+                text,
+                recentUserTexts: st.recentUserQueries.filter((item) => item !== normalizedQuery),
+                prevMode: st.interactionMode,
+                prevPhase: st.taskPhase,
+                hadMutations: st.triggerCounters.mutations > 0,
+            });
+            const mode = decision.mode;
             st.intent = { turnIndex: st.turnIndex, messageId, text };
             st.lastQuery = text;
             st.interactionMode = mode;
@@ -1119,18 +447,189 @@ function applyInner(ctx, config = {}) {
             st.toolSuccesses = 0;
             st.toolFailures = 0;
             st.toolUnknown = 0;
+            metricsLog.record({
+                kind: "route",
+                at: Date.now(),
+                sid,
+                turn: st.turnIndex,
+                mode: decision.mode,
+                matched: decision.matched,
+                source: decision.source,
+                excerpt: text.trim().replace(/\s+/g, " ").slice(0, 120),
+                ...(decision.evidence ? { evidence: decision.evidence.trim().replace(/\s+/g, " ").slice(0, 120) } : {}),
+            });
         }
         return { text: st.intent?.text ?? st.lastQuery ?? "", mode: st.interactionMode };
     }
+    /**
+     * 本步的注入文本，按「会话恒定 / 每步易变」分成四段。
+     *
+     * 恒定段必须在一个会话内逐字节不变——它排在消息序列最前面，变一个字就作废它
+     * 后面的全部内容（工具定义、结构化输出、**整段对话历史**）。所以恒定段只允许
+     * 依赖会话级状态：当值人设、契约正文、身份名、模型能力。任何按 query / 轮次 /
+     * 阶段变化的内容都归易变段。
+     */
+    /** 提示块装配的依赖：块表在 host/prompt-blocks.ts，这里只负责接线。 */
+    /** 会话事件处理器的依赖（处理器本体在 host/session-events.ts，这里只接线）。 */
+    /** disposed 处理器复用同一批依赖。 */
+    // ── 运行时度量（0.8.x）──
+    // 放在装配最前面：它是后面所有优化的**靶子**——没有度量，「路由改准了没有 / 条款加权有没有用」
+    // 都只能靠感觉（这正是上一轮改动没能证明自己变聪明的原因）。
+    const metricsLog = createMetricsLog({ enabled: metricsEnabled });
+    // 回读磁盘尾部：跨会话趋势（纠正率是升还是降）比单个会话更有信息量。
+    metricsLog.loadFromDisk();
+    // ── 依赖装配：三个 deps 对象集中在 host/wiring.ts（无状态函数由它自己 import）──
+    // 这里只传「index 才有的运行期状态」：ctx / 存储句柄 / 会话态 / 模型路由 / 项目访问入口 / 配置开关。
+    const wiring = {
+        ctx,
+        runtime,
+        stores: {
+            identity: () => stores.identity(),
+            project: () => stores.project(),
+            reflectionReady: stores.reflectionReady,
+        },
+        access: {
+            contractOf,
+            changesOf,
+            designOf,
+            requirementsOf,
+            hypothesesOf,
+            factsOf,
+            projectKeyFor,
+            flushPendingFacts,
+            settleVerification,
+            saveSessionMemory,
+            taskMemoriesOf,
+            needsDesignPass,
+            structureToolName,
+        },
+        projectTask: stores.projectTask,
+        llmRoute,
+        callLlm,
+        defaultName,
+        isTaskQuery,
+        scheduleExtraction,
+        triggerThresholds,
+        boundaryTurns,
+        taskSignalRe: TASK_SIGNAL_RE,
+        docArtifactRe: DOC_ARTIFACT_RE,
+        probeCaps: (context) => probeDocumentCapabilities(structureToolName(context), context),
+        reflectionFeedback: () => stores.reflectionStore()?.getFeedback() ?? null,
+        projectMemoryOn,
+        behaviorTriggersOn,
+        reflectionEnabled,
+        metrics: {
+            record: (record) => metricsLog.record(record),
+            summary: (scope) => metricsLog.summaryText(scope),
+            health: (sid) => metricsLog.health(sid),
+        },
+    };
+    // 会话补蒸馏：把最近 7 天的会话（**含已经撑满、聊不动的那些**）榨成跨会话知识。
+    // 为什么必须在这里做：上下文撑满 → 宿主压缩会失败（现场：compaction/end error=context overflow）→
+    // 会话再也产不出事件 → 期间没沉淀的知识会永久丢；但会话记录还躺在硬盘上。
+    // 分片执行（每片一个会话）以免阻塞宿主同进程的事件循环；幂等来自 addFact 的相似度去重。
+    ctx.effect(() => {
+        let stopBackfill = null;
+        void stores.projectReady
+            .then((store) => {
+            if (!store)
+                return;
+            stopBackfill = startSessionBackfill({
+                log: (message) => {
+                    // 日志同时走宿主 logger：appendLumeLog 依赖 DSH_HOME，宿主进程里可能没有 →
+                    // 补蒸馏会“跑了却没有任何日志”（现场踩过：重启后零沉淀零日志）。
+                    appendLumeLog(message);
+                    ctx.logger?.warn?.(`lume: ${message}`);
+                },
+                addFact: (key, fact) => store.addFact(key, fact, isDuplicateFact),
+            });
+        })
+            .catch((error) => ctx.logger?.warn?.(`lume: 会话补蒸馏启动失败：${describeError(error)}`));
+        return () => stopBackfill?.();
+    });
+    const sessionEventDeps = assembleSessionEventDeps(wiring);
+    const toolDeps = assembleToolDeps(wiring);
+    const blockDeps = assembleBlockDeps(wiring);
+    /**
+     * 每轮落两条度量：一条**状态快照**（效能判定的基线：契约/设计/台账/假设/计数器）
+     * 与一条**块装配**（预算压力 + 本轮加权了哪三条条款）。
+     *
+     * 同一步里提示词会被构建多次，所以状态快照按**步**去重（步键 = 轮号 + 本轮工具调用数，见下）——
+     * 否则长轮次里只有轮首那一条，效能判定就没有分辨率（真机实测：跑了十几分钟只有 3 条）。
+     * 块装配不按步去重：它记的是「这一步实际注入了什么」，逐步都要。
+     */
+    const metricsTurnSeen = new Map();
+    function recordTurnMetrics(sid, st, query, mode, composed) {
+        if (!metricsLog.enabled)
+            return;
+        const changes = changesOf(sid);
+        const unverified = changes.filter((item) => item.status !== "verified" && item.status !== "skipped").length;
+        const health = metricsLog.health(sid);
+        const state = {
+            hasContract: contractOf(sid) !== null,
+            unverifiedChanges: unverified,
+            // 纠正闭环：本模式被纠正过的次数与最后一次的轮号（与装配侧同一份数据，见 host/clauses.ts）
+            correctionModes: health.correctionsByMode,
+            lastCorrectionTurnByMode: health.lastCorrectionTurnByMode,
+        };
+        metricsLog.record({
+            kind: "blocks",
+            at: Date.now(),
+            sid,
+            turn: st.turnIndex,
+            mode,
+            kept: composed.kept,
+            dropped: composed.dropped,
+            chars: composed.chars,
+            budget: composed.budget,
+            focus: focusIdsFor(st, mode, query, state),
+        });
+        // 按**步**（而不是按轮）去重：一条长轮次里如果只记轮首快照，效能判定就没有分辨率
+        // （真机实测：一个跑了十几分钟的轮次只有 3 条记录）。步键取「轮号 + 本轮工具调用数」——
+        // 有工具动作才可能变，纯生成步骤不会灌水。
+        const stepKey = `${st.turnIndex}:${st.toolCalls}`;
+        if (metricsTurnSeen.get(sid) === stepKey)
+            return;
+        if (metricsTurnSeen.size > 400)
+            metricsTurnSeen.clear();
+        metricsTurnSeen.set(sid, stepKey);
+        metricsLog.record({
+            kind: "state",
+            at: Date.now(),
+            sid,
+            turn: st.turnIndex,
+            counters: { ...st.triggerCounters },
+            hasContract: state.hasContract,
+            designs: designOf(sid).length,
+            changes: changes.length,
+            unverified,
+            verified: changes.filter((item) => item.status === "verified").length,
+            hypotheses: hypothesesOf(sid).length,
+        });
+    }
+    const sessionDisposedHandler = createSessionDisposedHandler(sessionEventDeps);
+    const sessionEventHandler = createSessionEventHandler(sessionEventDeps);
+    /** 工具注册的依赖（工具定义本体在 host/tools.ts）。 */
+    // 工具定义本体在 host/tools.ts（调用点必须在 deps 声明之后）
+    registerLumeTools(toolDeps);
     function computeTurn(sid, context) {
         const st = runtime.get(sid);
         // 意图取自会话权威历史（resolveIntent），不再读事件缓存里的最新文本：
         // 后者会被注入消息覆盖，且首步可能还带着上一轮的值，导致模式在轮内漂移。
-        const { text: query, mode } = resolveIntent(context, st);
+        const { text: query, mode } = resolveIntent(sid, context, st);
+        // 路由自校：本会话已被用户纠正两次以上 → 顶一句带具体数字的提醒（上限 2 次防噪音）。
+        // 这是度量**回灌**到行为的那一环：只有记录没有回流，度量就只是日志。
+        const routeHealth = metricsLog.health(sid);
+        if (routeHealth.corrections >= 2 && noticeOpen(st, "metrics")) {
+            const modes = Object.entries(routeHealth.correctionsByMode)
+                .map(([name, count]) => `${name} ${count}`)
+                .join(" · ");
+            setNotice(st, "metrics", `〔路由自校〕本会话已有 ${routeHealth.corrections} 次判定被用户纠正${modes ? `（落在：${modes}）` : ""}。这一轮先复述你理解的真实请求再动手；判不准就问一句，不要按上一轮的模式惯性继续。`);
+        }
         // 协议正文按模型能力冻结（不随 query 切变体）：切变体会让系统提示词每轮改写，
         // 代价远超省下的几百 token。见 selectStableThinkingProtocol。
         const thinkingStable = selectStableThinkingProtocol({
-            isReasoningModel: typeof llmRoute?.model === "string" && REASONING_MODEL_RE.test(llmRoute.model),
+            isReasoningModel: typeof llmRoute.current?.model === "string" && REASONING_MODEL_RE.test(llmRoute.current.model),
         }).trim();
         // 易变的任务指令：路由、阶段、闲聊声明、长会话护栏、目标锚点、即时对齐、
         // 交付复核、压缩重锚、文档能力指引、失败纠偏、反思提醒——全部每步可变。
@@ -1139,24 +638,16 @@ function applyInner(ctx, config = {}) {
         // 记录工作目录：工具 exec / 会话事件里可能拿不到 cwd，项目键靠这里缓存兜住（实测项目知识曾落到 unknown）
         if (typeof context?.agent?.session?.cwd === "string" && context.agent.session.cwd)
             st.cwd = context.agent.session.cwd;
-        const thinkingRuntime = composeBlocks([
-            { text: buildInteractionDirective(mode) },
-            { text: buildTaskPhaseDirective(st.taskPhase) },
-            { text: buildCasualDirective(TASK_SIGNAL_RE.test(query)) },
-            { text: buildLongSessionGuard(st.turnIndex) },
-            { text: buildSessionAnchor(st.turnIndex, mode, query, st.recentTurns) },
-            { text: st.alignmentCorrection },
-            { text: st.postTurnReview },
-            { text: st.compaction ? buildCompactionNotice(st.compaction, st.turnIndex) : null },
-            { text: st.protocolCorrection },
-            { text: reflectionStore?.getFeedback() ?? null, droppable: true },
-            ...carrierBlocks(sid, context, st, query, mode),
-        ]);
+        // cwd 到手就补落盘暂存的项目知识（这条路径是"cwd 后到"的主要补写时机）
+        flushPendingFacts(sid, context);
+        const composed = composeBlocksDetailed(volatileBlocks(blockDeps, { sid, context, st, query, mode }));
+        recordTurnMetrics(sid, st, query, mode, composed);
+        const thinkingRuntime = composed.text;
         // 会话选择尚未就绪（启动竞态）：只出任务协议，人设段留空——与旧实现一致，
         // 也避免把「尚未选择」误记成一次人设切换。
-        if (!currentStore)
+        if (!stores.currentStore())
             return { thinkingStable, thinkingRuntime, personaStable: "", personaData: "", boundary: "" };
-        const selected = currentStore.get(sid);
+        const selected = stores.currentStore().get(sid);
         const personaName = selected ?? defaultName;
         const previous = st.lastInjected;
         if (previous !== undefined && previous !== personaName) {
@@ -1182,9 +673,9 @@ function applyInner(ctx, config = {}) {
         const personaStable = buildPersonaContractSection({ persona, profileName });
         const personaData = buildPersonaRuntimeSection({
             persona,
-            memories: personaName ? identity?.getMemory(personaName) ?? [] : [],
-            styleRules: personaName ? identity?.getStyleRules(personaName) ?? [] : [],
-            corpusPins: personaName ? identity?.getCorpusPins(personaName) ?? [] : [],
+            memories: personaName ? (stores.identity()?.getMemory(personaName) ?? []) : [],
+            styleRules: personaName ? (stores.identity()?.getStyleRules(personaName) ?? []) : [],
+            corpusPins: personaName ? (stores.identity()?.getCorpusPins(personaName) ?? []) : [],
             query,
             turnIndex: st.turnIndex,
             sessionKey: sid,
@@ -1210,9 +701,7 @@ function applyInner(ctx, config = {}) {
         if (layeredOn)
             return part === "thinking" ? turn.thinkingStable : turn.personaStable;
         const stable = part === "thinking" ? turn.thinkingStable : turn.personaStable;
-        const dynamic = part === "thinking"
-            ? turn.thinkingRuntime
-            : [turn.personaData, turn.boundary].filter(Boolean).join("\n\n");
+        const dynamic = part === "thinking" ? turn.thinkingRuntime : [turn.personaData, turn.boundary].filter(Boolean).join("\n\n");
         return [stable, dynamic].filter(Boolean).join("\n\n");
     }
     /** 易变段取文：任务指令 / 人设数据 / 切换播报三段各自成 context，由宿主按 order 归并成一条尾部快照。 */
@@ -1228,38 +717,40 @@ function applyInner(ctx, config = {}) {
             return builtins;
         },
         get store() {
-            return currentStore;
+            return stores.currentStore();
         },
         get registry() {
             return registry;
         },
         get identity() {
-            return identity;
+            return stores.identity();
         },
         get distill() {
             return distillRunner;
         },
         getProjectState(sessionId) {
             // 诊断视图：任务载具 + 项目知识（供排查"模型到底看到了什么"）。
-            if (!project)
+            if (!stores.project())
                 return null;
             const st = runtime.get(sessionId);
             return {
                 projectKey: st.projectKey,
-                contract: project.getContract(sessionId),
-                changes: project.getChanges(sessionId),
-                hypotheses: project.getHypotheses(sessionId),
-                facts: st.projectKey ? project.getFacts(st.projectKey) : [],
+                contract: stores.project().getContract(sessionId),
+                changes: stores.project().getChanges(sessionId),
+                hypotheses: stores.project().getHypotheses(sessionId),
+                facts: st.projectKey ? stores.project().getFacts(st.projectKey) : [],
+                design: stores.project() ? stores.project().getDesign(sessionId) : [],
+                requirements: stores.project() ? stores.project().getRequirements(sessionId) : [],
                 triggers: { ...st.triggerCounters, fired: st.triggerFiredAt },
             };
         },
         async clearProjectFacts(sessionId) {
-            if (!project)
+            if (!stores.project())
                 return false;
             const st = runtime.get(sessionId);
             if (!st.projectKey)
                 return false;
-            await project.clearFacts(st.projectKey);
+            await stores.project().clearFacts(st.projectKey);
             return true;
         },
     });
@@ -1267,66 +758,25 @@ function applyInner(ctx, config = {}) {
     // 挪到 apply 的最后注册：它只服务客户端菜单（人设列表/蒸馏/管理），
     // 绝不该挡住人设段、工具与易变段的注册（0.7.1 的教训：这里抛错 → 整段 apply 中断 → 界面看不到人设）。
     // 注册本身见下方 registerRpcChannel()。
-    // ── 系统提示词段落 ──
-    ctx.effect(() => ctx.systemPrompt.section({
-        name: LUME_PERSONA_SECTION,
-        order: personaOrder,
-        text: (context) => {
-            const sid = context.agent?.session?.id ?? context.agent?.id;
-            return sid ? systemSectionText(String(sid), context, "persona") : "";
-        },
-    }), "lume.persona-section()");
-    // 易变段走 runtime-context 通道：宿主把它渲染成对话尾部的一条快照消息（文案自带
-    // "supersedes earlier runtime-context snapshots"，新快照取代旧快照，不堆叠进历史），
-    // 因此它的每一次变化只花自己那几百 token，不作废前面的任何前缀。
-    // 宿主不支持该 API 时 layeredOn=false，易变段已并回 system 段（见 systemSectionText）。
-    if (layeredOn) {
-        const dynamicContexts = [
+    // ── 系统提示词段与易变段注册（三条通道的用意见 host/sections.ts）──
+    installPromptSections({
+        ctx,
+        layeredOn,
+        personaSection: LUME_PERSONA_SECTION,
+        personaOrder,
+        thinkingSection: LUME_THINKING_SECTION,
+        thinkingOrder: LUME_THINKING_ORDER,
+        contexts: [
             { name: LUME_RUNTIME_CONTEXT, order: LUME_RUNTIME_ORDER, part: "thinking" },
             { name: LUME_PERSONA_RUNTIME_CONTEXT, order: LUME_PERSONA_RUNTIME_ORDER, part: "persona" },
             { name: LUME_BOUNDARY_CONTEXT, order: LUME_BOUNDARY_ORDER, part: "boundary" },
-        ];
-        for (const entry of dynamicContexts) {
-            ctx.effect(() => ctx.systemPrompt.context({
-                name: entry.name,
-                order: entry.order,
-                text: (context) => {
-                    const sid = context.agent?.session?.id ?? context.agent?.id;
-                    return sid ? runtimeContextText(String(sid), context, entry.part) : "";
-                },
-            }), `lume.runtime-context(${entry.name})`);
-        }
-    }
-    ctx.effect(() => ctx.systemPrompt.section({
-        name: LUME_THINKING_SECTION,
-        order: LUME_THINKING_ORDER,
-        text: (context) => {
-            const sid = context.agent?.session?.id ?? context.agent?.id;
-            return sid ? systemSectionText(String(sid), context, "thinking") : "";
-        },
-    }), "lume.thinking-section()");
-    // 工具失败提示走 runtime-context 通道：宿主把它渲染成对话尾部的一条消息，
-    // 而不是拼进 system 串。system 串只要变化就会写一条新的 request/header，
-    // 既在界面上多出一行「系统提示词」，也让前缀缓存从系统提示词处整段失效。
-    // `systemPrompt.context` 是宿主较新版本才有的 API，缺失时静默跳过（旧宿主下
-    // 只是失去这条提示，不影响其余功能）。
-    ctx.effect(() => {
-        if (typeof ctx.systemPrompt?.context !== "function") {
-            ctx.logger?.warn?.("lume: 当前宿主不支持 systemPrompt.context，工具失败提示已跳过（不影响其余功能）");
-            return;
-        }
-        return ctx.systemPrompt.context({
-            name: LUME_TOOL_NOTICE_CONTEXT,
-            order: LUME_TOOL_NOTICE_ORDER,
-            text: (context) => {
-                const sid = context.agent?.session?.id ?? context.agent?.id;
-                const st = sid ? runtime.get(String(sid)) : null;
-                if (!st)
-                    return "";
-                return buildToolFailureNotice({ failures: st.toolFailures, unknown: st.toolUnknown }) ?? "";
-            },
-        });
-    }, "lume.tool-notice-context()");
+        ],
+        systemSectionText,
+        runtimeContextText,
+        toolNoticeContext: { name: LUME_TOOL_NOTICE_CONTEXT, order: LUME_TOOL_NOTICE_ORDER },
+        runtime,
+        buildToolFailureNotice,
+    });
     registerRpcChannel(ctx);
     /**
      * 注册客户端 RPC 通道（`/lume`）。放在最后 + 独立 try/catch：
@@ -1341,8 +791,7 @@ function applyInner(ctx, config = {}) {
      */
     function registerRpcChannel(scope) {
         const dispatch = async (endpoint, payload) => {
-            currentStore ??= await storesReady;
-            identity ??= await identityReady;
+            await stores.ensureReady();
             return handleEndpoint(endpoint, payload);
         };
         // 依赖组合与宿主自带 dsh-api-gateway 一致（["connection", "webServer"]）。