dsh-session-conductor 1.3.19 → 1.4.5

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/override.js

@@ -63,6 +63,41 @@ export async function setMemberModelOverride(ctx, sessionId, provider, model) {
   memberModelCache.set(sessionId, { provider, model });
 }
 
+/**
+ * 删除一个会话的 override（domain 与内存镜像同时清）。
+ *
+ * 【为什么需要】override 一旦存在，`agent/request` 就会**每轮**按它改写请求模型，
+ * 优先级压过官方 UI / `model/selection` 链路。因此「不带 override 参数」的切换
+ * 不能只是不写 —— 必须把存量条目删掉，官方链路才能接管；否则表现为
+ * 「切换成功但请求仍走旧模型」（selection 写入后，请求仍按 override 的值发出）。
+ *
+ * 幂等：不存在时返回 {removed:false}，不报错。
+ *
+ * @param {object} ctx 插件 context
+ * @param {string} sessionId 会话 id
+ * @returns {Promise<{removed: boolean}>}
+ */
+export async function deleteMemberModelOverride(ctx, sessionId) {
+  if (!sessionId) return { removed: false };
+  const hadCache = memberModelCache.delete(sessionId);
+  let removedInDomain = false;
+  try {
+    const domain = await loadPluginDomain(ctx);
+    const state = domain.global.get() ?? {};
+    const overrides = { ...(state.memberModelOverrides ?? {}) };
+    if (Object.prototype.hasOwnProperty.call(overrides, sessionId)) {
+      delete overrides[sessionId];
+      await domain.global.set({ ...state, memberModelOverrides: overrides });
+      removedInDomain = true;
+    }
+  } catch (error) {
+    // domain 不可用（如工作区自测环境缺宿主包）：内存镜像已清，但落盘那条还在。
+    // 必须如实把原因带回调用方 —— 否则「切换成功、请求仍走旧模型」无从排查。
+    return { removed: hadCache, error: String(error?.message ?? error) };
+  }
+  return { removed: hadCache || removedInDomain };
+}
+
 /**
  * 把成员模型 override 应用到一次请求配置上（`agent/request` hook 的核心逻辑，单独导出便于单测）。
  * 丢掉继承的 reasoningEffort：换模型后应回到目标模型自己的 provider 默认行为。