dsh-session-conductor 1.3.10 → 1.3.11

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

@@ -0,0 +1,208 @@
+// 创建团队成员，并让**第一轮真实任务**就用指定模型。
+//
+// 【为什么需要这一层】宿主 `spawn_teammate` 的参数里没有 provider/model，服务层的
+// SpawnTeammateRequest 也只有 provider —— 模型只能来自 agent-team 插件的
+// freshProvider/forkProvider 配置，所以「创建时就选模型」在原生入口做不到。
+//
+// 【为什么不只是「创建后切一下」】宿主是「创建即开跑」：直接带真实任务创建，第一轮一定用默认模型跑掉。
+// 所以这里拆成四步：
+//   ① 用**占位任务**创建（几乎不花钱，也不会动任何文件）
+//   ② 立刻中断，把这一轮停掉
+//   ③ 把 model/selection 写进该成员的运行记录（与 set_member_model 同一条链路）
+//   ④ 再用新模型投递真实任务
+// 这样真实任务从第一条指令起就用指定模型，而不是「先跑错一轮再切」。
+//
+// 【仍然存在的边界】① 占位那一轮确实发生过（只消耗一条极短提示的输入）；
+// ② 中断与切换之间存在极短窗口；③ 要彻底「创建前定模型」只能改宿主 agent-team
+// （把 model 加进 SpawnTeammateRequest 并在创建时应用），宿主升级会覆盖。
+//
+// 【两个 "provider" 别混】宿主 spawnTeammate 的 provider = **子代理 provider**（注册在 ctx.subagents，
+// 例如 spawn），而模型用的是 **模型 provider**（agnes/wb/d…）。两者是不同命名空间，
+// 直接拿模型 provider 去创建会报 `no subagent provider registered for "x"`。
+//
+// 【权限】只有 Team Lead 能创建成员（宿主会抛 TEAM_LEAD_REQUIRED），调用方 agent 必须透传。
+
+import { log } from "../../shared/log.js";
+import { switchAgentModel } from "./switch.js";
+
+/**
+ * 占位任务：只为让成员被创建出来，不产生实质动作。
+ * 写得极短是为了把首轮消耗压到最低（这一轮拿不到指定模型，越短越不亏）。
+ */
+const PLACEHOLDER_PROMPT = "先待命：不要执行任何操作，不要调用任何工具，不要读写任何文件，等待后续消息。";
+
+/**
+ * 等成员真正空闲（中断的取消信号被观测完）再投递。
+ *
+ * 【为什么必须等】只看 `interrupt()` 的返回不够：它只是「发出取消」，成员可能仍在收尾；
+ * 这时立刻投递，新一轮会撞上同一个取消信号，表现为成员「stopped/failed before it finished」。
+ * 用宿主自己的 `waitForChange` 等状态变化（事件驱动），不睡固定时间。
+ * @returns {Promise<{idle:boolean, status:string}>}
+ */
+async function waitUntilIdle(teams, caller, name, signal, budget = 60) {
+  if (typeof teams?.listMembers !== 'function' || typeof teams?.waitForChange !== 'function') {
+    // 老宿主没有这两个能力：退化为「不等待」，行为与之前一致
+    return { idle: false, status: 'unknown' };
+  }
+  for (let round = 0; round < budget; round += 1) {
+    let member = null;
+    try {
+      const list = teams.listMembers(caller) ?? [];
+      member = list.find((m) => m?.name === name || m?.target === name) ?? null;
+    } catch {
+      return { idle: false, status: 'unknown' };
+    }
+    if (!member || member.status !== 'running') return { idle: true, status: member?.status ?? 'absent' };
+    try {
+      // 等「下一次团队状态变化」，超时也算一次观察窗口（不是业务超时，只是等待预算）
+      await teams.waitForChange(caller, 5000, signal);
+    } catch {
+      return { idle: false, status: member.status ?? 'unknown' };
+    }
+  }
+  return { idle: false, status: 'still-running' };
+}
+
+/**
+ * 创建成员 → 中断首轮 → 设置模型 → 投递真实任务。
+ * @param {object} ctx 插件上下文
+ * @param {object} exec 工具执行上下文（含 agent / signal）
+ * @param {object} args 工具参数
+ * @returns {Promise<
+ *   {ok:true, member:object, interrupt:object, switchResult:object, delivery:object} |
+ *   {ok:true, member:object, interrupt:object, switchResult:object, delivery:null, error:string} |
+ *   {error:string}>}
+ */
+export async function createTeammateWithModel(ctx, exec, args) {
+  const name = String(args?.name ?? "").trim();
+  const description = String(args?.description ?? "").trim();
+  const prompt = String(args?.prompt ?? "").trim();
+  const modelProvider = String(args?.provider ?? "").trim(); // 模型 provider：agnes / wb / d …
+  const model = String(args?.model ?? "").trim();            // 模型 id
+  const context = args?.context === "fork" ? "fork" : "fresh";
+
+  if (!name || !description || !prompt) return { error: "name / description / prompt 都必填" };
+  if (!modelProvider || !model) return { error: "provider / model 都必填（先用 list_models 查确切值）" };
+
+  const teams = ctx.get("agentTeams");
+  if (typeof teams?.spawnTeammate !== "function") {
+    return { error: "agentTeams.spawnTeammate 不可用：当前 DSH 版本没有暴露创建接口" };
+  }
+  if (typeof teams?.sendMessage !== "function") {
+    return { error: "agentTeams.sendMessage 不可用：无法在创建后投递真实任务" };
+  }
+  const caller = exec?.agent ?? null;
+  if (!caller) return { error: "拿不到调用方 agent（该工具只能由 Team Lead 在自身的运行上下文里调用）" };
+
+  // 子代理 provider 与模型 provider 是两个命名空间：前者来自 ctx.subagents 注册表
+  let subagentProvider = String(args?.subagentProvider ?? "").trim();
+  if (!subagentProvider) {
+    const subagents = ctx.get("subagents");
+    const names = typeof subagents?.list === "function" ? subagents.list() : [];
+    subagentProvider = Array.isArray(names) && names.length > 0 ? String(names[0]) : "";
+  }
+  if (!subagentProvider) {
+    return { error: "没有可用的子代理 provider（ctx.subagents.list() 为空）——请在参数里显式传 subagentProvider" };
+  }
+
+
+  // signal：优先用工具调用自带的（可随宿主取消），否则用一个永不自废弃的控制器
+  const fallbackController = new AbortController();
+  const signal = exec?.signal ?? fallbackController.signal;
+
+  // ① 占位任务创建：真实任务留到模型设好之后再投
+  let spawned;
+  try {
+    spawned = await teams.spawnTeammate(caller, {
+      name,
+      description,
+      prompt: [{ type: "text", text: PLACEHOLDER_PROMPT }],
+      context,
+      provider: subagentProvider,
+      signal,
+    });
+  } catch (error) {
+    return { error: `创建成员失败：${String(error?.message ?? error)}` };
+  }
+
+  const member = spawned?.member ?? null;
+  const sessionId = member?.id ? String(member.id) : "";
+  if (!sessionId) return { error: "创建成功但成员视图里没有 id，无法继续设置模型" };
+
+  // ② 立刻中断：占位那一轮不该继续跑
+  let interrupt = { previousStatus: "unknown" };
+  let interruptError = "";
+  try {
+    interrupt = await teams.interrupt(caller, name);
+  } catch (error) {
+    // 中断失败不致命：成员可能刚好已经空闲（那就取不到 previousStatus）
+    interruptError = String(error?.message ?? error);
+  }
+
+  // ②·5 等它真正空闲：否则紧接着的投递会撞上同一个取消信号（实测表现为「stopped before it finished」）
+  const idleState = await waitUntilIdle(teams, caller, name, signal);
+  log(ctx, `创建成员 ${name}：中断后等待空闲 → ${JSON.stringify(idleState)}`);
+
+  // ③ 写 model/selection：与 set_member_model 完全同一条链路（默认不碰任何 @Remote）
+  const switchResult = await switchAgentModel(ctx, sessionId, modelProvider, model, null);
+  log(ctx, `创建成员 ${name}（${sessionId}）｜ 子代理provider=${subagentProvider} ｜ 中断=${JSON.stringify(interrupt)} ｜ 设模型 ${modelProvider}/${model}=${switchResult.error ? `失败 ${switchResult.error}` : "已写入"}`);
+
+  if (switchResult.error) {
+    // 模型没设上就不投递：否则真实任务会用默认模型跑掉，等于白跑
+    return {
+      ok: true,
+      member,
+      interrupt,
+      switchResult,
+      delivery: null,
+      error: `模型未设置成功（${switchResult.error}），已放弃投递真实任务；修好后可用 set_member_model + send_to_session 补`,
+    };
+  }
+
+  // ④ 投递真实任务：成员此时空闲，这条消息会唤醒它并用新模型执行
+  let delivery = null;
+  try {
+    delivery = await teams.sendMessage(caller, {
+      target: name,
+      content: [{ type: "text", text: prompt }],
+      signal,
+    });
+  } catch (error) {
+    return {
+      ok: true,
+      member,
+      interrupt,
+      switchResult,
+      delivery: null,
+      error: `模型已设置，但投递真实任务失败：${String(error?.message ?? error)}`,
+    };
+  }
+
+  return { ok: true, member, interrupt, idleState, switchResult, delivery, subagentProvider, ...(interruptError ? { interruptError } : {}) };
+}
+
+/**
+ * 把 createTeammateWithModel 的结果渲染成给模型看的文本。
+ * @param {{name:string, provider:string, model:string}} args
+ * @param {object} result
+ */
+export function renderCreateTeammateResult(args, result) {
+  if (!result?.ok) return `创建成员失败：${result?.error ?? "未知原因"}`;
+  const member = result.member ?? {};
+  const sessionId = String(member.id ?? "");
+  const interrupt = result.interrupt ?? {};
+  const switchResult = result.switchResult ?? {};
+  const delivery = result.delivery ?? null;
+  const lines = [
+    `已创建成员 ${member.name ?? args?.name ?? "?"}（${sessionId}）`,
+    `流程：占位任务创建（子代理 provider=${result.subagentProvider ?? "?"}）→ 中断（首轮状态 ${interrupt.previousStatus ?? "unknown"}）→ 等空闲（${result.idleState?.status ?? "unknown"}）→ 设模型 → 投递真实任务`,
+    `模型：${args?.provider ?? "?"}/${args?.model ?? "?"}（${switchResult.via ?? "已写入 model/selection"}）`,
+  ];
+  if (delivery) {
+    lines.push(`真实任务已投递：messageId=${delivery.messageId ?? "(无)"} —— 该成员会用上面的模型开始执行`);
+  }
+  if (result.interruptError) lines.push(`注：中断调用报错（${result.interruptError}），已按成员可能已空闲继续处理`);
+  if (result.error) lines.push(`⚠️ ${result.error}`);
+  lines.push("边界：占位那一轮确实发生过（只消耗一条极短提示）；要「创建前定模型」只能改宿主 agent-team。");
+  return lines.join("\n");
+}

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

