dsh-session-conductor 1.3.19 → 1.4.4

package/README.md

@@ -86,7 +86,9 @@ send_to_session({ sessionId, text, mode, dryRun }) // sessionId/text 必填；mo
 recall_memory({ rounds, session })                 // 都可空：rounds 默认取配置、上限 50；session 空=自己
 context_usage({})                                  // 无参
 read_member_trace({ session, rounds, detail, include, maxCharsPerItem })
-                                                   // session 空=自己；rounds 默认 1（上限 20）；detail=summary|full
+                                                   // session 空=自己（可填成员名/id/前缀/标题）；rounds 默认 1（上限 20）
+                                                   // detail=summary(每条一行)|full(完整文本)；include 可裁 reasoning,text,tool
+                                                   // maxCharsPerItem 单条截断（默认 800）
 ```
 
 典型调用：
@@ -103,6 +105,15 @@ clone_member_as({ source: "probe1", name: "rename1" })
 
 // 给另一个会话发消息（dryRun 先预览目标状态与限流余量）
 send_to_session({ sessionId: "session-xxxx", text: "继续刚才的任务", dryRun: true })
+
+// 看子代理最近一轮的执行过程（子代理只有最后一条回复会被自动发回，中间的思考靠这里读）
+read_member_trace({ session: "writer" })
+
+// 看最近 3 轮，只要思考与工具调用
+read_member_trace({ session: "writer", rounds: 3, include: "reasoning,tool" })
+
+// 要完整文本（默认 summary 每条压成一行）
+read_member_trace({ session: "writer", detail: "full" })
 ```
 
 ## API

package/lib/apply.js

