dsh-session-conductor 1.3.10 → 1.3.13

package/lib/features/session-ops.js

@@ -1,7 +1,7 @@
 /** 会话级操作：归档恢复、删除（单个/批量/按规则）、撤回最后一条消息。 */
 
 import { rm, readdir } from "node:fs/promises";
-import { readFileSync, copyFileSync, writeFileSync, renameSync, mkdirSync, chmodSync, statSync } from "node:fs";
+import { readFileSync, copyFileSync, mkdirSync } from "node:fs";
 import path from "node:path";
 import { hasOpenTurn } from "../sessions/turn.js";
 import { lazyRepair, lazyZstd, lazyValue } from "../core/lazy.js";
@@ -18,6 +18,8 @@ import {
 } from "../core/config.js";
 import { sessionEventsOf } from "../sessions/events.js";
 import { detachSessionAgent } from "../sessions/detach.js";
+import { sessionMetaOf } from "../sessions/lookup.js";
+import { replaceFileSync } from "../shared/atomic-file.js";
 import { markDeleted, forgetTrashed, expiredIds, loadTrash, saveTrashNow } from "./trash.js";
 import { invalidateSessionListCache } from "../sessions/list-cache.js";
 import { buildSessionListCached } from "../sessions/list.js";
@@ -205,17 +207,9 @@ export async function deleteSessionPhysically(ctx, sessionId) {
  * 预检/快照的成本上限是「读一次内存或索引」，不是「扫一遍所有会话日志」。
  */
 async function describeForTrash(ctx, sessionId) {
-  try {
-    const live = ctx.get("sessions")?.get?.(sessionId);
-    if (live) {
-      return { title: live.title ?? null, cwd: live.header?.cwd ?? null, updatedAt: null, archived: false };
-    }
-    const { loadListDiskCache } = await import("../sessions/list-cache.js");
-    const entry = loadListDiskCache(ctx)?.entries?.[sessionId];
-    return { title: entry?.title ?? null, cwd: entry?.cwd ?? null, updatedAt: entry?.updatedAt ?? null, archived: false };
-  } catch {
-    return {};
-  }
+  const meta = await sessionMetaOf(ctx, sessionId);
+  if (!meta) return {};
+  return { title: meta.title, cwd: meta.cwd, updatedAt: meta.updatedAt, archived: meta.archived };
 }
 
 /**
@@ -232,32 +226,44 @@ export async function deleteSession(ctx, sessionId) {
 }
 
 /** 到期真删：把超过保留天数的条目从磁盘上删掉（只由定时器/手动清理调用）。 */
-export async function purgeExpiredTrash(ctx, now = Date.now()) {
-  const ids = expiredIds(ctx, now);
+/**
+ * 逐条真删：到期清理与一键清空共用同一条链路（单条失败只跳过，不影响其余）。
+ * @returns {{deleted: string[], remaining: number}}
+ */
+async function purgeMany(ctx, ids) {
   const deleted = [];
   for (const id of ids) {
     try {
       const result = await deleteSessionPhysically(ctx, id);
-      if (result?.ok) { forgetTrashed(ctx, [id]); deleted.push(id); }
-    } catch { /* 单条失败跳过，下次再试 */ }
+      if (result?.ok) {
+        forgetTrashed(ctx, [id]);
+        deleted.push(id);
+      }
+    } catch {
+      // 单条失败跳过：下一次清理会再试，不阻断其余会话
+    }
   }
-  if (deleted.length > 0) { saveTrashNow(ctx); invalidateSessionListCache(); }
   return { deleted, remaining: ids.length - deleted.length };
 }
 
+/** 到期真删：把超过保留天数的条目从磁盘上删掉（只由定时器/手动清理调用）。 */
+export async function purgeExpiredTrash(ctx, now = Date.now()) {
+  const ids = expiredIds(ctx, now);
+  const result = await purgeMany(ctx, ids);
+  if (result.deleted.length > 0) {
+    saveTrashNow(ctx);
+    invalidateSessionListCache();
+  }
+  return result;
+}
+
 /** 一键清空：立即真删回收站里的全部会话（不可恢复）。 */
 export async function emptyTrash(ctx) {
   const ids = Object.keys(loadTrash(ctx).entries);
-  const deleted = [];
-  for (const id of ids) {
-    try {
-      const result = await deleteSessionPhysically(ctx, id);
-      if (result?.ok) { forgetTrashed(ctx, [id]); deleted.push(id); }
-    } catch { /* 单条失败跳过 */ }
-  }
+  const result = await purgeMany(ctx, ids);
   saveTrashNow(ctx);
   invalidateSessionListCache();
-  return { deleted, remaining: ids.length - deleted.length };
+  return result;
 }
 
 // ---------- 撤回最后一条用户消息 ----------
@@ -376,10 +382,7 @@ export async function undoLastMessage(ctx, sessionId, { dryRun = false } = {}) {
     // 6. 多帧写回（header 一帧 + body 一帧，带 checksum），原子替换
     const { encodeSessionText } = await lazyRepair();
     const newBuf = await encodeSessionText(newText);
-    const undoTmpPath = filePath + ".undotmp";
-    writeFileSync(undoTmpPath, newBuf);
-    try { chmodSync(undoTmpPath, statSync(filePath).mode); } catch { /* CIFS 无 chmod，尽力 */ }
-    renameSync(undoTmpPath, filePath);
+    replaceFileSync(filePath, newBuf, { tmpSuffix: ".undotmp" });
 
     return { ok: true, preview, removedLineCount, removedEventCount, remainingEventCount: check.eventCount, backup: bak };
   });

