dsh-session-conductor 1.3.10 → 1.3.13

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

@@ -3,9 +3,14 @@
 // 【职责】把一次「切模型」落到实处：持久化 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 { createZstdDecompress } from "node:zlib";
+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,59 +53,127 @@ 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 会兜底）
     }
   }
-  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 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 同款做法）
+  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`));
+    const file = path.join(backupDir, `${Date.now()}-${sessionId}.zstd`);
+    copyFileSync(filePath, file);
+    return { ok: true, file };
   } catch (error) {
     return { error: `备份失败（未写入）：${String(error?.message ?? error)}` };
   }
-  const newBuf = await encodeSessionText(newText);
-  const switchTmpPath = filePath + ".modelswitchtmp";
-  writeFileSync(switchTmpPath, newBuf);
+}
+
+/** 写后自检不合格时把日志还原回备份（宁可不动日志，也不能留下 corrupt 的会话）。 */
+function restoreSwitchLog(backup, filePath) {
+  if (!backup?.file) return { error: "没有可用备份，无法回滚" };
   try {
-    chmodSync(switchTmpPath, statSync(filePath).mode);
-  } catch {
-    // CIFS 无 chmod，尽力
+    copyFileSync(backup.file, filePath);
+    return { ok: true };
+  } catch (error) {
+    return { error: `回滚失败：${String(error?.message ?? error)}` };
+  }
+}
+
+export async function appendSelectionEventToLog(ctx, sessionId, provider, model) {
+  const startedAt = Date.now();
+  // 这条路径会整份解码会话日志再整份写回，而宿主在同一会话上会并发追加事件
+  // （turn/start、agent/inbox/spliced…）。若直接用「读到的 maxSeq+1」写回，就会写入过期序号，
+  // 表现为 released v2 row N has seq gap（序号回退），整份会话随即被判 corrupt。
+  // 因此这里做三件事：① 写前 CAS（对比快照是否已过期）② 过期就重读重试 ③ 写后自检 + 失败回滚。
+  //
+  // 【为什么改成「尾部读 + 追加帧」】原实现每次都整份解码（30MB 日志要 1~3s CPU 与数百 MB 内存），
+  // 而追加一条事件只需要知道「尾部 seq」。这里只解码最后几帧拿尾部事件，写入也是「把新事件压缩成一个
+  // 新帧追加到文件尾」——开销与日志总大小无关，且不回写已有帧（失败不会破坏历史）。
+  const { readTailEvents, appendEventFrame } = await import("../../sessions/tail-io.js");
+  let logInfo = await readSwitchLog(sessionId);
+  if (logInfo.error) return { error: logInfo.error };
+  const filePath = logInfo.filePath;
+  log(ctx, `切换写日志：定位+首读 ${Date.now() - startedAt}ms（行数 ${logInfo.lines.length}）`);
+
+  const tailOf = (events) => ({
+    maxSeq: events.reduce((max, e) => (typeof e?.seq === "number" && e.seq > max ? e.seq : max), -1),
+    count: events.length,
+  });
+
+  for (let attempt = 0; attempt < 3; attempt += 1) {
+    const { events } = logInfo;
+    const last = foldLastModelSelection(events);
+    if (last && last.provider === provider && last.model === model) {
+      return { ok: true, note: "日志里已是该模型，无需重复写入" };
+    }
+    const { maxSeq } = tailOf(events);
+    const event = { type: "model/selection", seq: maxSeq + 1, time: Date.now(), data: { provider, model } };
+
+    // ① CAS：写前再读一次尾部，确认快照期间宿主没有追加新事件（尾部 seq 未变才敢写）
+    const { readFile } = await import("node:fs/promises");
+    let freshTail;
+    try {
+      freshTail = await readTailEvents(await readFile(filePath), { tailFrames: 3 });
+    } catch (error) {
+      return { error: `写前重读失败：${String(error?.message ?? error)}` };
+    }
+    if (tailOf(freshTail.events).maxSeq !== maxSeq) {
+      log(ctx, `切换写日志：快照已过期（第 ${attempt + 1} 次，尾部 seq ${maxSeq} → ${tailOf(freshTail.events).maxSeq}），重读重试`);
+      logInfo = { ...logInfo, events: freshTail.events };
+      continue;
+    }
+
+    // ② 追加帧（appendEventFrame 内部自证首帧契约 + 长度 CAS + fsync）
+    const writeStartedAt = Date.now();
+    const written = await appendEventFrame(filePath, event);
+    log(ctx, `切换写日志：追加帧 ${Date.now() - writeStartedAt}ms（seq ${event.seq}）`);
+    if (!written.ok) return { error: `写入会话日志失败：${written.error}` };
+
+    // ③ 写后自检：只读尾部，确认新事件确实落在尾部且 seq 严格 +1 衔接
+    try {
+      const after = await readTailEvents(await readFile(filePath), { tailFrames: 3 });
+      const seqs = after.events.map((e) => e?.seq).filter((n) => typeof n === "number");
+      const tailOk = seqs.length > 0 && seqs.at(-1) === event.seq
+        && seqs.every((n, i) => i === 0 || n === seqs[i - 1] + 1);
+      if (tailOk) return { ok: true, note: "已直接写入会话日志" };
+      log(ctx, `切换写日志：写后自检失败（尾部 ${JSON.stringify(seqs.slice(-3))}），回滚`);
+    } catch (error) {
+      log(ctx, `切换写日志：写后自检读取失败：${String(error?.message ?? error)}`);
+    }
+    // 追加帧写坏时只能整份回退：用备份整份恢复
+    const backup = backupSwitchLog(filePath, sessionId);
+    if (backup.error) return { error: `写后自检失败且无备份可回滚：${backup.error}` };
+    restoreSwitchLog(backup, filePath);
+    return { error: "写入后 seq 不连续，已回滚（不改日志，改用选择意图生效）" };
   }
-  renameSync(switchTmpPath, filePath);
-  return { ok: true, note: "已直接写入会话日志" };
+  // 一直有并发写入：放弃写日志（不算失败，选择意图仍会生效）
+  log(ctx, "切换写日志：并发写入持续存在，放弃写日志（不影响切换）");
+  return { ok: true, note: "会话正在被并发写入，跳过日志写入（选择意图仍生效）" };
 }
 
 /**
@@ -120,21 +193,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) {
+    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) {
-    overrideNote = `，意图持久化失败：${String(error?.message ?? 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 +276,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 +289,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 +298,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 +369,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;
+}
+
 /**
  * 读会话日志里「最近一次实际请求使用的模型」与「最近一次切换意图」。
  *
@@ -258,6 +397,11 @@ export function resetSwitchWatchForTest() {
  *   · `model/selection` 的 `data.{provider,model}` —— 切换意图（有则一并返回，便于对照）。
  * 用按 zstd 帧流式读（常量内存），大日志也不会把整份文本读进内存。
  *
+ * 【内存纪律】① `pending` 加上限：只在「遇到换行才切走」的缓冲区，若某帧内长时间没有换行
+ * （单行超大事件，例如几 MB 的工具结果）会无限增长；超过上限直接抛错，不再硬撑。
+ * ② `readFile` 换成只读**最后若干帧**：查证只关心「最近一次请求」，没必要把整份文件读进内存
+ * （30MB 日志时这一项就省掉一份整文件 Buffer）。
+ *
  * @returns {Promise<{lastRequest: {provider,model,time}|null, lastSelection: {provider,model,time}|null, scanned: number}>}
  */
 export async function readLastRequestModel(sessionId, root = null) {
@@ -266,34 +410,63 @@ 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 { scanZstdFrames } = await import("../../zstd-frames.js");
+  // 只流式解码最后若干帧：请求头/选择意图判定只关心最近一次，够用且省内存
+  const TAIL_FRAMES = 8;
+  let tailFrames;
+  try {
+    const { frames } = scanZstdFrames(buf);
+    tailFrames = frames.slice(Math.max(0, frames.length - TAIL_FRAMES));
+  } catch {
+    // 帧扫描失败（文件损坏）：退回整份流式解码，让上层按损坏处理，不在这里静默丢数据
+    tailFrames = null;
+  }
   const decoder = new StringDecoder("utf8");
   let pending = "";
   let scanned = 0;
   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; }
-    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) => {
+  const onChunk = (chunk) => {
     pending += decoder.write(chunk);
+    if (pending.length > PENDING_LIMIT) {
+      throw new Error(`readLastRequestModel 单行缓冲超过 ${PENDING_LIMIT} 字节仍无换行（疑似异常大事件）`);
+    }
     let idx;
     while ((idx = pending.indexOf("\n")) >= 0) {
       const line = pending.slice(0, idx);
       pending = pending.slice(idx + 1);
       consume(line);
     }
-  });
+  };
+  if (tailFrames === null) {
+    await streamDecodedFrames(buf, onChunk);
+  } else {
+    for (const fr of tailFrames) {
+      await new Promise((resolve, reject) => {
+        const d = createZstdDecompress();
+        d.on("data", (c) => { try { onChunk(c); } catch (error) { reject(error); } });
+        d.on("end", resolve);
+        d.on("error", reject);
+        d.write(buf.subarray(fr.start, fr.end));
+        d.end();
+      });
+    }
+  }
   pending += decoder.end();
   consume(pending);
   return { lastRequest, lastSelection, scanned };

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

