dsh-session-conductor 1.3.13 → 1.3.16

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

@@ -0,0 +1,138 @@
+// dsh-session-conductor — 权限预设指令 `/perm-switch` 与 AI 工具 `set_member_permission`
+//
+// 【为什么需要指令】子代理会话在界面上无法手动切换权限预设（界面只对主会话开放），
+// 而权限预设一旦指向当前不可用的值（典型：`auto` 在「自动审查」关闭后悬空），
+// 该成员就永久唤不醒，且宿主只报一句 `subagent/not-resumable`，完全指不到权限层。
+// 所以必须提供一条不经界面的入口：用户直接在聊天框切，AI 也能用工具切。
+//
+// 【三条形态】与 `/model-switch` 对齐：
+//   · /perm-switch                        → 列出成员与各自权限预设（并标出 auto 悬空告警）
+//   · /perm-switch <成员|sessionId>        → 查该成员的 preset / sandbox / approval
+//   · /perm-switch <成员|sessionId> <预设>  → 切换（追加 permission/preset 事件）
+//
+// 【注册方式照宿主官方范例】ctx.commands.register({ definitionId, name, description, input, handler })，
+// definitionId 用 @deepseek-ai/dsh-commands/brand 的 CommandDefinitionId() 包一层。
+// 全程动态导入宿主包：工作区自测环境没有 @deepseek-ai/* 依赖，静态导入会在导入期
+// ERR_MODULE_NOT_FOUND 并连累整个插件加载失败；拿不到就跳过注册并留痕。
+import { log } from "../../shared/log.js";
+import {
+  describeMemberPermission,
+  findTargetAgent,
+  renderMemberPermissionList,
+  readPresetCatalog,
+  switchMemberPermission,
+} from "./permission.js";
+import { resolveTargets, isAllTarget } from "./locate.js";
+import { readLeaderRoute } from "./lead.js";
+import { applyPermissionToMany, renderBatchReport } from "./batch.js";
+
+const COMMAND_NAME = "perm-switch";
+const DEFINITION_ID = "@deepseek-ai/dsh-session-conductor/command-perm-switch";
+
+/**
+ * 指令处理入口（导出便于单测直接驱动，不必走宿主）。
+ *
+ * @param {object} ctx 插件 context
+ * @param {{rawInput?: string, agent?: object}} invocation 宿主给的调用信息
+ * @returns {Promise<{kind: "success"|"error", text: string}>} 交给聊天框渲染
+ */
+export async function handlePermSwitchCommand(ctx, invocation) {
+  const raw = String(invocation?.rawInput ?? "").trim();
+  const parts = raw.split(/\s+/).filter(Boolean);
+  const caller = invocation?.agent ?? null;
+  try {
+    // 无参：列成员与各自预设（与批量执行分开，避免「空参数」有两种含义）
+    if (parts.length === 0) return { kind: "success", text: await renderMemberPermissionList(ctx, invocation) };
+
+    const targetRaw = parts[0];
+    if (parts.length === 1) {
+      if (isAllTarget(targetRaw)) {
+        return {
+          kind: "error",
+          text: `批量操作需要指定预设：\n  /${COMMAND_NAME} * <预设名>   ← 全部成员切到该预设\n  /${COMMAND_NAME} * auto        ← 全部成员跟随主代理（Lead）当前预设`,
+        };
+      }
+      const found = findTargetAgent(ctx, targetRaw, { caller });
+      if (found?.error) return { kind: "error", text: `找不到成员：${found.error}` };
+      return { kind: "success", text: (await describeMemberPermission(found)).join("\n") };
+    }
+
+    // 二参：切换（单个或全部）
+    let preset = parts[1];
+    let followedLead = null;
+    if (preset.toLowerCase() === "auto") {
+      const lead = await readLeaderRoute(ctx, { caller });
+      if (lead.error) return { kind: "error", text: `跟随主代理失败：${lead.error}` };
+      if (!lead.preset) {
+        return { kind: "error", text: `主代理（${lead.sessionId}）自己没有记录权限预设，无法跟随；请显式指定预设名` };
+      }
+      preset = lead.preset;
+      followedLead = lead;
+    }
+
+    const resolved = resolveTargets(ctx, targetRaw, { caller });
+    if (resolved?.error) return { kind: "error", text: `找不到成员：${resolved.error}` };
+
+    // 单个目标：沿用原有回执（含旋钮与可选预设）
+    if (!resolved.all && resolved.targets.length === 1) {
+      const found = resolved.targets[0];
+      const result = await switchMemberPermission(ctx, found.sessionId, preset);
+      if (result.error) return { kind: "error", text: `切换失败：${result.error}` };
+      const name = found.member?.name ? `${found.member.name}(${found.sessionId})` : found.sessionId;
+      const lines = [`已把成员 ${name} 的权限预设切成 ${result.to}`, `原预设：${result.from ?? "(未记录)"} ｜ 新事件 seq：${result.seq}`];
+      if (followedLead) lines.push(`预设来源：跟随主代理 ${followedLead.sessionId}`);
+      if (result.note) lines.push(`说明：${result.note}`);
+      lines.push(`当前旋钮：sandbox=${result.knobs?.sandbox ?? "(未记录)"} ｜ approval=${result.knobs?.approval ?? "(未记录)"}`);
+      const catalog = await readPresetCatalog(ctx);
+      if (!catalog.error) lines.push(`可选预设：${catalog.names.join(" / ")}`);
+      lines.push("该改动写在会话日志里，成员下次加载/唤醒时按折叠语义生效。");
+      return { kind: "success", text: lines.join("\n") };
+    }
+
+    // 全部目标：串行逐个切，回执带名单
+    const report = await applyPermissionToMany(ctx, resolved.targets, preset);
+    const extra = [];
+    if (followedLead) {
+      extra.push(`预设来源：跟随主代理 ${followedLead.sessionId}（${followedLead.preset}）`);
+      for (const w of followedLead.warnings ?? []) extra.push(`提示：${w}`);
+    }
+    extra.push("批量切换逐条写入各成员会话日志；单个成员失败不影响其余成员。");
+    return {
+      kind: "success",
+      text: renderBatchReport(`批量切换权限预设 → ${preset}`, report, extra),
+    };
+  } catch (error) {
+    return { kind: "error", text: `执行失败：${String(error?.message ?? error)}` };
+  }
+}
+
+/**
+ * 注册 `/perm-switch` 指令。
+ *
+ * @returns {Promise<boolean>} true = 已注册；false = 宿主 commands 服务或 brand 包不可用（已留痕）
+ */
+export async function registerPermSwitchCommand(ctx) {
+  const commands = ctx?.get?.("commands");
+  if (!commands || typeof commands.register !== "function") {
+    log(ctx, "权限指令未注册：ctx.commands 不可用（宿主未挂载 commands 服务）");
+    return false;
+  }
+  let CommandDefinitionId = null;
+  try {
+    const mod = await import("@deepseek-ai/dsh-commands/brand");
+    if (typeof mod?.CommandDefinitionId === "function") CommandDefinitionId = mod.CommandDefinitionId;
+  } catch { /* 工作区自测环境没有宿主依赖 → 走下面的返回 false */ }
+  if (!CommandDefinitionId) {
+    log(ctx, "权限指令未注册：拿不到 @deepseek-ai/dsh-commands/brand 的 CommandDefinitionId（缺宿主依赖）");
+    return false;
+  }
+  commands.register({
+    definitionId: CommandDefinitionId(DEFINITION_ID),
+    name: COMMAND_NAME,
+    description: "查看或切换成员（子代理）的权限预设；无参 = 列出成员与各自预设",
+    input: { hint: "[<成员名|sessionId> [<预设名>]]" },
+    recordInput: false,
+    handler: (invocation) => handlePermSwitchCommand(ctx, invocation),
+  });
+  return true;
+}

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