@@ -3,37 +3,42 @@
 // 【职责】把「切模型」的目标解析出来：成员名/sessionId/标题 → 会话，
 // 并在切换前做状态门禁与 provider/model 组合校验。
 
+import { cfg } from "../../core/config.js";
+import { log } from "../../shared/log.js";
+
 /**
  * 取一个可用于 Team 名册查询的 caller agent（lead 优先）。
  * agentTeams.listMembers(caller) 需要一个 Team 成员作为 caller 来解析名册。
  * @returns {object|null} 可用 agent，取不到返回 null
  */
 export function pickTeamCaller(ctx, preferred = null) {
-  const agents = ctx.get("agents");
-  if (!agents) return null;
   // 0) 调用方显式给的发起方最可靠：命令/工具都能直接拿到 invocation.agent / exec.agent。
   //    currentInitiator() 依赖「当前在某个 agent 的异步链里」，命令处理器里经常拿不到 ——
   //    这正是「工具能切、聊天指令说找不到成员」的根因。
   if (preferred) return preferred;
-  try {
-    const initiator = agents.currentInitiator?.();
-    if (initiator) return initiator;
-  } catch {
-    // 不在异步链上下文时忽略
-  }
-  try {
-    const roots = agents.roots?.() ?? [];
-    if (roots.length > 0) return roots[0];
-  } catch {
-    // roots 不可用时忽略
+  const agents = ctx.get("agents");
+  if (!agents) return null;
+  for (const probe of CALLER_PROBES) {
+    const hit = safeProbe(probe, agents);
+    if (hit) return hit;
   }
+  return null;
+}
+
+/** 依次尝试的发起方来源（按可靠性从高到低）。 */
+const CALLER_PROBES = [
+  (agents) => agents.currentInitiator?.(),
+  (agents) => (agents.roots?.() ?? [])[0] ?? null,
+  (agents) => (agents.list?.() ?? [])[0] ?? null,
+];
+
+/** 任一来源不可用/抛错都当作「没有」，不影响下一个来源。 */
+function safeProbe(probe, agents) {
   try {
-    const list = agents.list?.() ?? [];
-    if (list.length > 0) return list[0];
+    return probe(agents) ?? null;
   } catch {
-    // list 不可用时忽略
+    return null;
   }
-  return null;
 }
 
 /**
@@ -68,12 +73,21 @@ export function memberStatusError(member) {
  * @returns {Promise<{ok: true, note?: string} | {error: string}>}
  */
 export async function validateModelPair(ctx, provider, model) {
+  // 组合校验只是「提前拦住无效组合」，不该成为切换的必经阻塞点：
+  //   · 默认就是关闭（modelSwitchValidateCatalog 缺省 false）——@Remote 取目录可能久不返回；
+  //   · 无论成败都把耗时打出来（sessionController.modelCatalog 是 @Remote，某些部署上很久才返回）。
+  if (cfg.modelSwitchValidateCatalog === false) {
+    return { ok: true, note: "已按配置跳过组合校验（modelSwitchValidateCatalog=false）" };
+  }
   let catalog = null;
+  const startedAt = Date.now();
   try {
     const sc = ctx.get("sessionController");
     catalog = sc?.modelCatalog ? await sc.modelCatalog() : null;
   } catch {
     catalog = null;
+  } finally {
+    log(ctx, `模型组合校验取目录耗时 ${Date.now() - startedAt}ms（分组数 ${(catalog?.groups ?? []).length}）`);
   }
   const groups = catalog?.groups ?? [];
   if (groups.length === 0) return { ok: true, note: "modelCatalog 不可用，已跳过组合校验" };

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

@@ -3,9 +3,13 @@
 // 【职责】把一次「切模型」落到实处：持久化 override、必要时等回合暂停、
 // 写 `model/selection` 事件（可观测 + 官方投影），未挂载时直接改会话日志文件。
 
-import { readFileSync, copyFileSync, writeFileSync, renameSync, mkdirSync, chmodSync, statSync } from "node:fs";
+import { readFileSync, copyFileSync, mkdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { replaceFileSync } from "../../shared/atomic-file.js";
 import path from "node:path";
 import { log } from "../../shared/log.js";
+import { createStageTimer } from "../../shared/timing.js";
+import { cfg } from "../../core/config.js";
 import { hasOpenTurn } from "../../sessions/turn.js";
 import { foldLastModelSelection } from "../../sessions/route.js";
 import { lazyZstd, lazyRepair } from "../../core/lazy.js";
@@ -48,58 +52,67 @@ export async function waitForIdle(agent, timeoutMs = 60000) {
  *
  * @returns {Promise<{ok: true, note?: string} | {error: string}>}
  */
-export async function appendSelectionEventToLog(ctx, sessionId, provider, model) {
-  const persistence = ctx.get("sessionPersistence");
-  if (!persistence?.listArtifacts) return { error: "sessionPersistence 服务不可用" };
-  const artifacts = await persistence.listArtifacts();
-  const artifact = (artifacts ?? []).find((entry) => entry.header?.id === sessionId);
-  if (!artifact?.path) return { error: `会话日志不存在（sessionId=${sessionId}）` };
-  const filePath = artifact.path;
+/** 读出会话日志的文本行与事件（定位失败/解码失败/空日志返回 error）。 */
+async function readSwitchLog(sessionId) {
+  // 0.2.x 已移除 persistence.listArtifacts（原实现因此恒报「服务不可用」，整条写日志路径是死的），
+  // 改为按 id 直接定位日志文件 —— 与删除链路用同一套定位（findSessionLogById）。
+  const { findSessionLogById, sessionsRootOf } = await import("../../sessions/events.js");
+  const filePath = findSessionLogById(sessionId, sessionsRootOf());
+  if (!filePath) return { error: `会话日志不存在（sessionId=${sessionId}）` };
   const { decodeAllFrames } = await lazyZstd();
   let text;
   try {
-    text = await decodeAllFrames(readFileSync(filePath));
+    text = await decodeAllFrames(await readFile(filePath));
   } catch (error) {
     return { error: `会话日志解码失败：${String(error?.message ?? error)}` };
   }
-  const lines = String(text).split("\n").filter((l) => l.trim() !== "");
+  const lines = String(text).split("\n").filter((line) => line.trim() !== "");
   if (lines.length === 0) return { error: "会话日志为空" };
   const events = [];
-  for (let i = 1; i < lines.length; i++) {
+  for (let i = 1; i < lines.length; i += 1) {
     try {
       events.push(JSON.parse(lines[i]));
     } catch {
-      // 跳过坏行（校验阶段会兜底）
+      // 跳过坏行（写入前的 validateSessionText 会兜底）
     }
   }
+  return { filePath, lines, events };
+}
+
+/** 写回前先备份（备份失败就不写，避免没有回滚点）。 */
+function backupSwitchLog(filePath, sessionId) {
+  const backupDir = path.join(path.dirname(filePath), ".model-switch-backup");
+  try {
+    mkdirSync(backupDir, { recursive: true });
+    copyFileSync(filePath, path.join(backupDir, `${Date.now()}-${sessionId}.zstd`));
+    return { ok: true };
+  } catch (error) {
+    return { error: `备份失败（未写入）：${String(error?.message ?? error)}` };
+  }
+}
+
+export async function appendSelectionEventToLog(ctx, sessionId, provider, model) {
+  const startedAt = Date.now();
+  const logInfo = await readSwitchLog(sessionId);
+  if (logInfo.error) return { error: logInfo.error };
+  const { filePath, lines, events } = logInfo;
+  // 这条路径要整份解码会话日志（几十 MB 时会明显耗时），把耗时单独记出来才能和「卡住」区分
+  log(ctx, `切换写日志：定位+解码 ${Date.now() - startedAt}ms（行数 ${lines.length}）`);
   const last = foldLastModelSelection(events);
   if (last && last.provider === provider && last.model === model) {
     return { ok: true, note: "日志里已是该模型，无需重复写入" };
   }
-  let maxSeq = -1;
-  for (const e of events) if (typeof e?.seq === "number" && e.seq > maxSeq) maxSeq = e.seq;
+  const maxSeq = events.reduce((max, e) => (typeof e?.seq === "number" && e.seq > max ? e.seq : max), -1);
   const event = { type: "model/selection", seq: maxSeq + 1, time: Date.now(), data: { provider, model } };
   const newText = [...lines, JSON.stringify(event)].join("\n") + "\n";
   const { validateSessionText, encodeSessionText } = await lazyRepair();
   const check = validateSessionText(newText);
   if (!check.ok) return { error: `写入后校验失败：${check.problems?.[0] ?? "未知"}` };
-  // 备份 + 原子写回（与 undo 同款做法）
-  const backupDir = path.join(path.dirname(filePath), ".model-switch-backup");
-  try {
-    mkdirSync(backupDir, { recursive: true });
-    copyFileSync(filePath, path.join(backupDir, `${Date.now()}-${sessionId}.zstd`));
-  } catch (error) {
-    return { error: `备份失败（未写入）：${String(error?.message ?? error)}` };
-  }
-  const newBuf = await encodeSessionText(newText);
-  const switchTmpPath = filePath + ".modelswitchtmp";
-  writeFileSync(switchTmpPath, newBuf);
-  try {
-    chmodSync(switchTmpPath, statSync(filePath).mode);
-  } catch {
-    // CIFS 无 chmod，尽力
-  }
-  renameSync(switchTmpPath, filePath);
+  const backup = backupSwitchLog(filePath, sessionId);
+  if (backup.error) return backup;
+  const encodeStartedAt = Date.now();
+  replaceFileSync(filePath, await encodeSessionText(newText), { tmpSuffix: ".modelswitchtmp" });
+  log(ctx, `切换写日志：重编码+原子写回 ${Date.now() - encodeStartedAt}ms`);
   return { ok: true, note: "已直接写入会话日志" };
 }
 
@@ -120,21 +133,81 @@ export async function appendSelectionEventToLog(ctx, sessionId, provider, model)
  * @param {object|null} agent 可选 live agent（不传则内部按 sessionId 查）
  * @returns {{via: string} | {error: string}}
  */
-export async function switchAgentModel(ctx, sessionId, provider, model, agent = null) {
-  if (!sessionId) return { error: "缺少 sessionId（无法定位目标会话）" };
-  // ① 持久化切换意图（不依赖 live agent——成员 inactive/未挂载时也能切，下次运行生效）
-  let overrideNote = "";
+/**
+ * ① 持久化切换意图：不依赖 live agent —— 成员 inactive/未挂载时也能切，下次运行生效。
+ * @returns {Promise<{note: string}>} note 直接拼进回执
+ */
+async function persistSwitchIntent(ctx, sessionId, provider, model) {
   try {
     await setMemberModelOverride(ctx, sessionId, provider, model);
-    overrideNote = "，已记录切换意图";
+    return { note: "，已记录切换意图" };
   } catch (error) {
-    overrideNote = `，意图持久化失败：${String(error?.message ?? error)}`;
+    return { note: `，意图持久化失败：${String(error?.message ?? error)}` };
   }
+}
+
+/**
+ * ⑤ 官方接口优先（若该部署暴露）：
+ *   · 新版 ctx.apiProxy.sessions.selectModel（会话级模型选择，持久化到会话）
+ *   · 旧版 ctx.get("sessionController").selectModel（Typert @Remote，服务端直调可能不可用）
+ * 任一成功返回 {via}；都不可用/失败返回 null（调用方回退到「写事件」机制）。
+ */
+async function tryOfficialSelectModel(ctx, sessionId, provider, model, overrideNote) {
+  // 可关：某些部署上 selectModel（Typert @Remote）会长时间不返回，表现为「切模型卡住」。
+  // 配置 modelSwitchOfficialApi=false 即只走「写 model/selection 事件」这条实测可用的路径。
+  if (cfg.modelSwitchOfficialApi === false) {
+    log(ctx, "已按配置跳过官方 selectModel（modelSwitchOfficialApi=false），仅写事件");
+    return null;
+  }
+  const apiProxy = ctx.apiProxy ?? (typeof ctx.get === "function" ? ctx.get("apiProxy") : null);
+  const proxySessions = apiProxy?.sessions;
+  if (typeof proxySessions?.selectModel === "function") {
+    const startedAt = Date.now();
+    try {
+      await proxySessions.selectModel({ sessionId, provider, model });
+      log(ctx, `apiProxy.sessions.selectModel 成功，耗时 ${Date.now() - startedAt}ms`);
+      return { via: `ctx.apiProxy.sessions.selectModel（官方，会话级持久）${overrideNote}` };
+    } catch (error) {
+      log(ctx, `apiProxy.sessions.selectModel 失败（耗时 ${Date.now() - startedAt}ms，回退事件机制）: ${String(error?.message ?? error)}`);
+    }
+  }
+  const sc = ctx.get("sessionController");
+  if (typeof sc?.selectModel !== "function") return null;
+  const remoteStartedAt = Date.now();
+  try {
+    await sc.selectModel({ sessionId, provider, model });
+    log(ctx, `sessionController.selectModel 成功，耗时 ${Date.now() - remoteStartedAt}ms`);
+    return { via: `sessionController.selectModel（官方，立即生效）${overrideNote}` };
+  } catch (error) {
+    // 服务端直调 @Remote 可能不被支持——已走「写事件」机制，这里只留日志
+    log(ctx, `selectModel 直调不可用（耗时 ${Date.now() - remoteStartedAt}ms，已用 model/selection 事件机制）: ${String(error?.message ?? error)}`);
+    return null;
+  }
+}
+
+export async function switchAgentModel(ctx, sessionId, provider, model, agent = null) {
+  const timer = createStageTimer();
+  try {
+    return await applyModelSwitch(ctx, sessionId, provider, model, agent, timer);
+  } finally {
+    // 无论成功失败都留一行分阶段耗时：排查「切模型卡很久」时直接看慢在哪一段
+    log(ctx, `模型切换耗时：${timer.summary()}（标记合计 ${timer.total()}ms）`);
+  }
+}
+
+/** 切换主流程（逐段打点，计时器只观测、不改变行为）。 */
+async function applyModelSwitch(ctx, sessionId, provider, model, agent, timer) {
+  if (!sessionId) return { error: "缺少 sessionId（无法定位目标会话）" };
+  // ① 持久化切换意图（不依赖 live agent——成员 inactive/未挂载时也能切，下次运行生效）
+  const { note: overrideNote } = await persistSwitchIntent(ctx, sessionId, provider, model);
+  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) {
     const written = await appendSelectionEventToLog(ctx, sessionId, provider, model);
+    timer.mark("写会话日志");
     if (written.error) {
       return { error: `成员未挂载，且写入会话日志失败：${written.error}（切换意图已记录，可稍后重试）` };
     }
@@ -143,7 +216,9 @@ export async function switchAgentModel(ctx, sessionId, provider, model, agent =
   // ③ 正在执行回合：等它暂停再切（当前回合已用旧模型发出请求，直接切会「只生效一回合」）
   const IDLE_WAIT_MS = 60_000;
   if (live.status === "running" || hasOpenTurn(live.session?.events)) {
+    log(ctx, `目标成员在运行中（status=${live.status ?? "?"}），先等其空闲再切（最多 ${IDLE_WAIT_MS}ms）`);
     const idle = await waitForIdle(live, IDLE_WAIT_MS);
+    timer.mark("等空闲");
     if (!idle) {
       return { error: `成员正在执行回合（status=${live.status ?? "?"}），已等待 60s 仍未结束——请稍后重试，或先用 interrupt_agent 中断该成员` };
     }
@@ -154,6 +229,7 @@ export async function switchAgentModel(ctx, sessionId, provider, model, agent =
   try {
     live.session.append("model/selection", { provider, model });
     eventNote = "，已写入 model/selection 事件";
+    timer.mark("写事件");
   } catch (error) {
     eventNote = `，事件写入失败：${String(error?.message ?? error)}`;
   }
@@ -162,26 +238,9 @@ export async function switchAgentModel(ctx, sessionId, provider, model, agent =
   //    · 新版：ctx.apiProxy.sessions.selectModel（会话级模型选择，持久化到会话）
   //    · 旧版：ctx.get("sessionController").selectModel（Typert @Remote，服务端直调可能不可用）
   //    两者任一成功都直接返回——它们比「只写事件」更权威（含模型归一化等官方处理）。
-  const apiProxy = ctx.apiProxy ?? (typeof ctx.get === "function" ? ctx.get("apiProxy") : null);
-  const proxySessions = apiProxy?.sessions;
-  if (typeof proxySessions?.selectModel === "function") {
-    try {
-      await proxySessions.selectModel({ sessionId, provider, model });
-      return { via: `ctx.apiProxy.sessions.selectModel（官方，会话级持久）${overrideNote}` };
-    } catch (error) {
-      log(ctx, `apiProxy.sessions.selectModel 失败（回退事件机制）: ${String(error?.message ?? error)}`);
-    }
-  }
-  const sc = ctx.get("sessionController");
-  if (typeof sc?.selectModel === "function") {
-    try {
-      await sc.selectModel({ sessionId, provider, model });
-      via = `sessionController.selectModel（官方，立即生效）${overrideNote}`;
-    } catch (error) {
-      // 服务端直调 @Remote 可能不被支持——已走上面的「写事件」机制，这里只留日志
-      log(ctx, `selectModel 直调不可用（已用 model/selection 事件机制）: ${String(error?.message ?? error)}`);
-    }
-  }
+  const official = await tryOfficialSelectModel(ctx, sessionId, provider, model, overrideNote);
+  timer.mark("官方接口");
+  if (official) return official;
   return { via };
 }
 
@@ -250,6 +309,26 @@ export function resetSwitchWatchForTest() {
   pendingOutcomes.clear();
 }
 
+/**
+ * 把一个会话事件归类成「请求头」或「切换意图」，都不是则返回 null。
+ * 抽出来是为了让 readLastRequestModel 的流式解析循环只负责「读一行 → 交给它判」。
+ * @returns {{kind:'request'|'selection', value:{provider:string, model:string, time:number|null}}|null}
+ */
+function modelEventOf(event) {
+  if (event?.type === "request/header") {
+    const config = event?.data?.header?.config;
+    if (!config?.provider || !config?.model) return null;
+    return { kind: "request", value: { provider: config.provider, model: config.model, time: event.time ?? null } };
+  }
+  if (event?.type === "model/selection" && event?.data?.provider) {
+    return {
+      kind: "selection",
+      value: { provider: event.data.provider, model: event.data.model, time: event.time ?? null },
+    };
+  }
+  return null;
+}
+
 /**
  * 读会话日志里「最近一次实际请求使用的模型」与「最近一次切换意图」。
  *
@@ -266,7 +345,7 @@ export async function readLastRequestModel(sessionId, root = null) {
   if (!file) return { lastRequest: null, lastSelection: null, scanned: 0 };
   const { streamDecodedFrames } = await import("../../zstd-frames.js");
   const { StringDecoder } = await import("node:string_decoder");
-  const buf = readFileSync(file);
+  const buf = await readFile(file); // 日志最大可达数十 MB，异步读避免阻塞事件循环
   const decoder = new StringDecoder("utf8");
   let pending = "";
   let scanned = 0;
@@ -276,13 +355,13 @@ export async function readLastRequestModel(sessionId, root = null) {
     if (!line) return;
     let event;
     try { event = JSON.parse(line); } catch { return; }
-    if (event?.type === "request/header") {
-      const cfg = event?.data?.header?.config;
-      if (cfg?.provider && cfg?.model) { lastRequest = { provider: cfg.provider, model: cfg.model, time: event.time ?? null }; scanned += 1; }
-      return;
-    }
-    if (event?.type === "model/selection" && event?.data?.provider) {
-      lastSelection = { provider: event.data.provider, model: event.data.model, time: event.time ?? null };
+    const hit = modelEventOf(event);
+    if (hit === null) return;
+    if (hit.kind === "request") {
+      lastRequest = hit.value;
+      scanned += 1;
+    } else {
+      lastSelection = hit.value;
     }
   };
   await streamDecodedFrames(buf, (chunk) => {