@@ -20,8 +20,8 @@
 import { readRecentUserTurns } from "../../sessions/events.js";
 import { log } from "../../shared/log.js";
 import { cfg } from "../../core/config.js";
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { writeJsonAtomicSync, readJsonSafeSync } from "../../shared/json-store.js";
+import { join } from "node:path";
 
 // ── 用量记忆的**持久化**（解决「重启后不触发」）──────────────────────────────
 // 只用内存 WeakMap 时实例一重启就清空 ⇒ 首个回合没有「上次用量」可比 ⇒
@@ -54,12 +54,9 @@ function loadDiskState() {
   diskState = {};
   const file = stateFilePath();
   if (!file) return diskState;
-  try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
-    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) diskState = parsed;
-  } catch {
-    // 首次运行 / 文件损坏：按空表继续
-  }
+  // 统一读实现：不存在/损坏都返回 null，按空表继续
+  const parsed = readJsonSafeSync(file);
+  if (parsed && !Array.isArray(parsed)) diskState = parsed;
   return diskState;
 }
 
@@ -71,9 +68,7 @@ function saveDiskStateThrottled(ctx) {
   const file = stateFilePath();
   if (!file) return;
   try {
-    mkdirSync(dirname(file), { recursive: true });
-    writeFileSync(`${file}.tmp`, JSON.stringify(diskState), "utf8");
-    renameSync(`${file}.tmp`, file);
+    writeJsonAtomicSync(file, diskState); // 统一原子写（tmp + rename）
   } catch (error) {
     log(ctx, `记忆取回：用量状态落盘失败（不影响功能）: ${String(error?.message ?? error)}`);
   }
@@ -254,6 +249,26 @@ const TEXT_OUTPUT = {
  *
  * @returns {boolean} 是否成功注册
  */
+/**
+ * 解析 recall_memory 的 `session` 参数：
+ *   · 缺省 / 空 / 等于自身 ⇒ 取自身（行为与未加该参数时逐字一致）
+ *   · 多个候选 / 找不到 ⇒ 返回可直接回给用户的 message（不猜一个）
+ * @param {Function} resolve 会话解析函数（由工具注册处注入，默认 resolveSessionTarget）
+ * @returns {Promise<{targetId: string, fromOther: boolean} | {message: string}>}
+ */
+async function resolveRecallTarget(ctx, want, selfId, resolve) {
+  if (!want || want === selfId) return { targetId: selfId, fromOther: false };
+  const hit = await resolve(ctx, want, selfId);
+  if (hit?.candidates) {
+    return {
+      message: `「${want}」匹配到多个目标，请用更完整的 id 重试：\n`
+        + hit.candidates.slice(0, 10).map((c) => `- ${c.id}${c.title ? ` ｜ ${c.title}` : ""}`).join("\n"),
+    };
+  }
+  if (!hit?.id) return { message: `找不到目标会话「${want}」：没有匹配的会话 id / id 前缀 / 标题。` };
+  return { targetId: hit.id, fromOther: true };
+}
+
 export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
   if (typeof defineTool !== "function" || typeof tools?.register !== "function") return false;
   const read = deps.readTurns ?? readRecentUserTurns;
@@ -279,19 +294,9 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
       const asked = Number.isSafeInteger(args?.rounds) && args.rounds > 0 ? args.rounds : (config?.retrieveMemoryRounds ?? 3);
       const rounds = Math.min(asked, maxRounds);
       const want = typeof args?.session === "string" ? args.session.trim() : "";
-      // 缺省 / 空 / 等于自身 ⇒ 走自身路径，行为与之前逐字一致
-      let targetId = selfId;
-      let fromOther = false;
-      if (want && want !== selfId) {
-        const hit = await resolve(ctx, want, selfId);
-        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 前缀 / 标题。`;
-        targetId = hit.id;
-        fromOther = true;
-      }
+      const target = await resolveRecallTarget(ctx, want, selfId, resolve);
+      if (target.message) return target.message;
+      const { targetId, fromOther } = target;
       try {
         const turns = await read(ctx, targetId, {
           rounds,
@@ -325,16 +330,20 @@ export function registerMemoryRecallTool(ctx, defineTool, tools, deps = {}) {
  */
 export async function resolveSessionTarget(ctx, want, selfId) {
   const { sessionsRootOf } = await import("../../sessions/events.js");
-  const { readdirSync, existsSync, statSync } = await import("node:fs");
+  // 异步遍历：会话目录可能上千个，同步 stat/readdir 会把事件循环钉住
+  const { readdir, stat } = await import("node:fs/promises");
   const { join } = await import("node:path");
   const root = sessionsRootOf();
   const ids = [];
-  if (root && existsSync(root)) {
-    for (const proj of readdirSync(root)) {
+  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);
-      try { if (!statSync(pp).isDirectory()) continue; } catch { continue; }
-      for (const dir of readdirSync(pp)) {
-        try { if (!statSync(join(pp, dir)).isDirectory()) continue; } catch { continue; }
+      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);
       }
     }

package/lib/features/rename/analysis.js

@@ -63,29 +63,38 @@ export async function runAnalysis(ctx, sessionId, opts = {}) {
  * modelCatalog 匹配 provider；匹配不到则借用当前路由的 provider）。
  * @returns {provider, model} 或 null（无法解析）
  */
-export async function resolveModelOverride(ctx, modelArg, fallbackRoute) {
-  const raw = String(modelArg ?? "").trim();
-  if (!raw) return null;
-  // "provider/model" 显式拆分；不匹配（含纯模型名）→ 走 catalog 匹配/fallback
-  const explicit = /^([^/]+)\/(.+)$/.exec(raw);
-  if (explicit) {
-    const provider = explicit[1].trim();
-    const model = explicit[2].trim();
-    if (provider && model) return { provider, model };
-  }
-  // 纯模型名：modelCatalog 里找第一个含该 model 的分组
+/** 拆 "provider/model" 形式；不是该形式返回 null（含纯模型名）。 */
+function splitExplicitModel(raw) {
+  const matched = /^([^/]+)\/(.+)$/.exec(raw);
+  if (!matched) return null;
+  const provider = matched[1].trim();
+  const model = matched[2].trim();
+  return provider && model ? { provider, model } : null;
+}
+
+/** 纯模型名：在 modelCatalog 里找第一个包含该模型的分组；catalog 不可用返回 null。 */
+async function providerOfModelName(ctx, raw) {
   try {
     const sc = ctx.get("sessionController");
     const catalog = sc?.modelCatalog ? await sc.modelCatalog() : null;
-    const groups = catalog?.groups ?? [];
-    for (const g of groups) {
-      if ((g.models ?? []).some((m) => m.id === raw || m.name === raw)) {
-        return { provider: g.id, model: raw };
+    for (const group of catalog?.groups ?? []) {
+      if ((group.models ?? []).some((m) => m.id === raw || m.name === raw)) {
+        return { provider: group.id, model: raw };
       }
     }
   } catch {
-    // catalog 不可用 → 落到 fallback provider
+    // catalog 不可用 → 交给 fallback provider
   }
+  return null;
+}
+
+export async function resolveModelOverride(ctx, modelArg, fallbackRoute) {
+  const raw = String(modelArg ?? "").trim();
+  if (!raw) return null;
+  const explicit = splitExplicitModel(raw);
+  if (explicit) return explicit;
+  const byCatalog = await providerOfModelName(ctx, raw);
+  if (byCatalog) return byCatalog;
   if (fallbackRoute?.provider) return { provider: fallbackRoute.provider, model: raw };
   return null;
 }

package/lib/features/rename/title.js

@@ -52,25 +52,37 @@ export function foldTitle(events) {
 }
 
 /** 从会话 cwd 推导工作区名：优先匹配 workspaceRegistry 分组 title，否则取 cwd basename。 */
-export function workspaceNameOf(ctx, cwd) {
-  if (typeof cwd !== "string" || cwd === "") return "";
-  const registry = ctx?.get?.("workspaceRegistry");
-  if (registry) {
-    try {
-      for (const workspace of registry.list?.() ?? []) {
-        const path = String(workspace?.path ?? "").replace(/\/+$/, "");
-        const normalizedCwd = String(cwd).replace(/\/+$/, "");
-        if (path !== "" && (normalizedCwd === path || normalizedCwd.startsWith(path + "/"))) {
-          if (typeof workspace.title === "string" && workspace.title.trim() !== "") return workspace.title.trim();
-        }
-      }
-    } catch {
-      // 分组服务不可用时回退 basename
+/**
+ * 在 workspaceRegistry 里找 cwd 所属工作区的标题（**第一个命中即返回**，与原实现同口径）。
+ * 服务不可用/无匹配返回 ""。
+ */
+function workspaceTitleOf(registry, normalizedCwd) {
+  try {
+    for (const workspace of registry.list?.() ?? []) {
+      const path = String(workspace?.path ?? "").replace(/\/+$/, "");
+      if (path === "") continue;
+      if (normalizedCwd !== path && !normalizedCwd.startsWith(path + "/")) continue;
+      const title = typeof workspace.title === "string" ? workspace.title.trim() : "";
+      if (title !== "") return title;
     }
+  } catch {
+    // 分组服务不可用：交给调用方回退 basename
   }
+  return "";
+}
+
+/** 取路径最后一段（工作区服务不可用时的兜底显示名）。 */
+function basenameOfPath(cwd) {
   return String(cwd).split(/[/\\]/).filter(Boolean).pop() ?? "";
 }
 
+export function workspaceNameOf(ctx, cwd) {
+  if (typeof cwd !== "string" || cwd === "") return "";
+  const registry = ctx?.get?.("workspaceRegistry");
+  const title = registry ? workspaceTitleOf(registry, cwd.replace(/\/+$/, "")) : "";
+  return title !== "" ? title : basenameOfPath(cwd);
+}
+
 /** 给标题加工作区前缀（幂等：已带前缀不叠加）。返回 {title, ws}。 */
 export function archiveTitleWithWs(title, ws) {
   const t = String(title ?? "");