dsh-any-agent 0.3.2 → 0.3.3

package/src/hub.mjs

@@ -41,6 +41,7 @@ import {
   SENTINEL_INCLUDE_REASONING,
   SENTINEL_TTL_MS,
   STATE_FILE,
+  DSH_HOME,
   defaultApprovalPolicy,
 } from './config.mjs';
 import { AcpProcess } from './acp.mjs';
@@ -60,6 +61,92 @@ import {
 const now = () => Date.now();
 const NOOP_LOG = { info: () => {}, debug: () => {}, dshStderr: () => {} };
 
+/**
+ * 会话元数据侧车（`.state/meta/<id>.json`）。
+ *
+ * 为什么需要：`forget=true` 只从注册表移除；之后按 id 查询时，`Hub.get()` 会从
+ * DSH 会话存储重建会话（这是多实例恢复的刻意设计）。但 DSH 的会话记录里**没有**
+ * 本服务选择的 `onApproval` / `reasoning_effort` / `title_hint` / 轮数，
+ * 重建就会悄悄回落到默认值（实测 auto-allow→ask、low→max）。这个侧车保存
+ * **仅元数据**（不含任何对话/思考正文），让重建后仍与原会话一致。
+ */
+const META_DIR = join(dirname(STATE_FILE), 'meta');
+const metaFilePath = (id) => join(META_DIR, `${id}.json`);
+
+function writeConversationMeta(conv) {
+  try {
+    mkdirSync(META_DIR, { recursive: true });
+    const file = metaFilePath(conv.id);
+    const tmp = `${file}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
+    writeFileSync(tmp, JSON.stringify(conv.toMeta(), null, 2), 'utf8');
+    renameSync(tmp, file);
+  } catch {
+    /* 元数据侧车只是辅助信息，写失败不影响主流程 */
+  }
+}
+
+function readConversationMetaFile(id) {
+  try {
+    return JSON.parse(readFileSync(metaFilePath(id), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * forget 墓碑：`release(forget=true)` 之后，按 id 查询必须**明确失败**，
+ * 而不是从 DSH 会话存储里悄悄复活。墓碑只含 id 与时间，不含任何内容；
+ * 删除 `.state/forgotten/<id>.json` 即可恢复按 id 找回（手动、可审计）。
+ */
+// 墓碑放在 DSH home 下而不是注册表旁边：不同实例即使注册表路径不同，
+// 也应该对同一个会话的 forget 达成一致（forget 是会话级终态，不是注册表级）。
+const FORGOTTEN_DIR = process.env.DSH_MCP_FORGOTTEN_DIR ?? join(DSH_HOME, '.dsh-any-agent-forgotten');
+const forgottenPath = (id) => join(FORGOTTEN_DIR, `${id}.json`);
+
+function writeTombstone(id) {
+  try {
+    mkdirSync(FORGOTTEN_DIR, { recursive: true });
+    const file = forgottenPath(id);
+    const tmp = `${file}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
+    writeFileSync(tmp, JSON.stringify({ id, forgottenAt: Date.now() }, null, 2), 'utf8');
+    renameSync(tmp, file);
+  } catch {
+    /* 墓碑写失败时 forget 仍从注册表移除；下次 get 可能仍会复活，但不影响主流程 */
+  }
+}
+
+function isForgotten(id) {
+  try {
+    return existsSync(forgottenPath(id));
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 启动时清掉“会话文件已经不存在”的墓碑：它们不再阻止任何 resurrection，
+ * 留着只会让测试/临时会话在 `$DSH_HOME/.dsh-any-agent-forgotten` 里堆积。
+ * 会话文件还在的墓碑必须保留 —— 那正是 forget 的效力所在。
+ */
+function pruneStaleTombstones() {
+  let removed = 0;
+  try {
+    if (!existsSync(FORGOTTEN_DIR)) return 0;
+    for (const f of readdirSync(FORGOTTEN_DIR)) {
+      if (!f.endsWith('.json')) continue;
+      const id = f.slice(0, -5);
+      if (findSessionHeader(id)) continue;
+      try {
+        rmSync(join(FORGOTTEN_DIR, f), { force: true });
+        removed++;
+      } catch {}
+    }
+  } catch {
+    /* 清理失败不影响启动 */
+  }
+  return removed;
+}
+
 /** 运行期输出环形缓冲的条目上限（仅内存，超出丢最旧的）。 */
 const MAX_OUT_ENTRIES = 500;
 /** 记录用户发话时的截断长度（避免一条把缓冲撑爆）。 */
@@ -149,11 +236,21 @@ async function applySessionConfig(proc, sessionId, cfg) {
  * 默认剥离以维持"思考不落盘"的保证，并留下 thinking_omitted 标记，
  * 免得调用方以为字段是意外丢失的。
  */
-function sanitizeResultForSentinel(result) {
+export function sanitizeResultForSentinel(result) {
   if (!result || typeof result !== 'object') return result ?? null;
   if (SENTINEL_INCLUDE_REASONING) return result;
   const { thinking, ...rest } = result;
-  return thinking ? { ...rest, thinking_omitted: true } : rest;
+  // 工具输入里会有完整命令、路径，甚至写入的文件内容。哨兵会保留 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) };
+    });
+  }
+  // 始终给出布尔值：调用方才能区分“思考被剥离”与“本来没有思考”。
+  return { ...rest, thinking_omitted: Boolean(thinking) };
 }
 
 export class Conversation {
@@ -194,6 +291,8 @@ export class Conversation {
      */
     this.out = [];
     this.outSeq = 0;
+    /** 输出缓冲的**修订号**：每次追加（含合并进已有条目）都 +1，供游标式增量读使用。 */
+    this.outRev = 0;
     this.turnOutChars = 0;
     this.currentTurn = 0;
     this.turnStartedAt = 0;
@@ -229,6 +328,11 @@ export class Conversation {
     };
   }
 
+  /** 侧车元数据：与注册表同字段，但独立落盘，forget 之后仍可恢复。 */
+  toMeta() {
+    return { version: 1, ...this.toState() };
+  }
+
   /** 合规的公开快照（含磁盘上的元信息）。 */
   snapshot() {
     const meta = readConversationMeta(this.id);
@@ -495,11 +599,33 @@ export class Conversation {
 
   async onPermissionRequest(params) {
     const options = params?.options ?? [];
-    const toolCall = params?.toolCall ?? {};
+    const rawToolCall = params?.toolCall ?? {};
+    // 真实 DSH 的 request_permission 只带 toolCallId，不带 rawInput；
+    // 同一 toolCallId 的参数通常已经在 tool_call 更新里记录过，按 id 关联回来，
+    // 否则审批详情里没有命令/路径，调用方无法裁决。
+    const known = this.collector?.tools?.get(rawToolCall.toolCallId) ?? null;
+    const toolCall = known
+      ? {
+          ...rawToolCall,
+          name: rawToolCall.name ?? known.name,
+          title: rawToolCall.title ?? known.title,
+          kind: rawToolCall.kind ?? known.kind,
+          rawInput: rawToolCall.rawInput ?? rawToolCall.input ?? known.input,
+          locations: rawToolCall.locations ?? known.locations,
+        }
+      : rawToolCall;
     const desc = sanitizeApprovalContext(String(toolCall.title ?? toolCall.name ?? toolCall.toolCallId ?? '未知操作'));
     const allowId = pickOption(options, 'allow');
     const rejectId = pickOption(options, 'reject');
 
+    // ★ read-only 是硬边界：即使会话被旧版本/显式参数配成 auto-allow，
+    //   这里也绝不放行任何审批 —— DSH 会借审批把 sandbox 提权到可写。
+    if (this.permission === 'read-only') {
+      this.#hub.log.info(`[conv ${this.id}] read-only 强制拒绝审批: ${desc}`);
+      return rejectId
+        ? { outcome: { outcome: 'selected', optionId: rejectId } }
+        : { outcome: { outcome: 'cancelled' } };
+    }
     if (this.onApproval === 'auto-allow') {
       this.#hub.log.info(`[conv ${this.id}] 审批放行: ${desc}`);
       return allowId
@@ -632,6 +758,14 @@ export class Conversation {
         this.busy = false;
         this.collector = null;
         this.currentTool = null;
+        // 回合结束后，任何仍挂着的审批都已失效：统一取消并清空，避免状态里
+        // 留下一个 dsh_approval_decide 只会回"没有待决审批"的幽灵。
+        for (const [, p] of this.pendingApprovals) {
+          try {
+            p.resolve({ outcome: { outcome: 'cancelled' } });
+          } catch {}
+        }
+        this.pendingApprovals.clear();
         this.pushOut('turn', `第 ${this.currentTurn} 轮结束（${stopReason ?? 'unknown'}）`, {
           phase: 'end',
           stop_reason: stopReason,
@@ -764,17 +898,24 @@ export class Conversation {
     if (last && last.kind === kind && last.turn === this.currentTurn && text) {
       last.text += text;
       last.at = now();
+      // ★ 合并进已有条目也必须推进修订号。否则游标已经读过这条的调用方
+      //   会永远看不到后续追加的正文（旧实现用 seq 当游标，seq 不变 = 漏读）。
+      last.rev = ++this.outRev;
     } else {
-      this.out.push({ seq: ++this.outSeq, kind, turn: this.currentTurn, text: text ?? '', at: now(), ...extra });
+      this.out.push({ seq: ++this.outSeq, rev: ++this.outRev, kind, turn: this.currentTurn, text: text ?? '', at: now(), ...extra });
       if (this.out.length > MAX_OUT_ENTRIES) this.out.shift();
     }
     if (kind === 'text') this.turnOutChars += text?.length ?? 0;
   }
 
-  /** 读输出：游标式增量。返回 seq > cursor 的条目 + 新游标。 */
+  /** 读输出：**按修订号**的游标式增量。条目被追加时会再次返回（按 seq 替换全文）。 */
   readOut({ cursor = 0, includeReasoning = false, limit = 200 } = {}) {
-    const entries = this.out.filter((e) => e.seq > cursor).slice(0, limit);
-    const next = entries.length ? entries[entries.length - 1].seq : cursor;
+    const cur = Number.isFinite(cursor) ? cursor : 0;
+    // limit 必须清洗：负数会被 slice 解释成“从头到尾少一条”，0 会让调用方原地空转。
+    const n = Number.isFinite(limit) ? Math.max(1, Math.min(Math.floor(limit), MAX_OUT_ENTRIES)) : 200;
+    const revOf = (e) => (typeof e.rev === 'number' ? e.rev : e.seq);
+    const entries = this.out.filter((e) => revOf(e) > cur).slice(0, n);
+    const next = entries.length ? revOf(entries[entries.length - 1]) : cur;
     const res = {
       conversation_id: this.id,
       state: this.state(),
@@ -782,9 +923,9 @@ export class Conversation {
       current_tool: this.currentTool,
       entries,
       cursor: next,
-      has_more: this.out.some((e) => e.seq > next),
+      has_more: this.out.some((e) => revOf(e) > next),
       /** 缓冲被环形覆盖时会为 true，表示你错过了中间一段。 */
-      gap: entries.length > 0 && this.out.length > 0 && this.out[0].seq > cursor + 1,
+      gap: entries.length > 0 && this.out.length > 0 && revOf(this.out[0]) > cur + 1,
     };
     // 思考内容只在显式要求时、且只针对"当前正在跑的回合"返回；不保留、不进缓冲
     if (includeReasoning && this.collector?.reasoning) {
@@ -824,24 +965,27 @@ export class Conversation {
     return this.runs.length ? this.runs[this.runs.length - 1] : null;
   }
 
-  /** 等到当前回合结束（不忙则立即返回 true；超时返回 false）。 */
+  /** 等到当前回合结束（不忙则立即返回 true；`timeoutMs <= 0` 一直等；超时返回 false）。 */
   async waitIdle(timeoutMs = 30 * 60 * 1000) {
     if (!this.busy) return true;
     return await new Promise((resolve) => {
       let settled = false;
+      let timer = null;
       const done = () => {
         if (settled) return;
         settled = true;
-        clearTimeout(timer);
+        if (timer) clearTimeout(timer);
         resolve(true);
       };
-      const timer = setTimeout(() => {
-        if (settled) return;
-        settled = true;
-        const i = this.idleWaiters.indexOf(done);
-        if (i >= 0) this.idleWaiters.splice(i, 1);
-        resolve(false);
-      }, timeoutMs);
+      if (timeoutMs > 0) {
+        timer = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          const i = this.idleWaiters.indexOf(done);
+          if (i >= 0) this.idleWaiters.splice(i, 1);
+          resolve(false);
+        }, timeoutMs);
+      }
       this.idleWaiters.push(done);
     });
   }
@@ -868,7 +1012,8 @@ export class Conversation {
     if (mode === 'interject') {
       this.proc?.notify('session/cancel', { sessionId: this.id });
     }
-    const idle = await this.waitIdle();
+    // 排队等待的时长跟随调用方的 timeout_ms（0 = 一直等），不再固定 30 分钟。
+    const idle = await this.waitIdle(timeoutMs);
     const waited = now() - t0;
     if (!idle) throw new Error('等待当前回合结束超时，插话未发送');
     const r = await this.prompt(message, { reasoning, timeoutMs });
@@ -885,10 +1030,21 @@ export class Conversation {
       } catch {}
       await proc.stop();
     }
+    // 回合已经结束/进程正在关闭，任何仍挂着的审批都不再可裁决。
+    for (const [, p] of this.pendingApprovals) {
+      try {
+        p.resolve({ outcome: { outcome: 'cancelled' } });
+      } catch {}
+    }
+    this.pendingApprovals.clear();
     // 进程没了 → 写锁也释放了，登记必须跟着删（否则会把"孤儿持有者"误报给抢占逻辑）
     removeMarker(this.id);
-    if (forget) this.#hub.remove(this.id);
-    else this.#hub.save();
+    if (forget) {
+      // 先写墓碑再从注册表移除：之后按 id 查询会明确报"已 forget"，
+      // 而不是从 DSH 会话存储把它重建回来（否则 forget 形同虚设）。
+      writeTombstone(this.id);
+      this.#hub.remove(this.id);
+    } else this.#hub.save();
     return { closed: true, forgotten: forget };
   }
 }
@@ -973,11 +1129,14 @@ export class Hub {
   #probeCache = null;
 
   load() {
+    const stale = pruneStaleTombstones();
+    if (stale) this.log.info(`[hub] 清理 ${stale} 个失效的 forget 墓碑`);
     if (!existsSync(STATE_FILE)) return;
     try {
       const doc = JSON.parse(readFileSync(STATE_FILE, 'utf8'));
       for (const s of doc.conversations ?? []) {
         if (!s?.id || !s?.cwd) continue;
+        if (isForgotten(s.id)) continue;
         this.conversations.set(s.id, new Conversation(s, this));
       }
       this.log.info(`[hub] 载入 ${this.conversations.size} 个会话`);
@@ -1000,6 +1159,9 @@ export class Hub {
       const tmp = `${STATE_FILE}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
       writeFileSync(tmp, JSON.stringify(doc, null, 2), 'utf8');
       renameSync(tmp, STATE_FILE);
+      // 侧车元数据独立于注册表：forget 移除注册表条目后仍然保留，
+      // 让按 id 重建的会话不会丢掉审批策略/思考深度/标题/轮数。
+      for (const c of this.conversations.values()) writeConversationMeta(c);
     } catch (e) {
       this.log.info(`[hub] 状态保存失败: ${e.message}`);
     }
@@ -1097,6 +1259,14 @@ export class Hub {
   }
 
   get(id) {
+    // ★ forget 是终态：墓碑存在时，任何按 id 的查询都必须明确失败，
+    //   否则 DSH 会话存储里的记录会让它悄悄复活（"forget 不持久"）。
+    if (isForgotten(id)) {
+      throw new Error(
+        `会话已被 forget（永久移除）: ${id}\n` +
+          `  它不会再被按 id 自动恢复。确实要恢复的话，删除墓碑文件 ${forgottenPath(id)} 后重试。`,
+      );
+    }
     let c = this.conversations.get(id);
     if (!c) {
       // 多实例常见情形：这个会话是**另一个 dsh-any-agent 实例**刚建的，我们内存里的注册表还没有。
@@ -1113,18 +1283,39 @@ export class Hub {
         //   一个当初用 read-only 建的会话，若注册表丢了、被我们以默认档接管，
         //   resume 时 DSH_PERMISSION_MODE 会把档位写进会话 —— 等于**悄悄提权**。
         const meta = readConversationMeta(id);
+        const persisted = readConversationMetaFile(id);
         const recordedPreset = meta?.permissions?.preset;
-        const permission = PERMISSION_TIERS.includes(recordedPreset) ? recordedPreset : DEFAULT_PERMISSION;
+        const recordedPermission = PERMISSION_TIERS.includes(recordedPreset) ? recordedPreset : null;
+        // 安全优先：会话记录说 read-only 就绝不能被侧车“提升”为可写档。
+        const permission =
+          recordedPermission === 'read-only'
+            ? 'read-only'
+            : PERMISSION_TIERS.includes(persisted?.permission)
+              ? persisted.permission
+              : (recordedPermission ?? DEFAULT_PERMISSION);
         const recordedApproval = meta?.permissions?.approval;
-        const onApproval = APPROVAL_POLICIES.includes(recordedApproval)
-          ? recordedApproval
-          : defaultApprovalPolicy(permission);
+        let onApproval = APPROVAL_POLICIES.includes(persisted?.onApproval)
+          ? persisted.onApproval
+          : APPROVAL_POLICIES.includes(recordedApproval)
+            ? recordedApproval
+            : defaultApprovalPolicy(permission);
+        if (permission === 'read-only' && onApproval !== 'auto-deny') onApproval = 'auto-deny';
         c = new Conversation(
           {
             id,
-            cwd: header.cwd,
+            cwd: persisted?.cwd ?? header.cwd,
             permission,
             onApproval,
+            titleHint: persisted?.titleHint ?? null,
+            reasoningEffort: REASONING_EFFORTS.includes(persisted?.reasoningEffort)
+              ? persisted.reasoningEffort
+              : DEFAULT_REASONING_EFFORT,
+            provider: persisted?.provider ?? null,
+            model: persisted?.model ?? null,
+            createdAt: persisted?.createdAt,
+            lastUsedAt: persisted?.lastUsedAt,
+            turnCount: persisted?.turnCount,
+            workspace: persisted?.workspace ?? null,
           },
           this,
         );
@@ -1153,6 +1344,7 @@ export class Hub {
       const doc = JSON.parse(readFileSync(STATE_FILE, 'utf8'));
       for (const s of doc.conversations ?? []) {
         if (!s?.id || !s?.cwd) continue;
+        if (isForgotten(s.id)) continue;
         if (this.conversations.has(s.id)) continue;
         this.conversations.set(s.id, new Conversation(s, this));
         added++;
@@ -1166,6 +1358,8 @@ export class Hub {
 
   remove(id) {
     this.conversations.delete(id);
+    // 注意：**不删侧车元数据**。forget 的语义是“从注册表移除”，
+    // 之后按 id 重建（多实例恢复）时，侧车让审批策略/思考深度/标题/轮数不漂移。
     this.save();
   }
 
@@ -1179,8 +1373,11 @@ export class Hub {
       );
     }
     if (!isAbsolute(cwd)) throw new Error(`cwd 必须是绝对路径: ${cwd}`);
-    if (!existsSync(cwd) || !statSync(cwd).isDirectory()) {
-      throw new Error(`工作区不存在或不是目录: ${cwd}（请先创建它）`);
+    if (!existsSync(cwd)) {
+      throw new Error(`工作区不存在或不是目录: ${cwd}（请先创建这个目录）`);
+    }
+    if (!statSync(cwd).isDirectory()) {
+      throw new Error(`工作区不存在或不是目录: ${cwd}（这是一个文件路径，请传目录）`);
     }
     if (!PERMISSION_TIERS.includes(permission)) {
       throw new Error(`permission 必须是 ${PERMISSION_TIERS.join(' | ')} 之一`);
@@ -1189,6 +1386,14 @@ export class Hub {
     if (!APPROVAL_POLICIES.includes(policy)) {
       throw new Error(`on_approval 必须是 ${APPROVAL_POLICIES.join(' | ')} 之一`);
     }
+    // ★ read-only 是硬边界：显式 auto-allow/ask 会放行 DSH 的 sandbox 提权，
+    //   实测能把文件写进工作区而会话记录仍显示 read-only。直接拒绝这个组合。
+    if (permission === 'read-only' && policy !== 'auto-deny') {
+      throw new Error(
+        'permission=read-only 强制要求 on_approval=auto-deny（或不传）。' +
+          ' auto-allow/ask 会放行 DSH 的 sandbox 提权，使只读档失效。',
+      );
+    }
     const effort = reasoningEffort ?? DEFAULT_REASONING_EFFORT;
     if (!REASONING_EFFORTS.includes(effort)) {
       throw new Error(`reasoning_effort 必须是 ${REASONING_EFFORTS.join(' | ')} 之一`);
@@ -1208,9 +1413,11 @@ export class Hub {
       onPermissionRequest: () => ({ outcome: { outcome: 'cancelled' } }),
     });
     proc.start();
+    let createdSessionId = null;
     try {
       await proc.initialize();
       const res = await proc.request('session/new', { cwd, mcpServers: [] });
+      createdSessionId = res.sessionId;
       const conv = new Conversation(
         {
           id: res.sessionId,
@@ -1235,6 +1442,16 @@ export class Hub {
       });
       // 套用会话级配置（思考深度默认 max；ACP 自己的默认是 Provider default）
       conv.lastConfigApplied = await applySessionConfig(proc, res.sessionId, conv.cfg);
+      // ★ 无效的 provider/model 必须 fail fast：旧行为是建出会话、静默回退
+      //   profile 默认模型，调用方以为指定模型已生效。这里在外层 catch 停止进程，
+      //   不注册会话，直接报错（不传 provider/model 才走 profile 默认）。
+      const modelFailure = (conv.lastConfigApplied.failed ?? []).find((f) => String(f).includes('模型='));
+      if (modelFailure) {
+        throw new Error(
+          `指定的 provider/model 无效，会话未创建：${modelFailure}\n` +
+            `  请检查 ${provider}/${model} 是否在 profile 中声明；不传这两个参数可使用 profile 默认模型。`,
+        );
+      }
       // 登记工作区，否则这些会话在你的 DSH GUI 里看不到。
       // ★ 必须容错：registerWorkspace 会写 workspace.json（磁盘满/被占时会抛），
       //   而它在 this.conversations.set 之前 —— 抛出去就会**丢掉这个会话并泄漏进程**。
@@ -1252,6 +1469,10 @@ export class Hub {
       );
       return conv;
     } catch (e) {
+      // 失败路径也要清掉写锁登记：session/new 可能已经成功、登记已写入，
+      // 但会话最终没有注册（例如无效 provider/model 被 fail-fast）。留下 marker
+      // 会被 dsh_list/dsh_takeover 误报成“孤儿持有者”，也会在 locks 目录里积垃圾。
+      if (createdSessionId) removeMarker(createdSessionId);
       await proc.stop().catch(() => {});
       throw e;
     }
@@ -1262,6 +1483,7 @@ export class Hub {
     const out = new Map();
     for (const c of this.conversations.values()) {
       if (cwd && c.cwd !== cwd) continue;
+      if (isForgotten(c.id)) continue;
       out.set(c.id, c.snapshot());
     }
     if (!includeClosed) return [...out.values()];
@@ -1294,6 +1516,7 @@ export class Hub {
     }
     for (const s of sessions) {
       if (out.has(s.sessionId)) continue;
+      if (isForgotten(s.sessionId)) continue;
       const meta = readConversationMeta(s.sessionId);
       out.set(s.sessionId, {
         conversation_id: s.sessionId,

package/src/mcp.mjs

@@ -48,6 +48,7 @@ DSH 自己有文件读写、shell、搜索、技能、子代理等全套工具
    dsh_read(conversation_id, cursor)          中途看它当前吐出的内容（增量）
    dsh_get(conversation_id, run_id)           验收：取那一次派活的完整结果
 4. dsh_interject / dsh_interrupt              跑偏了就插话改口 / 直接打断
+                                              （会话空闲时 interject 等价于 wait=true，会阻塞到回合结束）
 5. dsh_release                                交还会话（释放写锁，之后仍可 resume）
 6. dsh_takeover                               写锁被别人占着时的**抢占**（见下）
 
@@ -86,9 +87,12 @@ dsh_interject —— 一个回合 = 一个哨兵，没有例外）。dsh_send
 - 会话在忙时**不要**再 dsh_send：想改口用 dsh_interject，想停用 dsh_interrupt，
   想把话留到本轮结束后说用 dsh_interject(mode='queue')。
 - 思考内容**默认隐藏**（只返回字数/耗时统计）。确实需要时传 reasoning='full'，但很占上下文。
-- 权限档默认 ${DEFAULT_PERMISSION}，审批默认 ${process.env.DSH_MCP_APPROVAL ?? 'auto-allow'}（read-only 一律 auto-deny）。分析不信任样本（恶意软件、来路不明 dump）时用
+- 权限档默认 ${DEFAULT_PERMISSION}，审批默认 ${process.env.DSH_MCP_APPROVAL ?? 'auto-allow'}。**read-only 强制 auto-deny**：传 auto-allow/ask 会被直接拒绝（否则 DSH 的 sandbox 提权会被放行）。分析不信任样本（恶意软件、来路不明 dump）时用
   read-only：沙箱只读 + 审批一律拒绝。
 - 思考深度默认 max；想省钱可在 dsh_start 传 reasoning_effort 调低。
+- 隐私边界：本服务自己的日志、哨兵、注册表都不写思考正文（哨兵只留思考统计）；但 **DSH 自己的会话日志
+  ~/.dsh/sessions/** 会保存 reasoning，reasoning=hide 也照存** —— 分析敏感数据时要把它算进去。
+- 异步哨兵文件保存最终正文与工具输入（常见密钥字面量已脱敏），默认保留 7 天；消费后建议自行删除。
 - 想并行：开多个会话，dsh_list(only_running=true) 看谁在跑，再轮流 dsh_read。
 
 【不要做】

package/src/tools.mjs

@@ -39,7 +39,7 @@ export const TOOL_DEFS = [
           description:
             '工作区绝对路径。决定 agent 的工作目录、AGENTS.md/技能的发现范围、以及沙箱可写根。' +
             '**省略时自动用客户端当前打开的项目目录**（MCP roots），这样客户端里看到哪个项目就在这里干活；' +
-            '客户端不支持 roots 时才会要求你显式传入。别传用户家目录本身 —— 那里会让 DSH 的 ACL 沙箱起不来。',
+            '客户端不支持 roots、或 roots 为空时才会要求你显式传入。别传用户家目录本身 —— 那里会让 DSH 的 ACL 沙箱起不来。',
         },
         permission: {
           type: 'string',
@@ -52,7 +52,9 @@ export const TOOL_DEFS = [
         on_approval: {
           type: 'string',
           enum: APPROVAL_POLICIES,
-          description: `审批处理策略。默认 read-only → auto-deny，其余 → ${process.env.DSH_MCP_APPROVAL ?? 'auto-allow'}。ask 会把审批挂起，需用 dsh_approval_decide 裁决。`,
+          description:
+            `审批处理策略。**read-only 强制 auto-deny**（传 auto-allow/ask 会被直接拒绝，否则会放行 DSH 的 sandbox 提权）；` +
+            `其余档位默认 ${process.env.DSH_MCP_APPROVAL ?? 'auto-allow'}。ask 会把审批挂起，需用 dsh_approval_decide 裁决。`,
         },
         title_hint: {
           type: 'string',
@@ -103,7 +105,7 @@ export const TOOL_DEFS = [
         timeout_ms: {
           type: 'number',
           description:
-            '仅 wait=true 时的**等待**上限（毫秒），默认 30 分钟；0 = 一直等。到期不会取消回合，只会转成后台并给你 run_id。',
+            '仅 wait=true 时的**等待**上限（毫秒），**默认 0 = 一直等**（不会凭空发明 30 分钟）。到期不会取消回合，只会转成后台并给你 run_id。',
         },
       },
       ['conversation_id', 'prompt'],
@@ -137,7 +139,8 @@ export const TOOL_DEFS = [
       '不必等回合结束。典型用法：dsh_list(only_running) 找到在跑的会话 → 反复 dsh_read 并回传上次的 cursor，' +
       '就能像切换窗口一样轮流观察多个会话。' +
       '输出缓冲**只在内存里且有界**（环形，满则丢最旧），服务/进程退出即消失；' +
-      '**思考内容不进缓冲**——只有 include_reasoning=true 时才会附带"当前正在跑那一轮"的实时思考。',
+      '**思考内容不进缓冲**——只有 include_reasoning=true 时才会附带"当前正在跑那一轮"的实时思考。' +
+      'cursor 是**修订号**：同一条目被追加文本后会再次返回，调用方按 `seq` 用它替换全文（不要重复累加）。',
     inputSchema: S(
       {
         conversation_id: CONV_ID,
@@ -153,7 +156,8 @@ export const TOOL_DEFS = [
     description:
       '查看单个会话的详情；带 run_id 时**取那一次派活的最终结果**（异步模式的验收入口）。' +
       '不传 run_id 则取最近一次回合。返回：标题、工作区、权限档、状态、轮数、token 用量、' +
-      '上下文压力、待决审批，以及该回合的完整结果（正文/工具/用量/错误）。',
+      '上下文压力、待决审批，以及该回合的完整结果（正文/工具/用量/错误）。' +
+      '**run 记录只在内存、最多保留最近 20 条**；服务重启或记录被挤掉后请改读哨兵文件（它落盘且扛重启）。',
     inputSchema: S(
       {
         conversation_id: CONV_ID,
@@ -167,7 +171,7 @@ export const TOOL_DEFS = [
     description:
       '插话：会话正在跑某个回合时往里补一句话。两种模式——' +
       'interject（默认）打断当前回合并立刻改口；queue 不打断，等本轮自然结束后紧接着说。' +
-      '会话空闲时等同于一次普通 dsh_send。' +
+      '会话空闲时按 **wait=true 的普通回合**执行（会阻塞到回合结束并返回完整结果，不是收据）。' +
       '说明：ACP 明确拒绝并发 prompt，所以做不到"让模型在同一个回合里即时改向"；' +
       'interject 是它的实用等价物（取消 + 立刻开新回合，历史完整保留）。',
     inputSchema: S(
@@ -184,7 +188,7 @@ export const TOOL_DEFS = [
           enum: REASONING_MODES,
           description: `思考内容展示档位，默认 ${DEFAULT_REASONING}。`,
         },
-        timeout_ms: { type: 'number', description: '新回合的**等待**上限（毫秒），默认 30 分钟；0 = 一直等。到期转后台，不取消回合。' },
+        timeout_ms: { type: 'number', description: '新回合的**等待**上限（毫秒），**默认 0 = 一直等**；queue 模式也用它限制等待上一轮结束。到期转后台，不取消回合。' },
       },
       ['conversation_id', 'message'],
     ),
@@ -222,8 +226,10 @@ export const TOOL_DEFS = [
     name: 'dsh_release',
     description:
       '释放会话占用的 DSH 进程（释放写锁，让用户能在自己的 DSH GUI 里打开同一个会话）。' +
-      '会话本体留在磁盘上，之后仍可 resume；forget=true 才会从注册表里摘掉。' +
-      '★ 用完了想一次性腾内存就传 all=true（默认"永不回收"下每个会话约 300-480MB，全放掉即立刻归零，之后随时 resume）。',
+      '会话本体留在磁盘上，之后仍可 resume；**forget=true 会写墓碑**：从注册表移除，此后按 id 查询明确报“已被 forget”' +
+      '（想恢复可按错误里的路径删除墓碑文件，默认在 `$DSH_HOME/.dsh-any-agent-forgotten/<id>.json`）。' +
+      '★ 用完了想一次性腾内存就传 all=true（每个会话约 300-480MB；默认 `MAX_LIVE=8` 会回收最久未用者，' +
+      'all=true 可立即全部释放，之后随时 resume）。',
     inputSchema: S(
       {
         conversation_id: CONV_ID,
@@ -374,11 +380,24 @@ export function createHandlers(hub, opts = {}) {
         (snap.title_hint && snap.title !== snap.title_hint ? `（你给的标题提示: ${snap.title_hint}）` : ''),
         `工作区登记: ${snap.workspace_registered ? '已写入 DSH 工作区注册表（GUI 里能看到）' : '未登记'}`,
       ];
-      if (snap.config_failed?.length) lines.push(`⚠️ 配置未完全套用: ${snap.config_failed.join('; ')}`);
+      if (snap.config_failed?.length) {
+        lines.push(`⚠️ 配置未完全套用: ${snap.config_failed.join('; ')}`);
+        if (snap.config_failed.some((f) => String(f).startsWith('模型='))) {
+          lines.push(
+            '⚠️ 指定的 provider/model 无效：本会话已回退到 profile 默认模型，' +
+              '后续回合**不会**使用你指定的模型。',
+          );
+        }
+      }
       return { structured: snap, text: lines.join('\n') };
     },
 
     async dsh_send(args) {
+      // 空/纯空白 prompt 会被 DSH 以 [-32602] 拒绝；默认 wait=false 下那会变成
+      // 一个“accepted 但注定失败”的收据（错误只异步出现在哨兵里）。这里同步拦下。
+      if (typeof args.prompt !== 'string' || args.prompt.trim() === '') {
+        throw new Error('prompt 不能为空：至少包含一个非空白字符');
+      }
       const conv = hub.get(args.conversation_id);
       const opts = { reasoning: args.reasoning ?? DEFAULT_REASONING };
       if (args.timeout_ms) opts.timeoutMs = args.timeout_ms;
@@ -531,6 +550,9 @@ export function createHandlers(hub, opts = {}) {
     },
 
     async dsh_interject(args) {
+      if (typeof args.message !== 'string' || args.message.trim() === '') {
+        throw new Error('message 不能为空：至少包含一个非空白字符');
+      }
       const conv = hub.get(args.conversation_id);
       const opts = { mode: args.mode ?? 'interject', reasoning: args.reasoning ?? DEFAULT_REASONING };
       if (args.timeout_ms) opts.timeoutMs = args.timeout_ms;

package/src/workspace.mjs

@@ -24,6 +24,8 @@ import { DSH_HOME, REGISTER_WORKSPACE } from './config.mjs';
 
 const WORKSPACE_FILE = join(DSH_HOME, 'storages', 'workspace.json');
 const SESSIONS_ROOT = join(DSH_HOME, 'sessions');
+/** forget 墓碑目录（存 id+时间，不含内容）；清掉测试会话时一并清掉其墓碑。 */
+const FORGOTTEN_DIR = process.env.DSH_MCP_FORGOTTEN_DIR ?? join(DSH_HOME, '.dsh-any-agent-forgotten');
 
 /** 路径比较用：Windows 下大小写不敏感，且忽略结尾分隔符。 */
 const normPath = (p) => String(p ?? '').replace(/[\\/]+$/, '').toLowerCase();
@@ -329,6 +331,12 @@ export function purgeTestSessions({ dryRun = false, ids = [], tempOnly = false,
       } catch (e) {
         v.error = e.message;
       }
+      // 会话文件都没了，墓碑也就没有意义：一起清掉，避免测试残留。
+      try {
+        rmSync(join(FORGOTTEN_DIR, `${v.id}.json`), { force: true });
+      } catch {
+        /* 墓碑不存在或删不掉都不影响会话清理 */
+      }
     }
     // 清掉因删空而残留的空分桶目录（每个工作区一个桶，空桶会一直堆着）
     for (const bucket of readdirSync(SESSIONS_ROOT)) {