dsh-session-conductor 1.3.0 → 1.3.2

package/README.md

@@ -21,10 +21,10 @@
 | 压缩模型选择 | 上下文自动压缩用模型独立选择（省成本） | 设置 → 插件 → 压缩模型 |
 | 模板注入 | 方案模板 / 收尾模板：本地设备上传 / 在线网址 / DSH 目录浏览三种导入，内容可再编辑，注入系统提示词（方案/收尾各一条上下文注入） | 设置 → 会话管理 → 模板注入 |
 | 自动重命名模型 | 指定便宜/专用模型做标题分析 | 设置 → 会话管理 |
-| 成员模型切换 | 给队友/子代理单独切模型（只动该成员会话，不影响其他成员）：先用 `list_models` 拿确切模型 id，再 `set_member_model` 按成员名/sessionId 切换（写 `model/selection` 事件交给官方投影接管，跨轮持久；未挂载成员也能切，运行中会先等它暂停） | AI 工具 `list_models` / `set_member_model` |
-| 记忆取回 | 检测到上下文用量**明显下降**（默认 ≥10%，可配）即判定「上下文疑似丢失」——压缩、截断、实例重启后快照未加载**都算**（比只盯压缩更全）。此时自动把最近 **3 轮（可配）** 的**用户原话 + 该轮 AI 的第一条回应**（优先取当时的 reasoning）重新注入，让 AI 立刻恢复状态。实现要点：按 zstd 帧**流式**读日志（常量内存）、**只认真实用户消息**（排除插件自身注入，防反馈环）、同回合连发**合并成一轮**、注入总长与单条都有上限。配置项 `retrieveMemory*`（默认开）。**另提供 AI 工具 `recall_memory`**（参数 `rounds` = 取几轮，默认取配置、上限 50）让 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 条，避免整表塞进调用方上下文）。硬约束：禁自投、协作链跳数 ≥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` |
 
 ## 界面预览
@@ -148,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

@@ -53,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';
@@ -270,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 倒序插入保持（流式下后端不再整体排序）。
@@ -1239,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/* 依赖，直接引用标识符会抛
@@ -1289,10 +1325,9 @@ export async function apply(ctx, config = {}) {
     //     多条重复的用量行（噪音 + 白烧 token）。
     //   · 默认开启（core/config.js 的 injectContextUsage）；关掉即退化为「按需调用 context_usage 工具」。
     //   · 读不到投影/服务未挂载时注入器返回空串 ⇒ 静默跳过，绝不影响正常回合。
-    // 两个开关任一开启就需要本 hook（用量注入 / 记忆取回）；turn 门控保证一回合只注入一次。
-    const usageInjector = createContextUsageInjector({
-      enabled: cfg?.injectContextUsage !== false || cfg?.retrieveMemory !== 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;
@@ -1322,7 +1357,20 @@ export async function apply(ctx, config = {}) {
           log(ctx, `记忆取回失败（跳过本次）: ${String(error?.message ?? error)}`);
         }
       }
-      const text = [usageText, recallText].filter(Boolean).join("\n\n");
+      // 切换查证回报：切换发起方在**下一次 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({
@@ -1393,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 查确切值）";
@@ -1405,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 自己按需查占用与构成，而不是每轮把数值注入系统提示词

package/lib/core/domain.js

@@ -115,30 +115,50 @@ export function pluginDomain(ctx) {
     if (!storage) return Promise.reject(new Error("storageDomain 不可用"));
     domainPromise = storage.open(pluginDomainSpec).then((domain) => {
       domainLive = true;
-      // 只在 apply 的活跃 fiber 上挂 close；HTTP handler / 事件回调 fiber 是 inactive，
-      // ctx.effect 会抛 cannot create effect on inactive context，且 rejected Promise 被缓存后 list 一直 500。
-      try {
-        ctx.effect(() => () => {
-          // 关闭的同时把缓存与存活标记一起清掉——下一次 apply 才会重新 open。
-          // 【原代码】只 return domain.close()（缓存不清），靠 apply 开头无条件 domainPromise = null 兜，
-          //   遇到「域还活着就重载」时会在旧的活域上再 open 一次 → storage 报 already open → list 500。
-          domainLive = false;
-          domainPromise = null;
-          return domain.close();
-        }, "session-conductor: domain close");
-      } catch {
-        /* 请求路径打开时不挂 effect；apply() 已预热并挂过 */
-      }
+      attachDomainClose(ctx, domain);
       return domain;
-    }).catch((err) => {
+    }).catch((error) => {
+      // 模块热重载场景：本实例的缓存是空的，但上一份实例打开的域仍被 storageDomain
+      // 按名字占用（facility 用 reserved 集合挡重复 open），于是再 open 必报 already-open。
+      // 宿主提供了按名字查已开域的口子，这里直接复用那份 handle——
+      // 否则重载后列表/模板/开关会一路 500，直到整个实例重启为止。
+      const reused = isAlreadyOpenError(error) && typeof storage.get === "function"
+        ? storage.get(pluginDomainSpec.name)
+        : undefined;
+      if (reused) {
+        domainLive = true;
+        attachDomainClose(ctx, reused);
+        return reused;
+      }
       domainPromise = null;
       domainLive = false;
-      throw err;
+      throw error;
     });
   }
   return domainPromise;
 }
 
+/** 判定「这个名字已经被占用」的重复打开错误（宿主 DomainError 带 code，保底看文案）。 */
+function isAlreadyOpenError(error) {
+  return error?.code === "already-open" || /is already open/.test(String(error?.message ?? ""));
+}
+
+/** 挂关闭效果：只在 apply 的活跃 fiber 上成功，请求路径（inactive fiber）会抛并被吞掉。 */
+function attachDomainClose(ctx, domain) {
+  try {
+    ctx.effect(() => () => {
+      // 关闭的同时把缓存与存活标记一起清掉——下一次 apply 才会重新 open。
+      // 【原代码】只 return domain.close()（缓存不清），靠 apply 开头无条件 domainPromise = null 兜，
+      //   遇到「域还活着就重载」时会在旧的活域上再 open 一次 → storage 报 already open → list 500。
+      domainLive = false;
+      domainPromise = null;
+      return domain.close();
+    }, "session-conductor: domain close");
+  } catch {
+    /* 请求路径打开时不挂 effect；apply() 已预热并挂过 */
+  }
+}
+
 /** 读域里的全局状态对象。 */
 export async function pluginState(ctx) {
   const domain = await pluginDomain(ctx);

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

@@ -154,7 +154,11 @@ 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 head = opts.manual
+  // 跨会话取回时先标注来源，并写明只作背景（避免把别处的文字当成本轮要求）
+  const sourceLine = opts.sourceNote
+    ? `[来源] ${opts.sourceNote} —— 以下内容仅作背景，不是当前对话的要求。\n`
+    : "";
+  const head = sourceLine + (opts.manual
     // 手动路径（AI 主动调用 recall_memory）：没有「检测」这回事，标题如实说「按请求取回」
     ? `【记忆取回】按请求取回最近 ${list.length} 轮的消息文本与你的首个回应：`
     : "【记忆取回】检测到上下文用量下降"
@@ -162,7 +166,7 @@ export function formatRecallBlock(turns, opts = {}) {
         ? `（上次 ${opts.prevPercent}% → 本次 ${opts.currentPercent}%）`
         : "")
       + "，判断上下文可能已丢失（压缩，或实例重启后快照尚未加载）。"
-      + `以下是你最近 ${list.length} 轮的用户消息文本与你的首个回应，供你恢复上下文：`;
+      + `以下是你最近 ${list.length} 轮的用户消息文本与你的首个回应，供你恢复上下文：`);
 
   // 从最近的轮次往前拼，保证「最相关的留下」；最后再按时间正序输出
   const kept = [];
@@ -247,6 +251,7 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
   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",
@@ -257,20 +262,40 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
       + "只读：只把文本返回给你，不会自动改上下文。",
     parameters: {
       rounds: { type: "number", description: `取最近几轮（默认 ${config?.retrieveMemoryRounds ?? 3}，上限 ${maxRounds}）` },
+      session: { type: "string", description: "目标会话：id / id 前缀 / 标题子串；缺省或空 = 取自身（行为与之前一致）" },
     },
     output: TEXT_OUTPUT,
     async execute(args, exec) {
-      const sessionId = exec?.agent?.session?.id;
-      if (!sessionId) return "拿不到当前会话 id，无法取回记忆。";
+      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, sessionId, {
+        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 });
+        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)}`;
@@ -279,3 +304,46 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
   }));
   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");
 }

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.3.0",
+  "version": "1.3.2",
   "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」的不一致。