pi-web-ui 0.96.0 → 0.97.0

package/dist/server/client-state.js

@@ -6,7 +6,7 @@
  *
  * 从 agent-service.ts 抽出，行为保持不变。
  */
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { normalizeSoftCapByModel, normalizeSoftCapTokens } from "./soft-cap.js";
 import { deriveLegacy, legacyToDisabled, normalizeDisabledAgentTools } from "./tool-manager.js";
@@ -353,6 +353,12 @@ export class ClientStateStore {
             { path: cwd, lastUsed: now },
             ...state.projects.filter((p) => normalizePathKey(p.path) !== targetKey),
         ].slice(0, 30);
+        // Also persist in global settings so new tabs and sessions inherit it immediately
+        const globalState = (all[ClientStateStore.GLOBAL_SETTINGS_KEY] ??= { projects: [] });
+        globalState.projects = [
+            { path: cwd, lastUsed: now },
+            ...(globalState.projects ?? []).filter((p) => normalizePathKey(p.path) !== targetKey),
+        ].slice(0, 50);
         // Opening the workspace again clears its removal tombstone across all clients and global settings.
         for (const cState of Object.values(all)) {
             if (cState.removedProjects?.length) {
@@ -409,6 +415,82 @@ export class ClientStateStore {
         }
         return result;
     }
+    /**
+     * Get recent projects merged across the client's own history, global settings,
+     * and other clients in this store, filtering out tombstoned paths and non-existent paths.
+     */
+    getRecentProjects(clientId) {
+        const all = this.load();
+        const removedKeys = new Set(this.getRemovedProjects(clientId).map(normalizePathKey));
+        const map = new Map();
+        const merge = (list) => {
+            if (!list)
+                return;
+            for (const p of list) {
+                if (!p?.path)
+                    continue;
+                const key = normalizePathKey(p.path);
+                if (removedKeys.has(key))
+                    continue;
+                const existing = map.get(key);
+                if (!existing || p.lastUsed > existing.lastUsed) {
+                    map.set(key, { path: p.path, lastUsed: p.lastUsed });
+                }
+            }
+        };
+        // Merge client's own projects first, then global settings, then all other clients
+        merge(all[clientId]?.projects);
+        merge(all[ClientStateStore.GLOBAL_SETTINGS_KEY]?.projects);
+        for (const [id, cState] of Object.entries(all)) {
+            if (id !== clientId && id !== ClientStateStore.GLOBAL_SETTINGS_KEY) {
+                merge(cState.projects);
+            }
+        }
+        return [...map.values()]
+            .filter((p) => {
+            try {
+                return existsSync(p.path);
+            }
+            catch {
+                return false;
+            }
+        })
+            .sort((a, b) => b.lastUsed - a.lastUsed)
+            .slice(0, 30);
+    }
+    /** Record discovered projects into global settings cache (without clobbering tombstones). */
+    mergeDiscoveredProjects(projects) {
+        if (!projects.length)
+            return;
+        const all = this.load();
+        const globalState = (all[ClientStateStore.GLOBAL_SETTINGS_KEY] ??= { projects: [] });
+        const removedKeys = new Set((globalState.removedProjects ?? []).map(normalizePathKey));
+        const map = new Map();
+        for (const p of globalState.projects ?? []) {
+            const key = normalizePathKey(p.path);
+            if (!removedKeys.has(key))
+                map.set(key, p);
+        }
+        let changed = false;
+        for (const p of projects) {
+            const key = normalizePathKey(p.path);
+            if (removedKeys.has(key))
+                continue;
+            const existing = map.get(key);
+            if (!existing) {
+                map.set(key, p);
+                changed = true;
+            }
+            else if (p.lastUsed > existing.lastUsed) {
+                existing.lastUsed = p.lastUsed;
+                changed = true;
+            }
+        }
+        if (changed) {
+            globalState.projects = [...map.values()].sort((a, b) => b.lastUsed - a.lastUsed).slice(0, 50);
+            this.save();
+        }
+    }
     /** Last-used goal/review prefs for a client, or undefined if never set. */
     getGoalPrefs(clientId) {
         const s = this.load()[clientId];
@@ -418,6 +500,7 @@ export class ClientStateStore {
             reviewModel: s.goalPrefs.reviewModel ?? null,
             maxRounds: s.goalPrefs.maxRounds ?? 0,
             locked: s.goalPrefs.locked ?? true,
+            execModel: s.goalPrefs.execModel ?? null,
         };
     }
     /** 某项目当前的额外工作区根（空数组 = 单根）。 */
@@ -461,6 +544,7 @@ export class ClientStateStore {
             reviewModel: prefs?.reviewModel ?? null,
             maxRounds: prefs?.maxRounds ?? 0,
             locked: prefs?.locked ?? true,
+            execModel: prefs?.execModel ?? null,
         };
         this.save();
     }
