dsh-session-conductor 1.3.18 → 1.4.4

package/lib/core/domain-fallback.js

@@ -0,0 +1,93 @@
+// dsh-session-conductor — 存储域不可用时的文件后备（降级实现）
+//
+// 【为什么单独成文件】`core/domain.js` 顶层静态依赖宿主包 `@deepseek-ai/dsh-storage-domain`，
+// 工作区单测没有宿主依赖，静态 import 会让整个模块在导入时就 ERR_MODULE_NOT_FOUND。
+// 把降级逻辑放在这里（只依赖 node 内置 + 已抽出的 json-store），就能被单测直接覆盖。
+//
+// 【降级触发条件】storageDomain 域出现下面任一情况时，改读写域自己的落盘 JSON：
+//   · 服务拿不到（ctx.get("storageDomain") 为空）
+//   · 名字仍被占（already open）而查到的旧句柄已 closed 或停在 disposing
+// 这两种情况下插件所有依赖持久化的功能本会一路 500，只能重启恢复。
+
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readJsonSafeSync, writeJsonAtomicSync } from "../shared/json-store.js";
+
+/** DSH 主目录（与 core/config.js 的 resolveDshHome 同规则；此处内联避免底层模块反向依赖上层配置）。 */
+function dshHomePath() {
+  if (process.env.DSH_HOME) return process.env.DSH_HOME;
+  const home = process.env.HOME || process.env.USERPROFILE || homedir();
+  return home ? join(home, ".dsh") : "";
+}
+
+/**
+ * 判定域句柄是否还能用。
+ *
+ * 【为什么还要看 disposing】宿主的 DomainImpl 在 close 一开始就置 `disposing = true`，
+ * 要等写链排空、存储单元关闭后才置 `closed = true`。如果关闭过程卡住（写链未排空），
+ * 句柄会长期停在 `disposing`：`closed` 仍是 false，但任何读写都会抛「domain is closed」。
+ * 只看 `closed` 会把它当成活域继续用，于是接口一路 500。
+ */
+export function isUsableDomain(domain) {
+  return Boolean(domain) && domain.closed !== true && domain.disposing !== true;
+}
+
+/**
+ * 文件后备域：storageDomain 的域不可用（卡在关闭中 / 名字被占导致无法重新打开）时的降级实现。
+ *
+ * 【为什么要有它】域卡住时插件所有依赖持久化的功能（列表缓存、模板、各开关、成员模型 override）
+ * 会全部 500，只能靠重启宿主恢复。而这些状态本来就落盘在
+ * `<DSH_HOME>/storages/dsh_session_conductor.json`，直接读写同一份文件即可继续工作。
+ *
+ * 【只实现 global.get / global.set】全插件对域的使用面只有这两者（外加 close），没有用到 tables，
+ * 因此后备实现只管 global 一节，其余字段（unit / tables）原样保留，保证宿主下次启动能正常加载。
+ *
+ * 【串行写】域本身有写链保证串行；文件后备没有，这里用一条 Promise 链模拟，
+ * 避免并发 `global.set` 互相覆盖（读-改-写之间的丢更新）。
+ */
+export function fileFallbackDomain() {
+  const home = dshHomePath();
+  const file = home ? join(home, "storages", "dsh_session_conductor.json") : "";
+  const readAll = () => {
+    if (!file) return {};
+    try { return readJsonSafeSync(file) ?? {}; } catch { return {}; }
+  };
+  let chain = Promise.resolve();
+  return {
+    // 供 isUsableDomain 判断：后备域永远可用
+    closed: false,
+    disposing: false,
+    __fallback: true,
+    global: {
+      get() {
+        return readAll().global ?? {};
+      },
+      set(value) {
+        chain = chain.then(async () => {
+          if (!file) throw new Error("DSH_HOME 未知，无法写入后备存储");
+          const current = readAll();
+          // 保留 unit / tables 原值：它们由宿主维护，后备路径不改动
+          const next = { ...current, global: value, tables: current.tables ?? {} };
+          if (current.unit !== undefined) next.unit = current.unit;
+          await writeJsonAtomicSync(file, next);
+        });
+        return chain;
+      },
+    },
+    close() { /* 后备域无需关闭 */ },
+  };
+}
+
+/** 降级只提示一次，避免每个请求都刷一行日志。 */
+let fallbackLogged = false;
+export function logOnceFallback(error, reused) {
+  if (fallbackLogged) return;
+  fallbackLogged = true;
+  try {
+    console.warn(
+      "[session-conductor] 存储域不可用，已降级为直接读写 storages/dsh_session_conductor.json："
+      + `open 失败=${String(error?.message ?? error)}`
+      + `${reused ? "；复用的句柄已关闭/关闭中" : ""}。重启实例可恢复正常域。`,
+    );
+  } catch { /* 日志失败不影响主流程 */ }
+}