package/lib/repair.js

@@ -280,7 +280,8 @@ export async function repairCorruptSessions(ctx, { dryRun = false } = {}) {
       report.fixed += 1;
       report.backups.push(backupPath);
       report.sessions.push({ ...entry, fixedBlocks: fixedCount, backup: backupPath });
-      try { ctx.logger?.info?.(`dsh-session-conductor: 已修复会话 ${id}（${fixedCount} 个块）`); } catch {}
+      // 日志失败不影响修复结果本身
+      try { ctx.logger?.info?.(`dsh-session-conductor: 已修复会话 ${id}（${fixedCount} 个块）`); } catch { /* 日志失败忽略 */ }
     } catch (error) {
       report.errors.push({ id, error: `修复失败: ${String(error?.message ?? error)}` });
       report.sessions.push(entry);
@@ -394,8 +395,9 @@ export async function scanDualFormatSessions() {
       const zstd = findSessionLog(sessionDir);
       if (!plain || !zstd) continue;
       let plainBytes = 0, zstdBytes = 0;
-      try { plainBytes = statSync(plain).size; } catch {}
-      try { zstdBytes = statSync(zstd).size; } catch {}
+      // stat 失败（文件刚被移走等）按 0 字节展示，不阻断扫描
+      try { plainBytes = statSync(plain).size; } catch { /* 读不到按 0 */ }
+      try { zstdBytes = statSync(zstd).size; } catch { /* 读不到按 0 */ }
       report.dual.push({ id: sess, dir: sessionDir, plainBytes, zstdBytes });
     }
   }

package/lib/seq-gap-repair.js

@@ -7,7 +7,9 @@
 // 修复：动态定位 GAP/offset → 3 类引用映射（值 ≥ GAP 则 +offset）→ seq 重编号 → 自愈补全缺失引用
 //   → 官方 foldSurface 校验 → token-surface 协议校验 → packChunkRuns → 多帧 zstd 原子写回。
 
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
+import { writeFileSync, mkdirSync } from 'node:fs';
+import { replaceFileSync } from "./shared/atomic-file.js";
+import { readFile } from "node:fs/promises";
 import { join, dirname } from 'node:path';
 import { findSessionLog } from './session-log.js';
 import { zstdCompress, constants } from 'node:zlib';
