dsh-session-conductor 1.2.2 → 1.3.1

package/README.md

@@ -21,9 +21,10 @@
 | 压缩模型选择 | 上下文自动压缩用模型独立选择（省成本） | 设置 → 插件 → 压缩模型 |
 | 模板注入 | 方案模板 / 收尾模板：本地设备上传 / 在线网址 / DSH 目录浏览三种导入，内容可再编辑，注入系统提示词（方案/收尾各一条上下文注入） | 设置 → 会话管理 → 模板注入 |
 | 自动重命名模型 | 指定便宜/专用模型做标题分析 | 设置 → 会话管理 |
-| 成员模型切换 | 给队友/子代理单独切模型（只动该成员会话，不影响其他成员）：先用 `list_models` 拿确切模型 id，再 `set_member_model` 按成员名/sessionId 切换（写 `model/selection` 事件交给官方投影接管，跨轮持久；未挂载成员也能切，运行中会先等它暂停） | AI 工具 `list_models` / `set_member_model` |
-| 上下文用量自查 | AI 按需查自己会话的上下文占用（百分比、已用/容量 tokens）与构成（系统提示词/工具定义/对话消息），占用达 85% 时附收敛建议。数据与界面圆环同源（官方 `contextPressure` / `contextBreakdown` 投影），只读、无参数。**另：每轮把实时用量注入消息尾部**（AI 每轮都能直接看到数字；注入在尾部而非系统提示词前缀 ⇒ 前缀稳定、prompt cache 仍命中；按 turn 门控，一回合只注一次；配置 `injectContextUsage` 可关） | AI 工具 `context_usage` + 每轮注入 |
-| 跨会话消息 | AI 直接给另一个会话发消息（不经过人转达）：先 `list_sessions` 挑目标，再 `send_to_session` 投递；目标空闲时**由本体自动唤醒**它跑一个回合，运行中则排到其下一回合边界（`mode:"steer"` 改为注入当前回合）。全部走本体官方 `prompt` API（幂等 `requestId`、不自己写会话日志）。**支持 `dryRun` 预览**（报告目标状态与限流余量，不投递、不消耗配额）。`list_sessions` 支持 **`query` 子串过滤 + `limit`/`offset` 分页**（默认只给 20 条，避免整表塞进调用方上下文）。硬约束：禁自投、协作链跳数 ≥3 拒绝、同一对会话 60s 内最多 5 条 | AI 工具 `list_sessions` / `send_to_session` |
+| 成员模型切换 | 给队友/子代理单独切模型（只动该成员会话，不影响其他成员）：先用 `list_models` 拿确切模型 id，再 `set_member_model` 按成员名/sessionId 切换（写 `model/selection` 事件交给官方投影接管，跨轮持久；未挂载成员也能切，运行中会先等它暂停）。**返回值直接带「切没切成」的查证**：立刻给「最近一次实际请求的 provider/model（取自 `request/header`，请求级权威记录）+ 最近一次切换意图 + 一行判定」，并**注册查证任务（不阻塞）**——该成员下次发起请求时按 `agent/request` 事件判定，确认结果在下一次 step 注入给发起方（不轮询、不等待）；另附可复制的复核命令 `node scripts/check-member-model.mjs <sessionId>`。判定只认请求时真实使用的模型，不信注入的 `[model changed: …]` 提示 | AI 工具 `list_models` / `set_member_model` + 脚本 `scripts/check-member-model.mjs` |
+| 记忆取回 | 检测到上下文用量**明显下降**（默认 ≥10%，可配）即判定「上下文疑似丢失」——压缩、截断、实例重启后快照未加载**都算**（比只盯压缩更全）。此时自动把最近 **3 轮（可配）** 的**用户消息文本 + 该轮 AI 的第一条回应**（优先取当时的 reasoning）重新注入，让 AI 立刻恢复状态。实现要点：按 zstd 帧**流式**读日志（常量内存）、**只认真实用户消息**（排除插件自身注入，防反馈环）、同回合连发**合并成一轮**、注入总长与单条都有上限。配置项 `retrieveMemory*`（默认开）。**另提供 AI 工具 `recall_memory`**（参数 `rounds` = 取几轮，默认取配置、上限 50；参数 `session` = 目标会话：完整 id / 唯一前缀 / 标题子串，缺省或留空即取自身）让 AI 自己按需回溯，**也能取其它会话**（跨会话排查时在会话内直接看到对方上下文；命中多个候选会给出候选清单，不随便挑一个） | 每轮注入（`agent/pre-step`）+ AI 工具 `recall_memory` |
+| 上下文用量自查 | AI 按需查自己会话的上下文占用（百分比、已用/容量 tokens）与构成（系统提示词/工具定义/消息文本），占用达 85% 时附收敛建议。数据与界面圆环同源（官方 `contextPressure` / `contextBreakdown` 投影），只读、无参数。**另：每轮把实时用量注入消息尾部**（AI 每轮都能直接看到数字；注入在尾部而非系统提示词前缀 ⇒ 前缀稳定、prompt cache 仍命中；按 turn 门控，一回合只注一次；配置 `injectContextUsage` 可关） | AI 工具 `context_usage` + 每轮注入 |
+| 跨会话消息 | AI 直接给另一个会话发消息（不经过人转达）：先 `list_sessions` 挑目标，再 `send_to_session` 投递；目标空闲时**由本体自动唤醒**它跑一个回合，运行中则排到其下一回合边界（`mode:"steer"` 改为注入当前回合）。全部走本体官方 `prompt` API（幂等 `requestId`、不自己写会话日志）。**支持 `dryRun` 预览**（报告目标状态与限流余量，不投递、不消耗配额）。`list_sessions` 支持 **`query` 子串过滤 + `limit`/`offset` 分页**（默认只给 20 条，避免整表塞进调用方上下文）。**索引快路径 + 后台化**：`fromIndex=true` 直接读落盘索引（秒回、不重建，不含 live 状态与归档态），默认刷新路径先等 3 秒拿热缓存结果、超时就把**同一次在途构建**交给宿主后台 job 并立刻返回 jobId（冷缓存全量构建实测 226 秒 / 201 会话 / 1.5 GB 日志，热缓存 47 毫秒；job 注册失败会同步降级并带回原因）。硬约束：禁自投、协作链跳数 ≥3 拒绝、同一对会话 60s 内最多 5 条 | AI 工具 `list_sessions` / `send_to_session` |
 | 指定模型新建会话 | AI 新建会话并可**直接指定 provider/model**（建完即切到该模型），可选带一条初始消息让它立刻开始干活。**缺省工作目录 = 调用方会话自己的 cwd**（不落在 DSH 安装目录里）。本体 `create` 本身不带模型，所以是 `create` → `selectModel` 两步；任一步失败会如实回执（如「会话已建，但模型未设置」），不谎报成功。**支持 `dryRun` 预览**（含模型是否存在于目录的核对），不建会话 | AI 工具 `create_session` |
 
 ## 界面预览
@@ -147,7 +148,7 @@ allowBuilds:
 
 | 端点 | 方法 | 用途 |
 |---|---|---|
-| `/list` | GET | 会话列表（标题/目录/时间/状态，落盘缓存按 revision 增量） |
+| `/list` | GET | 会话列表（标题/目录/时间/状态，落盘缓存按 revision 增量）。加 `?job=1` 或请求头 `Accept: application/x-job` 改为注册宿主后台 job 并即刻返回 jobId（构建慢时不阻塞请求；宿主无 jobs 服务时返回 501，请求方回落到默认分支） |
 | `/archive` / `/restore` | POST | 归档 / 恢复会话 |
 | `/delete` | POST | 删除会话（拒绝运行中） |
 | `/undo` | POST | 撤回最后一条消息 |

package/lib/apply.js

@@ -28,8 +28,10 @@ import {
   maybeScheduleContinue, runAutoContinueSession, runAutoScan, scheduleScan, AUTO_CONTINUE_SCAN_DELAY_MS,
 } from "./features/continue/scan.js";
 import { num } from "./shared/util.js";
-import { registerContextUsageTool, createContextUsageInjector } from "./features/context-usage/index.js";
+import { registerContextUsageTool, createContextUsageInjector, readContextUsage } from "./features/context-usage/index.js";
+import { buildMemoryRecall } from "./features/memory-recall/index.js";
 import { registerSessionMessagingTools } from "./features/session-messaging/index.js";
+import { registerMemoryRecallTool } from "./features/memory-recall/index.js";
 import { registerGroupRoutes } from "./group.js";
 import { saveTemplate, saveTemplateFromUrl, saveTemplateFromPath, listTemplateDir, removeTemplate, readTemplateSync, readCompletionConventionSync, collectTemplateSlotText, planGateAllows, planEnforceDenyMessage, TEMPLATE_DEFAULTS, TEMPLATE_SLOTS, TEMPLATE_MAX_BYTES, PLAN_ENFORCE_EDIT_TOOLS, PLAN_ENFORCE_BASH_WRITE_RE } from "./template-inject.js";
 import { name } from "./shared/constants.js";
@@ -51,7 +53,8 @@ import { SEARCH_MIN_QUERY, searchSessions } from './features/search.js';
 // 成员模型：本文件用到 findTargetAgent / switchAgentModel / getMemberModelOverride /
 //   applyModelOverride / validateModelPair（拆出 apply.js 时漏了这一行 import，
 //   运行到相关代码路径会 ReferenceError: getMemberModelOverride is not defined）
-import { findTargetAgent, switchAgentModel, getMemberModelOverride, applyModelOverride, validateModelPair } from './features/member-model/index.js';
+import { findTargetAgent, switchAgentModel, getMemberModelOverride, applyModelOverride, validateModelPair,
+  registerSwitchWatch, noteRequestModel, takeSwitchOutcomes, readLastRequestModel } from './features/member-model/index.js';
 // 会话操作的路由注册已抽到独立模块（handler 实现见该模块；此处只留注册入口）
 import { registerSessionOpsRoutes } from './features/session-ops-routes.js';
 import { installProcessGuards } from './guards.js';