@@ -317,24 +317,38 @@ export async function apply(ctx, config = {}) {
     // 不依赖官方「投影 pending + 请求头链」（那条链在新回合会回落部署默认模型），
     // override 由 set_member_model 写入（domain 持久 + 内存缓存镜像），每轮都改 → 跨轮持久。
     ctx.on("agent/request", async ({ agent }, next) => {
-      const resolved = await next();
       const sessionId = agent?.session?.id;
+      // ① 进入即读 override 与官方 pending —— 这是 UI 切换「立即生效」的关键。
+      //    旧实现把同步放在 await next() 之后：请求组装阶段官方链路可能解析出旧模型
+      //    （system-prompt/assemble 被缓存时 selection.assembled 停留旧值），返回阶段我们
+      //    再拿旧 override 一盖，本次请求就定型了；残留的 pending 要等下一轮才被读到，
+      //    表现为「UI 切了模型，AI 用旧模型回完一轮才切过去」。pending 只会被请求后的
+      //    consumeSelection 清掉，waterfall 进入时它必然还在 —— 所以进入时同步最可靠。
       let override = await getMemberModelOverride(ctx, sessionId);
-      // 官方界面切换同步：override 优先级高于官方链路，若用户在主会话界面用官方选择器改了模型，
-      // 不把新值同步进 override 就会出现「界面显示新模型、请求一直走旧模型」且无处可查
-      // （实测事故：批量写入的 override 把会话钉在已失效 provider 上，界面切换、改日志、重启全无效）。
-      // 做法是同步而不是清除：官方切换会写投影 pending，这里把它写回 override，
-      // 既让界面选择立刻生效，又保留 override 的跨轮持久能力（不会回落部署默认）。
       try {
         const pending = readOfficialPendingSelection(ctx, agent);
         const adopt = adoptOfficialSelection(override, pending);
         if (adopt) {
           await setMemberModelOverride(ctx, sessionId, adopt.provider, adopt.model);
           override = adopt;
-          log(ctx, `官方界面切换已同步到 override：${sessionId} → ${adopt.provider}/${adopt.model}`);
+          log(ctx, `官方界面切换已同步到 override（请求前）：${sessionId} → ${adopt.provider}/${adopt.model}`);
+        }
+      } catch (error) {
+        // 同步失败绝不打断请求：退回用旧 override
+        log(ctx, `官方切换同步失败（不影响本次请求）: ${String(error?.message ?? error)}`);
+      }
+      const resolved = await next();
+      // ② 返回阶段兜底：极端情况下进入时投影尚未 fold 到最新（刚 append 事件还没被折叠），
+      //    返回阶段再给一次机会；正常路径这里 pending 与 override 已一致，不会再写。
+      try {
+        const pending = readOfficialPendingSelection(ctx, agent);
+        const adopt = adoptOfficialSelection(override, pending);
+        if (adopt) {
+          await setMemberModelOverride(ctx, sessionId, adopt.provider, adopt.model);
+          override = adopt;
+          log(ctx, `官方界面切换已同步到 override（返回兜底）：${sessionId} → ${adopt.provider}/${adopt.model}`);
         }
       } catch (error) {
-        // 同步失败绝不打断请求：退回用旧 override（行为与修复前一致）
         log(ctx, `官方切换同步失败（不影响本次请求）: ${String(error?.message ?? error)}`);
       }
       const applied = applyModelOverride(resolved, override);

package/lib/client.js

@@ -1,3 +1,15 @@
+function __dshScLoad(registration) {
+  const host = window.__ModuleLoader__;
+  if (registration.id === "dsh-session-conductor") { host.load(registration); return; }
+  const cycle = (window.__dshScCycle = (window.__dshScCycle ?? 0) + (window.__dshScCycleOpen ? 0 : 1));
+  window.__dshScCycleOpen = true;
+  const seen = (window.__dshScSeen ??= new Set());
+  const id = `${registration.id}@${cycle}`;
+  if (seen.has(id)) return;
+  seen.add(id);
+  host.load({ ...registration, id });
+}
+window.__dshScCycleOpen = false;
 // dsh-session-conductor —— 会话管理增强插件（浏览器半边）。
 // dsh-skip-quality（conv-log：fallback 行为 UI 文案内嵌 JSON，非文档注释，属规则误报）
 //
@@ -72,7 +84,7 @@ window.__SC_TR__ = (key, vars) => {
   return String(val);
 };
 
-window.__ModuleLoader__.load({
+__dshScLoad({
   id: "dsh-session-conductor",
   factory: (require) => {
     var module = { exports: {} };
@@ -2407,7 +2419,7 @@ window.__ModuleLoader__.load({
     return module.exports;
   },
 });
-window.__ModuleLoader__.load({
+__dshScLoad({
   id: "dsh-session-conductor-group",
   factory: (require) => {
     var module = { exports: {} };
@@ -2522,7 +2534,7 @@ window.__ModuleLoader__.load({
  * 排队消息列表仍由原生 dock 负责（不重复渲染）。不改 DSH 原生源码。
  */
 
-window.__ModuleLoader__.load({
+__dshScLoad({
   id: "dsh-session-conductor-processing",
   factory: (require) => {
     var module = { exports: {} };
@@ -2627,7 +2639,7 @@ window.__ModuleLoader__.load({
  * 设置 → 插件配置 → 「压缩模型」：会话模型旁单独选压缩用模型（省 pro 成本）。
  * 可选：跟随会话模型（默认）/ 指定便宜模型（agnes 等）。写入 /api/session-conductor/compaction-model。
  */
-window.__ModuleLoader__.load({
+__dshScLoad({
   id: "dsh-session-conductor-compaction-model",
   factory: (require) => {
     var module = { exports: {} };
@@ -2751,7 +2763,7 @@ window.__ModuleLoader__.load({
  * UI 组件 scs_* = 页面级。
  */
 
-window.__ModuleLoader__.load({
+__dshScLoad({
   id: "dsh-session-conductor-settings",
   factory: (require) => {
     var module = { exports: {} };

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

@@ -98,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" },
@@ -124,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}）`);
@@ -137,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 事件判定

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/export-restore.js

@@ -0,0 +1,384 @@
+// dsh-session-conductor — 从「会话导出包」恢复/覆盖会话
+//
+// 【为什么需要】DSH 的会话导出包是**明文 jsonl** 目录结构（`session.v4.jsonl` +
+// `subagents/<id>/session.v4.jsonl` + `media/`），而运行时读的是
+// `session.v4.jsonl.zstd` —— 带校验和的**多帧** zstd 容器，首帧必须恰好一行 header。
+// 因此「把备份覆盖回去」不是简单拷贝：必须按官方容器格式重新编码，否则宿主会报
+// 「会话文件 总和检查码不匹配」或 `corrupt session log`（本机两种都踩过）。
+//
+// 【三种坑与本模块的对应做法】
+//   ① 无校验和帧 ⇒ 宿主拒读：压缩时固定带 ZSTD_c_checksumFlag（复用 zstd-frames 的 CHECKSUM_OPTIONS）。
+//   ② 单帧塞进整份日志 ⇒ 读取端一次性解压整帧、内存尖峰：按 eventsPerFrame 分帧（宿主自己也是分批 append）。
+//   ③ 覆盖 seeded 会话时打乱 inherited 标记 ⇒ 宿主断言 "seeded session requires an inherited event count"：
+//      只覆盖日志文件本身，不动 projcache 与目录内其它文件；报告里回显 inherited 标记位置供核对。
+//
+// 【安全】默认 dryRun：只扫描并报告「会覆盖哪些会话、事件多少、帧多少」，不写盘。
+// 真正写盘时：先校验 header.id 与目标一致、事件 seq 严格连续，再写 tmp 后 rename 原子替换；
+// 写完重新逐帧解码复核事件数与末事件，复核不通过即记为错误。
+
+import { readFileSync, writeFileSync, renameSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import zlib from 'node:zlib';
+import { createHash } from 'node:crypto';
+import { scanZstdFrames, validateHeaderFrame, decodeAllFrames, CHECKSUM_OPTIONS } from '../zstd-frames.js';
+import { sessionsRootOf, findSessionLogById } from './events.js';
+import { log } from '../shared/log.js';
+
+/** 每个 zstd 事件帧里装多少条事件（宿主自己也是分批 append，太大会让读取端内存尖峰）。 */
+const DEFAULT_EVENTS_PER_FRAME = 1000;
+
+/** 导出包里明文的固定文件名。 */
+const PLAIN_NAME = 'session.v4.jsonl';
+
+/**
+ * 把一个明文 jsonl 编码成 DSH 官方 zstd 多帧容器（首帧恰好一行 header，每帧带校验和）。
+ *
+ * @param {string} plainText 明文 jsonl 全文
+ * @param {{eventsPerFrame?: number}} [opts]
+ * @returns {{ok: true, buffer: Buffer, header: object, eventCount: number, frames: number, inheritedAt: number|null}
+ *          | {ok: false, error: string}}
+ */
+export function encodePlainToZstd(plainText, opts = {}) {
+  const eventsPerFrame = Math.max(1, opts.eventsPerFrame ?? DEFAULT_EVENTS_PER_FRAME);
+  const lines = String(plainText).split('\n').filter((l) => l.trim() !== '');
+  if (lines.length < 2) return { ok: false, error: '明文事件不足（至少需要 header + 1 条事件）' };
+
+  let header;
+  try {
+    header = JSON.parse(lines[0]);
+  } catch (error) {
+    return { ok: false, error: `首行不是合法 JSON：${String(error?.message ?? error)}` };
+  }
+  if (header?.type !== 'session' || !header?.id) return { ok: false, error: '首行不是 session header' };
+
+  // 事件必须 seq 严格连续：不连续的日志写出去宿主也会判 corrupt，这里直接拒绝
+  const events = [];
+  let prev = -1;
+  let gaps = 0;
+  let bad = 0;
+  let inheritedAt = null;
+  for (let i = 1; i < lines.length; i += 1) {
+    let e;
+    try {
+      e = JSON.parse(lines[i]);
+    } catch {
+      bad += 1;
+      continue;
+    }
+    if (typeof e?.seq === 'number') {
+      if (prev >= 0 && e.seq !== prev + 1) gaps += 1;
+      prev = e.seq;
+    }
+    if (e?.type === 'session/end-seed' && e?.data?.inherited === true) inheritedAt = e.seq;
+    events.push(e);
+  }
+  if (bad > 0) return { ok: false, error: `明文里有 ${bad} 行坏 JSON` };
+  if (gaps > 0) return { ok: false, error: `明文事件 seq 不连续（${gaps} 处），拒绝编码` };
+
+  const frames = [zlib.zstdCompressSync(Buffer.from(lines[0] + '\n', 'utf8'), CHECKSUM_OPTIONS)];
+  for (let i = 0; i < events.length; i += eventsPerFrame) {
+    const chunk = events.slice(i, i + eventsPerFrame).map((e) => JSON.stringify(e)).join('\n') + '\n';
+    frames.push(zlib.zstdCompressSync(Buffer.from(chunk, 'utf8'), CHECKSUM_OPTIONS));
+  }
+  return { ok: true, buffer: Buffer.concat(frames), header, eventCount: events.length, frames: frames.length, inheritedAt };
+}
+
+/**
+ * 扫描导出包目录，列出「里面有哪些会话、各自对应哪个目标目录」。
+ *
+ * 目标目录解析顺序：① 按会话 id 找现有会话目录（覆盖已有会话）② 找不到就用同族目录
+ * （导出包里父会话所在的项目目录）新建 —— 同族会话必然同 cwd，避免自己实现路径编码。
+ *
+ * @param {string} exportDir 解压后的导出包目录
+ * @param {{home?: string}} [opts]
+ * @returns {{entries: Array<object>, error?: string}}
+ */
+export function scanExportDir(exportDir, opts = {}) {
+  if (!existsSync(exportDir)) return { entries: [], error: `导出目录不存在：${exportDir}` };
+  // 注意：sessionsRootOf() 不接受参数（它只读 process.env.DSH_HOME），
+  // 所以要支持自定义 home 必须自己拼 <home>/sessions，不能把 home 当参数传进去。
+  const root = opts.home ? join(opts.home, 'sessions') : sessionsRootOf();
+  const entries = [];
+
+  const readHeaderOf = (plainPath) => {
+    try {
+      const firstLine = readFileSync(plainPath, 'utf8').split('\n', 1)[0];
+      return JSON.parse(firstLine);
+    } catch {
+      return null;
+    }
+  };
+
+  // 父会话（导出包根下的 session.v4.jsonl）
+  const parentPlain = join(exportDir, PLAIN_NAME);
+  let familyDir = null;
+  if (existsSync(parentPlain)) {
+    const header = readHeaderOf(parentPlain);
+    if (header?.id) {
+      const existing = findSessionLogById(header.id, root);
+      const targetDir = existing ? join(existing, '..') : null;
+      if (targetDir) familyDir = join(targetDir, '..');
+      entries.push({
+        role: 'parent',
+        id: header.id,
+        plainPath: parentPlain,
+        targetDir,
+        action: targetDir ? 'overwrite' : 'skip',
+        reason: targetDir ? '' : '找不到该会话的现有目录',
+      });
+    }
+  }
+
+  // 子代理（subagents/<id>/session.v4.jsonl）
+  const subsDir = join(exportDir, 'subagents');
+  if (existsSync(subsDir)) {
+    for (const name of readdirSync(subsDir)) {
+      const plainPath = join(subsDir, name, PLAIN_NAME);
+      if (!existsSync(plainPath)) continue;
+      const header = readHeaderOf(plainPath);
+      const id = header?.id;
+      if (!id) {
+        entries.push({ role: 'subagent', id: name, plainPath, targetDir: null, action: 'skip', reason: '明文 header 无法解析' });
+        continue;
+      }
+      const existing = findSessionLogById(id, root);
+      if (existing) {
+        entries.push({ role: 'subagent', id, plainPath, targetDir: join(existing, '..'), action: 'overwrite' });
+      } else if (familyDir) {
+        entries.push({ role: 'subagent', id, plainPath, targetDir: join(familyDir, id), action: 'create' });
+      } else {
+        entries.push({ role: 'subagent', id, plainPath, targetDir: null, action: 'skip', reason: '既无现有目录、又无同族目录可落' });
+      }
+      if (id !== name) {
+        const last = entries[entries.length - 1];
+        last.reason = `${last.reason ? last.reason + '；' : ''}目录名(${name})与 header.id 不一致`;
+      }
+    }
+  }
+  return { entries };
+}
+
+/**
+ * 从导出包的 `media/` 恢复附件对象到内容寻址对象库。
+ *
+ * 【为什么必须做】会话消息里引用的是 `sha256:<64hex>` 附件对象，宿主按
+ * `<DSH_HOME>/attachments/v1/objects/<前两位>/<64hex>` 取文件。只覆盖会话日志而不恢复
+ * 附件，会话就会在下一轮报「Attachment object is missing」（本机实测：恢复 4 个会话后
+ * 168 个引用里缺 27 个）。
+ *
+ * 【安全】导出包里的文件名形如 `sha256:<64hex>.<ext>`，这里**逐个重算 sha256 与文件名比对**，
+ * 不一致直接拒绝（不把坏文件写进对象库）；已存在的对象跳过（内容寻址天然幂等）。
+ *
+ * @param {object} o
+ * @param {string} o.exportDir 解压后的导出包目录
+ * @param {string} o.home DSH_HOME
+ * @param {boolean} [o.dryRun] true 只统计不写盘（默认 true）
+ * @returns {{placed:number, existed:number, rejected:number, dryRun:boolean, errors:string[]}}
+ */
+export async function restoreExportMedia(o) {
+  const dryRun = o?.dryRun !== false;
+  const mediaDir = join(o?.exportDir ?? '', 'media');
+  const out = { placed: 0, existed: 0, rejected: 0, dryRun, errors: [] };
+  if (!existsSync(mediaDir)) return out;
+  const objRoot = join(o?.home ?? '', 'attachments', 'v1', 'objects');
+
+  for (const name of readdirSync(mediaDir)) {
+    const m = /^sha256:([0-9a-f]{64})(?:\.[A-Za-z0-9]+)?$/.exec(name);
+    if (!m) {
+      out.rejected += 1;
+      out.errors.push(`跳过（命名不合规范）：${name}`);
+      continue;
+    }
+    const hash = m[1];
+    const target = join(objRoot, hash.slice(0, 2), hash);
+    if (existsSync(target)) {
+      out.existed += 1;
+      continue;
+    }
+    let buf;
+    try {
+      buf = readFileSync(join(mediaDir, name));
+    } catch (e) {
+      out.rejected += 1;
+      out.errors.push(`${name}：读取失败 ${String(e?.message ?? e)}`);
+      continue;
+    }
+    // 内容自证：重算 sha256 必须等于文件名里的 hash
+    const actual = createHash('sha256').update(buf).digest('hex');
+    if (actual !== hash) {
+      out.rejected += 1;
+      out.errors.push(`${name}：内容校验失败（实际 sha256=${actual.slice(0, 12)}…），拒绝写入`);
+      continue;
+    }
+    if (dryRun) {
+      out.placed += 1;
+      continue;
+    }
+    try {
+      mkdirSync(join(objRoot, hash.slice(0, 2)), { recursive: true, mode: 0o700 });
+      writeFileSync(target, buf, { mode: 0o600 });
+      out.placed += 1;
+    } catch (e) {
+      out.rejected += 1;
+      out.errors.push(`${name}：写入失败 ${String(e?.message ?? e)}`);
+    }
+  }
+  return out;
+}
+
+/**
+ * 恢复后让「新日志」真正生效：清投影缓存 + 尝试把 live 会话卸载回冷状态。
+ *
+ * 【为什么必须做】DSH 有**三层状态**：会话日志（磁盘）/ projcache（投影缓存）/ 进程内存里的 agent。
+ * 只覆盖磁盘日志时，界面仍显示旧内容——本机实测：日志 11:20 已覆盖，projcache 还停在 11:06，
+ * 打开会话看到的就是替换前的内容。因此恢复后必须：
+ *   ① 删掉该会话的 projcache 条目（否则冷读仍会拿旧投影）；
+ *   ② 若会话还是 live 的（内存里有 agent），把它 detach 回冷状态，下次打开才会重新从磁盘读。
+ *
+ * detach 需要插件 ctx（要 agents/sessions 服务）；没有 ctx 时只清缓存并如实标注，
+ * 由调用方提示「需重载/重启宿主」。
+ *
+ * @param {object} o
+ * @param {string} o.home DSH_HOME
+ * @param {string} o.sessionId 会话 id
+ * @param {object} [o.ctx] 插件 ctx（有则尝试 detach）
+ * @returns {Promise<{projcacheCleared: boolean, detached: boolean, note?: string}>}
+ */
+async function invalidateAfterRestore({ home, sessionId, ctx }) {
+  const out = { projcacheCleared: false, detached: false };
+  // ① 清投影缓存
+  try {
+    const cacheFile = join(home, 'storages', 'session_projcache', 'sessions', `${sessionId}.json`);
+    if (existsSync(cacheFile)) {
+      unlinkSync(cacheFile);
+      out.projcacheCleared = true;
+    }
+  } catch (error) {
+    out.note = `清投影缓存失败：${String(error?.message ?? error)}`;
+  }
+  // ② 尝试 detach（让内存态丢弃；非 live 幂等返回 ok）
+  if (ctx) {
+    try {
+      const { detachSessionAgent } = await import('./detach.js');
+      const r = await detachSessionAgent(ctx, sessionId);
+      out.detached = r?.ok === true;
+      if (!r?.ok && r?.error?.message && !out.note) out.note = `detach 未执行：${r.error.message}`;
+    } catch (error) {
+      if (!out.note) out.note = `detach 失败：${String(error?.message ?? error)}`;
+    }
+  } else if (!out.note) {
+    out.note = '未传 ctx，未尝试 detach（若会话仍打开着，需重载/重启宿主才能看到新内容）';
+  }
+  return out;
+}
+
+/**
+ * 按导出包恢复/覆盖会话。
+ *
+ * @param {object} o
+ * @param {string} o.exportDir 解压后的导出包目录
+ * @param {string} [o.home] DSH_HOME（缺省按宿主约定推导）
+ * @param {string[]} [o.sessionIds] 只处理这些会话（缺省全部）
+ * @param {boolean} [o.dryRun] true 只扫描报告（默认 true）
+ * @param {number} [o.eventsPerFrame]
+ * @param {object} [o.ctx] 可选：传插件 ctx 时顺带写日志，并尝试 detach（把 live 会话卸载回冷状态）
+ * @param {boolean} [o.invalidate] 默认 true：恢复后清该会话 projcache，避免「覆盖了但界面还是旧内容」
+ * @param {boolean} [o.media] 默认 true：同时把导出包 media/ 里的附件恢复到对象库
+ *   （只覆盖日志不恢复附件，会话下一轮会报 Attachment object is missing）
+ * @returns {Promise<{ok:boolean, dryRun:boolean, results:Array<object>, errors:Array<string>}>}
+ */
+export async function restoreSessionsFromExport(o) {
+  const dryRun = o?.dryRun !== false;
+  const { entries, error } = scanExportDir(o?.exportDir, { home: o?.home });
+  if (error) return { ok: false, dryRun, results: [], errors: [error] };
+  const only = Array.isArray(o?.sessionIds) && o.sessionIds.length > 0 ? new Set(o.sessionIds) : null;
+  const results = [];
+  const errors = [];
+
+  for (const entry of entries) {
+    if (only && !only.has(entry.id)) continue;
+    if (entry.action === 'skip') {
+      results.push({ ...entry, status: 'skipped' });
+      continue;
+    }
+    let plain;
+    try {
+      plain = readFileSync(entry.plainPath, 'utf8');
+    } catch (e) {
+      errors.push(`${entry.id}：读明文失败 ${String(e?.message ?? e)}`);
+      results.push({ ...entry, status: 'error' });
+      continue;
+    }
+    const encoded = encodePlainToZstd(plain, { eventsPerFrame: o?.eventsPerFrame });
+    if (!encoded.ok) {
+      errors.push(`${entry.id}：${encoded.error}`);
+      results.push({ ...entry, status: 'error' });
+      continue;
+    }
+    if (encoded.header.id !== entry.id) {
+      errors.push(`${entry.id}：明文 header.id=${encoded.header.id} 与目录不一致`);
+      results.push({ ...entry, status: 'error' });
+      continue;
+    }
+    const summary = {
+      ...entry,
+      status: dryRun ? 'would-restore' : 'restored',
+      eventCount: encoded.eventCount,
+      frames: encoded.frames,
+      inheritedAt: encoded.inheritedAt,
+      bytes: encoded.buffer.length,
+    };
+    if (dryRun) {
+      results.push(summary);
+      continue;
+    }
+    // 真正写盘：目录缺则建，写 tmp 后 rename 原子替换，再逐帧复核
+    try {
+      if (!existsSync(entry.targetDir)) {
+        mkdirSync(entry.targetDir, { recursive: true, mode: 0o700 });
+        summary.created = true;
+      }
+      const target = join(entry.targetDir, 'session.v4.jsonl.zstd');
+      const tmp = join(entry.targetDir, '.session.restore.tmp');
+      writeFileSync(tmp, encoded.buffer, { mode: 0o600 });
+      renameSync(tmp, target);
+      const after = readFileSync(target);
+      const headerCheck = await validateHeaderFrame(after);
+      const { frames } = scanZstdFrames(after);
+      const checksums = frames.map((fr) => (after.readUInt8(fr.start + 4) & 0x04) !== 0);
+      const backLines = (await decodeAllFrames(after)).split('\n').filter((l) => l.trim() !== '');
+      const okVerify = headerCheck.ok && checksums.every(Boolean) && backLines.length - 1 === encoded.eventCount;
+      summary.verified = okVerify;
+      summary.sizeMB = Math.round((statSync(target).size / 1048576) * 10) / 10;
+      if (!okVerify) {
+        errors.push(
+          `${entry.id}：写后复核未通过（首帧 ${headerCheck.ok}、校验和 ${checksums.every(Boolean)}、事件 ${backLines.length - 1}/${encoded.eventCount}）`,
+        );
+      } else if (o?.invalidate !== false) {
+        // 复核通过才失效：顺序很重要——先确保磁盘是对的，再丢缓存/卸载
+        const inv = await invalidateAfterRestore({ home: o?.home ?? '', sessionId: entry.id, ctx: o?.ctx });
+        summary.projcacheCleared = inv.projcacheCleared;
+        summary.detached = inv.detached;
+        if (inv.note) summary.note = inv.note;
+      }
+      results.push(summary);
+    } catch (e) {
+      errors.push(`${entry.id}：写盘失败 ${String(e?.message ?? e)}`);
+      results.push({ ...summary, status: 'error' });
+    }
+  }
+  // 附件：只恢复会话日志、不恢复 media 会让会话下一轮报 Attachment object is missing
+  let media = null;
+  if (o?.media !== false) {
+    try {
+      media = await restoreExportMedia({ exportDir: o?.exportDir, home: o?.home ?? '', dryRun });
+      if (media.rejected > 0) errors.push(...media.errors.slice(0, 5));
+    } catch (e) {
+      errors.push(`恢复附件失败：${String(e?.message ?? e)}`);
+    }
+  }
+  if (o?.ctx) {
+    log(o.ctx, `导出包恢复：${dryRun ? '预览' : '执行'} ${results.length} 项，附件 ${media ? `新增 ${media.placed}/已有 ${media.existed}/拒绝 ${media.rejected}` : '未处理'}，错误 ${errors.length} 条`);
+  }
+  return { ok: errors.length === 0, dryRun, results, errors, media };
+}

package/lib/sessions/member-trace.js

@@ -16,6 +16,8 @@ import { readFile } from "node:fs/promises";
 import { findSessionLogById, sessionsRootOf } from "./events.js";
 // 流式逐事件读取的公共底座（与记忆取回共用；本模块只负责「按 turn/step 怎么组织」）
 import { streamSessionEvents } from "./log-stream.js";
+// 目标解析的公共底座（id / 前缀 / 标题 / 成员名；与记忆取回共用）
+import { resolveTargetSession } from "./resolve.js";
 
 /** 单条文本默认截断长度（summary 模式下更短，见 SUMMARY_CLIP）。 */
 const DEFAULT_MAX_ITEM = 800;
@@ -292,9 +294,10 @@ export function registerMemberTraceTool(ctx, defineTool, tools, deps = {}) {
       const selfId = exec?.agent?.session?.id;
       if (!selfId) return "拿不到当前会话 id，无法读取轨迹。";
 
-      // 目标解析：与记忆取回共用同一套（成员名 → id / 前缀 / 标题；命中多个给候选，不猜）
+      // 目标解析走公共底座（sessions/resolve.js）：id / id 前缀 / 标题 / 成员名，命中多个给候选不猜。
+      // 两个工具（本工具与记忆取回）共用同一套，避免各自一套解析各缺一块。
       const want = typeof args?.session === "string" ? args.session.trim() : "";
-      const resolveFn = resolve ?? (await import("../features/memory-recall/index.js")).resolveSessionTarget;
+      const resolveFn = resolve ?? resolveTargetSession;
       const rounds = Math.min(
         Number.isSafeInteger(args?.rounds) && args.rounds > 0 ? args.rounds : 1,
         maxRounds,
@@ -308,12 +311,14 @@ export function registerMemberTraceTool(ctx, defineTool, tools, deps = {}) {
 
       let targetId = selfId;
       if (want && want !== selfId) {
-        const hit = await resolveFn(ctx, want, selfId);
+        const hit = await resolveFn(ctx, want, selfId, { agent: exec?.agent });
         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 前缀 / 标题。`;
+        if (!hit?.id) {
+          return `找不到目标会话「${want}」：没有匹配的成员名 / 会话 id / id 前缀 / 标题。`;
+        }
         targetId = hit.id;
       }
 

package/lib/sessions/resolve.js

@@ -0,0 +1,120 @@
+// dsh-session-conductor — 会话目标解析（公共底座）
+//
+// 【为什么抽出来】「用户/AI 给一个模糊的目标（id / id 前缀 / 标题 / 成员名），解析成确切 sessionId」
+// 这件事原先只写在记忆取回里（`resolveSessionTarget`），成员轨迹又自己接了一套，两边各有缺口。
+//
+// 【原先的缺陷】旧实现判断「这是不是一个会话目录」用的是 `dir.startsWith("session-")`。
+// 主会话的目录名确实是 `session-<uuid>` 形式，**但子代理/成员会话的目录名是裸 UUID**
+// （例如 `c9a6a72c-908e-4040-b88c-2e6ce5014378`）。于是成员会话永远进不了候选集，
+// 完整 id 和 id 前缀都解析不出来，工具只好报「找不到目标会话」。
+//
+// 【现在的判据】不看目录名叫什么，只看**里面有没有会话日志文件**（`findSessionLog`）——
+// 这是宿主自己也用的判据，且与目录命名规则解耦（v0/v3/v4 各格式都能识别）。
+//
+// 【为什么异步】会话目录可能上千个；同步 stat/readdir 会把事件循环钉住，拖慢整个宿主。
+import { readdir, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { findSessionLog } from "../session-log.js";
+import { sessionsRootOf } from "./events.js";
+
+/**
+ * 列出全部会话 id（按「目录里有会话日志」判断，不看目录名前缀）。
+ *
+ * @param {string} root 会话根目录
+ * @returns {Promise<string[]>}
+ */
+async function listSessionIds(root) {
+  const ids = [];
+  const isDir = async (p) => {
+    try { return (await stat(p)).isDirectory(); } catch { return false; }
+  };
+  if (!root || !(await isDir(root))) return ids;
+  for (const group of await readdir(root)) {
+    const groupPath = join(root, group);
+    if (!(await isDir(groupPath))) continue;
+    for (const dir of await readdir(groupPath)) {
+      const dirPath = join(groupPath, dir);
+      if (!(await isDir(dirPath))) continue;
+      // 关键：用「有没有日志文件」而不是「目录名像不像 session-xxx」
+      if (findSessionLog(dirPath)) ids.push(dir);
+    }
+  }
+  return ids;
+}
+
+/**
+ * 把一个模糊目标解析成会话 id。支持：完整 id → id 前缀 → 标题子串。
+ *
+ * 多个命中时**不猜**，返回候选清单交给调用方展示。
+ *
+ * @param {object} ctx 插件 context（用于落盘索引里的标题）
+ * @param {string} want 用户给的目标
+ * @param {string} [selfId] 当前会话 id（等于它时直接返回）
+ * @param {{root?: string}} [opts]
+ * @returns {Promise<{id: string, title?: string|null} | {candidates: Array<{id: string, title?: string|null}>} | null>}
+ *          null = 三段都没命中
+ */
+export async function resolveSessionId(ctx, want, selfId, opts = {}) {
+  const raw = String(want ?? "").trim();
+  if (!raw) return null;
+  if (selfId && raw === selfId) return { id: selfId };
+
+  const root = opts.root ?? sessionsRootOf();
+  const ids = await listSessionIds(root);
+
+  if (ids.includes(raw)) return { id: raw };
+  const byPrefix = ids.filter((id) => id.startsWith(raw));
+  if (byPrefix.length === 1) return { id: byPrefix[0] };
+  if (byPrefix.length > 1) return { candidates: byPrefix.map((id) => ({ id })) };
+
+  // 标题子串：只查落盘索引（避免为了解析一个参数去逐份读日志）
+  try {
+    const { loadListDiskCache } = await import("./list-cache.js");
+    let entries = {};
+    try { entries = loadListDiskCache(ctx)?.entries ?? {}; } catch { entries = {}; }
+    const lower = raw.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;
+}
+
+/**
+ * 解析目标会话，**额外支持 Team 成员名**。
+ *
+ * 成员名是日常最顺手的写法（`read_member_trace({ session: "writer" })`），但成员名既不是会话 id
+ * 也不是会话标题，通用解析认不了。这里在通用解析未命中时补一层成员解析。
+ *
+ * 用动态 `import()` 引成员定位：`sessions/` 是本插件底层，`features/member-model/` 是上层，
+ * 静态引用会形成层级倒置；且宿主没装 agent-team 时成员解析本就不可用，动态导入让那种情况自然降级。
+ *
+ * @param {object} ctx 插件 context
+ * @param {string} want 用户给的目标
+ * @param {string} [selfId] 当前会话 id
+ * @param {{root?: string, agent?: object}} [opts] agent 用于成员名册的作用域（缺省按全局名册）
+ * @returns {Promise<{id: string, title?: string|null, matched?: string} | {candidates: Array<{id: string, title?: string|null}>} | null>}
+ */
+export async function resolveTargetSession(ctx, want, selfId, opts = {}) {
+  const direct = await resolveSessionId(ctx, want, selfId, opts);
+  if (direct) return direct;
+
+  try {
+    const { findTargetAgent } = await import("../features/member-model/locate.js");
+    const found = findTargetAgent(ctx, want, { caller: opts.agent ?? null });
+    if (found?.sessionId) return { id: found.sessionId, matched: found.matched ?? "成员名" };
+    if (found?.error && /匹配到 \d+ 个/.test(String(found.error))) {
+      // 成员名模糊命中多个：把它转成候选清单，保持「不猜」的一致行为
+      const ids = [...String(found.error).matchAll(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/g)]
+        .map((m) => ({ id: m[1] }));
+      if (ids.length > 1) return { candidates: ids };
+    }
+  } catch {
+    // 成员解析不可用：按未命中处理，由调用方给出统一报错
+  }
+  return null;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-session-conductor",
-  "version": "1.3.19",
+  "version": "1.4.4",
   "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",