@@ -542,6 +626,8 @@ export class ClientStateStore {
             visionBridgePrompt: stored?.visionBridgePrompt ?? "",
             scmCommitMsgPromptMode: stored?.scmCommitMsgPromptMode === "replace" ? "replace" : "append",
             scmCommitMsgPrompt: stored?.scmCommitMsgPrompt ?? "",
+            planModePromptMode: stored?.planModePromptMode === "replace" ? "replace" : "append",
+            planModePrompt: stored?.planModePrompt ?? "",
             subagentDefaultModel: stored?.subagentDefaultModel ?? null,
             retryMaxAttempts: normalizeRetryMaxAttempts(stored?.retryMaxAttempts),
             softCapTokens: normalizeSoftCapTokens(stored?.softCapTokens),
@@ -606,6 +692,8 @@ export class ClientStateStore {
             visionBridgePrompt: settings.visionBridgePrompt ?? cur.visionBridgePrompt ?? "",
             scmCommitMsgPromptMode: settings.scmCommitMsgPromptMode ?? cur.scmCommitMsgPromptMode ?? "append",
             scmCommitMsgPrompt: settings.scmCommitMsgPrompt ?? cur.scmCommitMsgPrompt ?? "",
+            planModePromptMode: settings.planModePromptMode ?? cur.planModePromptMode ?? "append",
+            planModePrompt: settings.planModePrompt ?? cur.planModePrompt ?? "",
             reviewPrompt: settings.reviewPrompt ?? cur.reviewPrompt ?? "",
             reviewDisabledSkills: settings.reviewDisabledSkills ?? cur.reviewDisabledSkills ?? [],
             disabledPlugins: settings.disabledPlugins ?? cur.disabledPlugins ?? [],

package/dist/server/compacted-history.js

@@ -0,0 +1,146 @@
+/**
+ * compacted-history.ts — 提取被上下文压缩折叠的历史消息（issue #398）。
+ *
+ * 核心原则：严格解耦「UI 展示流」与「LLM 推理视窗」。
+ * 当用户在聊天界面点击压缩卡片（CompactionCard）上的「展开查看被折叠的历史」时，
+ * 本模块根据 compactionMessageId 纯只读地从会话 DAG 祖先链中还原被该节点折叠的
+ * 历史消息，转换为 UiMessage[] 供前端展示，绝不重新送入后续大模型推理。
+ */
+import { findEntryByUiId, serializeMessage } from "./serialize.js";
+/**
+ * 在任意 entries 集合中按 parentId 回溯构造从根到 targetId 的祖先链。
+ * 纯函数，防循环引用，用于 getBranch 不可用或单测环境下的兜底。
+ */
+export function walkAncestors(targetId, allEntries) {
+    const byId = new Map();
+    for (const e of allEntries)
+        byId.set(e.id, e);
+    const path = [];
+    let curId = targetId;
+    const visited = new Set();
+    while (curId && byId.has(curId) && !visited.has(curId)) {
+        visited.add(curId);
+        const entry = byId.get(curId);
+        path.push(entry);
+        curId = entry.parentId;
+    }
+    return path.reverse();
+}
+/**
+ * 根据 Compaction 节点切分出被该节点折叠的历史 entries。
+ * 纯函数。
+ *
+ * 切分规则（遵循 Pi 内核 CompactionEntry 规范）：
+ * - 结束边界（keptIndex）：当前 compaction 的 firstKeptEntryId 所在位置。
+ *   若为 retain-none（firstKeptEntryId === id），则结束边界为压缩节点自身。
+ * - 起始边界（startIndex）：若前序存在更早的 compaction 节点，则从其 firstKeptEntryId
+ *   （或前序节点之后）开始，避免与前一张压缩卡片折叠的内容重叠；若无前序，则从 0 开始。
+ */
+export function sliceCompactedEntries(targetCompaction, branch) {
+    const targetIdx = branch.findIndex((e) => e.id === targetCompaction.id);
+    if (targetIdx === -1)
+        return [];
+    // 1. 确定保留起点边界 keptIdx
+    let keptIdx = targetIdx;
+    const firstKeptId = targetCompaction.firstKeptEntryId;
+    if (firstKeptId && firstKeptId !== targetCompaction.id) {
+        const found = branch.findIndex((e) => e.id === firstKeptId);
+        if (found >= 0 && found <= targetIdx) {
+            keptIdx = found;
+        }
+    }
+    // 2. 确定前序压缩起始点 startIndex
+    let startIdx = 0;
+    for (let i = targetIdx - 1; i >= 0; i--) {
+        if (branch[i].type === "compaction") {
+            const prevComp = branch[i];
+            const prevFirstKeptId = prevComp.firstKeptEntryId;
+            if (prevFirstKeptId && prevFirstKeptId !== prevComp.id) {
+                const prevKeptIdx = branch.findIndex((e) => e.id === prevFirstKeptId);
+                if (prevKeptIdx >= 0 && prevKeptIdx < targetIdx) {
+                    startIdx = prevKeptIdx;
+                    break;
+                }
+            }
+            startIdx = i + 1;
+            break;
+        }
+    }
+    if (startIdx >= keptIdx)
+        return [];
+    return branch.slice(startIdx, keptIdx);
+}
+/**
+ * 将被折叠的原始 entries 转换为只读 UiMessage[] 列表。
+ * 纯函数。
+ */
+export function serializeCompactedEntries(entries) {
+    const result = [];
+    let seq = 1;
+    for (const entry of entries) {
+        if (entry.type === "message" && entry.message) {
+            if (entry.message.role === "system")
+                continue;
+            const ui = serializeMessage(entry.message, seq++);
+            if (ui)
+                result.push(ui);
+        }
+        else if (entry.type === "custom_message" && entry.display !== false) {
+            const m = {
+                role: "custom",
+                content: entry.content,
+                timestamp: entry.timestamp ? new Date(entry.timestamp).getTime() : 0,
+            };
+            const ui = serializeMessage(m, seq++);
+            if (ui)
+                result.push(ui);
+        }
+    }
+    return result;
+}
+/**
+ * 根据前端 compactionMessageId 提取被折叠的历史消息（综合入口）。
+ */
+export function getCompactedMessages(sessionManager, compactionMessageId, seqOf) {
+    try {
+        const contextEntries = sessionManager.buildContextEntries?.() ?? [];
+        const allEntries = sessionManager.getEntries?.() ?? contextEntries;
+        // 1. 定位目标 compaction 条目
+        const defaultSeqOf = () => 1;
+        let targetCompaction = findEntryByUiId(contextEntries, compactionMessageId, seqOf ?? defaultSeqOf);
+        if (!targetCompaction) {
+            targetCompaction = findEntryByUiId(allEntries, compactionMessageId, seqOf ?? defaultSeqOf);
+        }
+        if (!targetCompaction || targetCompaction.type !== "compaction") {
+            // 直接以 raw id 查
+            targetCompaction =
+                sessionManager.getEntry?.(compactionMessageId) ??
+                    allEntries.find((e) => e.id === compactionMessageId && e.type === "compaction") ??
+                    null;
+        }
+        if (!targetCompaction || targetCompaction.type !== "compaction") {
+            return { messages: [], error: "Compaction entry not found" };
+        }
+        // 2. 获取该节点的分支祖先链
+        let branch = [];
+        if (typeof sessionManager.getBranch === "function") {
+            try {
+                branch = sessionManager.getBranch(targetCompaction.id) ?? [];
+            }
+            catch {
+                branch = [];
+            }
+        }
+        if (branch.length === 0) {
+            branch = walkAncestors(targetCompaction.id, allEntries);
+        }
+        // 3. 提取折叠区间并序列化
+        const foldedEntries = sliceCompactedEntries(targetCompaction, branch);
+        const messages = serializeCompactedEntries(foldedEntries);
+        return { messages };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { messages: [], error: msg };
+    }
+}

package/dist/server/delegate-mode.js

@@ -0,0 +1,149 @@
+/**
+ * server/delegate-mode.ts
+ *
+ * 审查者模式（自动委派 / delegate mode）：主对话**只审阅不施工**，活由服务端
+ * 派给一个**常驻落盘执行对话**（每会话一个，跨轮复用）。
+ *
+ * 形态：会话级开关（`set_delegate_mode`）→ 开启后：
+ *   1. 自动路由：用户在主对话发的每条 prompt，服务端直接转给执行对话执行
+ *      （`ClientSession.dispatchToDelegate`），主对话这一轮**不跑模型**；
+ *   2. 纯委派闸门：主对话的写类工具 / 非常规 bash / 派发类工具一律拒
+ *      —— 即便模型自己想动手也过不去（与计划模式同一套 `withXGate` 骨架）。
+ *
+ * 与计划模式的关系：**互斥优先级**。计划模式开着的时候不自动派活（计划模式已经
+ * 把 spawn/旁路工具全拒了，再自动派活就是死锁），由计划模式那一轮说了算。
+ *
+ * 判定全部是纯函数（无 IO），单测见 tests/unit/delegate-mode.test.ts。
+ */
+import { bashCommandIsReadOnly } from "./plan-mode.js";
+/** 审查者模式下确定禁止的工具：与计划模式同名单（写 / 改 / 增删 / git 写 / 形态变换）。 */
+const BLOCKED_TOOLS = new Set([
+    "write",
+    "create",
+    "create_file",
+    "write_file",
+    "edit",
+    "edit_file",
+    "edit_soft",
+    "apply_patch",
+    "patch",
+    "patch_tool",
+    "str_replace",
+    "str_replace_editor",
+    "multi_edit",
+    "notebook_edit",
+    "mv",
+    "move",
+    "cp",
+    "copy",
+    "mkdir",
+    "rm",
+    "rmdir",
+    "delete",
+    "delete_file",
+    "touch",
+    "chmod",
+    "chown",
+    "truncate",
+    "rename",
+    "git",
+    "format",
+    "prettier",
+    "lint_fix",
+    "autofix",
+]);
+/**
+ * 审查者模式下也禁掉的「派发类」工具：派活是**服务端**的活（自动路由），
+ * 模型再自己 spawn 一个只会绕开「一个常驻执行对话」这条语义线（多份上下文、
+ * 多份配额、左栏一堆对话），而且落盘对话占项目会话名额。
+ * 与计划模式禁它的理由不同：那边是「别绕开只读约束」，这边是「别绕开统一派活」。
+ */
+const DISPATCH_TOOLS = new Set([
+    "spawn",
+    "subagent_spawn",
+    "subagent",
+    "delegate_task",
+    "spawn_subagent",
+    "schedule",
+    "set_goal",
+    "start_goal_wizard",
+    "set_plan_mode",
+]);
+/** bash 家族（要逐条判命令是否只读）。 */
+const BASH_TOOLS = new Set(["bash", "shell", "sh", "zsh", "terminal", "terminal_bash", "run_command", "exec"]);
+/** 从工具参数里取命令文本（各工具字段名不同）。 */
+function commandOf(params) {
+    if (!params || typeof params !== "object")
+        return "";
+    const p = params;
+    for (const key of ["command", "cmd", "script", "input"]) {
+        const v = p[key];
+        if (typeof v === "string" && v.trim() !== "")
+            return v;
+    }
+    return "";
+}
+/**
+ * 审查者模式闸门（纯函数）：命中即拒绝，并把「该干什么」告诉模型 ——
+ * 提示词已经说明规则，这里再把可操作的下一步重复一遍（长任务里模型最容易
+ * 「顺手改一下」，拒绝理由就是它唯一的纠偏机会）。
+ */
+export function delegationDenial(toolName, params) {
+    const name = (toolName ?? "").trim();
+    if (!name)
+        return undefined;
+    if (DISPATCH_TOOLS.has(name)) {
+        return {
+            kind: "dispatch-tool",
+            reason: `审查者模式：不能调用 ${name} —— 派活由服务端统一做（一个常驻执行对话）。请只描述需求、审阅结果或提问。`,
+            reasonEn: `Reviewer mode: ${name} is unavailable — dispatching is done by the server (one persistent executor conversation). Describe the work, review the result, or ask questions.`,
+        };
+    }
+    if (BASH_TOOLS.has(name)) {
+        const cmd = commandOf(params);
+        if (cmd.trim() === "") {
+            return {
+                kind: "bash",
+                reason: "审查者模式：终端不可用 —— 施工由执行对话做。请用 read/grep/只读 git 看结果。",
+                reasonEn: "Reviewer mode: the terminal is unavailable — the executor conversation does the work. Inspect with read/grep/read-only git.",
+            };
+        }
+        if (bashCommandIsReadOnly(cmd))
+            return undefined;
+        return {
+            kind: "bash",
+            reason: `审查者模式：只允许只读命令，命令被拒：\`${cmd.slice(0, 200)}\`。施工请交给执行对话；你要做的是看结果、判断是否达标。`,
+            reasonEn: `Reviewer mode: only read-only commands are allowed; rejected: \`${cmd.slice(0, 200)}\`. The executor conversation makes the changes — your job is to inspect the result and judge whether it meets the goal.`,
+        };
+    }
+    if (BLOCKED_TOOLS.has(name)) {
+        return {
+            kind: "write-tool",
+            reason: `审查者模式：本对话不施工，${name} 被拒。需求已由服务端转给执行对话；请改为审阅它交回来的结果（读 diff/测试输出）并提出下一轮要求。`,
+            reasonEn: `Reviewer mode: this conversation does not make changes — ${name} was rejected. The request was forwarded to the executor conversation; review its result (read the diff, test output) and state what the next round should do.`,
+        };
+    }
+    return undefined;
+}
+/** 审查者模式系统提示词段（英文：进入模型上下文，按工具提示词卫生口径只写英文）。 */
+export const DELEGATION_SYSTEM_PROMPT = [
+    "# Reviewer mode (you review; a server-side executor does the work)",
+    "Reviewer mode is on for this conversation. The server forwards every user request to ONE persistent executor conversation, and that conversation is the only one allowed to change anything.",
+    "Hard rules:",
+    "- Never try to change files, run write commands, or dispatch other agents: those tools are blocked by the server and the rejection comes back as a tool error. Do not retry them.",
+    "- Your job per turn: state what you expect the executor to deliver (constraints, acceptance criteria, files/paths in scope), then when a result comes back, verify it — read the diff, run read-only commands, check the tests it claims to have run — and either accept it or state precise follow-up requirements for the next round.",
+    "- Keep your own messages short and decision-oriented. The executor keeps the working context; you are the reviewer, not the worker.",
+    "- If plan mode is also on, plan mode wins: no dispatch happens and you produce the plan yourself.",
+].join("\n");
+/** 拒给用户的界面文案（notice，zh + en 成对）。 */
+export function delegateNoticeText(enabled) {
+    return enabled
+        ? {
+            text: "🔎 审查者模式：本对话只审阅，你的每条请求已由服务端转给常驻执行对话执行",
+            textEn: "🔎 Reviewer mode on: this conversation only reviews; the server forwards your requests to a persistent executor conversation",
+        }
+        : {
+            text: "审查者模式已关闭：恢复正常对话（本对话可以直接施工）",
+            textEn: "Reviewer mode off: back to a normal conversation (this one can make changes again)",
+        };
+}

package/dist/server/delegate-task.js

@@ -51,7 +51,7 @@ export function normalizeDelegation(params) {
 export function validateDelegation(input, usableNames, lang = "en") {
     if (!input.agent || !usableNames.includes(input.agent)) {
         const shown = usableNames.slice(0, 12).join(" · ") + (usableNames.length > 12 ? " · …" : "");
-        return pick(lang, `派单被驳回：模板 "${input.agent || "(空)"}" 不可用（不存在或已停用）。可用模板：${shown || "(无)"}。用 subagent_templates 查简介再选；不要编造模板名。`, `Delegation rejected: template "${input.agent || "(empty)"}" is unavailable (missing or disabled). Available templates: ${shown || "(none)"}. Use subagent_templates for descriptions; do not invent template names.`, "delegate.validate.agent", { agent: input.agent, available: shown });
+        return pick(lang, `派单被驳回：模板 "${input.agent || "(空)"}" 不可用（不存在或已停用）。可用模板：${shown || "(无)"}。用 subagent(action="templates") 查简介再选；不要编造模板名。`, `Delegation rejected: template "${input.agent || "(empty)"}" is unavailable (missing or disabled). Available templates: ${shown || "(none)"}. Use subagent(action="templates") for descriptions; do not invent template names.`, "delegate.validate.agent", { agent: input.agent, available: shown });
     }
     const checks = [
         { section: "TASK", text: input.task, min: MIN_TASK },
@@ -63,7 +63,7 @@ export function validateDelegation(input, usableNames, lang = "en") {
     ];
     for (const c of checks) {
         if (c.text.trim().length < c.min) {
-            return pick(lang, `派单被驳回：${c.section} 段太短（至少 ${c.min} 字，当前 ${c.text.trim().length} 字）。六段缺一不可、含糊不得：补全后重试，不要改用 subagent_spawn 绕过校验。`, `Delegation rejected: section ${c.section} is too short (minimum ${c.min} chars, got ${c.text.trim().length}). All six sections are mandatory and vague prompts fail: complete it and retry; do not bypass validation via subagent_spawn.`, "delegate.validate.short", { section: c.section, min: c.min });
+            return pick(lang, `派单被驳回：${c.section} 段太短（至少 ${c.min} 字，当前 ${c.text.trim().length} 字）。六段缺一不可、含糊不得：补全后重试，不要改用 subagent(action="spawn") 绕过校验。`, `Delegation rejected: section ${c.section} is too short (minimum ${c.min} chars, got ${c.text.trim().length}). All six sections are mandatory and vague prompts fail: complete it and retry; do not bypass validation via subagent(action="spawn").`, "delegate.validate.short", { section: c.section, min: c.min });
         }
     }
     return null;
@@ -102,7 +102,7 @@ export function buildDelegationPrompt(input, lang = "en") {
 const delegateSchema = Type.Object({
     agent: Type.String({
         description: "Specialist template to delegate to (e.g. oracle, metis, momus, explore, librarian, sisyphus-junior, multimodal-looker, review). " +
-            "Must be an enabled template — use subagent_templates to see descriptions and pick the domain match.",
+            "Must be an enabled template — use subagent (action='templates') to see descriptions and pick the domain match.",
     }),
     task: Type.String({
         description: "Atomic, specific goal: ONE action per delegation (minimum 20 chars). Vague tasks are rejected.",
@@ -144,12 +144,12 @@ export function makeDelegateTaskTool(host, lang) {
         label: "Delegate task",
         description: "Delegate ONE well-defined task to a specialist subagent template via a structured six-section brief (TASK / EXPECTED OUTCOME / REQUIRED TOOLS / MUST DO / MUST NOT DO / CONTEXT). " +
             "The brief is validated server-side — missing or vague sections are rejected, so fill every section concretely. " +
-            "Prefer over subagent_spawn when the work fits a specialist template. Spawns a real subagent conversation; " +
-            "collect with subagent_wait_all / subagent_get_result, redirect with subagent_steer, stop with subagent_stop. " +
+            "Prefer over subagent (action='spawn') when the work fits a specialist template. Spawns a real subagent conversation; " +
+            "collect with subagent (action='wait_all' / 'get_result'), redirect with subagent (action='steer'), stop with subagent (action='stop'). " +
             "For follow-ups continue the SAME subagent session instead of delegating again.",
         promptSnippet: "Delegate a well-defined task to a specialist template with a validated six-section brief",
         promptGuidelines: [
-            "Prefer delegate_task over subagent_spawn when the work matches a specialist template's domain",
+            "Prefer delegate_task over subagent (action='spawn') when the work matches a specialist template's domain",
             "Before delegating, declare which template you chose and WHY its description matches the task",
             "After delegation ALWAYS verify the result: " +
                 "does it work, does it follow codebase patterns, did it respect MUST DO / MUST NOT DO",
@@ -179,10 +179,10 @@ export function makeDelegateTaskTool(host, lang) {
             const modelLineZh = input.model ? `\n模型：${input.model}` : "";
             const modelLineEn = input.model ? `\nModel: ${input.model}` : "";
             return text(pick(getLang(), `已派单：${convId}\n模板：${input.agent} · 标题：${title}${modelLineZh}` +
-                `\n子代理已在左栏运行列表中。用 subagent_wait_all 一次等全部完成（不用轮询）、subagent_get_result 取单个结果；` +
-                `追问请在同一子代理会话里继续（subagent_steer），不要重复派单。拿到结果后必须验证再汇报。`, `Delegated: ${convId}\nTemplate: ${input.agent} · Title: ${title}${modelLineEn}` +
-                `\nThe subagent is in the left running list. Use subagent_wait_all to wait for all at once (no polling), ` +
-                `subagent_get_result for a single result; continue follow-ups in the SAME subagent session (subagent_steer), ` +
+                `\n子代理已在左栏运行列表中。用 subagent(action="wait_all") 一次等全部完成（不用轮询）、subagent(action="get_result") 取单个结果；` +
+                `追问请在同一子代理会话里继续（subagent(action="steer")），不要重复派单。拿到结果后必须验证再汇报。`, `Delegated: ${convId}\nTemplate: ${input.agent} · Title: ${title}${modelLineEn}` +
+                `\nThe subagent is in the left running list. Use subagent(action="wait_all") to wait for all at once (no polling), ` +
+                `subagent(action="get_result") for a single result; continue follow-ups in the SAME subagent session (subagent(action="steer")), ` +
                 `do not delegate again. Verify the result before reporting.`, "delegate.started", { convId: convId, agent: input.agent, title: title, "input.model": input.model }), { convId, agent: input.agent, template: input.agent, model: input.model });
         },
     });

package/dist/server/dsh/dsh-agent-service.js

@@ -31,6 +31,7 @@ import { homedir } from "node:os";
 import { BgServerTracker } from "../bg-servers.js";
 import { ClientStateStore, DEFAULT_RETRY_MAX_ATTEMPTS, normalizePathKey, normalizeToolWatchdogTimeoutMs, } from "../client-state.js";
 import { normalizeUiLayout } from "../client-state.js";
+import { PLAN_MODE_SYSTEM_PROMPT } from "../plan-mode.js";
 import { FilesService, workspacePath, desktopDirWire } from "../files-service.js";
 import { QuiesceRejectedError } from "../agent-service.js";
 import { NATIVE_COMMANDS, parseSlash } from "../slash-commands.js";
@@ -1506,6 +1507,18 @@ export class DshClientSession {
     // prompt / 附件
     // -----------------------------------------------------------------------
     async prompt(text, attachments, queue = false) {
+        const trimmedText = (text ?? "").trim();
+        const hasAttachments = Boolean(attachments && attachments.length > 0);
+        if (!trimmedText && !hasAttachments) {
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: "发送已忽略：提示词为空且未附带文件或上下文引用。",
+                textEn: "Prompt ignored: text is empty and no attachments were provided.",
+            });
+            this.flushSnapshot();
+            return;
+        }
         // 斜杠命令拦截（内置 NATIVE + 插件 registerCommand）；带附件时不拦截。
         const parsed = parseSlash(text);
         if (parsed && !attachments?.length) {
@@ -2293,10 +2306,10 @@ export class DshClientSession {
     // 项目 / 文件 / SCM / 搜索
     // -----------------------------------------------------------------------
     async pushProjects() {
-        const saved = this.stateStore.get(this.clientId);
+        const recent = this.stateStore.getRecentProjects(this.clientId);
         const removedKeys = new Set(this.stateStore.getRemovedProjects(this.clientId).map(normalizePathKey));
         const projects = new Map();
-        for (const p of saved.projects ?? []) {
+        for (const p of recent) {
             if (!removedKeys.has(normalizePathKey(p.path))) {
                 projects.set(p.path, p.lastUsed);
             }
@@ -2639,6 +2652,10 @@ export class DshClientSession {
             // DSH 无「AI 生成提交信息」（scm_commitmsg 分发处直接报错），保协议完整。
             scmCommitMsgPromptMode: "append",
             scmCommitMsgPrompt: "",
+            // DSH 引擎不渲染计划按钮（无 customTools 注册面），保协议完整。
+            planModePromptMode: "append",
+            planModePrompt: "",
+            planModeDefaultPrompt: PLAN_MODE_SYSTEM_PROMPT,
             reviewPrompt: this.settings.reviewPrompt,
             reviewDisabledSkills: [],
             disabledPlugins: this.settings.disabledPlugins,
@@ -3041,6 +3058,22 @@ export class DshClientSession {
             });
         }
     }
+    /**
+     * 审查者模式：DSH 不支持（无 customTools 注册面 → 工具硬闸门无处可挂，
+     * 自动路由也没有可派发的会话通道）。明确回报而不是静默失败 ——
+     * “点了没反应”比“用不了”更让人怀疑是不是页面坏了。
+     */
+    async setDelegateMode(enabled) {
+        if (!enabled)
+            return;
+        this.emit({
+            type: "notice",
+            level: "warning",
+            text: "审查者模式仅支持 pi 引擎（DSH 没有工具硬闸门的注册面），未开启。",
+            textEn: "Reviewer mode needs the pi engine (DSH has no tool-gate registration surface); not enabled.",
+        });
+        this.flushSnapshot();
+    }
     async savePreset(name) {
         const presets = this.stateStore.getPresets(this.clientId);
         const existing = presets.find((p) => p.name === name);

package/dist/server/dsh/dsh-client.js

@@ -136,7 +136,9 @@ export class DshRuntime {
             throw new DshTransportError(bilingual(`launcher missing: ${this.launcher}`, `launcher 不存在: ${this.launcher}`));
         }
         if (!existsSync(this.jsonrpcEntry)) {
-            throw new DshTransportError(bilingual(`dsh-sdk-jsonrpc-server is not installed (missing ${this.jsonrpcEntry}). Run npm i @deepseek-ai/dsh-sdk-jsonrpc-server@0.1.1-rc.2 first`, `dsh-sdk-jsonrpc-server 未安装（缺 ${this.jsonrpcEntry}）。请先 npm i @deepseek-ai/dsh-sdk-jsonrpc-server@0.1.1-rc.2`));
+            // 不写死版本号：依赖版本会随 package.json 升（见 docs/dsh-engine.md §1
+            // 「版本族」），写死的提示迟早骗人。报当前实际解析到的路径即可。
+            throw new DshTransportError(bilingual(`dsh-sdk-jsonrpc-server is not installed (missing ${this.jsonrpcEntry}). Run npm i (see docs/dsh-engine.md for the pinned version family) first`, `dsh-sdk-jsonrpc-server 未安装（缺 ${this.jsonrpcEntry}）。请先 npm i（版本族见 docs/dsh-engine.md）`));
         }
         const key = loadDeepSeekKey(this.agentDir);
         const env = {

package/dist/server/eval-tool.js

@@ -503,7 +503,9 @@ export function makeEvalTool(opts) {
             code: Type.String({
                 description: "The code snippet to evaluate. Top-level variables and functions are preserved across calls.",
             }),
-            language: Type.Optional(Type.Union([Type.Literal("py"), Type.Literal("js"), Type.Literal("ts")], {
+            language: Type.Optional(Type.Unsafe({
+                type: "string",
+                enum: ["py", "js", "ts"],
                 description: 'Target language: "py" for Python (default), "js" or "ts" for Node.js sandbox.',
             })),
             title: Type.Optional(Type.String({