@@ -268,6 +271,33 @@ export async function apply(ctx, config = {}) {
         try {
           // 非 GET 请求会改动会话列表内容，先失效列表缓存，使面板随后的 refresh 立刻看到最新（而非 5s TTL 内的旧列表）。
           if (req.method !== "GET") invalidateSessionListCache();
+          // job 模式（`?job=1` 或 `Accept: application/x-job`）：冷缓存下全量构建很慢
+          //   （本机实测 201 份日志 / 1.5 GB 时 226 秒），把构建交给宿主后台 job 并**立即**返回 jobId，
+          //   调用方改用 job_output / job_list 取结果，前台不再被钉住。
+          //   默认（无 job 声明）仍走下面的普通 JSON / NDJSON 流式分支 —— 一字不动，避免改坏面板。
+          const wantJob = /application\/x-job/i.test(req.headers?.accept ?? "")
+            || String(req.url ?? "").includes("job=1");
+          if (wantJob) {
+            const jobs = ctx?.get?.("jobs");
+            if (!jobs || typeof jobs.start !== "function") {
+              send(res, 501, { ok: false, error: { code: "unsupported", message: "宿主未挂载 jobs 服务，无法注册后台 job；请改用默认（流式/JSON）路径" } });
+              return;
+            }
+            // 构建只做一次；完成后顺手失效 TTL，保证随后任何一条路径读到的都是本次结果
+            const done = buildSessionListCached(ctx).then(
+              (sessions) => { invalidateSessionListCache(); return { status: "completed", output: JSON.stringify({ ok: true, sessions }) }; },
+              (error) => ({ status: "failed", detail: String(error?.message ?? error) }),
+            );
+            const spec = { kind: "session-conductor-list", label: "list（会话列表刷新）", run: () => ({ cancel: () => {}, done }) };
+            // HTTP 入口没有执行主体 ⇒ 用「无主」注册（宿主存在全局 job 控制器即可）；
+            // 无主不可用时如实回 501，由调用方决定是否改用默认路径（不静默吞掉）。
+            try {
+              send(res, 200, { ok: true, async: true, jobId: jobs.start(spec), hint: "用宿主 job_output / job_list 取结果" });
+            } catch (error) {
+              send(res, 501, { ok: false, error: { code: "unsupported", message: `注册后台 job 失败：${String(error?.message ?? error)}` } });
+            }
+            return;
+          }
           // list 流式（仅当请求声明 Accept: application/x-ndjson）——live 会话先快速
           // 写出，冷会话串行逐个解析边写边出，前端 fetch stream 逐行追加（每获取一个立即显示，
           // 不等全部）；排序由前端按 updatedAt 倒序插入保持（流式下后端不再整体排序）。
@@ -1237,7 +1267,15 @@ export async function apply(ctx, config = {}) {
     ctx.on("agent/request", async ({ agent }, next) => {
       const resolved = await next();
       const override = await getMemberModelOverride(ctx, agent?.session?.id);
-      return applyModelOverride(resolved, override);
+      const applied = applyModelOverride(resolved, override);
+      // 切换查证（事件驱动）：记录本次请求**真实使用**的 provider/model；若该会话有待查证项，
+      // 就在这里按事件判定结果并入队（切换本身不阻塞、不轮询 —— 只等事件到）。
+      try {
+        noteRequestModel(agent?.session?.id, applied);
+      } catch (error) {
+        log(ctx, `切换查证记录失败（不影响本次请求）: ${String(error?.message ?? error)}`);
+      }
+      return applied;
     });
     // createUserMessage 来自宿主包：动态导入 + 守卫。
     //   为什么必须判类型：工作区自测环境没有 @deepseek-ai/* 依赖，直接引用标识符会抛
@@ -1287,18 +1325,56 @@ export async function apply(ctx, config = {}) {
     //     多条重复的用量行（噪音 + 白烧 token）。
     //   · 默认开启（core/config.js 的 injectContextUsage）；关掉即退化为「按需调用 context_usage 工具」。
     //   · 读不到投影/服务未挂载时注入器返回空串 ⇒ 静默跳过，绝不影响正常回合。
-    const usageInjector = createContextUsageInjector({ enabled: cfg?.injectContextUsage !== false });
+    // 三个开关任一开启就需要本 hook（用量注入 / 记忆取回 / 切换查证回报）；turn 门控保证一回合只注入一次。
+    // 固定 enabled=true：切换查证的结果是一句话回报，不能因为前两个功能关了就不送。
+    const usageInjector = createContextUsageInjector({ enabled: true });
     ctx.on("agent/pre-step", async ({ agent, turn, signal }, next) => {
       const decision = await next();
       if (decision?.kind === "reject" || signal?.aborted) return decision;
       // 与模板注入同款守卫：工作区自测环境没有 @deepseek-ai/* 依赖，createUserMessage 会是 null
       if (typeof createUserMessage !== "function") return decision;
       if (!usageInjector.shouldInject(agent, turn)) return decision;
-      const usageText = usageInjector.textFor(ctx, agent);
-      if (!usageText) return decision;
+      const usageText = cfg?.injectContextUsage === false ? "" : usageInjector.textFor(ctx, agent);
+      // 记忆取回：本回合用量比上次明显下降 ⇒ 判定上下文疑似丢失，取回最近几轮消息文本 + AI 首条回应。
+      // 与用量注入**合并成同一条消息**（一回合只注入一条，避免叠加）；阈值/轮数/上限见 cfg。
+      let recallText = null;
+      if (cfg?.retrieveMemory !== false) {
+        try {
+          const snapshot = readContextUsage(ctx, agent);
+          recallText = await buildMemoryRecall(ctx, {
+            sessionKey: agent,
+            sessionId: agent?.session?.id,
+            current: snapshot?.ok ? snapshot.occupancy : null,
+            opts: {
+              rounds: cfg?.retrieveMemoryRounds,
+              minDropRatio: cfg?.retrieveMemoryMinDropRatio,
+              minDropTokens: cfg?.retrieveMemoryMinDropTokens,
+              maxTotalChars: cfg?.retrieveMemoryMaxChars,
+              maxCharsPerItem: cfg?.retrieveMemoryMaxCharsPerItem,
+            },
+          });
+        } catch (error) {
+          log(ctx, `记忆取回失败（跳过本次）: ${String(error?.message ?? error)}`);
+        }
+      }
+      // 切换查证回报：切换发起方在**下一次 step** 收到一行结果（切换本身注册 job 后立刻返回，
+      // 判定由 agent/request 事件触发 —— 这里只负责把结果送到对的人手上）。
+      let switchNote = "";
+      try {
+        const outcomes = takeSwitchOutcomes(agent?.session?.id);
+        if (outcomes.length > 0) {
+          switchNote = outcomes.map((o) => (o.ok
+            ? `【切换查证】✅ 已确认生效：本次请求实际使用 ${o.actual}`
+            : `【切换查证】❌ 未生效：期望 ${o.expected}，本次请求实际使用 ${o.actual}`)).join("\n");
+        }
+      } catch (error) {
+        log(ctx, `切换查证回报失败（跳过本次）: ${String(error?.message ?? error)}`);
+      }
+      const text = [usageText, recallText, switchNote].filter(Boolean).join("\n\n");
+      if (!text) return decision;
       try {
         const injected = createUserMessage({
-          content: [{ type: "text", text: usageText }],
+          content: [{ type: "text", text }],
           source: { kind: "plugin:dsh-session-conductor", plugin: "dsh-session-conductor", form: "instructions" },
         });
         return { ...decision, messages: [...(decision.messages || []), injected] };
@@ -1365,7 +1441,7 @@ export async function apply(ctx, config = {}) {
           return [{ type: "text", text: String(value) }];
         }
       },
-      async execute(args) {
+      async execute(args, exec) {
         const provider = String(args?.provider ?? "").trim();
         const model = String(args?.model ?? "").trim();
         if (!provider || !model) return "切换失败：provider 和 model 都必填（先用 list_models 查确切值）";
@@ -1377,7 +1453,42 @@ export async function apply(ctx, config = {}) {
         const switchResult = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent);
         if (switchResult.error) return `切换失败：${switchResult.error}`;
         const memberLabel = found.member?.name ? `${found.member.name}(${found.sessionId})` : found.sessionId;
-        return `已把成员 ${memberLabel}（${found.matched} 匹配）切到 ${provider}/${model}；生效方式：${switchResult.via}`;
+        // 查证（注册 job，不阻塞）：登记待查证项 → 该成员下次发起请求时由 agent/request 事件判定
+        // → 结果注入回本次调用方。同时立刻附一份快照：最近一次实际请求 + 最近一次切换意图。
+        // 判定只认「请求时真实使用的模型」（request/header），不信注入的提示语。
+        try {
+          registerSwitchWatch(found.sessionId, provider, model, exec?.agent?.session?.id ?? null);
+        } catch (error) {
+          log(ctx, `切换查证登记失败（不影响本次切换）: ${String(error?.message ?? error)}`);
+        }
+        let snap = "";
+        let verdict = "";
+        try {
+          const { lastRequest, lastSelection } = await readLastRequestModel(found.sessionId);
+          if (lastRequest) {
+            snap = `【查证·最近一次实际请求】${lastRequest.provider}/${lastRequest.model}`
+              + (lastRequest.time ? `（${new Date(lastRequest.time).toLocaleString("zh-CN")}）` : "");
+            verdict = (lastRequest.provider === provider && lastRequest.model === model)
+              ? "【查证·判定】✅ 该成员最近的请求已经是新模型"
+              : "【查证·判定】⏳ 待下一回合生效：最近一次请求是切换前发出的（属正常，不代表失败）";
+          } else {
+            snap = "【查证·最近一次实际请求】会话日志里还没有 request/header 记录（该成员可能从未运行过）";
+            verdict = "【查证·判定】⏳ 待该成员首次运行后生效";
+          }
+          if (lastSelection) snap += `\n【查证·最近一次切换意图】${lastSelection.provider}/${lastSelection.model}`;
+        } catch (error) {
+          snap = `【查证·快照】读取会话日志失败：${String(error?.message ?? error)}`;
+        }
+        // 复核命令按**当前插件安装位置**生成（不写死本机路径），可直接复制执行
+        const scriptUrl = new URL("../scripts/check-member-model.mjs", import.meta.url);
+        const cmd = `node ${decodeURIComponent(scriptUrl.pathname)} ${found.sessionId}`;
+        return [
+          `已把成员 ${memberLabel}（${found.matched} 匹配）切到 ${provider}/${model}；生效方式：${switchResult.via}`,
+          snap,
+          verdict,
+          "【查证·任务】已登记（不阻塞）：该成员下次发起请求时按事件判定，结果会在下一次 step 注入给你",
+          `复核命令（可直接复制）：\n${cmd}`,
+        ].filter(Boolean).join("\n");
       }
     }));
     // 上下文用量自查工具：让 AI 自己按需查占用与构成，而不是每轮把数值注入系统提示词
@@ -1394,6 +1505,14 @@ export async function apply(ctx, config = {}) {
     } catch (error) {
       log(ctx, `跨会话工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
     }
+    try {
+      // 记忆取回的手动通道：让 AI 自己按需回溯（自动注入之外的补充）
+      if (registerMemoryRecallTool(ctx, defineTool, tools)) {
+        log(ctx, "记忆取回工具已注册 (recall_memory)");
+      }
+    } catch (error) {
+      log(ctx, `记忆取回工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
+    }
     log(ctx, "成员模型工具已注册 (list_models / set_member_model)");
   });
 }

package/lib/core/config.js

@@ -24,6 +24,13 @@ export const DEFAULTS = {
   turnTimeoutMs: 20 * 60 * 1000, // 单回合续跑最长等待，超时取消
   scanIntervalMs: 5 * 60 * 1000, // 周期扫描间隔
   injectContextUsage: true, // 每轮把上下文用量注入消息尾部（默认开；关掉则只有 context_usage 工具按需查）
+  // ── 记忆取回（memory-recall）：检测到上下文疑似丢失时，把最近几轮的用户消息文本 + AI 首条回应重新注入 ──
+  retrieveMemory: true, // 总开关（默认开）
+  retrieveMemoryRounds: 3, // 取回最近几轮
+  retrieveMemoryMinDropRatio: 0.10, // 触发阈值：已用量下降比例（0.10 = 10%）
+  retrieveMemoryMinDropTokens: 0, // 触发阈值：下降绝对量（0 = 不限；两者满足其一即触发）
+  retrieveMemoryMaxChars: 4000, // 注入总长上限（字符）
+  retrieveMemoryMaxCharsPerItem: 800, // 单条（用户消息文本 / AI 首条回应）上限（字符）
 };
 
 /** 运行期配置（面板/测试可改）。外部只读引用；改整体请用 setConfig。 */

package/lib/features/member-model/index.js

@@ -11,4 +11,9 @@
 export { pickTeamCaller, memberStatusError, validateModelPair, findTargetAgent } from "./locate.js";
 export { getMemberModelOverride, setMemberModelOverride, applyModelOverride, resetMemberModelCacheForTest } from "./override.js";
 export { waitForIdle, appendSelectionEventToLog, switchAgentModel } from "./switch.js";
+// 切换查证（事件驱动，注册 job 不阻塞）：登记待查证项 → 每次请求记录实际模型 → 按事件判定 → 结果回报
+export {
+  registerSwitchWatch, peekSwitchWatch, noteRequestModel, takeSwitchOutcomes,
+  peekLastRequestModel, readLastRequestModel, resetSwitchWatchForTest,
+} from "./switch.js";
 export { resumeSetupFor } from "./setup.js";

package/lib/features/member-model/override.js

@@ -3,7 +3,15 @@
 // 【职责】保存「这个会话要用哪个模型」的 override：domain 持久化 + 内存 Map 镜像，
 // 供 agent/request hook 每轮读取（避免每轮请求都 await 存储）。
 
-import { pluginDomain } from "../../core/domain.js";
+// 【为什么懒加载】core/domain.js 静态依赖宿主包 @deepseek-ai/dsh-storage-domain；
+// 工作区单测没有宿主依赖，静态 import 会让**整个本域**在导入时就 ERR_MODULE_NOT_FOUND
+// （实测：查证单测只想要纯逻辑，却被这条链挡住）。改成首次真正读写 domain 时才解析。
+let domainModPromise = null;
+async function loadPluginDomain(ctx) {
+  if (!domainModPromise) domainModPromise = import("../../core/domain.js");
+  const mod = await domainModPromise;
+  return mod.pluginDomain(ctx);
+}
 
 /**
  * 成员模型切换 override（sessionId → {provider, model}）。
@@ -31,7 +39,7 @@ export async function getMemberModelOverride(ctx, sessionId) {
   if (!sessionId) return null;
   if (!memberModelCacheLoaded) {
     try {
-      const domain = await pluginDomain(ctx);
+      const domain = await loadPluginDomain(ctx);
       const overrides = domain.global.get()?.memberModelOverrides ?? {};
       for (const [id, sel] of Object.entries(overrides)) {
         if (sel && typeof sel.provider === "string" && typeof sel.model === "string") {
@@ -48,7 +56,7 @@ export async function getMemberModelOverride(ctx, sessionId) {
 
 /** 写入一条 override（同时更新 domain 与内存镜像）。 */
 export async function setMemberModelOverride(ctx, sessionId, provider, model) {
-  const domain = await pluginDomain(ctx);
+  const domain = await loadPluginDomain(ctx);
   const state = domain.global.get() ?? {};
   const overrides = { ...(state.memberModelOverrides ?? {}), [sessionId]: { provider, model } };
   await domain.global.set({ ...state, memberModelOverrides: overrides });

package/lib/features/member-model/switch.js

@@ -74,7 +74,7 @@ export async function appendSelectionEventToLog(ctx, sessionId, provider, model)
   }
   const last = foldLastModelSelection(events);
   if (last && last.provider === provider && last.model === model) {
-    return { ok: true, note: "会话里已是该模型，无需重复写入" };
+    return { ok: true, note: "日志里已是该模型，无需重复写入" };
   }
   let maxSeq = -1;
   for (const e of events) if (typeof e?.seq === "number" && e.seq > maxSeq) maxSeq = e.seq;
@@ -184,3 +184,117 @@ export async function switchAgentModel(ctx, sessionId, provider, model, agent =
   }
   return { via };
 }
+
+// ── 切换查证：按「事件」判定是否真的换成了新模型（注册 job，不轮询、不阻塞）──────────
+//
+// 【为什么按事件而不是等待】切换「下一回合才生效」，等待就等于阻塞调用方；而插件本来就拦着
+// `agent/request`（每轮改写模型那处）—— 那里拿到的 provider/model 就是**本次请求真实使用**的值，
+// 即「请求级权威记录」。于是：切换时登记一条待查证项，下次请求到达时按事件判定，结果入队回报。
+//
+// 【为什么不信提示语】上下文里注入的 `[model changed: …]` 与 `model/selection` 事件都只表达「意图」，
+// 实测出现过「提示是 agnes、请求头仍是 wb」的不一致 —— 判定只认请求时实际使用的值。
+const switchWatches = new Map(); // sessionId(目标) → { provider, model, at, requesterSessionId }
+const lastRequestModels = new Map(); // sessionId → { provider, model, at }（进程内最近一次请求）
+const pendingOutcomes = new Map(); // sessionId(回报对象) → [ { ok, provider, model, actual, at } ]
+
+/** 登记一条待查证项（切换时调用）。requesterSessionId = 切换发起方，结果回报给它。 */
+export function registerSwitchWatch(sessionId, provider, model, requesterSessionId = null) {
+  if (!sessionId) return false;
+  switchWatches.set(sessionId, { provider, model, at: Date.now(), requesterSessionId });
+  return true;
+}
+
+/** 查看待查证项（诊断用；无则 null）。 */
+export function peekSwitchWatch(sessionId) {
+  return switchWatches.get(sessionId) ?? null;
+}
+
+/** 记录本次请求实际使用的模型，并在有待查证项时按事件判定结果。 */
+export function noteRequestModel(sessionId, config) {
+  const provider = config?.provider;
+  const model = config?.model;
+  if (!sessionId || !provider || !model) return null;
+  const at = Date.now();
+  lastRequestModels.set(sessionId, { provider, model, at });
+  const watch = switchWatches.get(sessionId);
+  if (!watch) return null;
+  const ok = provider === watch.provider && model === watch.model;
+  const outcome = { ok, expected: `${watch.provider}/${watch.model}`, actual: `${provider}/${model}`, at };
+  switchWatches.delete(sessionId);
+  const to = watch.requesterSessionId;
+  if (to) {
+    const list = pendingOutcomes.get(to) ?? [];
+    list.push(outcome);
+    pendingOutcomes.set(to, list);
+  }
+  return outcome;
+}
+
+/** 取走某会话待回报的查证结果（回报方调用一次即清空）。 */
+export function takeSwitchOutcomes(sessionId) {
+  if (!sessionId) return [];
+  const list = pendingOutcomes.get(sessionId) ?? [];
+  pendingOutcomes.delete(sessionId);
+  return list;
+}
+
+/** 进程内最近一次请求使用的模型（无则 null；跨进程看 readLastRequestModel）。 */
+export function peekLastRequestModel(sessionId) {
+  return sessionId ? lastRequestModels.get(sessionId) ?? null : null;
+}
+
+/** 测试钩子：清空查证状态。 */
+export function resetSwitchWatchForTest() {
+  switchWatches.clear();
+  lastRequestModels.clear();
+  pendingOutcomes.clear();
+}
+
+/**
+ * 读会话日志里「最近一次实际请求使用的模型」与「最近一次切换意图」。
+ *
+ * 数据来源（按可靠性排序）：
+ *   · `request/header` 的 `data.header.config.{provider,model}` —— **请求级权威记录**（判定只看它）；
+ *   · `model/selection` 的 `data.{provider,model}` —— 切换意图（有则一并返回，便于对照）。
+ * 用按 zstd 帧流式读（常量内存），大日志也不会把整份文本读进内存。
+ *
+ * @returns {Promise<{lastRequest: {provider,model,time}|null, lastSelection: {provider,model,time}|null, scanned: number}>}
+ */
+export async function readLastRequestModel(sessionId, root = null) {
+  const { sessionsRootOf, findSessionLogById } = await import("../../sessions/events.js");
+  const file = findSessionLogById(sessionId, root ?? sessionsRootOf());
+  if (!file) return { lastRequest: null, lastSelection: null, scanned: 0 };
+  const { streamDecodedFrames } = await import("../../zstd-frames.js");
+  const { StringDecoder } = await import("node:string_decoder");
+  const buf = readFileSync(file);
+  const decoder = new StringDecoder("utf8");
+  let pending = "";
+  let scanned = 0;
+  let lastRequest = null;
+  let lastSelection = null;
+  const consume = (line) => {
+    if (!line) return;
+    let event;
+    try { event = JSON.parse(line); } catch { return; }
+    if (event?.type === "request/header") {
+      const cfg = event?.data?.header?.config;
+      if (cfg?.provider && cfg?.model) { lastRequest = { provider: cfg.provider, model: cfg.model, time: event.time ?? null }; scanned += 1; }
+      return;
+    }
+    if (event?.type === "model/selection" && event?.data?.provider) {
+      lastSelection = { provider: event.data.provider, model: event.data.model, time: event.time ?? null };
+    }
+  };
+  await streamDecodedFrames(buf, (chunk) => {
+    pending += decoder.write(chunk);
+    let idx;
+    while ((idx = pending.indexOf("\n")) >= 0) {
+      const line = pending.slice(0, idx);
+      pending = pending.slice(idx + 1);
+      consume(line);
+    }
+  });
+  pending += decoder.end();
+  consume(pending);
+  return { lastRequest, lastSelection, scanned };
+}

package/lib/features/memory-recall/index.js

@@ -0,0 +1,349 @@
+// dsh-session-conductor — 记忆取回（memory-recall）
+//
+// 【解决什么】DSH 上下文被压缩、或重启后快照尚未加载时，AI 会「失忆」：重复提问、
+// 重复劳动、误解需求。而用户消息文本在上下文里占比极小（1M 上下文里可能总共没超过 3 句），
+// 却恰恰是最不该丢的部分 —— 本模块把这些消息文本（连同 AI 当时的首个回应）重新注入。
+//
+// 【怎么判「失忆」】每回合比较上下文已用量：本次比上次**明显下降**（默认 ≥10%，可配）即判定。
+//   为什么不直接监测压缩：用量下降能覆盖所有「失去上下文」的形态 —— 压缩只是最常见一种；
+//   例如实例重启后快照未加载时用量会掉到 0，那同样该按失忆处理。
+//
+// 【取什么】最近 N 轮（默认 3）的**用户消息文本** + 该轮 **AI 的第一条回应**（优先 reasoning）。
+//   · 以用户消息为锚：消息文本占比小但信息密度最高，是恢复上下文的支点；
+//   · 要 AI 的第一条回应：那是「当时」对消息文本的理解，直接给出结论，省得 AI 重新推测。
+//   具体读取（按 zstd 帧流式、常量内存）在 sessions/events.js 的 readRecentUserTurns。
+//
+// 【怎么注入】走 apply.js 的 agent/pre-step + 官方 createUserMessage（logged 通道），
+//   放在消息**尾部**（前缀保持稳定 ⇒ prompt cache 仍命中），与每轮用量注入**合并成一条**。
+//
+// 【失败即静默】日志缺失/损坏、用量读不到、首回合无上次用量 —— 一律返回 null，绝不阻断回合。
+import { readRecentUserTurns } from "../../sessions/events.js";
+import { log } from "../../shared/log.js";
+import { cfg } from "../../core/config.js";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+// ── 用量记忆的**持久化**（解决「重启后不触发」）──────────────────────────────
+// 只用内存 WeakMap 时实例一重启就清空 ⇒ 首个回合没有「上次用量」可比 ⇒
+// 而重启后用量恰好是 0（快照未加载）—— **最该触发的场景反而永不触发**。
+// 因此把每个会话的上次用量落盘（节流写），重启后读回来继续比较。
+const STATE_SUB = ["storages", "dsh-session-conductor"];
+const STATE_FILE = "recall-state.json";
+const STATE_WRITE_THROTTLE_MS = 30_000;
+let diskState = null; // { [sessionId]: { usedTokens, at } }
+let diskLoaded = false;
+let lastWriteAt = 0;
+let statePathOverride = null; // 测试注入：显式指定状态文件路径（不依赖 DSH_HOME 环境变量）
+
+/** 测试钩子：显式指定状态文件路径（传 null 恢复默认）。 */
+export function setStatePathForTest(path) {
+  statePathOverride = path ?? null;
+}
+
+/** 状态文件路径（随 DSH_HOME 走，不写死本机路径；拿不到 HOME 时返回空串 = 不落盘）。 */
+function stateFilePath() {
+  if (statePathOverride) return statePathOverride;
+  const home = process.env.DSH_HOME || (process.env.HOME ? join(process.env.HOME, ".dsh") : "");
+  return home ? join(home, ...STATE_SUB, STATE_FILE) : "";
+}
+
+/** 读落盘状态（进程内只读一次；任何异常都退化成空表，绝不向上抛）。 */
+function loadDiskState() {
+  if (diskLoaded) return diskState;
+  diskLoaded = true;
+  diskState = {};
+  const file = stateFilePath();
+  if (!file) return diskState;
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) diskState = parsed;
+  } catch {
+    // 首次运行 / 文件损坏：按空表继续
+  }
+  return diskState;
+}
+
+/** 节流落盘（每 STATE_WRITE_THROTTLE_MS 至多一次；失败只留痕，不影响回合）。 */
+function saveDiskStateThrottled(ctx) {
+  const now = Date.now();
+  if (now - lastWriteAt < STATE_WRITE_THROTTLE_MS) return;
+  lastWriteAt = now;
+  const file = stateFilePath();
+  if (!file) return;
+  try {
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(`${file}.tmp`, JSON.stringify(diskState), "utf8");
+    renameSync(`${file}.tmp`, file);
+  } catch (error) {
+    log(ctx, `记忆取回：用量状态落盘失败（不影响功能）: ${String(error?.message ?? error)}`);
+  }
+}
+
+/** 测试钩子：重置落盘状态缓存（配合把 DSH_HOME 指向临时目录用）。 */
+export function resetDiskStateForTest() {
+  diskState = null;
+  diskLoaded = false;
+  lastWriteAt = 0;
+}
+
+/** 每会话上一次的用量。WeakMap：键（会话/agent 对象）被回收即自动释放，不会泄漏。 */
+let lastUsageBySession = new WeakMap();
+
+/** 读取某会话上一次记录的用量（测试与诊断用）。 */
+export function takeLastUsage(key) {
+  return key ? lastUsageBySession.get(key) ?? null : null;
+}
+
+/** 记录本次用量（供下一回合比较）。 */
+export function noteUsage(key, usage) {
+  if (key && usage) lastUsageBySession.set(key, usage);
+}
+
+/** 测试钩子：清空用量记忆（WeakMap 无法逐项清，直接换新实例）。 */
+export function resetRecallStateForTest() {
+  lastUsageBySession = new WeakMap();
+}
+
+/**
+ * 判定「上下文疑似丢失」：本次已用量比上次明显下降。
+ *
+ * @param {{usedTokens:number, percent?:number}|null} prev 上次用量
+ * @param {{usedTokens:number, percent?:number}|null} current 本次用量
+ * @param {{minDropRatio?:number, minDropTokens?:number}} [opts] 阈值（默认比例 10%；绝对量 0=不限）
+ * @returns {{lost:boolean, prev:object|null, dropRatio:number, dropTokens:number, reason:string}}
+ *   `reason` 如实说明「为什么没触发」，便于诊断（也会写进注入文本的判定依据）
+ */
+export function detectContextLoss(prev, current, opts = {}) {
+  const minRatio = Number.isFinite(opts.minDropRatio) ? opts.minDropRatio : 0.10;
+  const minTokens = Number.isFinite(opts.minDropTokens) ? opts.minDropTokens : 0;
+  const base = { lost: false, prev: prev ?? null, dropRatio: 0, dropTokens: 0 };
+  if (!current || typeof current.usedTokens !== "number") return { ...base, reason: "本次用量不可用（投影未上报？）" };
+  if (!prev || typeof prev.usedTokens !== "number") return { ...base, prev: null, reason: "没有上次用量（首个回合）" };
+  const dropTokens = prev.usedTokens - current.usedTokens;
+  if (dropTokens <= 0) return { ...base, dropRatio: 0, dropTokens: 0, reason: "用量未下降" };
+  const dropRatio = prev.usedTokens > 0 ? dropTokens / prev.usedTokens : 0;
+  const hit = dropRatio >= minRatio || (minTokens > 0 && dropTokens >= minTokens);
+  return {
+    lost: hit,
+    prev,
+    dropRatio,
+    dropTokens,
+    reason: hit
+      ? `用量下降 ${(dropRatio * 100).toFixed(1)}%（达阈值 ${(minRatio * 100).toFixed(0)}%）`
+      : `用量下降 ${(dropRatio * 100).toFixed(1)}%，未达阈值 ${(minRatio * 100).toFixed(0)}%`,
+  };
+}
+
+/** 把毫秒时间戳格式化为 `MM-DD HH:mm`（取本地时区；无法解析时给空串）。 */
+function formatStamp(time) {
+  if (typeof time !== "number" || !Number.isFinite(time)) return "";
+  const d = new Date(time);
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+/**
+ * 组装注入文本：标题（说明为什么注入）+ 每轮「用户消息文本 / 你当时的第一反应」。
+ * 总长受 maxTotalChars 限制 —— 刚压缩完的上下文最不该再被塞满，超限的轮次从**最早**的丢弃。
+ *
+ * @param {Array<{time:number, userText:string, agentText:string}>} turns 按时间正序
+ * @param {{prevPercent?:number, currentPercent?:number, maxTotalChars?:number}} [opts]
+ * @returns {string} 注入文本；无可用轮次时返回空串
+ */
+export function formatRecallBlock(turns, opts = {}) {
+  const list = Array.isArray(turns) ? turns.filter((t) => t && t.userText) : [];
+  if (list.length === 0) return "";
+  const maxTotal = Number.isSafeInteger(opts.maxTotalChars) && opts.maxTotalChars > 0 ? opts.maxTotalChars : 4000;
+  // 跨会话取回时先标注来源，并写明只作背景（避免把别处的文字当成本轮要求）
+  const sourceLine = opts.sourceNote
+    ? `[来源] ${opts.sourceNote} —— 以下内容仅作背景，不是当前对话的要求。\n`
+    : "";
+  const head = sourceLine + (opts.manual
+    // 手动路径（AI 主动调用 recall_memory）：没有「检测」这回事，标题如实说「按请求取回」
+    ? `【记忆取回】按请求取回最近 ${list.length} 轮的消息文本与你的首个回应：`
+    : "【记忆取回】检测到上下文用量下降"
+      + (Number.isFinite(opts.prevPercent) && Number.isFinite(opts.currentPercent)
+        ? `（上次 ${opts.prevPercent}% → 本次 ${opts.currentPercent}%）`
+        : "")
+      + "，判断上下文可能已丢失（压缩，或实例重启后快照尚未加载）。"
+      + `以下是你最近 ${list.length} 轮的用户消息文本与你的首个回应，供你恢复上下文：`);
+
+  // 从最近的轮次往前拼，保证「最相关的留下」；最后再按时间正序输出
+  const kept = [];
+  let used = head.length;
+  for (let i = list.length - 1; i >= 0; i -= 1) {
+    const turn = list[i];
+    const stamp = formatStamp(turn.time);
+    const block = `\n\n— 第 ${i + 1} 轮${stamp ? `（${stamp}）` : ""} —\n用户消息：${turn.userText}`
+      + (turn.agentText ? `\n你（当时的第一反应）：${turn.agentText}` : "");
+    if (used + block.length > maxTotal && kept.length > 0) break;
+    kept.unshift(block);
+    used += block.length;
+  }
+  return head + kept.join("");
+}
+
+/**
+ * 主入口：检测 → 取回 → 组装。任何一步失败都返回 null（调用方据此跳过注入）。
+ *
+ * ⚠️ 无论是否触发，**都会记账**（`noteUsage`）：否则读取失败时会每个回合反复触发。
+ *
+ * @param {object} ctx 插件 context
+ * @param {object} args { sessionKey（会话/agent 对象，用作记忆键）, sessionId, current（本次用量）, opts }
+ * @returns {Promise<string|null>} 注入文本；不需要/拿不到时 null
+ */
+export async function buildMemoryRecall(ctx, { sessionKey, sessionId, current, opts = {} }) {
+  // 上次用量：优先内存（同进程最准），内存没有就读**落盘值** —— 重启后靠它才能比较出「掉到 0」。
+  const memory = takeLastUsage(sessionKey);
+  const disk = sessionId ? loadDiskState()[sessionId] : null;
+  const prev = memory ?? (disk && typeof disk.usedTokens === "number" ? disk : null);
+  noteUsage(sessionKey, current);
+  if (sessionId && current && typeof current.usedTokens === "number") {
+    loadDiskState()[sessionId] = { usedTokens: current.usedTokens, percent: current.percent, at: Date.now() };
+    saveDiskStateThrottled(ctx);
+  }
+  const verdict = detectContextLoss(prev, current, {
+    minDropRatio: opts.minDropRatio,
+    minDropTokens: opts.minDropTokens,
+  });
+  if (!verdict.lost) return null;
+  if (!sessionId) return null;
+  let turns = null;
+  try {
+    turns = await readRecentUserTurns(ctx, sessionId, {
+      rounds: opts.rounds,
+      maxCharsPerItem: opts.maxCharsPerItem,
+      root: opts.root,
+    });
+  } catch (error) {
+    log(ctx, `记忆取回：读会话日志失败（跳过本次注入）: ${String(error?.message ?? error)}`);
+    return null;
+  }
+  if (!turns || turns.length === 0) return null;
+  const text = formatRecallBlock(turns, {
+    prevPercent: verdict.prev?.percent,
+    currentPercent: current?.percent,
+    maxTotalChars: opts.maxTotalChars,
+  });
+  if (!text) return null;
+  log(ctx, `记忆取回：${verdict.reason} ⇒ 注入 ${turns.length} 轮（${text.length} 字符）`);
+  return text;
+}
+
+/** 工具输出形态（与其它工具一致：字符串 + text 渲染）。 */
+const TEXT_OUTPUT = {
+  schema: { type: "string" },
+  render(_args, value) {
+    return [{ type: "text", text: String(value) }];
+  },
+};
+
+/**
+ * 注册 `recall_memory` AI 工具：**让 AI 自己按需取回记忆**（自动注入之外的手动通道）。
+ *
+ * 用途：上下文被压缩后 AI 想主动回溯、或想翻更早的几轮时调用；参数 `rounds` = 取几轮
+ * （默认取配置 `retrieveMemoryRounds`，上限 50）。只读 —— 只返回文本给调用方，不改上下文。
+ *
+ * @returns {boolean} 是否成功注册
+ */
+export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
+  if (typeof defineTool !== "function" || typeof tools?.register !== "function") return false;
+  const read = deps.readTurns ?? readRecentUserTurns;
+  const format = deps.format ?? formatRecallBlock;
+  const config = deps.cfg ?? cfg;
+  const resolve = deps.resolveSession ?? resolveSessionTarget;
+  const maxRounds = 50;
+  tools.register(defineTool({
+    name: "recall_memory",
+    description:
+      "取回最近几轮的记忆：每轮的**用户消息文本** + 你当时的**首个回应**（优先取当时的 reasoning）。"
+      + "何时用：上下文被压缩/重启后想主动回溯，或想确认「用户最初是怎么说的」。"
+      + `参数 rounds = 取几轮（默认 ${config?.retrieveMemoryRounds ?? 3}，上限 ${maxRounds}）。`
+      + "只读：只把文本返回给你，不会自动改上下文。",
+    parameters: {
+      rounds: { type: "number", description: `取最近几轮（默认 ${config?.retrieveMemoryRounds ?? 3}，上限 ${maxRounds}）` },
+      session: { type: "string", description: "目标会话：id / id 前缀 / 标题子串；缺省或空 = 取自身（行为与之前一致）" },
+    },
+    output: TEXT_OUTPUT,
+    async execute(args, exec) {
+      const selfId = exec?.agent?.session?.id;
+      if (!selfId) return "拿不到当前会话 id，无法取回记忆。";
+      const asked = Number.isSafeInteger(args?.rounds) && args.rounds > 0 ? args.rounds : (config?.retrieveMemoryRounds ?? 3);
+      const rounds = Math.min(asked, maxRounds);
+      const want = typeof args?.session === "string" ? args.session.trim() : "";
+      // 缺省 / 空 / 等于自身 ⇒ 走自身路径，行为与之前逐字一致
+      let targetId = selfId;
+      let fromOther = false;
+      if (want && want !== selfId) {
+        const hit = await resolve(ctx, want, selfId);
+        if (hit?.candidates) {
+          return `「${want}」匹配到多个目标，请用更完整的 id 重试：\n`
+            + hit.candidates.slice(0, 10).map((c) => `- ${c.id}${c.title ? ` ｜ ${c.title}` : ""}`).join("\n");
+        }
+        if (!hit?.id) return `找不到目标会话「${want}」：没有匹配的会话 id / id 前缀 / 标题。`;
+        targetId = hit.id;
+        fromOther = true;
+      }
+      try {
+        const turns = await read(ctx, targetId, {
+          rounds,
+          maxCharsPerItem: config?.retrieveMemoryMaxCharsPerItem,
+        });
+        if (!turns || turns.length === 0) return "没取到可用的记忆（日志缺失，或该会话还没有用户消息）。";
+        const text = format(turns, {
+          maxTotalChars: config?.retrieveMemoryMaxChars,
+          manual: true,
+          // 跨会话时标注来源，并写明只作背景——别把别处的文字当成当前这轮的要求
+          ...(fromOther ? { sourceNote: `来自另一个会话 ${targetId}` } : {}),
+        });
+        return text || "没取到可用的记忆。";
+      } catch (error) {
+        return `取回记忆失败：${String(error?.message ?? error)}`;
+      }
+    },
+  }));
+  return true;
+}
+
+/**
+ * 解析 `session` 参数：完整 id → id 前缀 → 标题子串；命中多个返回候选清单（不猜）。
+ *
+ * 只用**便宜的来源**：会话目录名（id 的权威来源）与落盘索引里的标题。
+ * 不调用全量列表构建 —— 那是 226 秒级的重活，不该被一个参数解析拖进来。
+ *
+ * @returns {Promise<{id:string,title?:string|null}|{candidates:Array<{id:string,title?:string|null}>}|null>}
+ */
+export async function resolveSessionTarget(ctx, want, selfId) {
+  const { sessionsRootOf } = await import("../../sessions/events.js");
+  const { readdirSync, existsSync, statSync } = await import("node:fs");
+  const { join } = await import("node:path");
+  const root = sessionsRootOf();
+  const ids = [];
+  if (root && existsSync(root)) {
+    for (const proj of readdirSync(root)) {
+      const pp = join(root, proj);
+      try { if (!statSync(pp).isDirectory()) continue; } catch { continue; }
+      for (const dir of readdirSync(pp)) {
+        try { if (!statSync(join(pp, dir)).isDirectory()) continue; } catch { continue; }
+        if (dir.startsWith("session-") || dir === selfId) ids.push(dir);
+      }
+    }
+  }
+  if (ids.includes(want)) return { id: want };
+  const byPrefix = ids.filter((id) => id.startsWith(want));
+  if (byPrefix.length === 1) return { id: byPrefix[0] };
+  if (byPrefix.length > 1) return { candidates: byPrefix.map((id) => ({ id })) };
+  // 标题子串：只在落盘索引里找（避免为了解析一个参数去逐份读日志）
+  try {
+    const { loadListDiskCache } = await import("../../sessions/list-cache.js");
+    let entries = {};
+    try { entries = loadListDiskCache(ctx)?.entries ?? {}; } catch { entries = {}; }
+    const lower = want.toLowerCase();
+    const byTitle = Object.entries(entries)
+      .filter(([, e]) => String(e?.title ?? "").toLowerCase().includes(lower))
+      .map(([id, e]) => ({ id, title: e?.title ?? null }));
+    if (byTitle.length === 1) return byTitle[0];
+    if (byTitle.length > 1) return { candidates: byTitle };
+  } catch { /* 索引不可用：退化为只按 id 匹配 */ }
+  return null;
+}