@@ -0,0 +1,213 @@
+// dsh-session-conductor — 成员（子代理）权限预设的查看与切换
+//
+// 【这个文件解决什么】子代理会话在界面上无法手动切换权限预设（只有主会话能切），
+// 一旦它的 `permission/preset` 指向一个当前不可用的预设，该成员就会永久唤不醒：
+// 宿主 permission-presets 的 pinInitialPermission() 在会话发布前校验
+//   if (preset === 'auto' && autoAdmit === undefined) throw new Error('cannot restore preset "auto" without its active integration')
+// 而 subagent 的 coldResume() 把这个异常统一包成 `subagent/not-resumable`，
+// 报错文本完全指不到权限预设这一层。因此需要一条「不依赖界面、直接落到会话日志」的通道。
+//
+// 【为什么是追加事件而不是改历史】权限三个旋钮（preset / sandbox / approval）在宿主里是**折叠**语义，
+// 宿主明确保证「The LAST such event is the session's override」。所以追加一条 `permission/preset`
+// 就能让新值生效，已有事件一条不动、可删尾部帧回滚。
+//
+// 【为什么只写 preset 一条】切换预设时宿主自己会按 spec 补齐 sandbox / approval（见其 apply()）。
+// 这里不重复写：若目标预设的 sandbox/approval 与会话现值不同，回执会明确提示「需要宿主侧补齐」，
+// 避免我们自己造出「preset 与 knobs 不一致」的标签失配。
+import { log } from "../../shared/log.js";
+import { findTargetAgent, collectTeamMembers } from "./locate.js";
+
+/** 读会话日志路径（按 sessionId 定位，与切换模型链路同一套定位）。 */
+async function locateLog(sessionId) {
+  const { findSessionLogById, sessionsRootOf } = await import("../../sessions/events.js");
+  const filePath = findSessionLogById(sessionId, sessionsRootOf());
+  return filePath ?? null;
+}
+
+/**
+ * 折叠读成员当前的权限状态（只看最后一条同类事件，与宿主折叠语义一致）。
+ *
+ * @param {string} sessionId 成员会话 id
+ * @returns {Promise<{preset: string|null, sandbox: string|null, approval: string|null, lastSeq: number, error?: string}>}
+ */
+export async function readMemberPermission(sessionId) {
+  const filePath = await locateLog(sessionId);
+  if (!filePath) return { preset: null, sandbox: null, approval: null, lastSeq: -1, error: "会话日志不存在" };
+  const { readFile } = await import("node:fs/promises");
+  const { decodeAllFrames } = await import("../../zstd-frames.js");
+  let text;
+  try {
+    text = await decodeAllFrames(await readFile(filePath));
+  } catch (error) {
+    return { preset: null, sandbox: null, approval: null, lastSeq: -1, error: `日志解码失败：${String(error?.message ?? error)}` };
+  }
+  let preset = null;
+  let sandbox = null;
+  let approval = null;
+  let lastSeq = -1;
+  for (const line of text.split("\n")) {
+    if (line.trim() === "") continue;
+    let e;
+    try { e = JSON.parse(line); } catch { continue; }
+    if (typeof e.seq === "number" && e.seq > lastSeq) lastSeq = e.seq;
+    if (e.type === "permission/preset") preset = e.data?.preset ?? null;
+    else if (e.type === "sandbox/mode") sandbox = e.data?.mode ?? null;
+    else if (e.type === "approval/policy") approval = e.data?.policy ?? null;
+  }
+  return { preset, sandbox, approval, lastSeq };
+}
+
+/**
+ * 读宿主当前可选的预设目录（用于校验，避免把会话写成宿主无法恢复的值）。
+ *
+ * @param {object} ctx 插件 context
+ * @returns {Promise<{names: string[], defaults: string[], defaultPreset: string|null, specs: Map<string, {sandbox?: string, approval?: string}>} | {error: string}>}
+ */
+export async function readPresetCatalog(ctx) {
+  const service = ctx.get?.("permissionPresets") ?? null;
+  if (!service || typeof service.catalog !== "function") {
+    return { error: "拿不到 permissionPresets.catalog（宿主未挂载该服务），无法校验预设名" };
+  }
+  let catalog;
+  try {
+    catalog = await service.catalog();
+  } catch (error) {
+    return { error: `读取预设目录失败：${String(error?.message ?? error)}` };
+  }
+  const options = Array.isArray(catalog?.options) ? catalog.options : [];
+  const names = options.map((o) => String(o?.name ?? o?.id ?? "")).filter(Boolean);
+  const specs = new Map();
+  for (const option of options) {
+    const name = String(option?.name ?? option?.id ?? "");
+    if (!name) continue;
+    specs.set(name, { sandbox: option?.sandbox, approval: option?.approval });
+  }
+  return {
+    names,
+    defaults: Array.isArray(catalog?.defaultOptions) ? catalog.defaultOptions.map((o) => String(o?.name ?? "")) : [],
+    defaultPreset: catalog?.defaultPreset ?? null,
+    specs,
+  };
+}
+
+/**
+ * 把成员的权限预设切到目标值。
+ *
+ * 实现：定位会话日志 → 折叠读当前状态 → 校验预设名在宿主目录里 → 追加一条
+ * `permission/preset`（独立 zstd 帧、带 checksum、长度 CAS、fsync）→ 写后复核。
+ *
+ * @param {object} ctx 插件 context
+ * @param {string} sessionId 成员会话 id
+ * @param {string} preset 目标预设名
+ * @returns {Promise<{ok: true, from: string|null, to: string, seq: number, knobs: object, note?: string} | {error: string}>}
+ */
+export async function switchMemberPermission(ctx, sessionId, preset) {
+  const target = String(preset ?? "").trim();
+  if (!target) return { error: "预设名不能为空" };
+
+  const catalog = await readPresetCatalog(ctx);
+  if (catalog.error) return { error: catalog.error };
+  if (!catalog.names.includes(target)) {
+    // 明确点出 auto 的特殊性：它只有在「自动审查集成」挂载时才可选，
+    // 否则写进去会让该会话下次发布时直接抛错（表现为唤不醒）。
+    const hint = target === "auto"
+      ? "；注意 auto 只有在「自动审查」集成启用时才可用，写入后一旦关闭该功能，该会话就会唤不醒"
+      : "";
+    return { error: `预设 "${target}" 不在当前可选列表里（可选：${catalog.names.join(" / ")}）${hint}` };
+  }
+
+  const before = await readMemberPermission(sessionId);
+  if (before.error) return { error: before.error };
+  if (before.preset === target) {
+    return { ok: true, from: before.preset, to: target, seq: before.lastSeq, knobs: { sandbox: before.sandbox, approval: before.approval }, note: "已经是该预设，无需重复写入" };
+  }
+
+  const filePath = await locateLog(sessionId);
+  if (!filePath) return { error: "会话日志不存在" };
+  const { appendEventFrame } = await import("../../sessions/tail-io.js");
+  const written = await appendEventFrame(filePath, {
+    type: "permission/preset",
+    seq: before.lastSeq + 1,
+    time: Date.now(),
+    data: { preset: target },
+  });
+  if (!written.ok) return { error: `写入会话日志失败：${written.error}` };
+
+  // 写后复核：确认最后一条 preset 已生效（折叠语义下这就是当前值）
+  const after = await readMemberPermission(sessionId);
+  if (after.error) return { error: `写入后复核失败：${after.error}` };
+  if (after.preset !== target) return { error: `写入后复核不一致（期望 ${target}，实际 ${after.preset}）` };
+
+  // 预设有配套的 sandbox/approval 时给出提示：我们只写 preset，旋钮由宿主在下次加载时按 spec 补齐
+  const spec = catalog.specs.get(target);
+  let note;
+  if (spec && (spec.sandbox !== undefined || spec.approval !== undefined)) {
+    const mismatch = [];
+    if (spec.sandbox !== undefined && before.sandbox !== null && spec.sandbox !== before.sandbox) {
+      mismatch.push(`sandbox ${before.sandbox} → ${spec.sandbox}`);
+    }
+    if (spec.approval !== undefined && before.approval !== null && spec.approval !== before.approval) {
+      mismatch.push(`approval ${before.approval} → ${spec.approval}`);
+    }
+    if (mismatch.length > 0) {
+      note = `该预设自带 ${mismatch.join("、")}；本工具只写 preset 事件，旋钮需宿主加载时补齐（若界面显示与实际不一致，属预期）`;
+    }
+  }
+  log(ctx, `权限切换：${sessionId} preset ${before.preset} → ${target}（seq ${written.seq}）`);
+  return { ok: true, from: before.preset, to: target, seq: written.seq, knobs: { sandbox: before.sandbox, approval: before.approval }, note };
+}
+
+/** 成员标签（有名字就带上，便于人读）。 */
+function memberLabel(found) {
+  const name = found?.member?.name;
+  return name ? `${name}(${found.sessionId})` : String(found?.sessionId ?? "?");
+}
+
+/**
+ * 渲染单个成员的权限快照（供工具与指令共用）。
+ *
+ * @param {object} found findTargetAgent 的返回值
+ * @returns {Promise<string[]>} 多行文本
+ */
+export async function describeMemberPermission(found) {
+  const state = await readMemberPermission(found.sessionId);
+  if (state.error) return [`成员 ${memberLabel(found)}`, `  读取失败：${state.error}`];
+  return [
+    `成员 ${memberLabel(found)}`,
+    `  权限预设：${state.preset ?? "(未记录)"}`,
+    `  sandbox：${state.sandbox ?? "(未记录)"} ｜ approval：${state.approval ?? "(未记录)"}`,
+    `  末 seq：${state.lastSeq}`,
+  ];
+}
+
+/** 列出全部成员及其权限预设（指令无参形态）。 */
+export async function renderMemberPermissionList(ctx, invocation) {
+  const members = collectTeamMembers(ctx, { caller: invocation?.agent ?? null });
+  if (members.length === 0) return "没读到任何成员。可能当前不是 Team 成员、名册不可用，或确实还没有队友。";
+  const catalog = await readPresetCatalog(ctx);
+  const lines = [`成员权限预设（共 ${members.length} 个）`, ""];
+  for (const m of members) {
+    const state = await readMemberPermission(m.sessionId);
+    const name = m.name ? `${m.name}(${m.sessionId})` : m.sessionId;
+    const warn = state.preset === "auto" && !catalog.error && !catalog.names.includes("auto")
+      ? "  ⚠️ auto 当前不可用（自动审查未启用），该成员可能唤不醒"
+      : "";
+    lines.push(`  ${name}：${state.preset ?? "(未记录)"}${warn}`);
+  }
+  lines.push("");
+  if (catalog.error) lines.push(`可选预设：${catalog.error}`);
+  else lines.push(`可选预设：${catalog.names.join(" / ")}`);
+  lines.push("");
+  lines.push("切换：/perm-switch <成员名或 sessionId> <预设名>");
+  return lines.join("\n");
+}
+
+/** 解析「成员 + 预设」两个参数（预设名不含斜杠，直接取剩余文本）。 */
+export function parsePermissionArgs(rawInput) {
+  const raw = String(rawInput ?? "").trim();
+  if (raw === "") return { parts: [] };
+  const parts = raw.split(/\s+/).filter(Boolean);
+  return { parts };
+}
+
+export { findTargetAgent };

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

