dsh-session-conductor 1.3.9 → 1.3.11

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 ?? "");

package/lib/features/rename/value.js

@@ -21,42 +21,54 @@ const VALUE_LLM_MAX_TOKENS = 120;
  * @param {Function} [onError] 日志回调
  * @returns {Promise<object>} 会话 id → {value:"high"|"medium"|"low", reason}
  */
+/** 价值判定用的系统提示词（长常量提到模块级，函数体只留编排）。 */
+const VALUE_SYSTEM_PROMPT = "你是 DSH（DeepSeek Harness）会话价值分析师。给定一个会话的标题与最后回复片段，判断它在长期保留意义上的价值。高价值=含独有信息/未完成任务/学习成果/资产/待继续工作；低价值=灰尘/重复/过时空壳/可安全丢弃。输出严格 JSON，无 Markdown：{\"value\":\"high\"|\"medium\"|\"low\",\"reason\":\"一句话中文理由\"}";
+
+/**
+ * 单个会话的 LLM 价值判定。
+ * 无模型路由 / 输出解析失败都返回 null（由调用方的规则评分兜底）。
+ * @returns {Promise<{value:string, reason?:string}|null>}
+ */
+async function judgeSessionValue(llm, session, texts) {
+  const route = resolveRoute(session, llm);
+  if (!route?.provider || !route.model) return null; // 无模型路由 → 跳过
+  const title = session.title || session.cwd || session.id || "（无标题）";
+  const lastText = (texts?.[session.id] || "").slice(0, VALUE_PROMPT_TEXT_MAX_CHARS);
+  const text = [`会话标题：${title}`, "最后回复片段：", lastText].join("\n");
+  const assembler = new BlockAssembler();
+  for await (const chunk of llm.stream({
+    provider: route.provider,
+    model: route.model,
+    messages: [createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-session-conductor", plugin: "dsh-session-conductor" } })],
+    system: VALUE_SYSTEM_PROMPT,
+    maxTokens: VALUE_LLM_MAX_TOKENS,
+    sessionId: session.id,
+    purpose: "session-conductor-value-analysis",
+    signal: AbortSignal.timeout(AUTO_RENAME_TIMEOUT_MS),
+  })) assembler.push(chunk);
+  const raw = assembler.blocks().filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
+  return parseValueJson(raw);
+}
+
 export async function analyzeValueWithLlm(ctx, sessions, texts, onError) {
   const out = {};
-  let llm;
+  let llm = null;
   try {
     llm = ctx.get("llm");
-  } catch { llm = null; }
+  } catch {
+    llm = null;
+  }
   if (!llm) {
     if (typeof onError === "function") onError("会话价值 LLM 判断跳过：llm 服务不可用");
     return out;
   }
-  for (const s of sessions ?? []) {
+  for (const session of sessions ?? []) {
     try {
-      const route = resolveRoute(s, llm);
-      if (!route?.provider || !route.model) continue; // 无模型路由 → 跳过，规则兜底
-      const title = s.title || s.cwd || s.id || "（无标题）";
-      const last = (texts?.[s.id] || "").slice(0, VALUE_PROMPT_TEXT_MAX_CHARS);
-      const system = "你是 DSH（DeepSeek Harness）会话价值分析师。给定一个会话的标题与最后回复片段，判断它在长期保留意义上的价值。高价值=含独有信息/未完成任务/学习成果/资产/待继续工作；低价值=灰尘/重复/过时空壳/可安全丢弃。输出严格 JSON，无 Markdown：{\"value\":\"high\"|\"medium\"|\"low\",\"reason\":\"一句话中文理由\"}";
-      const text = [`会话标题：${title}`, "最后回复片段：", last].join("\n");
-      const assembler = new BlockAssembler();
-      for await (const chunk of llm.stream({
-        provider: route.provider,
-        model: route.model,
-        messages: [createUserMessage({ content: [{ type: "text", text }], source: { kind: "plugin:dsh-session-conductor", plugin: "dsh-session-conductor" } })],
-        system,
-        maxTokens: VALUE_LLM_MAX_TOKENS,
-        sessionId: s.id,
-        purpose: "session-conductor-value-analysis",
-        signal: AbortSignal.timeout(AUTO_RENAME_TIMEOUT_MS),
-      })) assembler.push(chunk);
-      const blocks = assembler.blocks();
-      const raw = blocks.filter((b) => b.type === "text").map((b) => b.text).join(" ").trim();
-      const parsed = parseValueJson(raw);
-      if (parsed) out[s.id] = { value: parsed.value, reason: parsed.reason || "" };
+      const parsed = await judgeSessionValue(llm, session, texts);
+      if (parsed) out[session.id] = { value: parsed.value, reason: parsed.reason || "" };
     } catch (error) {
-      if (typeof onError === "function") onError(`会话价值 LLM 判断失败 ${s.id}: ${String(error?.message ?? error)}`);
-      /* 单个会话失败跳过，规则兜底 */
+      if (typeof onError === "function") onError(`会话价值 LLM 判断失败 ${session.id}: ${String(error?.message ?? error)}`);
+      // 单个会话失败跳过，规则兜底
     }
   }
   return out;

package/lib/features/session-messaging/logic.js

@@ -12,6 +12,7 @@
 //   —— 自己写日志等于拿对方会话的完整性冒险。因此本域**不碰任何日志文件**。
 
 import { log } from "../../shared/log.js";
+import { sessionMetaOf } from "../../sessions/lookup.js";
 
 /** 单条消息长度上限（字符）：够写交接要点，不够塞长文档（长内容应落共享文件）。 */
 export const TEXT_LIMIT = 8 * 1024;
@@ -143,7 +144,7 @@ export function currentSessionId(agent) {
 /**
  * 调用方会话的工作目录。
  * 用途：`create_session` 不传 cwd/workspaceId 时的缺省值 —— 新会话落在**发起它的那个会话**
- * 的工作目录里，而不是本体的默认 cwd（实测是 DSH 安装目录 `/volume1/@appstore/DeepSeekHarness-NAS`，
+ * 的工作目录里，而不是本体的默认 cwd（实测是 DSH 安装目录（即本机程序目录），
  * 对干活毫无意义）。
  */
 export function callerCwd(agent) {
@@ -173,19 +174,11 @@ export async function listSessions(ctx) {
  */
 export async function describeTarget(ctx, sessionId) {
   try {
-    const live = ctx.get?.("sessions")?.get?.(sessionId);
-    if (live) {
-      const cwd = String(live.header?.cwd ?? "(无工作区)");
-      return `（进行中 ｜ ${cwd}）`;
-    }
-    const { loadListDiskCache } = await import("../../sessions/list-cache.js");
-    const entry = loadListDiskCache(ctx)?.entries?.[sessionId];
-    if (entry) {
-      const cwd = String(entry.cwd ?? "(无工作区)");
-      const updated = typeof entry.updatedAt === "number" ? new Date(entry.updatedAt).toISOString() : "未知";
-      return `（已落盘 ｜ ${cwd} ｜ 最后活动 ${updated}）`;
-    }
-    return "（⚠️ 内存与落盘索引里都没有这个 id —— 可能写错了，或它是刚建、尚未落盘的会话）";
+    const meta = await sessionMetaOf(ctx, sessionId);
+    if (!meta) return "（⚠️ 内存与落盘索引里都没有这个 id —— 可能写错了，或它是刚建、尚未落盘的会话）";
+    if (meta.live) return `（进行中 ｜ ${String(meta.cwd ?? "(无工作区)")}）`;
+    const updated = meta.updatedAt ? new Date(meta.updatedAt).toISOString() : "未知";
+    return `（已落盘 ｜ ${String(meta.cwd ?? "(无工作区)")} ｜ 最后活动 ${updated}）`;
   } catch (error) {
     return `（目标存在性无法核对：${shortError(error)}）`;
   }