package/lib/features/session-messaging/tools.js

@@ -26,6 +26,66 @@ const TEXT_OUTPUT = {
 
 // ── 工具：list_sessions ───────────────────────────────────────────────────
 
+/**
+ * 刷新路径的「快等待」窗口：先直接等构建这么久，等到了就直接给结果；
+ * 等不到再把它交给宿主后台 job（**复用同一份在途 Promise**，不重启构建）。
+ *
+ * 为什么需要它：冷缓存下全量构建实测 226 秒（201 会话 / 1.5 GB 日志），
+ * 工具直接把调用方钉住会让整轮长时间无回应；但热缓存只要 ~47 ms，
+ * 一律走 job 又会让常见情况白多一次 job_output 往返。所以按「先等一会儿，超时转 job」处理。
+ */
+const LIST_FAST_WAIT_MS = 3000;
+
+/**
+ * 注册宿主后台 job：带 owner 试一次，失败退「无主」再试，仍失败才降级同步。
+ *
+ * 宿主契约（照 dsh-git-push 的实测结论抄，不要凭猜）：
+ *   · `owner` 必须是**有活 agent 的会话 id 字符串**（`exec.agent.id`），传对象或错的 id 会抛
+ *     「session "xxx" has no live agent」；
+ *   · owner 缺省（unowned）在存在全局控制器时同样可注册，所以带 owner 失败 ≠ 不能后台化；
+ *   · 两步都失败才同步降级，并把失败原因带回去，便于当场定位（不静默降级）。
+ *
+ * @returns {{jobId?: string, error?: string}}
+ */
+function startHostJob(jobs, spec, owner) {
+  if (!jobs || typeof jobs.start !== "function") return { error: "宿主未挂载 jobs 服务（ctx.get('jobs') 不可用）" };
+  const reasons = [];
+  if (owner) {
+    try { return { jobId: jobs.start({ ...spec, owner }) }; } catch (error) { reasons.push(`带 owner 失败：${(error && error.message) || error}`); }
+  }
+  try { return { jobId: jobs.start(spec) }; } catch (error) { reasons.push(`无主注册失败：${(error && error.message) || error}`); }
+  return { error: reasons.join(" ｜ ") };
+}
+
+/** 从落盘索引直接组装一份精简列表（不重建索引）。索引不可用时返回 null。 */
+async function readListIndex(ctx) {
+  const { loadListDiskCache } = await import("../../sessions/list-cache.js");
+  const entries = loadListDiskCache(ctx)?.entries;
+  if (!entries || typeof entries !== "object") return null;
+  return Object.entries(entries).map(([id, e]) => ({
+    id,
+    title: e?.title ?? null,
+    cwd: e?.cwd ?? null,
+    updatedAt: e?.updatedAt ?? e?.createdAt ?? 0,
+    parentSession: e?.parentSession ?? null,
+    fromIndex: true,
+  }));
+}
+
+/** 索引入口（fromIndex=true）用的精简渲染：只给定位所需字段，明确标注来自索引。 */
+function formatIndexList(items, { limit, offset, query }) {
+  const q = typeof query === "string" ? query.trim().toLowerCase() : "";
+  const filtered = q
+    ? items.filter((it) => [it.id, it.title ?? "", it.cwd ?? ""].some((v) => String(v).toLowerCase().includes(q)))
+    : items;
+  const page = filtered.slice(offset, offset + limit);
+  const head = `索引直读：命中 ${filtered.length} 条（索引共 ${items.length} 条），本页 ${page.length} 条`
+    + (filtered.length > offset + limit ? `；下一页用 offset=${offset + limit}` : "")
+    + "。⚠️ 这是落盘索引里的记录，不含 live 状态与归档态；要看实时状态请去掉 fromIndex 走一次刷新。";
+  const body = page.map((it) => `- ${it.id}${it.title ? ` ｜ ${it.title}` : ""}${it.cwd ? ` ｜ ${it.cwd}` : ""}`).join("\n");
+  return body ? `${head}\n${body}` : `${head}\n（无匹配）`;
+}
+
 function registerListSessions(ctx, defineTool, tools) {
   tools.register(defineTool({
     name: "list_sessions",
@@ -36,21 +96,73 @@ function registerListSessions(ctx, defineTool, tools) {
       + "先用 query 按 id/标题/工作区子串收窄，再按回执提示的 offset 翻页。"
       + "状态含义：running = 正在跑回合；idle = 已挂载但空闲；inactive = 冷会话（未挂载，被投递时会被唤醒）。"
       + "用法：先调它拿目标 id，再把 id 原样传给 send_to_session —— 不要凭记忆或标题猜 id。"
-      + "缺 id 的脏数据会被自动跳过并如实标注。",
+      + "缺 id 的脏数据会被自动跳过并如实标注。"
+      + `**慢路径会注册宿主后台 job**：冷缓存时全量构建很慢（实测 226 秒），`
+      + `所以等过 ${LIST_FAST_WAIT_MS / 1000} 秒还没好就转后台 job 并立即回 jobId，`
+      + "用宿主 job_output 取正式列表（前台不再被钉住）。"
+      + "**想立刻拿一份精简列表可用 fromIndex=true**：直接读落盘索引，不触发重建（很适合「先看有哪些会话、拿 id」这一步）。",
     parameters: {
       query: { type: "string", description: "按 id / 标题 / 工作区子串过滤（不区分大小写），会话多时先用它收窄" },
       limit: { type: "number", description: `本页最多返回多少条（默认 ${LIST_DEFAULT_LIMIT}，上限 ${LIST_MAX_LIMIT}）` },
       offset: { type: "number", description: "跳过前多少条（默认 0；回执里会给出下一页该用的 offset）" },
+      fromIndex: { type: "boolean", description: "true = 直接读落盘索引（秒回，不含 live 状态），不触发重建；缺省 = 刷新（可能等很久，超时自动转后台 job）" },
     },
     output: TEXT_OUTPUT,
     async execute(args, exec) {
       try {
-        const items = await listSessions(ctx);
         const limit = Number.isSafeInteger(args?.limit) && args.limit > 0
           ? Math.min(args.limit, LIST_MAX_LIMIT)
           : LIST_DEFAULT_LIMIT;
         const offset = Number.isSafeInteger(args?.offset) && args.offset > 0 ? args.offset : 0;
-        return formatSessionList(items, currentSessionId(exec?.agent), { limit, offset, query: args?.query });
+        const currentId = currentSessionId(exec?.agent);
+
+        // ① 索引直读：快路径，不重建索引
+        if (args?.fromIndex === true) {
+          const items = await readListIndex(ctx);
+          if (!items) return "索引直读不可用：落盘索引为空或尚未建立。请去掉 fromIndex 走一次刷新（会重建索引）。";
+          return formatIndexList(items, { limit, offset, query: args?.query });
+        }
+
+        // ② 刷新路径：构建一次（build 是唯一那份在途 Promise，后面转 job 时复用它，不重启构建）
+        const build = (async () => {
+          const items = await listSessions(ctx);
+          // 本次查询结束后让面板随后的刷新能看到最新结果：失效 TTL + 确保索引落盘。
+          // 面板交互本身维持原样（仍走 /list 的 NDJSON 流式），这里只保证它下一次取到的是新数据。
+          try {
+            const { invalidateSessionListCache, saveListDiskCacheNow } = await import("../../sessions/list-cache.js");
+            invalidateSessionListCache();
+            saveListDiskCacheNow(ctx);
+          } catch { /* 面板更新是尽力而为，不影响工具结果 */ }
+          return formatSessionList(items, currentId, { limit, offset, query: args?.query });
+        })();
+
+        const timer = new Promise((resolve) => {
+          const t = setTimeout(() => resolve(null), LIST_FAST_WAIT_MS);
+          t.unref?.();
+        });
+        const quick = await Promise.race([build, timer]);
+        if (quick !== null) return quick; // 快路径：直接给结果
+
+        // ③ 慢路径：交给宿主后台 job（done 直接 await 上面那份 build）
+        const jobs = ctx?.get?.("jobs");
+        const started = startHostJob(jobs, {
+          kind: "session-conductor-list",
+          label: "list_sessions 刷新",
+          run: () => {
+            const done = build.then(
+              (output) => ({ status: "completed", output }),
+              (error) => ({ status: "failed", detail: shortError(error) }),
+            );
+            return { cancel: () => {}, done };
+          },
+        }, exec?.agent?.id);
+        if (started.jobId) {
+          return `已注册宿主后台 job（正在后台列出，完成会自动返回）；如需主动查：job_output ${started.jobId}`
+            + "（想立刻拿一份精简列表可改用 fromIndex=true）";
+        }
+        // ④ 连 job 都注册不上：退回同步执行，并把原因带回（不静默降级）
+        const output = await build;
+        return `${output}\n\n（注：宿主后台 job 不可用，已同步执行。原因：${started.error}）`;
       } catch (error) {
         return `列出会话失败：${shortError(error)}`;
       }

package/lib/repair.js

@@ -185,7 +185,27 @@ export async function encodeSessionText(text) {
 export async function repairCorruptSessions(ctx, { dryRun = false } = {}) {
   const persistence = ctx.get("sessionPersistence");
   if (!persistence?.listArtifacts || !persistence?.readRaw) {
-    return { error: "sessionPersistence 服务不可用（无 listArtifacts/readRaw）" };
+    // ── 0.2.x 兜底：退回 zstd 帧修复 ─────────────────────────────────────────
+    // 内容修复依赖 0.1.x 的 listArtifacts/readRaw，0.2.x 起这两个方法已不存在 ⇒
+    // 原实现直接返回 error；而面板「扫描/修复损坏会话」按钮打的正是本函数
+    // ⇒ 用户明明有 zstd 帧损坏（会话列表消失、加载报 corrupt Zstandard），面板却扫不出来、只显示无损坏。
+    // 因此：内容路径不可用时改用帧修复（同一「损坏会话」语义，且它只依赖文件系统，实测可用）。
+    const frames = dryRun ? await scanCorruptFrames() : await repairCorruptFrames({ dryRun: false });
+    return {
+      framesFallback: true,
+      scanned: frames.total ?? frames.scanned ?? 0,
+      healthy: frames.healthy ?? 0,
+      corrupt: typeof frames.corrupt === "number" ? frames.corrupt : (frames.corrupt?.length ?? 0),
+      fixed: frames.fixed ?? 0,
+      failed: frames.failed ?? 0,
+      sessions: (frames.corruptList ?? frames.corrupt ?? []).map((c) => ({
+        id: typeof c === "string" ? c : c.id,
+        problems: [String(typeof c === "string" ? "帧损坏" : (c.error ?? "帧损坏")).slice(0, 140)],
+      })),
+      errors: frames.errors ?? [],
+      backups: [],
+      note: "当前 DSH 的持久化后端不提供 listArtifacts/readRaw（0.2.x），已按 zstd 帧损坏扫描/修复。",
+    };
   }
   const sessionsSvc = ctx.get("sessions");
   const liveIds = new Set((sessionsSvc?.list() ?? []).map((s) => s.id));
@@ -274,10 +294,15 @@ export async function scanCorruptSessions(ctx) {
   return repairCorruptSessions(ctx, { dryRun: true });
 }
 
-/** 当前文件是否为 jsonl 后端（支持 listArtifacts/readRaw）。 */
+/** 当前实例是否可做会话修复。 */
 export function supportsRepair(ctx) {
   const persistence = ctx.get("sessionPersistence");
-  return persistence !== void 0 && typeof persistence?.listArtifacts === "function" && typeof persistence?.readRaw === "function";
+  if (persistence !== void 0
+    && typeof persistence?.listArtifacts === "function"
+    && typeof persistence?.readRaw === "function") return true; // 0.1.x：内容修复路径可用
+  // 0.2.x：listArtifacts/readRaw 已移除 ⇒ 改按「磁盘上有 jsonl.zstd 会话日志」判定
+  // （帧修复只依赖文件系统）。历史判据在 0.2.x 恒为 false，会让面板的扫描按钮拿到 501「不支持」。
+  try { return existsSync(sessionsRootOf()); } catch { return false; }
 }
 
 // ==================== zstd 帧修复（救援恢复完善，） ====================

package/lib/sessions/events.js

@@ -119,7 +119,7 @@ export async function readColdSessionEvents(ctx, sessionId) {
 // ---------- 按 zstd 帧流式读（列表专用，常量内存）----------
 
 /** 会话日志根目录：`<DSH_HOME>/sessions`。 */
-function sessionsRootOf() {
+export function sessionsRootOf() {
   const dshHome = process.env.DSH_HOME || join(process.env.HOME ?? "", ".dsh");
   return join(dshHome, "sessions");
 }
@@ -217,3 +217,106 @@ export async function readColdSessionSummary(ctx, sessionId, opts = {}) {
     frames: stats.frames,
   };
 }
+
+// ---------- 记忆取回：取最近 N 轮「用户消息文本 + AI 首条回应」----------
+
+/** 从 content 分块里取纯文本（跳过 reasoning 等非文本块）。 */
+function textPartsOf(content) {
+  if (!Array.isArray(content)) return "";
+  const parts = [];
+  for (const part of content) {
+    if (typeof part?.text === "string" && part.text) parts.push(part.text);
+  }
+  return parts.join("\n");
+}
+
+/**
+ * 从 `assistant/message` 里取「该轮 AI 的第一条回应」文本。
+ * 优先 `reasoning`（当时的推理最能体现「我那时怎么理解你的话」），没有则取正文 `text`。
+ */
+function firstAgentTextOf(data) {
+  const content = data?.message?.content;
+  if (!Array.isArray(content)) return "";
+  const pick = (kind) => content.find((p) => p?.type === kind && typeof p.text === "string" && p.text)?.text ?? "";
+  return pick("reasoning") || pick("text") || "";
+}
+
+/** 截断到 maxChars（超出加省略号），并压缩连续空白行。 */
+function clipText(text, maxChars) {
+  const normalized = String(text ?? "").replace(/\n{3,}/g, "\n\n").trim();
+  if (maxChars > 0 && normalized.length > maxChars) return `${normalized.slice(0, maxChars)}…`;
+  return normalized;
+}
+
+/**
+ * 取最近 N 轮「用户消息文本 + 该轮 AI 的第一条回应」（**按 zstd 帧流式读，常量内存**）。
+ *
+ * 【锚点为什么是 user/message 而不是 agent/inbox/spliced】前者是「真正成为用户输入」的那条，
+ * 后者是同一句话的**投递副本**（实测同一句话会先出现在 spliced、后出现在 user/message），
+ * 用后者会把一轮数成两条。
+ * 【为什么只认 source.kind === "user"】插件自己注入的消息（`plugin:dsh-session-conductor`）
+ * 以及 runtime-context / user-approval / model-selection 都不是用户消息文本；若不排除，
+ * 「记忆取回」注入的块本身会被下一轮取回，形成越注越多的反馈环。
+ * 【连续多条用户消息算一轮】同一回合内（其间没有 turn/end）到达的多条用户消息合并成一条。
+ *
+ * @param {object} ctx 插件 context（本函数不取服务，保留同签名）
+ * @param {string} sessionId 会话 id
+ * @param {object} [opts] rounds（默认 3）/ maxCharsPerItem（默认 800）/ root（测试用）
+ * @returns {Promise<Array<{time:number, userText:string, agentText:string}>|null>} 按时间正序；null = 日志没找到
+ */
+export async function readRecentUserTurns(ctx, sessionId, opts = {}) {
+  const file = findSessionLogById(sessionId, opts.root ?? sessionsRootOf());
+  if (!file) return null;
+  const rounds = Number.isSafeInteger(opts.rounds) && opts.rounds > 0 ? opts.rounds : 3;
+  const perItem = Number.isSafeInteger(opts.maxCharsPerItem) && opts.maxCharsPerItem > 0 ? opts.maxCharsPerItem : 800;
+  const buf = readFileSync(file);
+  const decoder = new StringDecoder("utf8");
+  let pending = "";
+  const turns = [];
+  let current = null;
+
+  const consumeLine = (line) => {
+    if (!line) return;
+    let event;
+    try { event = JSON.parse(line); } catch { return; }
+    const type = event?.type;
+    if (type === "turn/end") {
+      // 回合结束：此后到来的用户消息算新的一轮
+      if (current) current.closed = true;
+      return;
+    }
+    if (type === "user/message") {
+      if (event?.data?.source?.kind !== "user") return; // 排除注入与运行期上下文
+      const text = clipText(textPartsOf(event?.data?.content), perItem);
+      if (!text) return;
+      if (current && !current.closed) {
+        // 同回合内的连续用户消息：合并（用空行分隔，保持消息文本可辨）
+        current.userText = current.userText ? `${current.userText}\n\n${text}` : text;
+        return;
+      }
+      current = { time: typeof event?.time === "number" ? event.time : null, userText: text, agentText: "", closed: false };
+      turns.push(current);
+      if (turns.length > rounds) turns.shift(); // 只留最近 rounds 轮（常量内存）
+      return;
+    }
+    if (type === "assistant/message") {
+      if (!current || current.agentText) return; // 只要该轮的第一条
+      const text = clipText(firstAgentTextOf(event?.data), perItem);
+      if (text) current.agentText = text;
+    }
+  };
+
+  await streamDecodedFrames(buf, (chunk) => {
+    pending += decoder.write(chunk);
+    let idx;
+    while ((idx = pending.indexOf("\n")) >= 0) {
+      const line = pending.slice(0, idx);
+      pending = pending.slice(idx + 1);
+      consumeLine(line);
+    }
+  });
+  pending += decoder.end();
+  consumeLine(pending);
+
+  return turns.map((t) => ({ time: t.time, userText: t.userText, agentText: t.agentText }));
+}

package/lib/zstd-frames.js

@@ -148,14 +148,23 @@ export function validateHeaderFrame(buf) {
  * @returns {{ok:boolean, id?:string, eventCount?:number, fixed?:boolean, error?:string}}
  */
 export async function fixZstdFile(path, backupDir = join(dirname(path), '.zstd-fix-backup')) {
+  const origBuf = readFileSync(path);
   // 先校验：本身已合规则跳过（避免无谓重写）
-  const check = await validateHeaderFrame(readFileSync(path));
+  const check = await validateHeaderFrame(origBuf);
   if (check.ok) return { ok: true, id: check.header.id, eventCount: null, fixed: false, note: '已合规' };
+
+  // ── 帧级损坏（bad magic / 末帧内容坏）⇒ 截断到「最长的可解码前缀」────────────
+  // 为什么必须单独处理：本机最常见的两种损坏是「尾部垃圾」（进程在写入中途被杀，
+  // 最后一次 append 留下半截数据）与「末帧内容坏」（帧头正常但 zstd 载荷校验失败），
+  // 这两种情况下前面成百上千帧往往**完好**。原实现一遇 bad magic 就直接返回失败
+  // ⇒ 等于修不了（线上实测：`fixZstdFile` 对一份 4798 帧、只有末帧坏 + 尾部 7KB 垃圾的
+  // 日志报 `bad magic at 11649807` 后放弃）。
   if (!check.error?.includes('corrupt') && !check.error?.includes('header')) {
+    const truncated = await truncateToDecodablePrefix(path, origBuf, check.error, backupDir);
+    if (truncated) return truncated;
     return { ok: false, error: check.error };
   }
 
-  const origBuf = readFileSync(path);
   let text;
   try { text = await decodeAllFrames(origBuf); } catch (e) {
     return { ok: false, error: '帧解码失败: ' + e.message };
@@ -183,6 +192,72 @@ export async function fixZstdFile(path, backupDir = join(dirname(path), '.zstd-f
   return { ok: true, id: header.id, eventCount: events.length, fixed: true, backup: bak, origSize: origBuf.length, newSize: newBuf.length };
 }
 
+/**
+ * 把「帧级损坏」的日志截断到**最长的可解码前缀**（保留原始帧，不重编码）。
+ *
+ * 步骤：① 取帧表 —— `scanZstdFrames` 遇坏 magic 会抛错（错误信息含偏移），
+ * 据此退回到该偏移之前的前缀再扫一次；② **逐帧解码**，停在第一帧解不开之前，
+ * 那个位置就是安全截断点；③ 截断后首帧必须仍是「恰好一行 header」。
+ *
+ * 返回 null 表示「不是截断能解的损坏形态」，交给调用方按原错误返回。
+ *
+ * @param {string} path 日志文件绝对路径
+ * @param {Buffer} buf 该文件当前内容
+ * @param {string} [originalError] 触发修复的原始错误（写进返回值便于排查）
+ * @param {string} backupDir 备份目录
+ */
+async function truncateToDecodablePrefix(path, buf, originalError, backupDir) {
+  let frames = null;
+  try {
+    ({ frames } = scanZstdFrames(buf));
+  } catch (error) {
+    const at = /bad magic at (\d+)/.exec(String(error?.message ?? ''));
+    const cut = at ? Number(at[1]) : 0;
+    if (!(cut > 0)) return null; // 连开头都不是合法帧 ⇒ 截断无意义
+    try { ({ frames } = scanZstdFrames(buf.subarray(0, cut))); } catch { return null; }
+  }
+  if (!frames || frames.length === 0) return null;
+
+  let safeEnd = 0;
+  let dropped = null;
+  for (const [i, fr] of frames.entries()) {
+    try {
+      const plain = await decodeFrame(buf.subarray(fr.start, fr.end));
+      if (!plain || plain.length === 0) throw new Error('解出空内容');
+    } catch (error) {
+      dropped = { index: i, reason: String(error?.message ?? error) };
+      break;
+    }
+    safeEnd = fr.end;
+  }
+  if (!dropped || safeEnd < 4) return null; // 没找到坏帧 ⇒ 不是本函数负责的形态
+
+  const head = await validateHeaderFrame(buf.subarray(0, safeEnd));
+  if (!head.ok) return null;
+
+  mkdirSync(backupDir, { recursive: true });
+  const rel = path.replace(/^.*\/sessions\//, '').replace(/\//g, '__');
+  const bak = join(backupDir, rel);
+  if (!existsSync(bak)) copyFileSync(path, bak);
+  const tmp = path + '.fixtmp';
+  writeFileSync(tmp, buf.subarray(0, safeEnd));
+  try { chmodSync(tmp, statSync(path).mode); } catch { /* 尽力 */ }
+  renameSync(tmp, path);
+  return {
+    ok: true,
+    id: head.header.id,
+    fixed: true,
+    mode: 'truncate',
+    origSize: buf.length,
+    newSize: safeEnd,
+    droppedFrame: dropped.index,
+    droppedBytes: buf.length - safeEnd,
+    droppedReason: dropped.reason,
+    originalError,
+    backup: bak,
+  };
+}
+
 /**
  * 扫描会话目录下全部 session.jsonl.zstd，找出帧损坏的文件。
  * @param sessionsRoot 会话根目录（如 <dshHome>/sessions）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-conductor",
-  "version": "1.2.2",
+  "version": "1.3.1",
   "description": "DSH session management enhancement: archive/restore sessions, batch & conditional delete, AI auto-rename, interrupted-session auto-resume, release idle sessions, workspace grouping, undo last message, repair damaged session logs, value analysis, full-text search, per-member model switching (list_models / set_member_model), and plan/closing template injection (system-prompt + context).",
   "type": "module",
   "main": "lib/index.js",
@@ -19,6 +19,7 @@
   },
   "files": [
     "lib",
+    "scripts",
     "skills",
     "cordis.patch.yml"
   ],

package/scripts/check-member-model.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// 复核「成员模型切换是否生效」——**只认请求级权威记录**。
+//
+// 用法：
+//   node scripts/check-member-model.mjs <sessionId>
+//
+// 输出：该会话最近一次实际请求使用的 provider/model（来自 `request/header`）+
+//       最近一次切换意图（来自 `model/selection`），两者对照即可判断「切没切成」。
+//
+// 【为什么以 request/header 为准】上下文里注入的 `[model changed: …]` 通知与 `model/selection`
+// 事件都只表达「意图」；实测出现过「提示是 agnes、请求头仍是 wb」的不一致 ——
+// 只有请求时**真实使用**的 provider/model 算数。
+import { readLastRequestModel } from "../lib/features/member-model/switch.js";
+
+const sessionId = process.argv[2];
+if (!sessionId) {
+  console.error("用法：node scripts/check-member-model.mjs <sessionId>");
+  process.exit(2);
+}
+
+const { lastRequest, lastSelection, scanned } = await readLastRequestModel(sessionId);
+if (!lastRequest) {
+  console.log(`会话 ${sessionId}：日志里没有 request/header 记录（该会话可能从未发起过请求）`);
+} else {
+  const when = lastRequest.time ? new Date(lastRequest.time).toLocaleString("zh-CN") : "时间未知";
+  console.log(`最近一次实际请求：${lastRequest.provider}/${lastRequest.model}（${when}）`);
+}
+if (lastSelection) {
+  console.log(`最近一次切换意图：${lastSelection.provider}/${lastSelection.model}`);
+}
+console.log(`（共扫描 ${scanned} 条 request/header；判定只看「最近一次实际请求」）`);

package/skills/dsh-session-conductor-functions.md

@@ -136,7 +136,8 @@ whenToUse: 需要了解 dsh-session-conductor 某个功能怎么用/参数是什
   - **同时仍写 `model/selection` 事件**：让官方 `agent/pre-step` 追加 `[model changed: …]` 通知（可观测痕迹）。
   - **成员状态**：未挂载（inactive）**也能切**——override 落 domain；若会话日志里还没有该选择，会把事件直接写进会话日志（`appendSelectionEventToLog`，解码 → 追加 → 校验 → 备份 → 原子写回）。正在执行回合时会**先等它暂停**（`whenIdle`，最长 60s）再切。
 - **验收方式（重要）**：
-  - ✅ **请求级权威记录**：`request/header` 的 `config.model`——**连续多轮都应是新模型**（这是「跨轮持久」的唯一可靠证据）。
+  - ✅ **现在不用自己查了**：`set_member_model` 的返回值**直接带查证**——立刻给「最近一次实际请求的 provider/model + 最近一次切换意图 + 一行判定」，并**注册查证任务（不阻塞）**：该成员下次发起请求时由 `agent/request` 事件判定（插件本来就拦这个事件改模型），确认结果在下一次 step 注入给发起方。想要更细的自查，用返回值里附的复核命令 `node scripts/check-member-model.mjs <sessionId>`。
+  - ✅ **请求级权威记录**：`request/header` 的 `data.header.config.{provider,model}` —— 注意是**两层**（`data.header.config`，不是 `data.config`）；**连续多轮都应是新模型**（这是「跨轮持久」的唯一可靠证据）。
   - ✅ 会话 `model/selection` 事件（切换意图落盘）。
   - ✅ projcache `modelSelection.lastUsed` / `pending`（官方投影状态）。
   - ⚠️ **不要**只用 `model/selection` 事件或会话内注入的 `[model changed: …]` 提示下结论——实测出现过「提示是 agnes、请求头仍是 wb」的不一致。
@@ -227,6 +228,37 @@ whenToUse: 需要了解 dsh-session-conductor 某个功能怎么用/参数是什
 ### 节约模式（token-saving-mode）
 - 用户表达节约 token 意愿（"省点""节约"）时启用：直达答案不客套、结构优先、默认 ≤200 字或 10 行代码、禁冗余、复杂问题先结论后理由、高峰价格用户自己留意勿主动提醒。
 
+## 十三、记忆取回（memory-recall，1.3.0 起）
+
+**解决什么**：上下文被压缩、截断，或实例重启后快照未加载时，AI 会「失忆」——重复提问、重复劳动、
+误解需求。而用户消息在上下文里占比极小（1M 上下文可能总共没超过 3 句），却最不该丢。
+
+**两条通道**：
+
+| 通道 | 触发 | 参数 |
+|---|---|---|
+| **自动注入** | 每回合比较上下文已用量：本次比上次下降 ≥ `retrieveMemoryMinDropRatio`（默认 0.10）⇒ 判定「疑似丢失」，取回后与用量行**合并成一条**注入（消息尾部） | 无（走配置） |
+| **AI 工具 `recall_memory`** | AI 自己想回溯时主动调用 | `rounds` = 取几轮（默认取配置，上限 50） |
+
+**取什么**：最近 N 轮（默认 3）的**用户消息文本** + 该轮 **AI 的第一条回应**（优先 reasoning，缺失取正文）。
+
+- 以用户消息为锚：占比小但信息密度最高，是恢复上下文的支点；
+- 要 AI 的第一条回应：那是「当时」对消息的理解，直接给结论，省得重新推测。
+
+**实现要点（改这里前先读）**：
+
+- 读取走 `readRecentUserTurns`（`lib/sessions/events.js`）：按 zstd 帧**流式**读日志文件，
+  常量内存（实测 3 轮 27 ms / heap 6.1 MB）；
+- 锚点只认 `user/message` 且 `data.source.kind === "user"` —— **必须排除插件自身注入**
+  （`plugin:dsh-session-conductor`）与 `runtime-context`，否则注入块会被下一轮取回形成反馈环；
+- `agent/inbox/spliced` 是同一句话的投递副本，**忽略**（否则一轮会数成两条）；
+- 同回合内（其间无 `turn/end`）连续多条用户消息**合并成一轮**；
+- 无论是否触发都记账（`noteUsage`），否则读取失败会每回合反复触发；
+- 任何一步失败（日志缺失/损坏、用量读不到、首回合无上次用量）都静默返回 null，绝不阻断回合。
+
+**配置**：`retrieveMemory`（默认开）/ `retrieveMemoryRounds`(3) / `retrieveMemoryMinDropRatio`(0.10) /
+`retrieveMemoryMinDropTokens`(0) / `retrieveMemoryMaxChars`(4000) / `retrieveMemoryMaxCharsPerItem`(800)。
+
 ## 相关
 
 - dsh-session-conductor（使用手册，与本文档配套）