@@ -22,7 +24,7 @@ const SURFACE_TYPES = new Set(['user/message', 'assistant/message', 'tool/result
 
 /** 解码会话文件 → { header, events }。返回 null 表示无法解析（非 seq-gap 损坏）。 */
 async function loadSessionFile(path) {
-  const orig = readFileSync(path);
+  const orig = await readFile(path);
   const text = await decodeAllFrames(orig);
   const lines = text.split('\n');
   const header = JSON.parse(lines[0]);
@@ -192,9 +194,7 @@ export async function repairSeqGap(path, { dryRun = false, backupDir } = {}) {
   const bodyFrame = await zstdCompressAsync(Buffer.from(bodyText, 'utf8'), CHECKSUM_OPTIONS);
   const newBuf = Buffer.concat([headerFrame, bodyFrame]);
   report.sizeAfter = newBuf.length;
-  const fixedTmpPath = path + '.fixing';
-  writeFileSync(fixedTmpPath, newBuf);
-  renameSync(fixedTmpPath, path);
+  replaceFileSync(path, newBuf, { tmpSuffix: '.fixing' }); // 统一原子替换（写 tmp → 继承权限 → rename）
   report.ok = true;
   return report;
 }

package/lib/sessions/events.js

@@ -16,7 +16,8 @@
 // 宿主包**懒加载**：顶层 `import` 会让本文件在「工作区自测」环境直接解析失败
 // （仓库里踩过同类坑），而 events.js 是最需要被单测覆盖的模块之一（冷会话读法）。
 // 这里改成顶层 await import + 兜底：没有宿主依赖时退化为「不加闭合器」，其余逻辑照常可测。
-import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
+import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
@@ -43,6 +44,11 @@ function withInterruptedClosers(events) {
   }
 }
 
+/** 只读尾部时默认保留的事件行数（提出来是为了让 2000 这个数字有名字）。 */
+const DEFAULT_TAIL_KEEP = 2000;
+/** 单条消息默认截断字符数。 */
+const DEFAULT_MAX_CHARS_PER_ITEM = 800;
+
 /**
  * 该子会话是否归属 API remote（不该被插件当普通会话处理）。
  * 等价判定：header.origin==="subagent"，或 parent live agent 拥有该 child（agents.isOwnedBy）。
@@ -166,8 +172,8 @@ export function findSessionLogById(sessionId, root = sessionsRootOf()) {
 export async function readColdSessionSummary(ctx, sessionId, opts = {}) {
   const file = findSessionLogById(sessionId, opts.root ?? sessionsRootOf());
   if (!file) return null;
-  const tailKeep = Number.isSafeInteger(opts.tailKeep) && opts.tailKeep >= 0 ? opts.tailKeep : 2000;
-  const buf = readFileSync(file); // 压缩态（最大 ~50 MB），不是解压态
+  const tailKeep = Number.isSafeInteger(opts.tailKeep) && opts.tailKeep >= 0 ? opts.tailKeep : DEFAULT_TAIL_KEEP;
+  const buf = await readFile(file); // 压缩态（最大 ~50 MB），不是解压态
   const decoder = new StringDecoder("utf8");
   let pending = "";
   let meta = null;
@@ -268,8 +274,8 @@ export async function readRecentUserTurns(ctx, sessionId, opts = {}) {
   const file = findSessionLogById(sessionId, opts.root ?? sessionsRootOf());
   if (!file) return null;
   const rounds = Number.isSafeInteger(opts.rounds) && opts.rounds > 0 ? opts.rounds : 3;
-  const perItem = Number.isSafeInteger(opts.maxCharsPerItem) && opts.maxCharsPerItem > 0 ? opts.maxCharsPerItem : 800;
-  const buf = readFileSync(file);
+  const perItem = Number.isSafeInteger(opts.maxCharsPerItem) && opts.maxCharsPerItem > 0 ? opts.maxCharsPerItem : DEFAULT_MAX_CHARS_PER_ITEM;
+  const buf = await readFile(file);
   const decoder = new StringDecoder("utf8");
   let pending = "";
   const turns = [];

package/lib/sessions/interruption.js

@@ -1,4 +1,4 @@
-// dsh-session-conductor — 会话中断判定（自动续跑资格 + 标题状态后缀共用）
+// dsh-session-conductor — 回合中断判定（自动续跑资格 + 标题状态后缀共用）
 //
 // 【为什么放在 sessions 域】「这个会话是不是中断了、能不能自动续」是会话自身的属性判定，
 // 既被续跑域用（是否触发续跑），也被标题域用（是否加「已中断」后缀）——放在中立位置避免相互依赖。
@@ -20,7 +20,7 @@ export function interruptionInfo(events) {
       const reason = event.data?.reason;
       if (reason === null || typeof reason !== "object") return null;
       if (reason.kind === "interrupted") {
-        return { kind: "interrupted", seq: event.seq, message: "回合因进程/会话中断而未完成（崩溃修复）" };
+        return { kind: "interrupted", seq: event.seq, message: "回合因进程中断/运行失败而未完成（崩溃修复）" };
       }
       if (reason.kind === "error") {
         const code = typeof reason.error?.code === "string" ? reason.error.code : "UNKNOWN";

package/lib/sessions/lookup.js

@@ -0,0 +1,50 @@
+// 会话「便宜元信息」的唯一查找入口。
+//
+// 【为什么抽出来】同一件事在两个地方各写了一遍：
+//   · send_to_session 的 dryRun 预检（要报「目标是否活跃/在哪个目录」）
+//   · 回收站标记删除（要存一份标题/目录快照供回收站列表展示）
+// 两处都是「先看内存里的 live 会话，再看落盘索引」，逻辑重复且口径容易漂。
+//
+// 【铁律】只查这两个来源，**绝不**为了一个标题或目录去跑全量列表构建
+//   （冷缓存实测 41~226 秒，曾把 dryRun 预检拖成「发消息前卡死」）。
+//   查不到就返回 null，由调用方如实说「查不到」，不升级成昂贵查询。
+
+/**
+ * 取会话元信息：live 优先，其次落盘索引。
+ * @param {object} ctx 插件上下文
+ * @param {string} sessionId 会话 id
+ * @returns {Promise<{live:boolean,title:string|null,cwd:string|null,updatedAt:number|null,archived:boolean}|null>}
+ */
+export async function sessionMetaOf(ctx, sessionId) {
+  if (typeof sessionId !== "string" || sessionId === "") return null;
+  try {
+    const live = ctx.get?.("sessions")?.get?.(sessionId);
+    if (live) {
+      return {
+        live: true,
+        title: live.title ?? null,
+        cwd: live.header?.cwd ?? null,
+        updatedAt: null,
+        archived: false,
+      };
+    }
+  } catch {
+    // live 查询不可用：退回落盘索引
+  }
+  try {
+    const { loadListDiskCache } = await import("./list-cache.js");
+    const entry = loadListDiskCache(ctx)?.entries?.[sessionId];
+    if (entry) {
+      return {
+        live: false,
+        title: entry.title ?? null,
+        cwd: entry.cwd ?? null,
+        updatedAt: typeof entry.updatedAt === "number" ? entry.updatedAt : null,
+        archived: false,
+      };
+    }
+  } catch {
+    // 索引不可用：按「查不到」处理
+  }
+  return null;
+}

package/lib/sessions/route.js

@@ -40,7 +40,7 @@ export function defaultModelSelection(ctx) {
 }
 
 /**
- * 折叠会话里最后一次 `model/selection` 事件（切模型意图——官方 selectForNextRequest 也写这个事件）。
+ * 折叠日志里最后一次 `model/selection` 事件（切模型意图——官方 selectForNextRequest 也写这个事件）。
  * 【为什么】resume 时若只用「最后请求头」当选择，会把切换覆盖回原模型
  * （表现为「切了只生效一个回合」）；优先用该事件可与官方 selectionFor 的投影恢复保持一致。
  * @returns {{provider: string, model: string} | null}

package/lib/sessions/tail-io.js

@@ -0,0 +1,155 @@
+// dsh-session-conductor — 会话日志的「尾部」增量读写
+//
+// 【为什么单独成文件】成员模型切换（/model-switch、set_member_model、create_teammate_with_model）
+// 需要往会话日志追加一条 model/selection 事件。原实现是「整份解码 → 拼全文 → 全量校验 → 整份重编码」，
+// 一次切换要完整解码 3 次，30MB 日志时峰值内存数百 MB 且同步 parse 阻塞事件循环数秒。
+//
+// 本模块把这条路径改成「只看尾部」：
+//   · readTailEvents  —— 只解码最后 N 帧，取最后若干条事件（seq / 行数判定都在尾部完成）
+//   · appendEventFrame —— 只把「新事件一行」压缩成一个新帧追加到文件尾，**不重写已有内容**
+//
+// 【为什么追加帧是合法的】DSH 会话日志是【多帧容器】：第一帧必须恰好一行 header，其后是事件帧，
+// 帧与帧之间在解码层直接拼接（见 zstd-frames.js decodeAllFrames）。因此「在文件尾追加一个新事件帧」
+// 与「重写整份」在解码后的文本上等价，但内存与 CPU 开销与日志总大小无关。
+//
+// 【安全性】追加帧只改文件尾，失败时不影响已有帧；调用方仍会在写后自检（自检也走尾部读）。
+
+import { readFile, open } from "node:fs/promises";
+import { scanZstdFrames, decodeFrame, ZSTD_MAGIC } from "../zstd-frames.js";
+import zlib from "node:zlib";
+const { zstdCompress, constants } = zlib;
+
+const FRAME_OPTIONS = { params: { [constants.ZSTD_c_checksumFlag]: 1 } };
+
+/**
+ * 只解码会话日志的**最后若干帧**，返回其中的事件与统计信息。
+ *
+ * 与原「整份解码」的差异：不返回全部行，只返回尾部帧内的事件；
+ * 因此内存峰值 = 最后 N 帧的解压结果，与日志总大小无关。
+ *
+ * @param {Buffer} buf 整份（压缩的）日志文件内容
+ * @param {{tailFrames?: number, maxEvents?: number}} [opts]
+ * @returns {Promise<{events: object[], frames: number, tailStartFrame: number, torn: boolean}>}
+ *          events 为倒序无关、按日志顺序的尾部事件；frames 为总帧数；tailStartFrame 为尾部第一帧序号
+ */
+export async function readTailEvents(buf, opts = {}) {
+  const tailFrames = Math.max(1, opts.tailFrames ?? 3);
+  const maxEvents = Math.max(1, opts.maxEvents ?? 2000);
+  const { frames, tornStart } = scanZstdFrames(buf);
+  const tail = frames.slice(Math.max(0, frames.length - tailFrames));
+  // 逐帧解码 → 逐行消费，**不把尾部文本拼成一个大字符串**：
+  // 只保留「最后 maxEvents 条事件」，因此单帧再大也只在这一个数组上有峰值。
+  const events = [];
+  let carry = "";
+  for (const fr of tail) {
+    const frameText = (await decodeFrame(buf.subarray(fr.start, fr.end))).toString("utf8");
+    if (frameText === "") continue;
+    const lines = (carry + frameText).split("\n");
+    // 最后一段可能是不完整行（帧边界断开），留给下一帧拼接
+    carry = lines.pop() ?? "";
+    for (const line of lines) {
+      if (line.trim() === "") continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+        // 尾部帧里理论上都是完整行；解析失败不致命，交给调用方的 seq 自检兜底
+      }
+    }
+  }
+  if (carry.trim() !== "") {
+    try {
+      events.push(JSON.parse(carry));
+    } catch {
+      // 末尾残行：容忍，交给调用方自检
+    }
+  }
+  // 只保留最后 maxEvents 条（尾部帧通常很小，这是防止极端大帧的兜底）
+  return {
+    events: events.length > maxEvents ? events.slice(events.length - maxEvents) : events,
+    frames: frames.length,
+    tailStartFrame: Math.max(0, frames.length - tail.length),
+    torn: tornStart !== undefined,
+  };
+}
+
+/** 压缩「单行事件」成一个独立的 zstd 帧（带 checksum）。 */
+async function compressEventLine(line) {
+  const buf = Buffer.from(line.endsWith("\n") ? line : `${line}\n`, "utf8");
+  return new Promise((resolve, reject) => {
+    zstdCompress(buf, FRAME_OPTIONS, (error, out) => (error ? reject(error) : resolve(out)));
+  });
+}
+
+/**
+ * 把一个事件**以新帧形式追加**到会话日志尾部。
+ *
+ * 为什么不用「读整份 → 拼字符串 → 重编码」：那条路径内存与 CPU 都随日志大小线性增长，
+ * 而这里只压缩一行（几百字节～几 KB），开销恒定。
+ *
+ * 追加前会自证两件事，任一只怕就直接报错（宁可不动日志）：
+ *   ① 文件当前确实是合法的多帧容器（能扫描出帧、首帧能解出 header 行）；
+ *   ② 尾部事件的 seq 与将要写入的 seq 严格衔接（调用方传入 expectedSeq 时）。
+ *
+ * @param {string} filePath 会话日志路径
+ * @param {object} event 要追加的事件（会被 JSON.stringify 成一行）
+ * @returns {Promise<{ok: true, seq: number, bytes: number} | {ok: false, error: string}>}
+ */
+export async function appendEventFrame(filePath, event) {
+  let buf;
+  try {
+    buf = await readFile(filePath);
+  } catch (error) {
+    return { ok: false, error: `读取失败：${String(error?.message ?? error)}` };
+  }
+  let frames;
+  try {
+    ({ frames } = scanZstdFrames(buf));
+  } catch (error) {
+    return { ok: false, error: `帧扫描失败（文件可能已损坏，先修复再追加）：${String(error?.message ?? error)}` };
+  }
+  if (frames.length === 0) return { ok: false, error: "日志没有任何 zstd 帧" };
+  // 首帧必须能解出「一行 header」——否则这个文件不是合法会话日志，拒绝追加
+  let headerText;
+  try {
+    headerText = (await decodeFrame(buf.subarray(frames[0].start, frames[0].end))).toString("utf8");
+  } catch (error) {
+    return { ok: false, error: `首帧解码失败：${String(error?.message ?? error)}` };
+  }
+  const headerLine = headerText.split("\n").find((l) => l.trim() !== "");
+  if (!headerLine) return { ok: false, error: "首帧没有 header 行" };
+  try {
+    const header = JSON.parse(headerLine);
+    if (header?.type !== "session") return { ok: false, error: "首帧 header 不是 session 类型" };
+  } catch (error) {
+    return { ok: false, error: `首帧 header 解析失败：${String(error?.message ?? error)}` };
+  }
+
+  let frame;
+  try {
+    frame = await compressEventLine(JSON.stringify(event));
+  } catch (error) {
+    return { ok: false, error: `压缩新帧失败：${String(error?.message ?? error)}` };
+  }
+  try {
+    const handle = await open(filePath, "r+");
+    try {
+      // 追加前最后确认一次文件长度未被他人改变（粗粒度 CAS）
+      const stat = await handle.stat();
+      if (stat.size !== buf.length) {
+        return { ok: false, error: "文件在读取后被修改（长度变化），放弃追加" };
+      }
+      await handle.write(frame, 0, frame.length, buf.length);
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    return { ok: false, error: `追加写入失败：${String(error?.message ?? error)}` };
+  }
+  return { ok: true, seq: event.seq, bytes: frame.length };
+}
+
+/** 文件是否以 zstd magic 开头（快速判定，避免对非日志文件做帧扫描）。 */
+export function looksLikeZstd(buf) {
+  return Buffer.isBuffer(buf) && buf.length >= 4 && buf.readUInt32LE(0) === ZSTD_MAGIC;
+}

package/lib/shared/atomic-file.js

@@ -0,0 +1,38 @@
+// 文件级原子操作 —— 全仓唯一实现。
+//
+// 【为什么抽出来】「写 tmp → 复制原文件权限 → rename 覆盖」这段在 zstd-frames（帧修复、截断修复）
+// 与 session-ops（撤回消息写回）各写了一遍，共 3 份；备份那段（已存在不覆盖）也重复了 3 次。
+// 这类代码一旦哪份漏了 chmod 或 rename，表现是「文件权限被重置」或「留下半个日志」，
+// 而且都发生在**修复会话日志**这种最不能出错的路径上 —— 收敛成一处才好审。
+//
+// 说明：CIFS/网络盘上 chmod 可能直接失败，因此权限保留是「尽力而为」，失败不影响替换本身。
+
+import { writeFileSync, renameSync, chmodSync, statSync, existsSync, copyFileSync } from "node:fs";
+
+/**
+ * 原子替换文件内容：写 tmp → 继承原文件权限 → rename 覆盖。
+ * @param {string} targetPath 目标文件
+ * @param {string|Buffer} data 新内容
+ * @param {{tmpSuffix?: string}} [opts] tmp 后缀（默认 .tmp，便于排查是哪条路径留下的）
+ * @returns {string} 实际使用的 tmp 路径（已被 rename，仅供日志）
+ */
+export function replaceFileSync(targetPath, data, { tmpSuffix = ".tmp" } = {}) {
+  const tmpPath = targetPath + tmpSuffix;
+  writeFileSync(tmpPath, data);
+  try {
+    chmodSync(tmpPath, statSync(targetPath).mode);
+  } catch {
+    // CIFS/网络盘无 chmod：权限沿用默认，替换本身照做
+  }
+  renameSync(tmpPath, targetPath);
+  return tmpPath;
+}
+
+/**
+ * 备份一次（目标已存在则不覆盖，避免二次操作把原始备份冲掉）。
+ * @returns {string} 备份路径
+ */
+export function ensureBackupSync(srcPath, backupPath) {
+  if (!existsSync(backupPath)) copyFileSync(srcPath, backupPath);
+  return backupPath;
+}

package/lib/shared/json-store.js

@@ -0,0 +1,54 @@
+// 原子 JSON 读写 —— 全仓唯一实现。
+//
+// 【为什么抽出来】config / index-store / memory-recall 三处各写了一遍「写 tmp → rename」：
+//   · 任何一处漏掉 rename 都会留下半个文件（下次启动读到坏 JSON）；
+//   · tmp 文件名若不带 pid，两个进程/两次并发写会互相踩；
+//   · 每处还要各自处理「目录不存在」「文件损坏」。
+// 现在统一到这里，调用方只管传 file + data。
+//
+// 同步版给「一次性初始化 / CLI」用；异步版给「请求路径」用（避免阻塞事件循环）。
+
+import { readFileSync, writeFileSync, renameSync, mkdirSync } from "node:fs";
+import { readFile, writeFile, rename, mkdir } from "node:fs/promises";
+import path from "node:path";
+
+/** tmp 文件名带上 pid，避免并发写互相覆盖。 */
+function tmpPathOf(file) {
+  return `${file}.tmp-${process.pid}`;
+}
+
+/** 同步原子写：先写 tmp 再 rename（rename 在同一文件系统上是原子的）。失败向上抛。 */
+export function writeJsonAtomicSync(file, data) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const tmpPath = tmpPathOf(file);
+  writeFileSync(tmpPath, JSON.stringify(data), "utf8");
+  renameSync(tmpPath, file);
+}
+
+/** 异步原子写：语义同上，给请求路径用。失败向上抛。 */
+export async function writeJsonAtomic(file, data) {
+  await mkdir(path.dirname(file), { recursive: true });
+  const tmpPath = tmpPathOf(file);
+  await writeFile(tmpPath, JSON.stringify(data), "utf8");
+  await rename(tmpPath, file);
+}
+
+/** 同步读 JSON：文件不存在 / 损坏 / 不是对象 → 返回 null（绝不抛）。 */
+export function readJsonSafeSync(file) {
+  try {
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 异步读 JSON：语义同上。 */
+export async function readJsonSafe(file) {
+  try {
+    const parsed = JSON.parse(await readFile(file, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}

package/lib/shared/timing.js

@@ -0,0 +1,37 @@
+// 分阶段计时 —— 只做观测，不改变任何行为。
+//
+// 【为什么需要】「切模型要等很久」这类问题，光看总耗时没法定位：一次切换里串了
+// 写意图 / 定位成员 / 等 idle / 写会话日志（整份解码+重编码）/ 官方 @Remote 调用 好几段。
+// 每段各自打点，末尾输出一行「写意图 12ms ｜ 等空闲 60000ms ｜ …」，
+// 一眼能看出慢在哪一段。
+//
+// 【为什么不设超时】超时代码会改变行为、还会掩盖真实的慢；这里只测量、只记录。
+
+/**
+ * 创建分阶段计时器。
+ * @returns {{mark:(name:string)=>number, summary:()=>string, total:()=>number, stages:()=>Array<{name:string,ms:number}>}}
+ */
+export function createStageTimer() {
+  const marks = [];
+  let lastAt = Date.now();
+  return {
+    /** 记录一个阶段（从上次打点到现在）。 */
+    mark(name) {
+      const now = Date.now();
+      marks.push({ name, ms: now - lastAt });
+      lastAt = now;
+      return now;
+    },
+    /** 一行汇总，如「写意图 12ms ｜ 等空闲 60000ms」。 */
+    summary() {
+      return marks.map((m) => `${m.name} ${m.ms}ms`).join(" ｜ ");
+    },
+    /** 各阶段耗时合计（不含未被标记覆盖的空隙）。 */
+    total() {
+      return marks.reduce((sum, m) => sum + m.ms, 0);
+    },
+    stages() {
+      return marks.slice();
+    },
+  };
+}

package/lib/zstd-frames.js

@@ -6,7 +6,8 @@
 // fixZstdFile（多帧正确写回，原子+备份）/ scanAllCorruptFrames（全仓扫描损坏）。
 // 与 fix-zstd-frames-v2.mjs 同逻辑，DSH_HOME 参数化，供插件 API 与 CLI 共用。
 
-import fs, { readFileSync, writeFileSync, mkdirSync, statSync, renameSync, copyFileSync, chmodSync, readdirSync, existsSync } from 'node:fs';
+import fs, { readFileSync, mkdirSync, statSync, readdirSync, existsSync } from 'node:fs';
+import { replaceFileSync, ensureBackupSync } from "./shared/atomic-file.js";
 import { join, dirname } from 'node:path';
 import { findSessionLog } from './session-log.js';
 import { createZstdDecompress, zstdCompress, constants } from 'node:zlib';
@@ -184,11 +185,8 @@ export async function fixZstdFile(path, backupDir = join(dirname(path), '.zstd-f
   mkdirSync(backupDir, { recursive: true });
   const rel = path.replace(/^.*\/sessions\//, '').replace(/\//g, '__');
   const bak = join(backupDir, rel);
-  if (!existsSync(bak)) copyFileSync(path, bak);
-  const fixedTmpPath = path + '.fixtmp';
-  writeFileSync(fixedTmpPath, newBuf);
-  try { chmodSync(fixedTmpPath, statSync(path).mode); } catch { /* 尽力 */ }
-  renameSync(fixedTmpPath, path);
+  ensureBackupSync(path, bak);
+  replaceFileSync(path, newBuf, { tmpSuffix: '.fixtmp' });
   return { ok: true, id: header.id, eventCount: events.length, fixed: true, backup: bak, origSize: origBuf.length, newSize: newBuf.length };
 }
 
@@ -238,11 +236,8 @@ async function truncateToDecodablePrefix(path, buf, originalError, backupDir) {
   mkdirSync(backupDir, { recursive: true });
   const rel = path.replace(/^.*\/sessions\//, '').replace(/\//g, '__');
   const bak = join(backupDir, rel);
-  if (!existsSync(bak)) copyFileSync(path, bak);
-  const tmp = path + '.fixtmp';
-  writeFileSync(tmp, buf.subarray(0, safeEnd));
-  try { chmodSync(tmp, statSync(path).mode); } catch { /* 尽力 */ }
-  renameSync(tmp, path);
+  ensureBackupSync(path, bak);
+  replaceFileSync(path, buf.subarray(0, safeEnd), { tmpSuffix: '.fixtmp' });
   return {
     ok: true,
     id: head.header.id,

package/package.json

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

package/skills/dsh-session-conductor-functions.md

@@ -188,7 +188,7 @@ whenToUse: 需要了解 dsh-session-conductor 某个功能怎么用/参数是什
 2. 建新会话：`list_models()` 查确切 provider/model → `create_session({provider, model, dryRun:true})` 预览 → 确认后去掉 dryRun 真建
 3. 给已有会话发消息：`send_to_session({sessionId, text, dryRun:true})` 预览 → 确认后真投
 
-- **`create_session` 缺省工作目录 = 调用方会话自己的 cwd**（发起它的那个 AI 在哪干活，新会话就落在哪）。**不要**依赖本体默认：那是 DSH 安装目录（实测 `/volume1/@appstore/DeepSeekHarness-NAS`），新会话落在程序目录里对干活毫无意义。显式给 `cwd` 或 `workspaceId` 可覆盖（二者互斥）。
+- **`create_session` 缺省工作目录 = 调用方会话自己的 cwd**（发起它的那个 AI 在哪干活，新会话就落在哪）。**不要**依赖本体默认：那是 DSH 安装目录（实测 `<DSH 安装目录>`），新会话落在程序目录里对干活毫无意义。显式给 `cwd` 或 `workspaceId` 可覆盖（二者互斥）。
 - **dryRun（两个写操作工具都支持）**：只做校验与预览、**不产生任何副作用**。`create_session` 的 dryRun 还会**核对 provider/model 是否真在模型目录里**；`send_to_session` 的 dryRun 会**报告目标状态与限流余量**，且**不消耗限流配额**（可以先 dryRun 多次再真投）。dryRun 同样执行全部本地校验（自投/超长/跳数等照常被拒）。
 - **状态含义**（`list_sessions` 输出）：`running` = 正在跑回合；`idle` = 已挂载但空闲；`inactive` = 冷会话（未挂载，投递时会被唤醒）。缺 id 的脏条目会被跳过并如实标注（不会渲染成 `undefined`）。
 - **会话列表的内存边界（实测，别再踩）**：宿主的 `handle.read(offset, length)` **不能流式读** —— offset/length 只是**内存数组切片**，后端每次调用都会把整份日志读进来解压（`session-persistence-jsonl/src/storage.ts` 的 `readCurrent`）。实测单份日志 49.2 MB 压缩 → **173.3 MB 解压**（3.2~5.0×）。

package/skills/dsh-session-conductor.md

@@ -128,7 +128,7 @@ pnpm add github:EIGHTfs/dsh-session-conductor#<commit>
 1. **本机要有 `npm`** —— pnpm 构建 git 来源的包时会在临时目录执行 `npm install`；
    缺 npm 时报 `ERR_PNPM_PREPARE_PACKAGE` + `spawn ENOENT: npm: command not found`。
    （本机 2026-10-12 已装 npm 10.9.2：解包到 `<APP>/lib/node_modules/npm`，再链到
-   `/var/packages/DeepSeekHarness-NAS/target/.local/bin/npm` —— `/usr/local/bin` 不可写。）
+   `<DSH 安装目录>/bin/npm` —— 系统级 bin 目录不可写。）
 2. **pnpm 11 默认禁止 git 源依赖执行构建脚本**（供应链策略）：只有带 `prepare`/`prepack` 的插件
    需要放行，在 profile 的 `pnpm-workspace.yaml` 里加，否则报 `ERR_PNPM_GIT_DEP_PREPARE_NOT_ALLOWED`：