package/lib/core/domain.js

@@ -6,6 +6,9 @@
 
 import { defineDomain } from "@deepseek-ai/dsh-storage-domain";
 import { z } from "zod";
+// 域降级为文件后备时用（与域落盘同一份 JSON，保持 unit/global/tables 结构）
+// 域不可用时的文件后备（抽到独立文件，便于工作区单测直接覆盖）
+import { isUsableDomain, fileFallbackDomain, logOnceFallback } from "./domain-fallback.js";
 
 /** 插件自身的持久化域：自动重命名/自动续跑开关 + 记账，存于 <DSH_HOME>/storages/dsh-session-conductor.json。
  *  版本保持 1：autoContinue 是纯增量字段（带 default），旧域文件可无损加载。 */
@@ -110,9 +113,33 @@ let domainLive = false;
  * @returns {Promise<object>} 域对象；storageDomain 服务缺失时 reject
  */
 export function pluginDomain(ctx) {
-  if (domainPromise === null) {
+  if (domainPromise !== null) {
+    return domainPromise.then((cached) => {
+      if (isUsableDomain(cached)) return cached;
+      // 缓存里的句柄已不可用（关闭中 / 已关闭）：丢掉重建
+      domainPromise = null;
+      domainLive = false;
+      if (cached && cached.__fallback) {
+        // 后备域本身可用，上面的 isUsableDomain 已放行；走到这里说明它被误标，直接重取
+        domainPromise = Promise.resolve(fileFallbackDomain());
+        return domainPromise;
+      }
+      return pluginDomain(ctx);
+    }, () => {
+      // 上次 open 失败：清掉缓存让它重新尝试（rejected Promise 不能被永久缓存）
+      domainPromise = null;
+      domainLive = false;
+      return pluginDomain(ctx);
+    });
+  }
+  {
     const storage = ctx.get("storageDomain");
-    if (!storage) return Promise.reject(new Error("storageDomain 不可用"));
+    if (!storage) {
+      // 服务都拿不到：直接文件后备（报错只会让所有功能一起不可用）
+      domainLive = false;
+      domainPromise = Promise.resolve(fileFallbackDomain());
+      return domainPromise;
+    }
     domainPromise = storage.open(pluginDomainSpec).then((domain) => {
       domainLive = true;
       attachDomainClose(ctx, domain);
@@ -120,22 +147,25 @@ export function pluginDomain(ctx) {
     }).catch((error) => {
       // 模块热重载场景：本实例的缓存是空的，但上一份实例打开的域仍被 storageDomain
       // 按名字占用（facility 用 reserved 集合挡重复 open），于是再 open 必报 already-open。
-      // 宿主提供了按名字查已开域的口子，这里直接复用那份 handle——
-      // 否则重载后列表/模板/开关会一路 500，直到整个实例重启为止。
+      // 宿主提供了按名字查已开域的口子，这里直接复用那份 handle。
       const reused = isAlreadyOpenError(error) && typeof storage.get === "function"
         ? storage.get(pluginDomainSpec.name)
         : undefined;
-      if (reused) {
+      if (isUsableDomain(reused)) {
         domainLive = true;
         attachDomainClose(ctx, reused);
         return reused;
       }
+      // 复用的句柄也不可用（典型：上一次 close 卡在 disposing）—— 此时既不能再 open
+      // （名字仍被占），也没有活句柄可用，只能降级到文件后备，让功能继续可用。
+      // 【注意】绝不能在这里递归调用 pluginDomain：它还会走 already-open 分支，形成死循环。
       domainPromise = null;
       domainLive = false;
-      throw error;
+      logOnceFallback(error, reused);
+      return fileFallbackDomain();
     });
+    return domainPromise;
   }
-  return domainPromise;
 }
 
 /** 判定「这个名字已经被占用」的重复打开错误（宿主 DomainError 带 code，保底看文案）。 */

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

@@ -24,12 +24,12 @@ export function memberDisplay(member, sessionId) {
  * @param {{provider: string, model: string}} route 目标路由
  * @returns {Promise<{rows: Array<{sessionId: string, label: string, ok: boolean, detail: string}>, okCount: number, failCount: number}>}
  */
-export async function applyModelToMany(ctx, targets, { provider, model }) {
+export async function applyModelToMany(ctx, targets, { provider, model, override }) {
   const rows = [];
   for (const t of targets) {
     const label = memberDisplay(t.member, t.sessionId);
     try {
-      const result = await switchAgentModel(ctx, t.sessionId, provider, model, t.agent ?? null);
+      const result = await switchAgentModel(ctx, t.sessionId, provider, model, t.agent ?? null, { override });
       if (result?.error) {
         rows.push({ sessionId: t.sessionId, label, ok: false, detail: String(result.error) });
       } else {

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

@@ -120,8 +120,8 @@ async function renderMemberDetail(found) {
  * 二参：切换 + 回显查证快照（与 AI 工具 `set_member_model` 同一套落点：
  * 写 override / 事件、登记查证任务、按请求级记录给判定）。
  */
-async function switchMember(ctx, found, provider, model, invocation) {
-  const result = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent);
+async function switchMember(ctx, found, provider, model, invocation, override = false) {
+  const result = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent, { override });
   if (result.error) return { kind: "error", text: `切换失败：${result.error}` };
   // 登记查证任务：该成员下次发起请求时由 agent/request 事件判定，结果会注入发起方
   try {
@@ -179,7 +179,9 @@ export async function handleModelSwitchCommand(ctx, invocation) {
       return { kind: "success", text: await renderMemberDetail(found) };
     }
 
-    // 二参：切换（单个或全部）
+    // 二/三参：切换（单个或全部）。可选尾参 `override` = 旧行为（额外写每轮强制改写的
+    // override）；默认不写 —— 官方 model/selection 链路当轮生效且持久，不压 UI 的选择。
+    const wantOverride = parts.some((x) => x.toLowerCase() === "override");
     const routeRaw = parts[1];
     let provider;
     let model;
@@ -203,11 +205,11 @@ export async function handleModelSwitchCommand(ctx, invocation) {
 
     // 单个目标：沿用原有路径（带查证快照与查证任务登记）
     if (!resolved.all && resolved.targets.length === 1) {
-      return await switchMember(ctx, resolved.targets[0], provider, model, invocation);
+      return await switchMember(ctx, resolved.targets[0], provider, model, invocation, wantOverride);
     }
 
     // 全部目标：串行逐个切，回执必须带完整名单
-    const report = await applyModelToMany(ctx, resolved.targets, { provider, model });
+    const report = await applyModelToMany(ctx, resolved.targets, { provider, model, override: wantOverride });
     const extra = [];
     if (followedLead) {
       extra.push(`模型来源：跟随主代理 ${followedLead.sessionId}（${followedLead.modelSource}）`);

package/lib/features/member-model/create-teammate.js

@@ -144,7 +144,9 @@ export async function createTeammateWithModel(ctx, exec, args) {
   log(ctx, `创建成员 ${name}：中断后等待空闲 → ${JSON.stringify(idleState)}`);
 
   // ③ 写 model/selection：与 set_member_model 完全同一条链路（默认不碰任何 @Remote）
-  const switchResult = await switchAgentModel(ctx, sessionId, modelProvider, model, null);
+  // 建成员即指定模型：成员未挂载、冷恢复走 descriptor，selection 链路管不到首轮 ——
+  // 这里保持旧行为（写 override），与「创建时定模型」的工具语义一致。
+  const switchResult = await switchAgentModel(ctx, sessionId, modelProvider, model, null, { override: true });
   log(ctx, `创建成员 ${name}（${sessionId}）｜ 子代理provider=${subagentProvider} ｜ 中断=${JSON.stringify(interrupt)} ｜ 设模型 ${modelProvider}/${model}=${switchResult.error ? `失败 ${switchResult.error}` : "已写入"}`);
 
   if (switchResult.error) {

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

@@ -334,10 +334,14 @@ export async function appendSelectionEventToLog(ctx, sessionId, provider, model)
  * ① 持久化切换意图：不依赖 live agent —— 成员 inactive/未挂载时也能切，下次运行生效。
  * @returns {Promise<{note: string}>} note 直接拼进回执
  */
-async function persistSwitchIntent(ctx, sessionId, provider, model) {
+async function persistSwitchIntent(ctx, sessionId, provider, model, options = {}) {
+  // override 是**显式参数**（/model-switch … override / set_member_model 的 override:true）：
+  // 默认不写 —— 官方 model/selection 链路当轮立即生效且跨轮持久（干净会话实测），
+  // 每轮强制改写的 override 会压过 UI 的选择，表现为「界面切了、请求不动」。
+  if (options?.override !== true) return { note: "，未写 override（走官方 model/selection 链路）" };
   try {
     await setMemberModelOverride(ctx, sessionId, provider, model);
-    return { note: "，已记录切换意图" };
+    return { note: "，已写 override（每轮强制改写，旧行为；UI 切换依赖同步机制）" };
   } catch (error) {
     return { note: `，意图持久化失败：${String(error?.message ?? error)}` };
   }
@@ -382,10 +386,40 @@ async function tryOfficialSelectModel(ctx, sessionId, provider, model, overrideN
   }
 }
 
-export async function switchAgentModel(ctx, sessionId, provider, model, agent = null) {
+/**
+ * 把切换结果同步到 live agent 的 `options`（宿主官方「查看子智能体」视图读的就是它）。
+ *
+ * 【为什么需要】宿主 experimental/agent-team 的 `memberView()` 里，成员模型取的是
+ * `live.options.model` —— 即 agent **创建时**的 AgentOptions，与我们写的 `model/selection`
+ * 事件无关。不同步的话会出现「界面一直显示创建时的老模型，而实际请求早已换了模型」，
+ * 两边长期对不上，排查时极易误判。
+ *
+ * 【为什么能改】宿主 ReactLoopAgent 构造里是 `this.options = options` 直接引用、**没有 freeze**
+ * （该文件只冻结 boundaryMessages 与请求标记）。这里仍做 `isFrozen` 兜底：
+ * 万一将来宿主冻结了，跳过同步即可，绝不影响切换本身。
+ *
+ * @returns {boolean} 是否真的写进去了
+ */
+export function syncLiveAgentOptions(ctx, live, provider, model) {
+  if (!live || !live.options) return false;
+  try {
+    if (Object.isFrozen(live.options)) {
+      log(ctx, "成员模型切换：live agent 的 options 已被冻结，跳过视图同步（不影响实际请求）");
+      return false;
+    }
+    live.options.provider = provider;
+    live.options.model = model;
+    return true;
+  } catch (error) {
+    log(ctx, `成员模型切换：同步 live options 失败（不影响实际请求）: ${String(error?.message ?? error)}`);
+    return false;
+  }
+}
+
+export async function switchAgentModel(ctx, sessionId, provider, model, agent = null, options = {}) {
   const timer = createStageTimer();
   try {
-    return await applyModelSwitch(ctx, sessionId, provider, model, agent, timer);
+    return await applyModelSwitch(ctx, sessionId, provider, model, agent, timer, options);
   } finally {
     // 无论成功失败都留一行分阶段耗时：排查「切模型卡很久」时直接看慢在哪一段
     log(ctx, `模型切换耗时：${timer.summary()}（标记合计 ${timer.total()}ms）`);
@@ -393,20 +427,27 @@ export async function switchAgentModel(ctx, sessionId, provider, model, agent =
 }
 
 /** 切换主流程（逐段打点，计时器只观测、不改变行为）。 */
-async function applyModelSwitch(ctx, sessionId, provider, model, agent, timer) {
+async function applyModelSwitch(ctx, sessionId, provider, model, agent, timer, options = {}) {
   if (!sessionId) return { error: "缺少 sessionId（无法定位目标会话）" };
-  // ① 持久化切换意图（不依赖 live agent——成员 inactive/未挂载时也能切，下次运行生效）
-  const { note: overrideNote } = await persistSwitchIntent(ctx, sessionId, provider, model);
+  // ① 持久化切换意图（不依赖 live agent——成员 inactive/未挂载时也能切，下次运行生效）。
+  //    只有显式传 override:true 才写 override（旧行为）；默认走官方 model/selection 链路。
+  const { note: overrideNote } = await persistSwitchIntent(ctx, sessionId, provider, model, options);
   timer.mark("写意图");
   const live = agent ?? ctx.get("agents")?.get?.(sessionId) ?? null;
   timer.mark("定位成员");
-  // ② 成员当前未挂载（inactive）：直接把事件写进会话日志——官方 selectionFor 读投影即生效。
-  //    （Team 成员唤醒走 sendMessage → followup，不经过 resumeSetupFor，只记意图不会被应用。）
-  if (typeof live?.ctx?.on !== "function" || !live?.session) {
+  // ② 成员真的没有被实例化（agents 里取不到、或没有 session）：只能把事件写进会话日志，
+  //    官方 selectionFor 读投影即生效。
+  //
+  // 【判定为什么只看 session】旧条件还要求 `typeof live.ctx.on === "function"`，但 agent 空闲后
+  // `ctx.scope` 已 unwind，`live.ctx.on` 不再可用 —— 于是「空闲但仍在内存」的成员被误判成未挂载，
+  // 走这条分支就永远拿不到 live.options 去同步（官方 list_agents / 查看子智能体显示的模型会一直
+  // 停在创建时的值）。实测：官方 list_agents 对空闲成员仍能返回 model 字段，说明 agents.get() 有对象，
+  // 那就是能同步的。写事件与同步 options 都只需要 session，不需要活跃的 ctx。
+  if (!live?.session) {
     const written = await appendSelectionEventToLog(ctx, sessionId, provider, model);
     timer.mark("写会话日志");
     if (written.error) {
-      return { error: `成员未挂载，且写入会话日志失败：${written.error}（切换意图已记录，可稍后重试）` };
+      return { error: `成员未挂载，且写入会话日志失败：${written.error}${overrideNote}，可稍后重试` };
     }
     return { via: `已写入会话日志的 model/selection 事件（成员未挂载）${written.note ? "，" + written.note : ""}${overrideNote}，该成员下次运行时生效` };
   }
@@ -430,7 +471,12 @@ async function applyModelSwitch(ctx, sessionId, provider, model, agent, timer) {
   } catch (error) {
     eventNote = `，事件写入失败：${String(error?.message ?? error)}`;
   }
-  let via = `model/selection 事件（官方投影接管）${eventNote}${overrideNote}，下一回合生效`;
+  // ④-补：把结果同步进 live agent 的 options —— 官方「查看子智能体」视图显示的是它
+  //      （memberView 读 live.options.model），不跟着改就会一直显示创建时的老模型。
+  const synced = syncLiveAgentOptions(ctx, live, provider, model);
+  timer.mark("同步视图");
+  let via = `model/selection 事件（官方投影接管）${eventNote}${overrideNote}，下一回合生效`
+    + (synced ? "；已同步成员视图的模型显示" : "");
   // ⑤ 官方接口优先（若该部署暴露）：
   //    · 新版：ctx.apiProxy.sessions.selectModel（会话级模型选择，持久化到会话）
   //    · 旧版：ctx.get("sessionController").selectModel（Typert @Remote，服务端直调可能不可用）
@@ -549,8 +595,10 @@ export async function readLastRequestModel(sessionId, root = null) {
   const { StringDecoder } = await import("node:string_decoder");
   const buf = await readFile(file); // 日志最大可达数十 MB，异步读避免阻塞事件循环
   const { scanZstdFrames } = await import("../../zstd-frames.js");
-  // 只流式解码最后若干帧：请求头/选择意图判定只关心最近一次，够用且省内存
-  const TAIL_FRAMES = 8;
+  // 只流式解码尾部若干帧：判定只关心最近一次，够用且省内存。
+  // 【为什么不是 8】一个回合常有上百个事件（step/tool/assistant 各占一帧），
+  // 请求头往往落在倒数几十帧之外；取 8 帧会把「跑过很多轮」的会话误报成「从未运行过」。
+  const TAIL_FRAMES = 400;
   let tailFrames;
   try {
     const { frames } = scanZstdFrames(buf);
@@ -565,10 +613,8 @@ export async function readLastRequestModel(sessionId, root = null) {
   let lastRequest = null;
   let lastSelection = null;
   const PENDING_LIMIT = 8 * 1024 * 1024; // 单行缓冲上限：超过即视为异常，避免无上限增长
-  const consume = (line) => {
-    if (!line) return;
-    let event;
-    try { event = JSON.parse(line); } catch { return; }
+  // 事件级处理（行级与全量兜底共用）：只记「最后一次」请求头与选择意图
+  const consumeEvent = (event) => {
     const hit = modelEventOf(event);
     if (hit === null) return;
     if (hit.kind === "request") {
@@ -578,6 +624,12 @@ export async function readLastRequestModel(sessionId, root = null) {
       lastSelection = hit.value;
     }
   };
+  const consume = (line) => {
+    if (!line) return;
+    let event;
+    try { event = JSON.parse(line); } catch { return; }
+    consumeEvent(event);
+  };
   const onChunk = (chunk) => {
     pending += decoder.write(chunk);
     if (pending.length > PENDING_LIMIT) {
@@ -606,5 +658,11 @@ export async function readLastRequestModel(sessionId, root = null) {
   }
   pending += decoder.end();
   consume(pending);
+  // 尾部窗口内没有任何模型事件：退回全量流式扫一遍（复用公共底座，常量内存），
+  // 避免把「跑过很多轮但最近几帧都是工具/正文」的会话误报成「从未运行过」。
+  if (lastRequest === null && lastSelection === null) {
+    const { streamSessionEvents } = await import("../../sessions/log-stream.js");
+    await streamSessionEvents(buf, consumeEvent);
+  }
   return { lastRequest, lastSelection, scanned };
 }

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

@@ -19,6 +19,8 @@ import { applyModelToMany, applyPermissionToMany, renderBatchReport } from "./ba
 import { registerModelSwitchCommand } from "./command.js";
 import { registerContextUsageTool } from "../context-usage/index.js";
 import { registerMemoryRecallTool } from "../memory-recall/index.js";
+// 成员轨迹读取（子代理只有最后一条回复会被自动发回主代理）
+import { registerMemberTraceTool } from "../../sessions/member-trace.js";
 import { registerSessionMessagingTools } from "../session-messaging/index.js";
 import { registerPermSwitchCommand } from "./permission-command.js";
 import { cloneMemberAs, renderCloneMemberResult } from "./clone-member.js";
@@ -96,7 +98,8 @@ async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
       parameters: {
         target: { type: "string", description: "目标成员：成员名、sessionId 或标题关键字。留空 = 全部成员（排除 Lead）" },
         provider: { type: "string", description: "provider 分组名（list_models 的顶层分组）。留空 = 跟随主代理的 provider" },
-        model: { type: "string", description: "该 provider 下的模型 id（含前缀）。留空 = 跟随主代理的 model" }
+        model: { type: "string", description: "该 provider 下的模型 id（含前缀）。留空 = 跟随主代理的 model" },
+        override: { type: "boolean", description: "可选。true = 额外写持久 override（每轮强制改写请求，旧行为；用于官方 selection 链路不生效的场景）。默认 false = 只写 model/selection 事件，走官方链路（UI 切换不被压制）" }
       },
       output: {
         schema: { type: "string" },
@@ -122,10 +125,11 @@ async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
         const pair = await validateModelPair(ctx, provider, model);
         if (pair.error) return `切换失败：${pair.error}`;
         // target 留空 = 作用于全部成员；与聊天指令 /model-switch 走同一套目标解析
+        const wantOverride = args?.override === true;
         const resolved = resolveTargets(ctx, args?.target, { caller });
         if (resolved.error) return `切换失败：${resolved.error}`;
         if (resolved.all) {
-          const report = await applyModelToMany(ctx, resolved.targets, { provider, model });
+          const report = await applyModelToMany(ctx, resolved.targets, { provider, model, override: wantOverride });
           const extra = [];
           if (followedLead) {
             extra.push(`模型来源：跟随主代理 ${followedLead.sessionId}（${followedLead.modelSource}）`);
@@ -135,7 +139,7 @@ async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
           return renderBatchReport(`批量切换模型 → ${provider}/${model}`, report, extra);
         }
         const found = resolved.targets[0];
-        const switchResult = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent);
+        const switchResult = await switchAgentModel(ctx, found.sessionId, provider, model, found.agent, { override: wantOverride });
         if (switchResult.error) return `切换失败：${switchResult.error}`;
         const memberLabel = found.member?.name ? `${found.member.name}(${found.sessionId})` : found.sessionId;
         // 查证（注册 job，不阻塞）：登记待查证项 → 该成员下次发起请求时由 agent/request 事件判定
@@ -312,6 +316,14 @@ async function describeSwitchSnapshot(ctx, sessionId, provider, model) {
     } catch (error) {
       log(ctx, `记忆取回工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
     }
+    try {
+      // 成员轨迹：子代理只有最后一条回复会被自动发回主代理，中间的思考与工具调用靠这个工具读
+      if (registerMemberTraceTool(ctx, defineTool, tools)) {
+        log(ctx, "成员轨迹工具已注册 (read_member_trace)");
+      }
+    } catch (error) {
+      log(ctx, `成员轨迹工具注册失败（不影响其它工具）: ${String(error?.message ?? error)}`);
+    }
     log(ctx, "成员模型工具已注册 (list_models / set_member_model)");
     // 把成员「换名」成新成员（新建 + 搬会话内容）。
     // 宿主把成员名钉死为不可变身份字段：`team/member` 投影里 name/provider/context 一变就抛

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

@@ -18,6 +18,8 @@
 //
 // 【失败即静默】日志缺失/损坏、用量读不到、首回合无上次用量 —— 一律返回 null，绝不阻断回合。
 import { readRecentUserTurns } from "../../sessions/events.js";
+// 会话目标解析的公共底座（id / 前缀 / 标题 / 成员名；与成员轨迹共用）
+import { resolveTargetSession } from "../../sessions/resolve.js";
 import { log } from "../../shared/log.js";
 import { cfg } from "../../core/config.js";
 import { writeJsonAtomicSync, readJsonSafeSync } from "../../shared/json-store.js";
@@ -329,40 +331,12 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
  * @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");
-  // 异步遍历：会话目录可能上千个，同步 stat/readdir 会把事件循环钉住
-  const { readdir, stat } = await import("node:fs/promises");
-  const { join } = await import("node:path");
-  const root = sessionsRootOf();
-  const ids = [];
-  const isDirectory = async (p) => {
-    try { return (await stat(p)).isDirectory(); } catch { return false; }
-  };
-  if (root && await isDirectory(root)) {
-    for (const proj of await readdir(root)) {
-      const pp = join(root, proj);
-      if (!(await isDirectory(pp))) continue;
-      for (const dir of await readdir(pp)) {
-        if (!(await isDirectory(join(pp, dir)))) 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;
+  // 实现已抽到公共底座 sessions/resolve.js（成员轨迹与记忆取回共用同一套解析）。
+  //
+  // 旧实现在这里用 `dir.startsWith("session-")` 判断会话目录，而子代理/成员会话的目录名是
+  // **裸 UUID**（不带 session- 前缀），导致那些会话永远进不了候选集 —— 完整 id 与前缀都解析不出来。
+  // 公共底座改为「目录里有会话日志文件」作为判据，与目录命名规则解耦。
+  //
+  // 顺带获得成员名支持：`recall_memory({ session: "writer" })` 这类写法现在也能解析。
+  return await resolveTargetSession(ctx, want, selfId);
 }

package/lib/features/session-ops-routes.js

@@ -7,6 +7,7 @@
  * 其余（会话操作实现、标题工具、日志）在本模块内直接 import，不再依赖 apply 的作用域。
  */
 import { log } from '../shared/log.js';
+import { restoreSessionsFromExport } from '../sessions/export-restore.js';
 import { MSG_NEED_SESSION_ID } from '../shared/constants.js';
 import { titleString, foldTitle, workspaceNameOf, archiveTitleWithWs, stripArchiveWsPrefix } from './rename/title.js';
 import { unarchiveSession, deleteSession, undoLastMessage, deleteBatchSessions, deleteByRule, emptyTrash, purgeExpiredTrash } from './session-ops.js';
@@ -107,6 +108,26 @@ export function registerSessionOpsRoutes({ webServer, ctx, send, readJson, inval
     }
   };
 
+  // ---------- POST /api/session-conductor/restore-from-export ----------
+  // 把「会话导出包」（解压后的明文 jsonl 目录）覆盖回运行时格式。
+  // 为什么不能直接拷：导出包是明文 session.v4.jsonl，而运行时读的是带校验和的多帧
+  // session.v4.jsonl.zstd；直接拷会被宿主判「总和检查码不匹配」或 corrupt。
+  // 默认 dryRun（只报告会覆盖哪些、事件多少），body.dryRun=false 才写盘。
+  route("/api/session-conductor/restore-from-export", "restore-from-export-failed", async (body, res) => {
+    const exportDir = typeof body?.exportDir === "string" ? body.exportDir : "";
+    if (exportDir === "") {
+      return send(res, 400, { ok: false, error: { code: "bad-request", message: "需要 exportDir（解压后的导出包目录绝对路径）" } });
+    }
+    const result = await restoreSessionsFromExport({
+      exportDir,
+      sessionIds: Array.isArray(body?.sessionIds) ? body.sessionIds : undefined,
+      dryRun: body?.dryRun !== false,
+      eventsPerFrame: typeof body?.eventsPerFrame === "number" ? body.eventsPerFrame : undefined,
+      ctx,
+    });
+    send(res, result.ok ? 200 : 400, result);
+  }, { requireSessionId: false });
+
   // ---------- POST /api/session-conductor/archive ----------
   // 归档时给标题加「[工作区名] 」前缀（数据层带前缀，面板显示剥离，已归档视图按前缀分组）。
   route("/api/session-conductor/archive", "archive-failed", async (body, res) => {

package/lib/sessions/events.js

@@ -22,6 +22,8 @@ import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
 import { streamDecodedFrames } from "../zstd-frames.js";
+// 流式逐事件读取的公共底座（与成员轨迹共用，避免帧边界/坏行/解码器收尾各写一套）
+import { streamSessionEvents } from "./log-stream.js";
 import { findSessionLog } from "../session-log.js";
 
 let interruptedTurnClosers = null;
@@ -276,15 +278,12 @@ export async function readRecentUserTurns(ctx, sessionId, opts = {}) {
   const rounds = Number.isSafeInteger(opts.rounds) && opts.rounds > 0 ? opts.rounds : 3;
   const perItem = Number.isSafeInteger(opts.maxCharsPerItem) && opts.maxCharsPerItem > 0 ? opts.maxCharsPerItem : DEFAULT_MAX_CHARS_PER_ITEM;
   const buf = await readFile(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; }
+  // 流式逐事件读取走公共底座（log-stream.js）：帧边界跨行、坏行跳过、解码器收尾这些细节
+  // 与「成员轨迹」共用同一份实现，避免两边各写一套后只在某类会话上少读一段。
+  const onEvent = (event) => {
     const type = event?.type;
     if (type === "turn/end") {
       // 回合结束：此后到来的用户消息算新的一轮
@@ -312,17 +311,7 @@ export async function readRecentUserTurns(ctx, sessionId, opts = {}) {
     }
   };
 
-  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);
+  await streamSessionEvents(buf, onEvent);
 
   return turns.map((t) => ({ time: t.time, userText: t.userText, agentText: t.agentText }));
 }