@@ -104,6 +104,132 @@ function restoreSwitchLog(backup, filePath) {
   }
 }
 
+/**
+ * 该会话是否带「委派策略快照」，带则返回一条排查提示。
+ *
+ * 【为什么需要】本机实测：子代理会话开头会有 `approval/policy`（source=delegation，
+ * 创建时从父级快照）。若部署侧关掉「自动审查」，宿主恢复这条快照会失败，失败被
+ * `manager.coldResume` 统一包成 `subagent/not-resumable` —— 界面只看到
+ * 「subagent cannot be resumed」，极具误导性（会让人去查模型/描述符/文件）。
+ * 因此切换时若发现该会话带这种快照，就主动提示先去查自动审查开关。
+ *
+ * 只读首帧（header + 开头几条策略事件），失败一律返回空字符串，绝不影响切换本身。
+ *
+ * @param {string} filePath 会话日志路径
+ * @returns {Promise<string>} 提示文案；不适用或读不到时为空串
+ */
+export async function delegationPolicyHint(filePath) {
+  try {
+    const { readFile } = await import("node:fs/promises");
+    const { scanZstdFrames, decodeFrame } = await import("../../zstd-frames.js");
+    const buf = await readFile(filePath);
+    const { frames } = scanZstdFrames(buf);
+    if (frames.length === 0) return "";
+    // 策略事件在会话最开头（header 之后几条），解首帧通常就够
+    let text = (await decodeFrame(buf.subarray(frames[0].start, frames[0].end))).toString("utf8");
+    if (frames.length > 1) {
+      text += (await decodeFrame(buf.subarray(frames[1].start, frames[1].end))).toString("utf8").slice(0, 20000);
+    }
+    if (text.includes('"type":"approval/policy"') && text.includes('"source":"delegation"')) {
+      return '该成员带委派策略快照（approval/policy, source=delegation）；若它之后唤不醒并报 subagent/not-resumable，先检查部署侧「自动审查」开关是否被关掉——本机实测这才是真因，与模型/描述符/文件无关';
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * 切换模型时同步修正「失效的 descriptor 路由」。
+ *
+ * 【为什么必须做】宿主 cold resume 子代理时，provider/model 取自会话日志里的
+ * `subagent/descriptor`（manager.coldResume → materialize 的 agentOptions），
+ * `model/selection` 不参与该路径。若 descriptor 仍指向一个已被删除的 provider
+ * （例如配置里移除了某个渠道），materialize 必然失败并被统一包成
+ * `subagent/not-resumable` —— 表现为「这个成员永远唤不醒，怎么切模型都没用」。
+ * 因此这里在写入 selection 之后顺带校验 descriptor 的路由是否仍存在，失效就同步改掉。
+ *
+ * 保守原则：拿不到模型目录（服务不可用）或 descriptor 本就有效时，一律不动日志。
+ *
+ * @returns {Promise<{repaired?: boolean, skipped?: string, error?: string}>}
+ */
+async function repairDescriptorIfStale(ctx, filePath, sessionId, provider, model) {
+  const { readDescriptorEvent } = await import("../../sessions/tail-io.js");
+  const { readFile } = await import("node:fs/promises");
+  let buf;
+  try {
+    buf = await readFile(filePath);
+  } catch (error) {
+    return { error: `读取会话日志失败：${String(error?.message ?? error)}` };
+  }
+  let found;
+  try {
+    found = await readDescriptorEvent(buf);
+  } catch (error) {
+    return { error: `读取 descriptor 失败：${String(error?.message ?? error)}` };
+  }
+  const descriptor = found.descriptor;
+  if (!descriptor || typeof descriptor !== "object") return { skipped: "不是子代理会话（无 descriptor）" };
+
+  // 取当前可用 provider 列表；拿不到就不猜、不动日志
+  const sc = ctx.get("sessionController");
+  if (typeof sc?.modelCatalog !== "function") return { skipped: "modelCatalog 不可用，跳过 descriptor 校验" };
+  let groups;
+  try {
+    const catalog = await sc.modelCatalog();
+    groups = catalog?.groups ?? [];
+  } catch (error) {
+    return { skipped: `modelCatalog 调用失败，跳过：${String(error?.message ?? error)}` };
+  }
+  if (groups.length === 0) return { skipped: "模型目录为空，跳过 descriptor 校验" };
+
+  const providerIds = new Set(groups.map((g) => g.id));
+  const staleProvider = descriptor.agentProvider !== undefined && !providerIds.has(descriptor.agentProvider);
+  const staleModel = (() => {
+    if (descriptor.agentProvider === undefined || descriptor.agentModel === undefined) return false;
+    const group = groups.find((g) => g.id === descriptor.agentProvider);
+    if (!group) return false;
+    return !(group.models ?? []).some((m) => m.id === descriptor.agentModel);
+  })();
+  if (!staleProvider && !staleModel) return { skipped: "descriptor 路由有效" };
+
+  // 整份重写（descriptor 在文件头部，追加帧改不了它）；这条路径只在路由失效时走一次，代价可接受
+  const { encodeSessionText } = await lazyRepair();
+  const { decodeAllFrames } = await import("../../zstd-frames.js");
+  const fullText = buf.length > 0 ? await decodeAllFrames(buf) : "";
+  const lines = fullText.split("\n").filter((l) => l.trim() !== "");
+  if (lines.length === 0) return { error: "会话日志为空，无法修正 descriptor" };
+  let patched = 0;
+  for (let i = 1; i < lines.length; i += 1) {
+    let e;
+    try { e = JSON.parse(lines[i]); } catch { continue; }
+    if (e.type !== "subagent/descriptor") continue;
+    e.data.agentProvider = provider;
+    e.data.agentModel = model;
+    lines[i] = JSON.stringify(e);
+    patched += 1;
+    break;
+  }
+  if (patched === 0) return { skipped: "未找到可改写的 descriptor" };
+
+  // 写前校验 seq 严格连续，避免把会话写成 corrupt
+  let prev = -1, gaps = 0;
+  for (let i = 1; i < lines.length; i += 1) {
+    let e;
+    try { e = JSON.parse(lines[i]); } catch { return { error: "改写后存在坏行，放弃写盘" }; }
+    if (typeof e.seq !== "number") continue;
+    if (prev >= 0 && e.seq !== prev + 1) gaps += 1;
+    prev = e.seq;
+  }
+  if (gaps > 0) return { error: `改写后 seq 不连续（${gaps} 处），放弃写盘` };
+
+  const backup = backupSwitchLog(filePath, sessionId);
+  if (backup.error) return { error: backup.error };
+  replaceFileSync(filePath, await encodeSessionText(lines.join("\n") + "\n"), { tmpSuffix: ".descfixtmp" });
+  log(ctx, `切换写日志：descriptor 路由失效（${staleProvider ? "provider 已不存在" : "model 不在目录"}），已改为 ${provider}/${model}`);
+  return { repaired: true };
+}
+
 export async function appendSelectionEventToLog(ctx, sessionId, provider, model) {
   const startedAt = Date.now();
   // 这条路径会整份解码会话日志再整份写回，而宿主在同一会话上会并发追加事件
@@ -153,6 +279,17 @@ export async function appendSelectionEventToLog(ctx, sessionId, provider, model)
     const written = await appendEventFrame(filePath, event);
     log(ctx, `切换写日志：追加帧 ${Date.now() - writeStartedAt}ms（seq ${event.seq}）`);
     if (!written.ok) return { error: `写入会话日志失败：${written.error}` };
+    // descriptor 路由失效会让成员永久唤不醒（宿主报 subagent/not-resumable），这里顺带修
+    const descFix = await repairDescriptorIfStale(ctx, filePath, sessionId, provider, model);
+    if (descFix.error) log(ctx, `切换写日志：descriptor 校验失败（不影响本次切换）：${descFix.error}`);
+
+    // 附带排查提示：本机实测「成员唤不醒」的真凶是部署侧的「自动审查」开关被关掉，
+    // 与 descriptor / 帧校验和 / 写锁全都无关（详见 docs/VERSIONS.md 1.3.15）。
+    // 判据：该会话日志开头存在 `approval/policy` 且 source 为 delegation（创建时从父级快照），
+    // 此时若自动审查被关掉，宿主恢复这条委派快照会失败，且失败被 coldResume 统一包成
+    // `subagent/not-resumable` —— 表现就是「切什么模型都唤不醒、重启也没用」。
+    const policyHint = await delegationPolicyHint(filePath);
+    if (policyHint) log(ctx, `切换写日志：${policyHint}`);
 
     // ③ 写后自检：只读尾部，确认新事件确实落在尾部且 seq 严格 +1 衔接
     try {