dsh-any-agent 0.3.4 → 0.3.6

package/src/hub.mjs

@@ -14,6 +14,8 @@
  */
 
 import {
+  copyFileSync,
+  cpSync,
   mkdirSync,
   readFileSync,
   writeFileSync,
@@ -41,13 +43,17 @@ import {
   SENTINEL_INCLUDE_REASONING,
   SENTINEL_TTL_MS,
   STATE_FILE,
+  LEGACY_STATE_FILE,
+  USING_DEFAULT_STATE,
   DSH_HOME,
+  assertWritableDir,
   defaultApprovalPolicy,
 } from './config.mjs';
 import { AcpProcess } from './acp.mjs';
 import { readConversationMeta } from './titles.mjs';
 import { registerWorkspace, findSessionHeader } from './workspace.mjs';
 import {
+  LOCKS_DIR,
   classifyHolder,
   describeLeaseConflict,
   heartbeat as lockHeartbeat,
@@ -149,6 +155,8 @@ function pruneStaleTombstones() {
 
 /** 运行期输出环形缓冲的条目上限（仅内存，超出丢最旧的）。 */
 const MAX_OUT_ENTRIES = 500;
+/** 单条输出正文的字符上限；超出保留尾部，避免一条超长输出把内存撑爆。 */
+const MAX_OUT_TEXT = 200_000;
 /** 记录用户发话时的截断长度（避免一条把缓冲撑爆）。 */
 const MAX_PROMPT_ECHO = 4000;
 /** 保留的回合记录条数（run 结果含正文，所以只留最近若干条，仅内存）。 */
@@ -240,13 +248,18 @@ export function sanitizeResultForSentinel(result) {
   if (!result || typeof result !== 'object') return result ?? null;
   if (SENTINEL_INCLUDE_REASONING) return result;
   const { thinking, ...rest } = result;
+  // 正文/错误/标题同样可能夹带密钥；哨兵是落盘副本，统一套脱敏。
+  for (const key of ['answer', 'error', 'title']) {
+    if (typeof rest[key] === 'string') rest[key] = sanitizeApprovalContext(rest[key], key);
+  }
   // 工具输入里会有完整命令、路径，甚至写入的文件内容。哨兵会保留 7 天，
   // 所以按审批上下文同一套规则脱敏（密钥/令牌/密码类字段与常见内联字面量）。
   if (Array.isArray(rest.tools_used)) {
     rest.tools_used = rest.tools_used.map((t) => {
       if (!t || typeof t !== 'object') return t;
       const { input, ...meta } = t;
-      return input === undefined ? meta : { ...meta, input: sanitizeApprovalContext(input) };
+      const safeMeta = sanitizeApprovalContext(meta);
+      return input === undefined ? safeMeta : { ...safeMeta, input: sanitizeApprovalContext(input) };
     });
   }
   // 始终给出布尔值：调用方才能区分“思考被剥离”与“本来没有思考”。
@@ -271,6 +284,8 @@ export class Conversation {
       model: state.model ?? null,
     };
     this.lastConfigApplied = null;
+    /** 是否已回读并确认会话记录的权限档（null=尚未核对，true/false=结果）。 */
+    this.permissionVerified = null;
     /** 工作区登记结果（决定你的 DSH GUI 里能不能看到这个会话）。 */
     this.workspace = state.workspace ?? null;
     this.#hub = hub;
@@ -337,10 +352,15 @@ export class Conversation {
   snapshot() {
     const meta = readConversationMeta(this.id);
     const nativeTitle = meta?.title ?? null;
+    const holder = this.proc?.alive
+      ? { kind: 'self', reason: '本进程持有该会话的写锁' }
+      : classifyHolder(this.id, { knownChildPid: this.lastChildPid });
     return {
       conversation_id: this.id,
       /** 对话名来自 DSH 的 session/title 事件（自动生成）；未生成时用建会话提示兜底。 */
       title: nativeTitle ?? this.titleHint ?? null,
+      /** native = DSH 自动标题；title_hint = 建会话时给的提示；null = 还没有名字。 */
+      title_source: nativeTitle ? 'native' : this.titleHint ? 'title_hint' : null,
       /**
        * DSH 自动生成的标题是**首条消息的截断前缀**（实测 13–15 个字符，
        * 例如「这是一次连通性冒烟测试，请」），信息量很低。
@@ -350,6 +370,8 @@ export class Conversation {
       title_hint: this.titleHint ?? null,
       cwd: this.cwd,
       permission: this.permission,
+      /** true=已回读会话记录且一致；false/null=缓存暂时没有记录（read-only 仍由审批层兜底）。 */
+      permission_verified: this.permissionVerified,
       on_approval: this.onApproval,
       alive: !!this.proc?.alive,
       busy: this.busy,
@@ -375,8 +397,13 @@ export class Conversation {
         approval_id: approvalId,
         ...pending.params.details,
       })),
-      /** 不在本进程手里时，写锁在谁手上（none=多半是你自己的 GUI / stale-mcp=可抢占的孤儿 / live-mcp=另一个实例）。 */
-      lock_holder: this.proc?.alive ? 'self' : classifyHolder(this.id, { knownChildPid: this.lastChildPid }).kind,
+      /**
+       * 不在本进程手里时，写锁在谁手上：
+       * self / stale-mcp / live-mcp / none。none 只表示"没有本服务可识别的持有者"，
+       * 可能是空闲/已释放，也可能被 GUI 持有；原因见 lock_holder_reason。
+       */
+      lock_holder: holder.kind,
+      lock_holder_reason: holder.reason ?? null,
       /** ★ 最近一次"撞写锁"的持久记录。
        *  只报一次错是不够的：撞锁往往**一次就长期成立**（实测：在 GUI 里点开一次，
        *  dsh web 会一直持有写锁，切走/等待都不释放），所以要把"谁占用、怎么解"留在状态里，
@@ -418,6 +445,8 @@ export class Conversation {
       // 新进程不记得会话级配置（思考深度/模型），resume 后必须重套
       this.lastConfigApplied = await applySessionConfig(proc, this.id, this.cfg);
       for (const f of this.lastConfigApplied.failed) this.#hub.log.info(`[conv ${this.id}] ${f}`);
+      // ★ 回读会话自己的权限记录，防止 profile defaultPreset 无声提权。
+      await this.verifyPermissionRecorded();
       // 锁到手了，这时才登记；从此别人能查到"锁在我们手上"
       writeMarker(this.id, { childPid: proc.pid, cwd: this.cwd });
       this.lockConflict = null; // 拿到锁了，之前的撞锁记录作废
@@ -465,6 +494,39 @@ export class Conversation {
     }
   }
 
+  /**
+   * 核对**会话自己记录**的权限档是否与请求一致。
+   *
+   * 为什么不能只信入参：DSH profile 里的 `permission.defaultPreset` 会在
+   * session/new 时覆盖 `DSH_PERMISSION_MODE`（test/permission.mjs 实测抓到过
+   * read-only 被静默提升）。投影缓存可能稍后才刷盘，所以短轮询；读不到时
+   * 不阻断（read-only 仍有审批层的硬拒绝兜底），但读到不一致就立刻失败。
+   */
+  async verifyPermissionRecorded({ attempts = 6, delayMs = 250 } = {}) {
+    for (let i = 0; i < attempts; i++) {
+      const meta = readConversationMeta(this.id);
+      const recorded = meta?.permissions?.preset;
+      if (recorded) {
+        if (!PERMISSION_TIERS.includes(recorded) || recorded !== this.permission) {
+          throw new Error(
+            `会话实际权限档为 ${JSON.stringify(recorded)}，与请求的 ${this.permission} 不一致。\n` +
+              '  这通常意味着 DSH profile 里写了 permission.defaultPreset，覆盖了启动时传入的权限档。\n' +
+              `  请检查 ${join(DSH_HOME, 'profiles', process.env.DSH_MCP_PROFILE ?? 'dsh-mcp', 'cordis.patch.yml')}，` +
+              '删掉 permission.defaultPreset 后重试。',
+          );
+        }
+        this.permissionVerified = true;
+        return recorded;
+      }
+      if (i < attempts - 1) await new Promise((r) => setTimeout(r, delayMs));
+    }
+    this.permissionVerified = false;
+    this.#hub.log.info(
+      `[conv ${this.id}] 投影缓存里暂时没有权限记录，跳过运行期核对（read-only 仍由审批层强制拒绝）`,
+    );
+    return null;
+  }
+
   /**
    * 抢占写锁。
    *
@@ -519,7 +581,7 @@ export class Conversation {
     }
 
     // 3) 杀 + 重试（内核在持有者进程退出时释放信号量）
-    const kill = killHolderChild(killTarget);
+    const kill = killHolderChild(killTarget, { expectedSpawnedAt: holder.marker?.spawned_at });
     report.killed_pid = killTarget;
     report.kill = kill;
     if (!kill.killed) {
@@ -806,7 +868,9 @@ export class Conversation {
         //   之前只在"调用方没在原地等"时才写，于是插话那一轮没有哨兵 —— 调用方的
         //   等待逻辑（等文件出现）就永远空等，即使 run 早已 status=done（真实事故）。
         //   统一规则也消除了整类"有 run_id 却没有哨兵"的坑。
-        this.#hub.writeRunSentinel(this.id, runRecord);
+        const sentinelFile = this.#hub.writeRunSentinel(this.id, runRecord);
+        result.sentinel_file = sentinelFile ?? this.#hub.runSentinelPath(this.id, runRecord.run_id);
+        if (!sentinelFile) result.sentinel_error = runRecord.sentinel_error ?? '哨兵文件写入失败';
         return result;
       } catch (e) {
         this.#hub.log.info(`[conv ${this.id}] 回合收尾异常（已兜底）: ${e.message}`);
@@ -830,7 +894,9 @@ export class Conversation {
         runRecord.status = 'error';
         runRecord.error = fallback.error;
         runRecord.result = fallback;
-        this.#hub.writeRunSentinel(this.id, runRecord);
+        const sentinelFile = this.#hub.writeRunSentinel(this.id, runRecord);
+        fallback.sentinel_file = sentinelFile ?? this.#hub.runSentinelPath(this.id, runRecord.run_id);
+        if (!sentinelFile) fallback.sentinel_error = runRecord.sentinel_error ?? '哨兵文件写入失败';
         return fallback;
       }
     };
@@ -895,14 +961,15 @@ export class Conversation {
   /** 追加一条输出记录；同类相邻文本会合并，避免每个 token 一条。 */
   pushOut(kind, text, extra = {}) {
     const last = this.out[this.out.length - 1];
+    const cap = (s) => (s.length > MAX_OUT_TEXT ? `…[已截断，保留尾部 ${MAX_OUT_TEXT} 字]…\n${s.slice(-MAX_OUT_TEXT)}` : s);
     if (last && last.kind === kind && last.turn === this.currentTurn && text) {
-      last.text += text;
+      last.text = cap(last.text + text);
       last.at = now();
       // ★ 合并进已有条目也必须推进修订号。否则游标已经读过这条的调用方
       //   会永远看不到后续追加的正文（旧实现用 seq 当游标，seq 不变 = 漏读）。
       last.rev = ++this.outRev;
     } else {
-      this.out.push({ seq: ++this.outSeq, rev: ++this.outRev, kind, turn: this.currentTurn, text: text ?? '', at: now(), ...extra });
+      this.out.push({ seq: ++this.outSeq, rev: ++this.outRev, kind, turn: this.currentTurn, text: cap(text ?? ''), at: now(), ...extra });
       if (this.out.length > MAX_OUT_ENTRIES) this.out.shift();
     }
     if (kind === 'text') this.turnOutChars += text?.length ?? 0;
@@ -1051,8 +1118,17 @@ export class Conversation {
 
 /** 收集当前工作区的 git 变更摘要（非 git 目录返回 null）。 */
 export function gitStatus(cwd) {
+  if (process.env.DSH_MCP_GIT_STATUS === '0') return null;
   try {
-    const r = spawnSync('git', ['status', '--porcelain'], { cwd, encoding: 'utf8', timeout: 8000 });
+    // ★ 在不可信仓库里 `git status` 可能触发仓库配置的 fsmonitor/filter；这些
+    //   命令发生在 DSH 沙箱与审批层之外。禁用可选锁与 fsmonitor，并允许用
+    //   DSH_MCP_GIT_STATUS=0 完全关掉。
+    const r = spawnSync('git', ['-c', 'core.fsmonitor=false', 'status', '--porcelain', '--no-optional-locks'], {
+      cwd,
+      encoding: 'utf8',
+      timeout: 8000,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+    });
     if (r.status !== 0 || !r.stdout) return null;
     const lines = r.stdout.split('\n').filter(Boolean);
     if (!lines.length) return null;
@@ -1120,7 +1196,12 @@ export class Hub {
   constructor({ log } = {}) {
     this.conversations = new Map();
     this.log = log ?? NOOP_LOG;
-    this.approvalTimeoutMs = Number(process.env.DSH_MCP_APPROVAL_TIMEOUT_MS ?? 5 * 60 * 1000);
+    /** 最近一次 dsh_list 磁盘探测的结果：{ok, error, cached, at}。 */
+    this.lastProbe = { ok: null, error: null, cached: false, at: 0 };
+    const rawApprovalTimeout = Number(process.env.DSH_MCP_APPROVAL_TIMEOUT_MS ?? 5 * 60 * 1000);
+    // 空串会变成 0 / NaN → setTimeout(0) 会把 ask 审批立刻取消；统一回落到 5 分钟。
+    this.approvalTimeoutMs =
+      Number.isFinite(rawApprovalTimeout) && rawApprovalTimeout > 0 ? rawApprovalTimeout : 5 * 60 * 1000;
     this.#reaper = null;
   }
 
@@ -1129,6 +1210,30 @@ export class Hub {
   #probeCache = null;
 
   load() {
+    // ★ 启动即确认三个关键目录可写。以前"写失败只记 silent 日志"会让服务
+    //   看起来正常，但注册表/哨兵/锁登记全部丢失，异步等待永远醒不过来。
+    assertWritableDir(dirname(STATE_FILE), '状态目录');
+    assertWritableDir(RUNS_DIR, '哨兵目录');
+    assertWritableDir(LOCKS_DIR, '锁登记目录');
+
+    // 旧版本的默认状态文件在包安装目录里；一次性迁移到新的用户可写目录。
+    // 只在没有显式设置 DSH_MCP_STATE 时做，避免覆盖用户指定的路径。
+    if (USING_DEFAULT_STATE && !existsSync(STATE_FILE) && existsSync(LEGACY_STATE_FILE)) {
+      try {
+        copyFileSync(LEGACY_STATE_FILE, STATE_FILE);
+        this.log.info(`[hub] 已迁移旧状态文件: ${LEGACY_STATE_FILE} → ${STATE_FILE}`);
+        // 侧车元数据（审批策略/思考深度/标题/轮数）也一并搬过来；
+        // 否则旧会话按 id 重建时会悄悄回落到默认值。
+        const legacyMeta = join(dirname(LEGACY_STATE_FILE), 'meta');
+        if (existsSync(legacyMeta) && !existsSync(META_DIR)) {
+          cpSync(legacyMeta, META_DIR, { recursive: true });
+          this.log.info(`[hub] 已迁移旧元数据侧车: ${legacyMeta} → ${META_DIR}`);
+        }
+      } catch (e) {
+        this.log.info(`[hub] 旧状态文件迁移失败（继续用新路径）: ${e.message}`);
+      }
+    }
+
     const stale = pruneStaleTombstones();
     if (stale) this.log.info(`[hub] 清理 ${stale} 个失效的 forget 墓碑`);
     if (!existsSync(STATE_FILE)) return;
@@ -1186,24 +1291,34 @@ export class Hub {
     return join(RUNS_DIR, conversationId, `${runId}.json`);
   }
 
-  /** 写完成哨兵（原子）。失败只记日志，绝不影响主流程。 */
+  /**
+   * 写完成哨兵（原子）。
+   * @returns {string|null} 成功返回文件路径；失败返回 null，并把原因记进 run.sentinel_error。
+   *
+   * 失败不阻断回合收尾，但**必须让调用方看得见**：以前只记 silent 日志，
+   * 调用方会拿着一个永远不会出现的路径一直等。
+   */
   writeRunSentinel(conversationId, run) {
+    const file = this.runSentinelPath(conversationId, run.run_id);
     try {
-      const file = this.runSentinelPath(conversationId, run.run_id);
       mkdirSync(dirname(file), { recursive: true });
       const payload = {
         conversation_id: conversationId,
         run_id: run.run_id,
         status: run.status ?? 'unknown',
         ended_at: run.ended_at ?? Date.now(),
-        error: run.error ?? run.result?.error ?? null,
+        error: sanitizeApprovalContext(run.error ?? run.result?.error ?? null, 'error'),
         result: sanitizeResultForSentinel(run.result ?? null),
       };
       const tmp = `${file}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
       writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
       renameSync(tmp, file);
+      return file;
     } catch (e) {
-      this.log.info(`[hub] 写完成哨兵失败: ${e.message}`);
+      const msg = `写完成哨兵失败（${file}）: ${e.message}`;
+      run.sentinel_error = msg;
+      this.log.info(`[hub] ${msg}`);
+      return null;
     }
   }
 
@@ -1287,12 +1402,15 @@ export class Hub {
         const recordedPreset = meta?.permissions?.preset;
         const recordedPermission = PERMISSION_TIERS.includes(recordedPreset) ? recordedPreset : null;
         // 安全优先：会话记录说 read-only 就绝不能被侧车“提升”为可写档。
+        // ★ 档位未知（没有投影缓存、也没有本服务侧车）时 **fail-closed 到 read-only**。
+        //   以前回落到 DEFAULT_PERMISSION（danger-full-access），等于把一个可能是
+        //   只读的外部会话悄悄提升为完全访问。宁可让用户显式新建会话，也不要无声提权。
         const permission =
           recordedPermission === 'read-only'
             ? 'read-only'
             : PERMISSION_TIERS.includes(persisted?.permission)
               ? persisted.permission
-              : (recordedPermission ?? DEFAULT_PERMISSION);
+              : (recordedPermission ?? 'read-only');
         const recordedApproval = meta?.permissions?.approval;
         let onApproval = APPROVAL_POLICIES.includes(persisted?.onApproval)
           ? persisted.onApproval
@@ -1452,6 +1570,8 @@ export class Hub {
             `  请检查 ${provider}/${model} 是否在 profile 中声明；不传这两个参数可使用 profile 默认模型。`,
         );
       }
+      // ★ 回读会话自己的权限记录；不一致会在这里失败并走 catch（停进程、删登记）。
+      await conv.verifyPermissionRecorded();
       // 登记工作区，否则这些会话在你的 DSH GUI 里看不到。
       // ★ 必须容错：registerWorkspace 会写 workspace.json（磁盘满/被占时会抛），
       //   而它在 this.conversations.set 之前 —— 抛出去就会**丢掉这个会话并泄漏进程**。
@@ -1486,7 +1606,10 @@ export class Hub {
       if (isForgotten(c.id)) continue;
       out.set(c.id, c.snapshot());
     }
-    if (!includeClosed) return [...out.values()];
+    if (!includeClosed) {
+      this.lastProbe = { ok: null, error: null, cached: false, at: now() };
+      return [...out.values()];
+    }
 
     // 磁盘探测要 spawn 一个 DSH 进程（实测约 1 秒），所以同 cwd 的结果缓存一小段时间，
     // 避免"连着列几次会话"就反复拉进程。
@@ -1498,7 +1621,9 @@ export class Hub {
 
     const probeCwd = cwd ?? [...this.conversations.values()][0]?.cwd ?? process.cwd();
     let sessions = cached;
-    if (!sessions) {
+    if (cached) {
+      this.lastProbe = { ok: true, error: null, cached: true, at: this.#probeCache.at };
+    } else if (!sessions) {
       let proc = null;
       try {
         proc = new AcpProcess({ cwd: probeCwd, permission: 'read-only' });
@@ -1507,9 +1632,12 @@ export class Hub {
         const res = await proc.request('session/list', cwd ? { cwd } : {});
         sessions = res?.sessions ?? [];
         this.#probeCache = { key: cacheKey, at: now(), sessions };
+        this.lastProbe = { ok: true, error: null, cached: false, at: this.#probeCache.at };
       } catch (e) {
         this.log.info(`[hub] session/list 探测失败: ${e.message}`);
         sessions = []; // 失败不缓存，下次重试
+        // ★ 调用方必须能区分"没有别的会话"和"探测失败"，否则会以为会话丢了。
+        this.lastProbe = { ok: false, error: e.message, cached: false, at: now() };
       } finally {
         await proc?.stop().catch(() => {});
       }
@@ -1619,10 +1747,17 @@ export class Hub {
    * 场景：默认"永不回收"下每个用过的会话会常驻一个 DSH 进程（实测约 300-480MB ✗）。
    * 一批活干完了就调它，内存立刻归零 ✓；下次派活按需 resume ✓。
    */
-  async releaseAll() {
+  async releaseAll({ force = false } = {}) {
     const released = [];
+    const skippedBusy = [];
     for (const c of this.conversations.values()) {
       if (!c.proc?.alive) continue;
+      // ★ 默认不打断正在跑的回合：all=true 是"腾内存"，不是"取消任务"。
+      //   确实要连跑着的也停掉时传 force=true。
+      if (c.busy && !force) {
+        skippedBusy.push(c.id);
+        continue;
+      }
       const proc = c.proc;
       c.proc = null;
       await proc.stop().catch(() => {});
@@ -1630,7 +1765,7 @@ export class Hub {
       released.push(c.id);
     }
     this.save();
-    return { released: released.length, conversations: released };
+    return { released: released.length, conversations: released, skipped_busy: skippedBusy };
   }
 
   async shutdown() {

package/src/locks.mjs

@@ -27,6 +27,7 @@
  */
 
 import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, readdirSync, renameSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 import { join, dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { STATE_FILE, REAP_INTERVAL_MS, numEnv } from './config.mjs';
@@ -220,8 +221,21 @@ export function classifyHolder(conversationId, { knownChildPid = null } = {}) {
  * 杀掉一个 DSH 子进程。**只允许对 classification 判定为 `stale-mcp` / `live-mcp(force)`
  * 的、由本 MCP 登记过的进程调用** —— 调用方负责先做分类。
  */
-export function killHolderChild(pid) {
+export function killHolderChild(pid, { expectedSpawnedAt } = {}) {
   if (!pid || !isPidAlive(pid)) return { killed: false, reason: '进程已经不在了' };
+  // ★ PID 会被复用。抢占是"杀进程"这种不可逆动作，所以先核对启动时间：
+  //   登记时间与 OS 记录的启动时间差太多 → 这已经不是当初登记的那个进程，拒绝杀。
+  if (Number.isFinite(expectedSpawnedAt)) {
+    const actual = processStartTime(pid);
+    if (Number.isFinite(actual) && Math.abs(actual - expectedSpawnedAt) > 10 * 60 * 1000) {
+      return {
+        killed: false,
+        reason:
+          `PID ${pid} 的启动时间与登记不符（登记 ${new Date(expectedSpawnedAt).toISOString()}，` +
+          `实际 ${new Date(actual).toISOString()}），疑似 PID 已被复用，拒绝杀。`,
+      };
+    }
+  }
   try {
     process.kill(pid, 'SIGKILL');
   } catch (e) {
@@ -230,6 +244,30 @@ export function killHolderChild(pid) {
   return { killed: true, reason: `已向 PID ${pid} 发送 SIGKILL` };
 }
 
+/**
+ * 读取进程启动时间（毫秒时间戳）。拿不到时返回 null（调用方按旧行为处理）。
+ * Windows 用 PowerShell 的 Get-Process.StartTime；POSIX 用 ps -o lstart=。
+ * 只在 takeover 这种低频、不可逆动作前调用，不在热路径上。
+ */
+export function processStartTime(pid) {
+  if (!pid) return null;
+  try {
+    const args =
+      process.platform === 'win32'
+        ? ['-NoProfile', '-NonInteractive', '-Command', `(Get-Process -Id ${Number(pid)} -ErrorAction SilentlyContinue).StartTime.ToUniversalTime().ToString('o')`]
+        : ['-o', 'lstart=', '-p', String(pid)];
+    const r = spawnSync(process.platform === 'win32' ? 'powershell' : 'ps', args, {
+      encoding: 'utf8',
+      timeout: 3000,
+      windowsHide: true,
+    });
+    const t = Date.parse(String(r.stdout || '').trim());
+    return Number.isFinite(t) ? t : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * 启动清理：删掉"MCP 已死 + 子进程也死了"的登记文件。
  * 注意**不删**那些子进程还活着的登记 —— 那正是后面抢占要用的线索。

package/src/mcp.mjs

@@ -183,6 +183,12 @@ export function createMcpServer({ hub, toolDefs = TOOL_DEFS, handlers = createHa
     // 通知（无 id）：不需要回包
     if (id === undefined) {
       if (method === 'notifications/initialized') initialized = true;
+      // 客户端换了打开的项目：丢掉缓存并重新问一次，下一次 dsh_start 才会用新目录。
+      if (method === 'notifications/roots/list_changed') {
+        clientRoots = null;
+        rootsRequested = false;
+        requestRoots().catch(() => {});
+      }
       return;
     }
 

package/src/tools.mjs

@@ -45,7 +45,7 @@ export const TOOL_DEFS = [
           type: 'string',
           enum: PERMISSION_TIERS,
           description:
-            `权限档。默认 ${DEFAULT_PERMISSION}。read-only 适合分析不信任样本（如恶意软件）；workspace-write 越界操作会冒泡为待决审批。` +
+            `权限档。默认 ${DEFAULT_PERMISSION}。read-only 适合分析不信任样本（如恶意软件）；workspace-write 由 DSH 沙箱限制可写范围，越界请求默认 auto-allow，想在调用方挂起审批请传 on_approval=ask。` +
             '**档位在创建时定下**：DSH 设计上"resume 的会话保留它自己记录的权限"，所以事后改这个参数不会改变已有会话，要换档需新建。' +
             '（本档位是**真实生效**的 —— 由启动时传入的 env 决定，并有 test/permission.mjs 对着会话自己的记录逐档核验。）',
         },
@@ -188,7 +188,7 @@ export const TOOL_DEFS = [
           enum: REASONING_MODES,
           description: `思考内容展示档位，默认 ${DEFAULT_REASONING}。`,
         },
-        timeout_ms: { type: 'number', description: '新回合的**等待**上限（毫秒），**默认 0 = 一直等**；queue 模式也用它限制等待上一轮结束。到期转后台，不取消回合。' },
+        timeout_ms: { type: 'number', description: '新回合的**等待**上限（毫秒），**默认 0 = 一直等**；queue 模式也用它限制等待上一轮结束。忙时等待超时会报错（本次插话未发送，会话不受损）；空闲时到期只转后台，不取消回合。' },
       },
       ['conversation_id', 'message'],
     ),
@@ -229,14 +229,19 @@ export const TOOL_DEFS = [
       '会话本体留在磁盘上，之后仍可 resume；**forget=true 会写墓碑**：从注册表移除，此后按 id 查询明确报“已被 forget”' +
       '（想恢复可按错误里的路径删除墓碑文件，默认在 `$DSH_HOME/.dsh-any-agent-forgotten/<id>.json`）。' +
       '★ 用完了想一次性腾内存就传 all=true（每个会话约 300-480MB；默认 `MAX_LIVE=8` 会回收最久未用者，' +
-      'all=true 可立即全部释放，之后随时 resume）。',
+      'all=true 会释放**空闲**会话，正在跑回合的默认跳过；确实要连跑着的也停掉请传 force=true）。' +
+      '对单个会话 release 会停掉其 DSH 进程；若它正在跑回合，该回合会被中断。',
     inputSchema: S(
       {
         conversation_id: CONV_ID,
         forget: { type: 'boolean', description: '同时从本服务的注册表里移除，默认 false。' },
         all: {
           type: 'boolean',
-          description: '忽略 conversation_id，释放**所有**活着的会话进程（腾内存用）。默认 false。',
+          description: '忽略 conversation_id，释放所有**空闲**会话进程（腾内存用）。正在跑回合的默认跳过。默认 false。',
+        },
+        force: {
+          type: 'boolean',
+          description: '仅配合 all=true：连正在跑回合的会话也停掉（会中断那些回合）。默认 false。',
         },
       },
       [],
@@ -454,9 +459,13 @@ export function createHandlers(hub, opts = {}) {
         if (c.turns != null) bits.push(`轮数=${c.turns}`);
         return `- ${bits.join(' | ')}`;
       };
+      const probe = hub.lastProbe ?? { ok: null, error: null, cached: false };
+      const probeNote = probe.ok === false
+        ? `\n\n⚠️ 磁盘会话探测失败：${probe.error}\n   上面只列出本服务已打开的会话；磁盘上未打开的会话可能没显示。`
+        : '';
       const text = items.length
         ? `${items.length} 个会话（其中 ${running} 个正在跑）：\n${items.map(describe).join('\n')}`
-        : '(没有会话)';
+        : probe.ok === false ? '(本服务没有已打开的会话；磁盘探测失败)' : '(没有会话)';
       // 孤儿锁持有者：上一代 MCP 崩了但它的 DSH 子进程还活着握着写锁 —— 不主动报出来，
       // 用户只会在下一次撞上"被占用"时才发现。这里顺手提示，并给出可执行的动作。
       const orphans = listOrphans();
@@ -466,8 +475,16 @@ export function createHandlers(hub, opts = {}) {
           '\n→ 用 dsh_takeover 抢占即可（这些是本服务自己的残留，抢占是安全的）。'
         : '';
       return {
-        structured: { count: items.length, running, conversations: items, orphan_holders: orphans },
-        text: text + orphanNote,
+        structured: {
+          count: items.length,
+          running,
+          conversations: items,
+          orphan_holders: orphans,
+          probe_ok: probe.ok,
+          probe_error: probe.error ?? null,
+          probe_cached: probe.cached === true,
+        },
+        text: text + probeNote + orphanNote,
       };
     },
 
@@ -503,7 +520,12 @@ export function createHandlers(hub, opts = {}) {
       let run = null;
       const meta = [];
       // DSH 的自动标题是首条消息的截断前缀，信息量低；调用方给过 title_hint 就一并显示。
-      meta.push(`对话名: ${snap.title ?? '(尚未生成)'}（DSH 自动生成）` +
+      const titleKind = snap.title_source === 'native'
+        ? 'DSH 自动生成'
+        : snap.title_source === 'title_hint'
+          ? '来自 title_hint（DSH 尚未生成标题）'
+          : '尚未生成';
+      meta.push(`对话名: ${snap.title ?? '(尚未生成)'}（${titleKind}）` +
         (snap.title_hint && snap.title !== snap.title_hint ? ` / 标题提示: ${snap.title_hint}` : ''));
       meta.push(`工作区: ${snap.cwd}`);
       meta.push(`状态: ${snap.busy ? '忙' : snap.alive ? '空闲(进程活着)' : '未打开(可用 resume 复活)'}`);
@@ -587,12 +609,15 @@ export function createHandlers(hub, opts = {}) {
       // ★ all=true：一次性放掉所有活着的会话进程（腾内存）。
       //   无损：会话日志都在磁盘上，之后照样 resume。
       if (args.all === true) {
-        const r = await hub.releaseAll();
+        const r = await hub.releaseAll({ force: args.force === true });
         return {
-          structured: { released: r.released, conversations: r.conversations },
+          structured: { released: r.released, conversations: r.conversations, skipped_busy: r.skipped_busy },
           text:
-            `已释放 ${r.released} 个会话进程（写锁全部让出，内存立刻回收）。` +
-            `\n会话日志都在磁盘上，之后派活会自动 resume；其中一个都没在跑时 released=0。`,
+            `已释放 ${r.released} 个空闲会话进程（写锁让出，内存回收）。` +
+            (r.skipped_busy.length
+              ? `\n跳过 ${r.skipped_busy.length} 个正在跑回合的会话；要连它们一起停掉请传 force=true。`
+              : '') +
+            `\n会话日志都在磁盘上，之后派活会自动 resume；没有一个可释放时 released=0。`,
         };
       }
       const conv = hub.get(args.conversation_id);
@@ -633,11 +658,14 @@ export function createHandlers(hub, opts = {}) {
       if (snap.lock_holder && snap.lock_holder !== 'self') {
         const hint =
           snap.lock_holder === 'stale-mcp'
-            ? '（本服务残留的孤儿，可 dsh_takeover 抢占）'
+            ? '（本服务残留/卡死的持有者，可 dsh_takeover 抢占）'
             : snap.lock_holder === 'live-mcp'
               ? '（另一个活着的 dsh-any-agent 实例在用；要夺需 dsh_takeover(force=true)）'
-              : '（多半是你自己的 DSH GUI 正开着它；本服务不会去杀它）';
+              : snap.lock_conflict
+                ? '（最近撞过锁：多半是你自己的 DSH GUI 正开着它；本服务不会去杀它）'
+                : '（没有本服务的持锁登记；空闲/已释放时也会是 none，只有在撞锁时才可能是 GUI）';
         bits.push(`写锁=${snap.lock_holder}${hint}`);
+        if (snap.lock_holder_reason) bits.push(`   判定：${snap.lock_holder_reason}`);
       }
       // ★ 撞过锁就把"谁占用 + 怎么解"讲清楚。实测：GUI 点开一次就会长期持有写锁
       //   （切走、等十几分钟都不释放），所以这条信息必须持久可见，而不是一闪而过的报错。
@@ -661,6 +689,7 @@ export function createHandlers(hub, opts = {}) {
           pending_approval_details: snap.pending_approval_details,
           turns: snap.turns,
           lock_holder: snap.lock_holder,
+          lock_holder_reason: snap.lock_holder_reason,
           lock_conflict: snap.lock_conflict,
           run: run
             ? {