pi-web-ui 0.96.1 → 0.97.0

package/dist/server/agent-service.js

@@ -14,9 +14,11 @@
 // provider so built-in model lists follow the official pi.dev catalog
 // wholesale (no union merge / no stale built-in leftovers).
 import "./patch-remote-catalog.js";
+import "./patch-turn-end-boundary.js";
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
+import * as fsPromises from "node:fs/promises";
 import { appendFileSync, existsSync, readFileSync, renameSync, rmSync, statSync, mkdirSync, watch, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
@@ -34,7 +36,7 @@ import { removeQueuedByIndexOrText } from "./queue-utils.js";
 import { syncPluginToolsIntoSession } from "./plugins.js";
 import { denialText, } from "./plugin-tool-guard.js";
 import { SettingsService } from "./settings-service.js";
-import { GoalService, buildDiffFingerprint } from "./goal-service.js";
+import { GoalService, buildDiffFingerprint, extractErrorSnippetFromSession, lastToolNameOfSession, } from "./goal-service.js";
 import { MarkerService } from "./marker-service.js";
 import { SlashCommandsService, parseSlash } from "./slash-commands.js";
 import { ModelAdminService } from "./model-admin.js";
@@ -49,8 +51,13 @@ import { createWorkspaceSnapshot, restoreWorkspaceSnapshot } from "./workspace-s
 import { isPathInsideRoot } from "./approval-rules.js";
 import { approvalSuppressionReason, checkDangerousToolCall, isApprovalPolicyEmpty, pluginApprovalCategory, } from "./tool-approval.js";
 import { PlanManager } from "./plan-manager.js";
+import { buildPlanModePrompt, planModeDenial, planModeNoticeText, PLAN_MODE_BLOCKED_TOOL_NAMES } from "./plan-mode.js";
+import { DELEGATION_SYSTEM_PROMPT, delegationDenial, delegateNoticeText } from "./delegate-mode.js";
+import { goalReviewDenial, shouldDeferPromptForReview } from "./goal-review-gate.js";
+import { readPlanModeFromSession } from "./permission-preset.js";
+import { readDelegateModeFromSession } from "./permission-preset.js";
 import { applyHeadTail, makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, } from "./terminals.js";
-import { applyAgentToolsGating, ASK_USER_QUESTION_TOOL_NAME, BROWSER_PAGE_TOOL_NAME, effectiveDisabledAgentTools, isAgentToolEnabled, isTerminalGuidanceOn, MARKERS_LIST_TOOL_NAME, PI_AGENT_PRESETS, PI_PERMISSION_OPTIONS, PLAN_UPDATE_TOOL_NAME, PRESENT_FILES_TOOL_NAME, presetAllowsPluginTools, presetHasQuestionnaire, presetShowsSkillCatalog, } from "./tool-manager.js";
+import { applyAgentToolsGating, ASK_USER_QUESTION_TOOL_NAME, BROWSER_PAGE_TOOL_NAME, effectiveDisabledAgentTools, isAgentToolEnabled, isTerminalGuidanceOn, localizedName, MARKERS_LIST_TOOL_NAME, PI_AGENT_PRESETS, PI_PERMISSION_OPTIONS, PLAN_UPDATE_TOOL_NAME, PRESENT_FILES_TOOL_NAME, presetAllowsPluginTools, presetHasQuestionnaire, presetShowsSkillCatalog, } from "./tool-manager.js";
 import { WebUIContext } from "./webui-context.js";
 import { DEFAULT_COMPACTION_RESERVE_TOKENS, effectiveSoftCap, softCapToReserve } from "./soft-cap.js";
 import { pruneContextHierarchically } from "./context-budget.js";
@@ -75,6 +82,7 @@ import { extractTouches, formatTouchesCompact, intersectTouches } from "./conver
 import { ClaimStore, matchClaims, mergeTouchSidecar, readTouchSidecar, removeTouchSidecar } from "./claim-store.js";
 import { makeClaimFilesTool } from "./claim-files-tool.js";
 import { makeSkillTool } from "./skill-tool.js";
+import { getCompactedMessages } from "./compacted-history.js";
 import { makeScheduleTools } from "./schedule-agent-tool.js";
 import { makePatchTool } from "./patch-tool.js";
 import { makeLspTool } from "./lsp-tool.js";
@@ -266,6 +274,85 @@ export function makeAdaptiveBashTool(killable, terminalBacked, useTerminal) {
         },
     };
 }
+/**
+ * 计划模式闸门装饰（通用）：套在任何工具定义外层，只在**执行前**判定一次。
+ * 与权限沙箱/插件守卫平行且更靠外 —— 计划模式是会话级硬约束，不给任何
+ * 「记住同类/全部允许」的口子（允许了就等于放开了实施）。
+ * 关闭时零开销（返回原定义，不包 execute）。
+ */
+export function withPlanModeGate(def, planMode, getLang) {
+    return {
+        ...def,
+        execute: (async (...args) => {
+            if (planMode()) {
+                const params = args[1];
+                const denied = planModeDenial(def.name, params);
+                if (denied) {
+                    const reason = pick(getLang(), denied.reason, denied.reasonEn);
+                    const err = new Error(reason);
+                    err.details = {
+                        guardDenied: true,
+                        planModeDenied: true,
+                        kind: denied.kind,
+                    };
+                    throw err;
+                }
+            }
+            return def.execute(...args);
+        }),
+    };
+}
+/**
+ * 目标审查回合闸门（server/goal-review-gate.ts）：主对话在 `awaitingVerdict`
+ * 置位期间是审查者 —— 写类工具、非常规 bash、派发类工具、向用户提问一律拒。
+ * 形状与 withPlanModeGate / withDelegationGate 同构，串在最外层（理由最贴合
+ * 此刻：跟模型说「这是审查回合」比「这是计划/审查者模式」更有用）。闸门无状态
+ * （每次执行只读 `awaitingVerdict`），verdict 落定即自动恢复，不存在钉死。
+ */
+export function withGoalReviewGate(def, reviewTurn, getLang) {
+    return {
+        ...def,
+        execute: (async (...args) => {
+            if (reviewTurn()) {
+                const params = args[1];
+                const denied = goalReviewDenial(def.name, params);
+                if (denied) {
+                    return {
+                        content: [{ type: "text", text: pick(getLang(), denied.reason, denied.reasonEn) }],
+                        details: { guardDenied: true, goalReviewDenied: true, kind: denied.kind },
+                        isError: true,
+                    };
+                }
+            }
+            return def.execute(...args);
+        }),
+    };
+}
+/**
+ * 审查者模式闸门（server/delegate-mode.ts）：主对话只审阅不施工 ——
+ * 写类工具、非常规 bash、派发类工具一律拒。形状与 withPlanModeGate 同构，
+ * 串在它**外层**（两者都开时，先问计划模式还是审查者模式都不影响结果：
+ * 都是拒，只是理由不同）。
+ */
+export function withDelegationGate(def, delegateMode, getLang) {
+    return {
+        ...def,
+        execute: (async (...args) => {
+            if (delegateMode()) {
+                const params = args[1];
+                const denied = delegationDenial(def.name, params);
+                if (denied) {
+                    return {
+                        content: [{ type: "text", text: pick(getLang(), denied.reason, denied.reasonEn) }],
+                        details: { guardDenied: true, delegateDenied: true, kind: denied.kind },
+                        isError: true,
+                    };
+                }
+            }
+            return def.execute(...args);
+        }),
+    };
+}
 /**
  * 给已接管工具（bash/read）包上拦截守卫与人机协同审批：
  * 1. pre guard 命中 deny → 直接阻断；
@@ -666,7 +753,11 @@ export function makePlanUpdateTool(planManager, getActiveConvId, emit, flushSnap
             steps: Type.Array(Type.Object({
                 id: Type.String({ description: "Unique step ID, e.g. '1', 'step-1'" }),
                 title: Type.String({ description: "Short step title" }),
-                status: Type.Optional(Type.Union([Type.Literal("pending"), Type.Literal("in_progress"), Type.Literal("done"), Type.Literal("failed")], { description: "Step status: pending | in_progress | done | failed (default: pending)" })),
+                status: Type.Optional(Type.Unsafe({
+                    type: "string",
+                    enum: ["pending", "in_progress", "done", "failed"],
+                    description: "Step status: pending | in_progress | done | failed (default: pending)",
+                })),
                 description: Type.Optional(Type.String({
                     description: "Optional detailed description, acceptance criteria, file touch list, or rollback note.",
                 })),
@@ -718,6 +809,7 @@ function wrapBashToolWithPermission(tool, getPermission, getLang) {
 function makeMarkersListTool(getActiveId, markerSvc) {
     return {
         name: MARKERS_LIST_TOOL_NAME,
+        promptSnippet: "list current inline-marker tasks (read-only — writes go through [[todo:...]] inline markers)",
         label: "List marker state",
         description: "Read-only query of inline marker state. All WRITE operations must use inline markers ([[todo:new:...]] etc.) in the reply body — never this tool.",
         parameters: Type.Object({
@@ -757,52 +849,50 @@ export function makeAskUserQuestionTool(clientSession,
 /** 本 runtime 所属会话：提问跟着对话走，快照只把当前对话的问卷推给客户端。 */
 ownerId) {
     const QuestionOptionSchema = Type.Object({
-        label: Type.String({ description: "Display label for the option (1-5 words)" }),
+        label: Type.String({ description: "Display label (1-5 words)" }),
         description: Type.Optional(Type.String({
-            description: "One short sentence explaining the impact or tradeoff if selected.",
+            description: "Short explanation of impact/tradeoff",
         })),
         preview: Type.Optional(Type.String({
-            description: "Optional preview rendered below when this option is selected (markdown or HTML — use for mockups/code/config).",
+            description: "Optional preview (markdown/HTML/code)",
         })),
     });
     const QuestionSchema = Type.Object({
-        id: Type.String({ description: "Unique identifier for this question (snake_case)" }),
-        question: Type.String({ description: "The full question text to display (markdown/HTML ok)" }),
-        detail: Type.Optional(Type.String({ description: "Optional detail/context shown under the question" })),
-        header: Type.Optional(Type.String({ description: "Optional short header for this question" })),
+        id: Type.String({ description: "Unique identifier (snake_case)" }),
+        question: Type.String({ description: "Question text (markdown/HTML ok)" }),
+        detail: Type.Optional(Type.String({ description: "Optional context under question" })),
+        header: Type.Optional(Type.String({ description: "Optional short header" })),
         options: Type.Optional(Type.Array(QuestionOptionSchema, {
-            description: "2-4 mutually exclusive choices. Put the recommended option first when there is a clear default.",
+            description: "2-4 choices (recommended option first)",
             minItems: 2,
             maxItems: 4,
         })),
-        multiSelect: Type.Optional(Type.Boolean({ description: "Allow selecting multiple options (default: false)" })),
+        multiSelect: Type.Optional(Type.Boolean({ description: "Allow multiple choices (default: false)" })),
         dependsOn: Type.Optional(Type.Object({
-            questionId: Type.String({ description: "ID of the prior question this question depends on" }),
+            questionId: Type.String({ description: "Prior question ID" }),
             value: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String())], {
-                description: "Show only when the prior answer equals this value (or is in the array). Omit to show whenever answered.",
+                description: "Show when prior answer matches",
             })),
         })),
         optionsMap: Type.Optional(Type.Record(Type.String(), Type.Array(QuestionOptionSchema), {
-            description: "Dynamic options based on prior question's chosen value: e.g. { 'React': [opts...], 'Vue': [opts...] }",
+            description: "Dynamic options keyed by prior answer",
         })),
     });
     return {
         name: "ask_user_question",
         label: "Ask the user",
-        description: "Ask the user focused questions to clarify ambiguous requirements (clarify the task, confirm decisions, get preferences). " +
-            "Strictly ask 1 to 3 questions per call (prefer 1, max 3); provide 2 to 4 mutually exclusive options with the " +
-            "recommended option first, and explain impact/tradeoff in each option description. " +
-            "Each question renders a browser dialog with markdown/HTML rich text; options may carry a `preview`. Submit or cancel to resume.",
+        description: "Ask the user 1-3 focused questions to clarify requirements, confirm decisions, or choose options. " +
+            "Provide 2-4 choices (recommended first) with concise tradeoffs. " +
+            "Renders a rich browser dialog; resumes on submit or cancel.",
         promptSnippet: "ask the user 1-3 focused questions with recommended options and tradeoffs to clarify requirements",
         promptGuidelines: [
-            "When requirements are ambiguous, use ask_user_question to clarify instead of guessing: " +
-                "ask 1 to 3 focused questions (prefer 1, max 3), provide 2-4 mutually exclusive options with the " +
-                "recommended option first, and explain impact/tradeoff in description",
-            "A cancelled question comes back as a tool error — respect it and continue without re-asking immediately",
+            "When requirements are ambiguous, use ask_user_question to clarify: " +
+                "strictly 1 to 3 focused questions (prefer 1), 2-4 choices with recommended option first, and explain impact/tradeoff concisely",
+            "A cancelled question comes back as a tool error — respect it without immediately re-asking",
         ],
         parameters: Type.Object({
             questions: Type.Array(QuestionSchema, {
-                description: "Questions to ask the user (strictly 1 to 3 questions; prefer 1).",
+                description: "1-3 questions to ask (prefer 1)",
                 minItems: 1,
                 maxItems: 3,
             }),
@@ -1361,6 +1451,238 @@ export function isInsideSessionsDir(agentDir, targetPath) {
         roots.push(resolve(extra));
     return roots.some((root) => abs.startsWith(root + sep));
 }
+/**
+ * 从会话文件首行读取 cwd（轻量探测，最多读取 2KB，绝不完整解析整个 jsonl 消息历史）。
+ */
+async function readCwdFromSessionHeader(filePath) {
+    let handle;
+    try {
+        handle = await fsPromises.open(filePath, "r");
+        const buf = Buffer.alloc(2048);
+        const { bytesRead } = await handle.read(buf, 0, 2048, 0);
+        const text = buf.toString("utf8", 0, bytesRead);
+        const nl = text.indexOf("\n");
+        const firstLine = nl !== -1 ? text.slice(0, nl) : text;
+        if (!firstLine.trim())
+            return null;
+        const parsed = JSON.parse(firstLine);
+        return typeof parsed.cwd === "string" && parsed.cwd.trim() ? parsed.cwd : null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (handle)
+            await handle.close().catch(() => { });
+    }
+}
+/**
+ * 快速轻量地从 SDK 会话目录中发现项目路径（仅读取会话文件的第一行头部获取 cwd，
+ * 绝不使用 SessionManager.listAll 遍历解析全部会话文本，避免大历史时阻塞数秒到数十秒）。
+ */
+async function discoverRecentProjectsFromDisk(sessionRoots, limit = 30) {
+    const projects = new Map();
+    for (const root of sessionRoots) {
+        if (projects.size >= limit)
+            break;
+        try {
+            if (!existsSync(root))
+                continue;
+            const entries = await fsPromises.readdir(root, { withFileTypes: true });
+            // 1. 扁平布局（PI_CODING_AGENT_SESSION_DIR）：根目录下直接是 .jsonl
+            const flatFiles = entries.filter((e) => e.isFile() && e.name.endsWith(".jsonl"));
+            if (flatFiles.length > 0) {
+                const fileStats = await Promise.all(flatFiles.map(async (f) => {
+                    const fp = join(root, f.name);
+                    try {
+                        const st = await fsPromises.stat(fp);
+                        return { path: fp, mtime: st.mtimeMs };
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                fileStats.sort((a, b) => (b?.mtime ?? 0) - (a?.mtime ?? 0));
+                for (const s of fileStats) {
+                    if (!s || projects.size >= limit)
+                        break;
+                    const cwd = await readCwdFromSessionHeader(s.path);
+                    if (cwd) {
+                        const key = normalizePathKey(cwd);
+                        if (!projects.has(key)) {
+                            try {
+                                if (existsSync(cwd))
+                                    projects.set(key, { path: cwd, lastUsed: s.mtime });
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+            // 2. 默认子目录布局（<agentDir>/sessions/--<cwd>--/）：每 cwd 一个子目录
+            const subdirs = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => join(root, e.name));
+            if (subdirs.length > 0 && projects.size < limit) {
+                const CHUNK = 64;
+                const dirStats = [];
+                for (let i = 0; i < subdirs.length; i += CHUNK) {
+                    const chunk = subdirs.slice(i, i + CHUNK);
+                    const stats = await Promise.all(chunk.map(async (dir) => {
+                        try {
+                            const st = await fsPromises.stat(dir);
+                            return { path: dir, mtime: st.mtimeMs };
+                        }
+                        catch {
+                            return null;
+                        }
+                    }));
+                    for (const s of stats)
+                        if (s)
+                            dirStats.push(s);
+                }
+                dirStats.sort((a, b) => b.mtime - a.mtime);
+                for (let i = 0; i < dirStats.length; i += 16) {
+                    if (projects.size >= limit)
+                        break;
+                    const batch = dirStats.slice(i, i + 16);
+                    const batchRes = await Promise.all(batch.map(async (d) => {
+                        try {
+                            const files = await fsPromises.readdir(d.path);
+                            const jsonls = files.filter((f) => f.endsWith(".jsonl"));
+                            if (jsonls.length === 0)
+                                return null;
+                            let newestFile = "";
+                            let newestMtime = 0;
+                            for (const f of jsonls) {
+                                const fp = join(d.path, f);
+                                try {
+                                    const st = await fsPromises.stat(fp);
+                                    if (st.mtimeMs > newestMtime) {
+                                        newestMtime = st.mtimeMs;
+                                        newestFile = fp;
+                                    }
+                                }
+                                catch { }
+                            }
+                            if (!newestFile)
+                                return null;
+                            const cwd = await readCwdFromSessionHeader(newestFile);
+                            if (!cwd)
+                                return null;
+                            return { path: cwd, lastUsed: newestMtime };
+                        }
+                        catch {
+                            return null;
+                        }
+                    }));
+                    for (const r of batchRes) {
+                        if (!r)
+                            continue;
+                        const key = normalizePathKey(r.path);
+                        if (!projects.has(key)) {
+                            try {
+                                if (existsSync(r.path)) {
+                                    projects.set(key, r);
+                                }
+                            }
+                            catch { }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            /* best effort */
+        }
+    }
+    return [...projects.values()].sort((a, b) => b.lastUsed - a.lastUsed);
+}
+/**
+ * 快速解析单个会话文件（提取 id/cwd/name/parentSessionPath/firstMessage/messageCount/modified/allMessagesText）。
+ * 仅用于会话列表发现与搜索，避免调用 SDK 重型的全量树解析。
+ */
+async function parseSessionInfoFast(filePath, fileMtime) {
+    try {
+        const content = await fsPromises.readFile(filePath, "utf8");
+        const lines = content.split("\n");
+        let id = "";
+        let cwd = "";
+        let name;
+        let parentSessionPath;
+        let firstMessage = "";
+        let messageCount = 0;
+        let lastActivityTime = 0;
+        let headerTime = 0;
+        const allMessages = [];
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const rec = entry;
+            if (!rec)
+                continue;
+            if (rec.type === "session") {
+                id = typeof rec.id === "string" ? rec.id : "";
+                cwd = typeof rec.cwd === "string" ? rec.cwd : "";
+                if (typeof rec.timestamp === "string")
+                    headerTime = new Date(rec.timestamp).getTime();
+                if (typeof rec.parentSession === "string")
+                    parentSessionPath = rec.parentSession;
+            }
+            else if (rec.type === "session_info") {
+                if (typeof rec.name === "string" && rec.name.trim())
+                    name = rec.name.trim();
+            }
+            else if (rec.type === "message") {
+                messageCount++;
+                const msg = rec.message;
+                if (msg) {
+                    if (typeof msg.timestamp === "number")
+                        lastActivityTime = Math.max(lastActivityTime, msg.timestamp);
+                    let text = "";
+                    if (typeof msg.content === "string") {
+                        text = msg.content;
+                    }
+                    else if (Array.isArray(msg.content)) {
+                        for (const part of msg.content) {
+                            if (part && typeof part.text === "string") {
+                                text += (text ? " " : "") + part.text;
+                            }
+                        }
+                    }
+                    if (text) {
+                        if (!firstMessage && msg.role === "user")
+                            firstMessage = text;
+                        allMessages.push(text);
+                    }
+                }
+            }
+        }
+        if (!id)
+            return null;
+        const modified = lastActivityTime > 0 ? lastActivityTime : headerTime > 0 ? headerTime : fileMtime;
+        return {
+            path: filePath,
+            id,
+            cwd,
+            name,
+            parentSessionPath,
+            created: new Date(headerTime || fileMtime),
+            modified: new Date(modified),
+            messageCount,
+            firstMessage: firstMessage || "(no messages)",
+            allMessagesText: allMessages.join(" "),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /** 会话当前模型的 "provider/id"（无模型时 null；软上限按模型覆盖用，issue #229）。 */
 function modelKeyOf(session) {
     const m = session?.model;
@@ -1470,6 +1792,9 @@ export class ClientSession {
      *  top bar applies to every chat, not just the one that set it. Seeded by
      *  the first conversation and reused by later ones. */
     sharedModelRuntime;
+    /** 目标模式「委托执行」（Plan A）的「本轮结束」等待者：convId → 回调集合。
+     *  agent_end 到达时唤醒（事件驱动，绝不轮询）；对话被移出时按 gone 收。 */
+    turnEndWaiters = new Map();
     // -----------------------------------------------------------------------
     // Goal / review / wizard —— 自包含模块，见 goal-service.ts。每个对话有独立
     // 的 GoalStatus，审查可并发；宿主回调在构造函数里接入。
@@ -1631,7 +1956,7 @@ export class ClientSession {
      *  `model`（可选）："provider/id"，显式指定子代理模型。不传时由调用方决定是否
      *  回退到模板模型 / 设置面板默认模型；null = 跟随主对话当前模型（默认行为，
      *  runtime 重建时会继承共享 ModelRuntime 的当前默认）。 */
-    async spawnSubagentConversation(prompt, type, cwd, apply, model, parentId, persist) {
+    async spawnSubagentConversation(prompt, type, cwd, apply, model, parentId, persist, title) {
         // 数量上限先行：每个子代理都是完整 runtime + TerminalManager，无上限时一次
         // 并行派发几十个会把服务进程拖垮。持久化普通对话则受项目会话上限限制。
         if (persist) {
@@ -1690,7 +2015,7 @@ export class ClientSession {
         // syncPluginTools 不回补，模板热改不影响已运行的子代理（与 prompt/技能一致）。
         conv.subagentBarsPluginTools = !!apply && apply.enabledExtensions.length > 0;
         conv.listed = true;
-        conv.title = subagentTitle(prompt);
+        conv.title = title ?? subagentTitle(prompt);
         this.convs.set(conv.id, conv);
         // 子代理会话同样订阅 SDK 事件：否则 onEvent 永不触发，点开查看时没有
         // message_delta 流式增量、快照也不刷新，只能靠切走切回时的 flushSnapshot
@@ -1778,8 +2103,9 @@ export class ClientSession {
                 });
             }
         }
-        // 触发回合（后台执行；失败转识为通知）。
-        void conv.session.sendUserMessage(prompt).catch((err) => {
+        // 触发回合（后台执行；失败转识为通知）。把 Promise 挂在对话上：目标模式的
+        // 「等本回合结束」要先等它落定，才能区分「还没开跑」与「已跑完」。
+        conv.kickoff = conv.session.sendUserMessage(prompt).catch((err) => {
             this.emit({
                 type: "notice",
                 level: "error",
@@ -1877,6 +2203,92 @@ export class ClientSession {
         }
         return {};
     }
+    /**
+     * 事件驱动地等某对话「当前回合结束」（目标模式委托执行用）。
+     * 若当前并未在跑则立即返回既有结局；超时返回 "timeout"；对话已消失返回 "gone"。
+     * 不轮询：靠 agent_end 的 notifyTurnEnd / removeConversation 唤醒。
+     */
+    async waitConversationTurnEnd(convId, timeoutMs) {
+        const isStreaming = (c) => {
+            try {
+                return c.session.isStreaming;
+            }
+            catch {
+                return false;
+            }
+        };
+        let conv = this.convs.get(convId);
+        if (!conv)
+            return Promise.resolve("gone");
+        // spawn 的首回合是 fire-and-forget 投递的：先等它落定，否则「还没开跑」会被
+        // 误判成「已跑完」（空取样 → 下一轮派活撞在一起）。
+        if (conv.kickoff) {
+            await conv.kickoff.catch(() => { });
+            conv = this.convs.get(convId);
+            if (!conv)
+                return "gone";
+        }
+        // 极短的启动宽限：投递刚返回时 isStreaming 可能还差一拍。只在这里等，
+        // 一旦开跑就交给事件驱动（agent_end），不是长轮询。
+        if (!isStreaming(conv)) {
+            const graceEnd = Date.now() + Math.min(3000, Math.max(0, timeoutMs));
+            while (!isStreaming(conv) && Date.now() < graceEnd) {
+                await new Promise((resolve) => setTimeout(resolve, 50));
+                const again = this.convs.get(convId);
+                if (!again)
+                    return "gone";
+                conv = again;
+            }
+        }
+        if (!isStreaming(conv))
+            return this.roleOutcomeOf(conv);
+        return new Promise((resolve) => {
+            const set = this.turnEndWaiters.get(convId) ?? new Set();
+            this.turnEndWaiters.set(convId, set);
+            let settled = false;
+            let timer;
+            const finish = (o) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timer)
+                    clearTimeout(timer);
+                set.delete(finish);
+                if (set.size === 0)
+                    this.turnEndWaiters.delete(convId);
+                resolve(o);
+            };
+            timer = setTimeout(() => finish("timeout"), Math.max(1000, timeoutMs));
+            timer.unref?.();
+            set.add(finish);
+            // 注册后复检：agent_end 可能恰好在 isStreaming 检查与注册之间到达。
+            const still = this.convs.get(convId);
+            if (!still) {
+                finish("gone");
+                return;
+            }
+            if (!isStreaming(still))
+                finish(this.roleOutcomeOf(still));
+        });
+    }
+    /** 对话结局 → 角色轮结局（报错 > 中止 > 正常）。 */
+    roleOutcomeOf(conv) {
+        const { error, canceled } = this.subagentRunOutcome(conv);
+        if (error)
+            return "error";
+        if (canceled)
+            return "canceled";
+        return "done";
+    }
+    /** 某对话回合结束 → 唤醒它的等待者（agent_end / 中止路径都调）。 */
+    notifyTurnEnd(conv) {
+        const set = this.turnEndWaiters.get(conv.id);
+        if (!set || set.size === 0)
+            return;
+        const outcome = this.roleOutcomeOf(conv);
+        for (const fn of set)
+            fn(outcome);
+    }
     emitTerminal(conversationId, msg) {
         // Background conversations keep collecting output in their own PTY buffer.
         // Do not stream it into the active xterm; push the retained window on switch.
@@ -2661,7 +3073,11 @@ export class ClientSession {
             },
             applyRetryOverrides: () => this.applyRetryOverrides(),
             applyCompactionOverrides: () => this.applyCompactionOverrides(),
-            applyToolGating: () => this.applyToolGating(this.session, this.conv?.agentPreset),
+            applyToolGating: () => {
+                for (const conv of this.convs.values()) {
+                    this.applyToolGating(conv.session, conv.agentPreset);
+                }
+            },
             promptSnapshot: () => this.promptSnapshot(),
             getMarkerState: () => ({
                 markersEnabled: this.markerSvc.current.markersEnabled,
@@ -2669,6 +3085,10 @@ export class ClientSession {
                 markers: this.markerSvc.listForUi(),
             }),
             getApprovalPolicy: () => this.approvalPolicyState(),
+            // 目标模式总开关关闭 → 在飞的目标/调研立即停（幂等；无在飞目标时无声）。
+            onGoalModeDisabled: () => {
+                void this.goalSvc.stopAllGoals();
+            },
         }, this.subagentTemplates, this.approvalRules);
         this.goalSvc = new GoalService({
             clientId,
@@ -2687,8 +3107,122 @@ export class ClientSession {
             activeConv: () => this.conv,
             getConv: (id) => this.convs.get(id),
             cwd: () => this.cwd,
-            reviewSettings: () => this.settingsSvc.reviewPrefs,
             gitDiff: (dir) => this.gitDiff(dir),
+            // 任务计划看板（#389 目标与计划联动）：审查者核验步骤看板，向导产物注入看板
+            getPlan: (convId) => this.planManager.getPlan(convId),
+            describePlan: (convId) => this.planManager.describePlan(convId),
+            setPlan: (convId, steps) => {
+                this.updatePlan(steps, undefined, convId);
+            },
+            // 工作区 git 可用性（目标模式停滞判定的可信信号开关）：非仓库目录下
+            // git diff 恒为空，取样会跳过停滞计数，纯问答类目标不再被误熔断。
+            isGitRepo: async (cwd) => {
+                try {
+                    const r = await this.runAsync("git", ["rev-parse", "--is-inside-work-tree"], 5_000, cwd || this.cwd);
+                    return r.code === 0;
+                }
+                catch {
+                    return false;
+                }
+            },
+            // ---- 目标模式 2.0 的角色对话桥（唯一审查/执行路径）----
+            // 复用子代理通道（同一套模板/模型/思考强度/配额/左栏展示），但角色对话**落盘**
+            // （persist=true）：转录进历史、服务重启后仍可打开回看。
+            // 代价：落盘对话 isSubagent=false → 占「每项目 8 个普通对话」名额之一
+            // （spawnSubagentConversation 满员时抛错 → GoalService 降级回 self 并提示），
+            // 且左栏不再有「子代理」徽标 —— 故给它一个带前缀的标题保持可辨识。
+            spawnRoleAgent: async ({ role, prompt, cwd, model, parentId, title }) => {
+                const baseCwd = cwd || (parentId ? this.convs.get(parentId)?.cwd : undefined) || this.cwd;
+                const convId = await this.spawnSubagentConversation(prompt, role === "executor" ? "goal-executor" : "goal-reviewer", baseCwd, undefined, model ?? null, parentId, true, title);
+                if (title) {
+                    const conv = this.convs.get(convId);
+                    if (conv)
+                        conv.title = title;
+                }
+                return convId;
+            },
+            waitRoleAgent: (convId, timeoutMs) => this.waitConversationTurnEnd(convId, timeoutMs),
+            sendRoleAgent: async (convId, message, deliverAs) => {
+                const conv = this.convs.get(convId);
+                if (!conv?.session)
+                    return false;
+                await conv.session.sendUserMessage(message, deliverAs ? { deliverAs } : conv.session.isStreaming ? { deliverAs: "steer" } : undefined);
+                return true;
+            },
+            readRoleAgent: (convId) => {
+                const conv = this.convs.get(convId);
+                if (!conv?.session)
+                    return undefined;
+                let text = "";
+                try {
+                    text = conv.session.getLastAssistantText() ?? "";
+                }
+                catch {
+                    text = "";
+                }
+                // 执行者 vitals（目标条实时进度 + 用量累计用；轮次边界才读一次，
+                // getSessionStats 会遍历转写，不在高频路径上调）。
+                let streaming;
+                let lastTool;
+                let usage;
+                try {
+                    streaming = conv.session.isStreaming;
+                }
+                catch {
+                    streaming = undefined;
+                }
+                try {
+                    lastTool = lastToolNameOfSession(conv.session);
+                }
+                catch {
+                    lastTool = undefined;
+                }
+                try {
+                    const t = conv.session.getSessionStats()?.tokens;
+                    if (t && typeof t.input === "number" && typeof t.output === "number") {
+                        usage = { input: t.input, output: t.output };
+                    }
+                }
+                catch {
+                    usage = undefined;
+                }
+                return {
+                    text,
+                    errorSnippet: extractErrorSnippetFromSession(conv.session, text),
+                    streaming,
+                    lastTool,
+                    usage,
+                };
+            },
+            stopRoleAgent: async (convId) => {
+                const conv = this.convs.get(convId);
+                if (!conv)
+                    return;
+                try {
+                    if (conv.session.isStreaming || !conv.session.isIdle) {
+                        await this.interruptRun(conv, pick(this.getLang(), "目标模式停止角色对话", "Goal mode stopped a role conversation", "agent.role.stop"));
+                    }
+                }
+                catch {
+                    // best-effort
+                }
+            },
+            dismissRoleAgent: async (convId) => {
+                const conv = this.convs.get(convId);
+                if (!conv)
+                    return;
+                // 用户正看着这个角色对话时不要把他弹走（对话留着，用户可自行关闭）。
+                if (convId === this.activeId)
+                    return;
+                try {
+                    await this.dismissConversation(convId, true, true);
+                }
+                catch {
+                    // best-effort
+                }
+            },
+            hasConv: (convId) => this.convs.has(convId),
+            roleDeadlineMs: () => this.getBaseToolWatchdogTimeoutMs(),
         });
         this.modelAdmin = new ModelAdminService({
             agentDir,
@@ -2829,6 +3363,21 @@ export class ClientSession {
                             out.push(pickTemplatePrompt(apply, this.getLang()));
                         }
                         // 主会话自定义「追加」已并入组合模板的 {{append}} 覆盖，不再在此注入。
+                        // 计划模式：只规划不实施 —— 硬闸门（server/plan-mode.ts 拒写类/旁路
+                        // 工具与非常规 bash）之外再补一段软约束，每轮重建提示词时读当前
+                        // 会话状态，切换后下一次 reload 生效。提示词正文可在设置面板改
+                        // （追加/替换内置默认，见 buildPlanModePrompt）。
+                        // ⚠️ 这一段与平台无关（曾在 win32 分支里被误嵌套，导致非 Windows
+                        // 上计划模式的软约束从来没进过提示词，只有硬闸门在挡）。
+                        if (this.planModeOf(ownerId)) {
+                            const planPrefs = this.settingsSvc.current;
+                            out.push(buildPlanModePrompt(planPrefs.planModePromptMode, planPrefs.planModePrompt));
+                        }
+                        // 审查者模式（自动委派）：本对话只审阅，活由服务端派给常驻执行对话。
+                        // 与计划模式**互斥优先级**：计划模式开着时以计划模式为准，不派活。
+                        if (this.delegateModeOf(ownerId) && !this.planModeOf(ownerId)) {
+                            out.push(DELEGATION_SYSTEM_PROMPT);
+                        }
                         if (process.platform === "win32") {
                             // Windows 专属 persona：bash 工具跑 Git Bash 且无默认超时、终端
                             // 是交互式 TTY——注入约束避免 heredoc/交互/长驻命令挂死整个会话；
@@ -2994,6 +3543,8 @@ export class ClientSession {
                 // 覆盖 SDK 内置 bash（customTools 按 name 覆盖）。双实现分流：
                 // 「默认 bash 覆盖」开关（terminalBash）关 → 原生 SDK bash（纯进程、不开终端）；
                 // 开 → 终端接管 bash（persist 决定一次性/持久，可静默自动转后台）。
+                // 整列工具统一过计划模式闸门（只规划不实施，写类/旁路工具执行前拒），
+                // read/write/edit 三处覆盖在会话建好后另注入（见 installToolOverrides）。
                 customTools: [
                     // P1-5：bash/read 包插件拦截（pre 拒/问即拦、post 脱敏补上下文；
                     // 未注入 toolGuard 时 withToolGuard 原样返回，零开销）。
@@ -3026,6 +3577,18 @@ export class ClientSession {
                         "workspace-write-never", () => this.getLang()),
                     ...makePersistentTerminalTools(terminals, effectiveCwd, () => this.getLang(), {
                         checkSafety: (cmd) => {
+                            // 计划模式：终端只放行只读命令（常驻终端也走这条，与 bash 覆盖同口径）。
+                            if (this.planModeOf(ownerId)) {
+                                const denied = planModeDenial("bash", { command: cmd });
+                                if (denied)
+                                    return { blocked: true, reason: denied.reason };
+                            }
+                            // 目标审查回合：常驻终端同样只放只读命令（审查者跑测试可以，改文件不行）。
+                            if (this.goalReviewTurnOf(ownerId)) {
+                                const denied = goalReviewDenial("bash", { command: cmd });
+                                if (denied)
+                                    return { blocked: true, reason: denied.reason };
+                            }
                             const perm = (ownerId ? this.convs.get(ownerId)?.permissionPreset : undefined) ??
                                 this.settingsSvc.current.defaultPermissionPreset ??
                                 "workspace-write-never";
@@ -3046,9 +3609,10 @@ export class ClientSession {
                     // 扩展加载顺序无关，直接塞进来会静默顶掉第三方扩展注册的同名工具（见
                     // tool-overrides.ts）；它们改在会话建好后由 installToolOverrides 注入。
                     // 不覆盖内置 edit 的独立宽松编辑工具（缩进不敏感匹配；开关看设置；带权限沙箱拦截与人机协同）。
-                    wrapEditSoftToolWithPermission(makeEditSoftTool(effectiveCwd, () => this.getLang()), effectiveCwd, () => (ownerId ? this.convs.get(ownerId)?.permissionPreset : undefined) ??
+                    // 目标审查闸门包在最外层：审查回合的理由最贴合此刻（跟模型说「这是审查回合」）。
+                    withGoalReviewGate(withDelegationGate(withPlanModeGate(wrapEditSoftToolWithPermission(makeEditSoftTool(effectiveCwd, () => this.getLang()), effectiveCwd, () => (ownerId ? this.convs.get(ownerId)?.permissionPreset : undefined) ??
                         this.settingsSvc.current.defaultPermissionPreset ??
-                        "workspace-write-never", () => this.roots, () => this.getLang(), (toolCallId, toolName, params, reason, reasonEn, convId, category) => this.askApproval(toolCallId, toolName, params, reason, reasonEn, convId, category), () => ownerId, () => this.approvalRules.list()),
+                        "workspace-write-never", () => this.roots, () => this.getLang(), (toolCallId, toolName, params, reason, reasonEn, convId, category) => this.askApproval(toolCallId, toolName, params, reason, reasonEn, convId, category), () => ownerId, () => this.approvalRules.list()), () => this.planModeOf(ownerId), () => this.getLang()), () => this.delegateModeOf(ownerId), () => this.getLang()), () => this.goalReviewTurnOf(ownerId), () => this.getLang()),
                     // 插件注册的 AI 工具（创建时刻的实时快照，已按 disabledPluginTools 过滤；
                     // 后续注册经 refreshPluginTools 动态补入已有会话）。
                     // 子代理模板带非空扩展白名单时不注入：插件/MCP 工具没有 SDK extensionKey
@@ -3133,7 +3697,11 @@ export class ClientSession {
                     makePatchTool({ cwd: effectiveCwd, ownerId }),
                     // 原生语言服务器工具（lsp，定义跳转/引用/悬停/诊断）。
                     makeLspTool({ cwd: effectiveCwd, ownerId }),
-                ],
+                ].map((t) => 
+                // 目标审查闸门在最外层（理由最贴合此刻）；插件工具也在这个数组里，
+                // 创建时注册的同样被闸门覆盖（后续动态补入的走 syncPluginTools，与
+                // 计划/审查者闸门同口径不在覆盖面，见 goal-review-gate.ts 头注）。
+                withGoalReviewGate(withDelegationGate(withPlanModeGate(t, () => this.planModeOf(ownerId), () => this.getLang()), () => this.delegateModeOf(ownerId), () => this.getLang()), () => this.goalReviewTurnOf(ownerId), () => this.getLang())),
             });
             // 桥接工具归属锚点：SDK 会话对象在本 runtime 生命周期内稳定，过户只搬对话
             // 不改它（见 ClientSession.findConversationHome）。
@@ -3175,6 +3743,8 @@ export class ClientSession {
             permissionPreset: readPermissionFromSession(runtime.session.sessionManager) ??
                 this.settingsSvc.current.defaultPermissionPreset ??
                 "workspace-write-never",
+            planMode: readPlanModeFromSession(runtime.session.sessionManager) === true,
+            delegateMode: readDelegateModeFromSession(runtime.session.sessionManager) === true,
             // A brand-new conversation is not yet LISTED — it enters the running
             // list only when it is displaced to the background while still
             // streaming (its runtime is what `listed` protects). A blank chat is
@@ -3188,7 +3758,6 @@ export class ClientSession {
             stallNoticed: false,
             goal: this.makeGoalStatus(),
             goalGeneration: 0,
-            goalReviewGeneration: 0,
             wizardRunning: false,
             deltaSeq: 0,
             terminals,
@@ -3598,6 +4167,9 @@ export class ClientSession {
             const modelId = curModel ? `${curModel.provider}/${curModel.id}` : undefined;
             return {
                 conversationId: target.id,
+                sessionId: target.session.sessionId,
+                sessionFile: target.session.sessionFile,
+                sessionDir: target.session.sessionManager?.getSessionDir?.(),
                 title: target.title,
                 model: modelId,
                 at: target.lastActiveAt,
@@ -3885,6 +4457,11 @@ export class ClientSession {
         // Any SDK event proves the run is alive — feeds the stall watchdog below.
         conv.lastSdkEventAt = Date.now();
         conv.stallNoticed = false;
+        // 模型可能在 pi-web-ui 之外被换（SDK 从会话历史恢复、/model 命令等），
+        // 而软上限 reserve 是按注入那一刻的窗口换算的固定值——模型一变必须重算，
+        // 否则大窗口算出的 reserve 泄漏到小窗口模型上，触发点被压成负数，
+        // 上下文刚过几万 token 就反复触发压缩。热路径只做一次字符串比对。
+        this.reapplySoftCapIfModelChanged(conv);
         switch (event.type) {
             case "bash_execution_update": {
                 if (event.id) {
@@ -4141,6 +4718,8 @@ export class ClientSession {
                     return a.role === "assistant" && a.stopReason === "aborted";
                 });
                 if (aborted) {
+                    // 角色轮等待者先唤醒（中止也算「本轮结束」），再让 GoalService 作废目标。
+                    this.notifyTurnEnd(conv);
                     const stopNotice = this.goalSvc.onAgentEnd(conv, true);
                     if (stopNotice) {
                         this.emit({ type: "notice", level: "warning", text: stopNotice.text, textEn: stopNotice.textEn });
@@ -4169,6 +4748,9 @@ export class ClientSession {
                     this.emitConversations();
                 }
                 // Goal review hook lives in GoalService.onAgentEnd(conv, false).
+                // 先唤醒角色轮等待者：委托执行（Plan A）下服务端正阻塞在「等主对话给 verdict」
+                // 或「等对话空闲」上，而 onAgentEnd 随后会把它需要的 verdict 交回。
+                this.notifyTurnEnd(conv);
                 this.goalSvc.onAgentEnd(conv, false);
                 // Deferred settings reload: settings (system prompt / skills /
                 // extensions) changed while the run was streaming — applying now
@@ -4596,11 +5178,17 @@ export class ClientSession {
             pendingQuestion: this.pendingQuestionForSnapshot(),
             pendingApproval: this.pendingApprovalForSnapshot(),
             plan: this.planManager.getPlan(this.activeId),
+            // 计划模式是**会话级**开关：快照恒给布尔（不用 undefined），否则
+            // snapshot_delta 里 key 缺席 → 前端 spread 合并会残留上一对话的 true。
+            planMode: conv?.planMode === true,
+            // 审查者模式同样是**会话级**：布尔恒给（理由同 planMode），另带执行对话 id。
+            delegateMode: conv?.delegateMode === true,
+            delegateConvId: conv?.delegateConvId ?? null,
             subagentHandoffs: this.subagentHandoffs.length > 0 ? [...this.subagentHandoffs] : undefined,
             agentPreset: conv
                 ? {
                     id: conv.agentPreset ?? "standard",
-                    name: PI_AGENT_PRESETS.find((p) => p.id === conv.agentPreset)?.name ?? "全功能",
+                    name: localizedName(PI_AGENT_PRESETS.find((p) => p.id === conv.agentPreset), this.getLang(), "全功能"),
                     locked: conv.presetLocked || !this.isBlankConversation(conv),
                 }
                 : null,
@@ -6018,24 +6606,50 @@ export class ClientSession {
      *  合并视图，SDK 每次自动压缩检查前都重读 getCompactionSettings()，
      *  无需 reload；软上限关闭时回填 SDK 默认 reserve（不让旧覆盖泄漏）。
      *  窗口未知（会话未就绪/无模型）的会话跳过——创建/就绪/换模型路径
-     *  会重放（见各 applyRetryOverrides 调用点）。 */
+     *  会重放（见各 applyRetryOverrides 调用点）；此外 onEvent 按模型
+     *  key 变化兜底重放（reapplySoftCapIfModelChanged），保证会话模型
+     *  在 pi-web-ui 之外被换（如 SDK 从会话历史恢复）后覆盖不泄漏。 */
     applyCompactionOverrides() {
         const s = this.settingsSvc.current;
         for (const c of this.convs.values()) {
             try {
-                const modelId = modelKeyOf(c.session);
-                const contextWindow = contextWindowOf(c.session);
-                const cap = effectiveSoftCap(s.softCapTokens, s.softCapByModel, modelId);
-                const reserve = softCapToReserve(contextWindow, cap);
-                c.session.settingsManager.applyOverrides({
-                    compaction: { reserveTokens: reserve ?? DEFAULT_COMPACTION_RESERVE_TOKENS },
-                });
+                this.applyCompactionOverrideForConv(c, s);
             }
             catch {
                 // 会话未就绪或已释放 → 其 runtime 创建时统一注入。
             }
         }
     }
+    /** 单会话换算并注入软上限 reserve（applyCompactionOverrides 的循环体；
+     *  reapplySoftCapIfModelChanged 单会话重放也复用）。抛错交调用方处置。 */
+    applyCompactionOverrideForConv(c, s) {
+        const modelId = modelKeyOf(c.session);
+        const contextWindow = contextWindowOf(c.session);
+        const cap = effectiveSoftCap(s.softCapTokens, s.softCapByModel, modelId);
+        const reserve = softCapToReserve(contextWindow, cap);
+        c.session.settingsManager.applyOverrides({
+            compaction: { reserveTokens: reserve ?? DEFAULT_COMPACTION_RESERVE_TOKENS },
+        });
+    }
+    /** 会话模型变化时重放该会话的软上限覆盖。SDK 恢复历史会话的模型
+     *  （findInitialModel）与 /model 命令都不经过 pi-web-ui 的 setModel
+     *  路径，注入过的 reserve 会停留在旧模型窗口的换算值上——例如默认
+     *  模型（1M 窗口）算出 748576，泄漏到 500K 窗口的会话后压缩触发点
+     *  变成负数，上下文几万 token 就被反复压缩。onEvent 每个事件比对
+     *  一次 model key（O(1) 字符串比较），变化才重放。 */
+    reapplySoftCapIfModelChanged(conv) {
+        try {
+            const key = modelKeyOf(conv.session);
+            if (conv.lastModelKey === key)
+                return;
+            conv.lastModelKey = key;
+            if (key)
+                this.applyCompactionOverrideForConv(conv, this.settingsSvc.current);
+        }
+        catch {
+            // 会话未就绪或已释放 → 留给创建/换模型路径与后续事件重试。
+        }
+    }
     /** 当前活动对话的生效软上限（快照底栏标记线用；null = 关闭/未知）。 */
     activeSoftCap(contextWindow) {
         try {
@@ -6151,6 +6765,12 @@ export class ClientSession {
                 return c.agentPreset;
         return undefined;
     }
+    convOfSession(session) {
+        for (const c of this.convs.values())
+            if (c.session === session)
+                return c;
+        return undefined;
+    }
     /**
      * read / write / edit 三处覆盖的注入规格：基底 = 扩展注册的同名工具优先，否则 SDK 内置实现
      * （见 tool-overrides.ts —— 这三处覆盖不能塞进创建时的 `customTools`，那会静默顶掉扩展的
@@ -6177,8 +6797,10 @@ export class ClientSession {
             getRules: () => this.approvalRules.list(),
         };
         // 写/编的权限沙箱包装：同一个函数，有扩展同名工具时把它的定义当基底（末参）。
-        const composeWrite = (base) => wrapWriteToolWithPermission(cwd, currentPermission, () => this.roots, () => this.getLang(), approve, () => ownerId, () => this.approvalRules.list(), base);
-        const composeEdit = (base) => wrapEditToolWithPermission(cwd, currentPermission, () => this.roots, () => this.getLang(), approve, () => ownerId, () => this.approvalRules.list(), base);
+        // 目标审查闸门包在**最外层**（权限沙箱之前）：审查回合只读核实，写类直接拒。
+        const planGate = (def) => withGoalReviewGate(withDelegationGate(withPlanModeGate(def, () => this.planModeOf(ownerId), () => this.getLang()), () => this.delegateModeOf(ownerId), () => this.getLang()), () => this.goalReviewTurnOf(ownerId), () => this.getLang());
+        const composeWrite = (base) => planGate(wrapWriteToolWithPermission(cwd, currentPermission, () => this.roots, () => this.getLang(), approve, () => ownerId, () => this.approvalRules.list(), base));
+        const composeEdit = (base) => planGate(wrapEditToolWithPermission(cwd, currentPermission, () => this.roots, () => this.getLang(), approve, () => ownerId, () => this.approvalRules.list(), base));
         return [
             {
                 name: "read",
@@ -6197,8 +6819,20 @@ export class ClientSession {
      *  session.reload() 与新会话创建都会把 custom 工具加回活跃集，
      *  所以这两条路径之后都要重放本方法（见 reloadSession/创建处）。 */
     applyToolGating(session, preset) {
-        const targetPreset = preset ?? this.presetOfSession(session) ?? this.settingsSvc.current.defaultAgentPreset ?? "standard";
-        applyAgentToolsGating(session, effectiveDisabledAgentTools(this.settingsSvc.current), targetPreset);
+        const conv = this.convOfSession(session);
+        const targetPreset = preset ??
+            conv?.agentPreset ??
+            this.presetOfSession(session) ??
+            this.settingsSvc.current.defaultAgentPreset ??
+            "standard";
+        const isPlanMode = conv?.planMode === true;
+        const disabled = new Set(effectiveDisabledAgentTools(this.settingsSvc.current));
+        if (isPlanMode) {
+            for (const toolName of PLAN_MODE_BLOCKED_TOOL_NAMES) {
+                disabled.add(toolName);
+            }
+        }
+        applyAgentToolsGating(session, [...disabled], targetPreset);
         this.syncPluginTools(session, targetPreset);
         this.sessionStatsCache = null;
         this.cachedBaseTokens = null;
@@ -6269,8 +6903,8 @@ export class ClientSession {
         this.emit({
             type: "notice",
             level: "info",
-            text: `已切换为「${hit.name}」预设`,
-            textEn: `Switched to preset "${hit.name}"`,
+            text: `已切换为「${localizedName(hit, this.getLang())}」预设`,
+            textEn: `Switched to preset "${localizedName(hit, this.getLang())}"`,
         });
         this.pushSettings();
         this.flushSnapshot();
@@ -6328,10 +6962,207 @@ export class ClientSession {
         this.emit({
             type: "notice",
             level: "info",
-            text: `当前会话权限已切换为「${hit.name}」`,
-            textEn: `Current session permission switched to "${hit.name}"`,
+            text: `当前会话权限已切换为「${localizedName(hit, this.getLang())}」`,
+            textEn: `Current session permission switched to "${localizedName(hit, this.getLang())}"`,
+        });
+        this.flushSnapshot();
+    }
+    /** 该会话是否处于计划模式（ownerId 缺省 = 当前对话）。 */
+    planModeOf(ownerId) {
+        const id = ownerId ?? this.activeId;
+        return this.convs.get(id)?.planMode === true;
+    }
+    /** 审查者模式（自动委派）是否对该 runtime 所属会话开着。 */
+    delegateModeOf(ownerId) {
+        const id = ownerId ?? this.activeId;
+        return this.convs.get(id)?.delegateMode === true;
+    }
+    /** 该会话是否正在跑目标审查回合（awaitingVerdict 置位）：是则写类 / 派发类工具
+     *  走目标审查闸门（server/goal-review-gate.ts）。ownerId 恒为会话 id（创建时传入），
+     *  缺省才回退活动对话 —— 与 planModeOf / delegateModeOf 同口径。 */
+    goalReviewTurnOf(ownerId) {
+        const id = ownerId ?? this.activeId;
+        return this.convs.get(id)?.awaitingVerdict != null;
+    }
+    /**
+     * 切换审查者模式（会话级，默认关）。
+     *  开启后：① 本对话只审阅（写类/派发类工具硬闸门 + 提示词段）；② 用户发的每条
+     *  prompt 由服务端转给一个**常驻落盘执行对话**执行。计划模式优先（两者同开不派活）。
+     */
+    async setDelegateMode(enabled, conversationId) {
+        const target = conversationId ? this.convs.get(conversationId) : this.conv;
+        if (!target)
+            return;
+        if (target.delegateMode === enabled) {
+            this.flushSnapshot();
+            return;
+        }
+        target.delegateMode = enabled;
+        if (!enabled)
+            target.delegateConvId = null; // 关闭后不再指向旧执行对话
+        try {
+            // 与 plan/mode 同口径写进转录：切会话/重载能回放（布尔），执行对话 id 不落盘。
+            const sm = target.session.sessionManager;
+            sm?.appendCustomEntry?.("delegate/mode", { enabled });
+        }
+        catch {
+            // best effort for in-memory sessions
+        }
+        const notice = delegateNoticeText(enabled);
+        this.emit({ type: "notice", level: "info", text: notice.text, textEn: notice.textEn });
+        this.flushSnapshot();
+        // 提示词段随之增减（下一轮生效）；失败不阻断（硬闸门仍拦得住）。
+        try {
+            await target.session.reload?.();
+        }
+        catch {
+            // best effort
+        }
+    }
+    /**
+     * 自动路由：把本轮用户输入转给常驻执行对话执行（审查者模式的干活路径）。
+     *  返回 true = 已接管（调用方不要再跑主会话的模型）；false = 没收走（走正常路径）。
+     *
+     *  与计划模式互斥：计划模式开着时**不派活**（那边已把 spawn/旁路工具全拒，
+     *  再自动派活就是死锁），由计划模式那一轮自己在主对话里出计划。
+     */
+    async dispatchToDelegate(conv, text) {
+        if (conv.delegateMode !== true)
+            return false;
+        if (conv.planMode === true)
+            return false; // 计划模式优先
+        if (this.quiesceBlocked())
+            return false;
+        const trimmed = text.trim();
+        if (!trimmed)
+            return false;
+        let execId = conv.delegateConvId;
+        if (execId && !this.convs.get(execId)?.session)
+            execId = null;
+        // 首轮：第一条 prompt 直接交给 spawnSubagentConversation（它会跑起这一轮）——
+        // **不要再 sendUserMessage 一次**，否则执行对话正在处理中，第二次投递会被
+        // SDK 拒（"Agent is already processing a prompt"）。之后每轮才走追加投递。
+        const firstTurn = !execId;
+        if (firstTurn) {
+            try {
+                // 常驻执行对话：落盘普通对话（进历史、可续聊），与目标模式的执行对话同一通道。
+                // 满员（项目 8 个普通对话）→ 抛错 → 下面提示用户，不会静默把活留在主对话。
+                execId = await this.spawnSubagentConversation(trimmed, "delegate-executor", conv.cwd ?? this.cwd, undefined, null, conv.id, true, pick(this.getLang(), "委派执行", "Delegate executor"));
+                const execConv = this.convs.get(execId);
+                if (execConv)
+                    execConv.title = pick(this.getLang(), "委派执行", "Delegate executor");
+                conv.delegateConvId = execId;
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.emit({
+                    type: "notice",
+                    level: "error",
+                    text: `审查者模式：无法创建执行对话（${msg}）。请关闭审查者模式，或先释放一些对话名额。`,
+                    textEn: `Reviewer mode: could not create the executor conversation (${msg}). Turn reviewer mode off, or free up some conversation slots first.`,
+                });
+                this.flushSnapshot();
+                return false;
+            }
+        }
+        else {
+            const execConv = this.convs.get(execId);
+            if (!execConv?.session)
+                return false;
+            try {
+                await execConv.session.sendUserMessage(trimmed, execConv.session.isStreaming ? { deliverAs: "steer" } : undefined);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                this.emit({
+                    type: "notice",
+                    level: "error",
+                    text: `审查者模式：派活失败（${msg}）`,
+                    textEn: `Reviewer mode: dispatch failed (${msg})`,
+                });
+                this.flushSnapshot();
+                return false;
+            }
+        }
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: `🔎 已派给执行对话：${trimmed.slice(0, 120)}${trimmed.length > 120 ? "…" : ""}（本对话只审阅）`,
+            textEn: `🔎 Dispatched to the executor conversation: ${trimmed.slice(0, 120)}${trimmed.length > 120 ? "…" : ""} (this conversation reviews only)`,
         });
         this.flushSnapshot();
+        // 执行对话跑完 → 回报主对话（只通知，不自动验收：验收由人/主对话下一轮做）。
+        void this.notifyWhenDelegateFinishes(conv, execId);
+        return true;
+    }
+    /** 等常驻执行对话这一轮结束，回主对话一条通知（带它的最后一条回复摘要）。 */
+    async notifyWhenDelegateFinishes(conv, execId) {
+        try {
+            await this.waitConversationTurnEnd(execId, 30 * 60 * 1000);
+        }
+        catch {
+            // 超时/取消：仍给一条「执行对话还没结束」的弱提示，避免主对话永远静默。
+        }
+        const execConv = this.convs.get(execId);
+        if (!execConv)
+            return;
+        const last = [...execConv.session.agent.state.messages]
+            .reverse()
+            .find((m) => m.role === "assistant");
+        const summary = typeof last?.content === "string" ? last.content : JSON.stringify(last?.content ?? "").slice(0, 400);
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: `✅ 执行对话已交付，请审阅：${summary.slice(0, 300)}${summary.length > 300 ? "…" : ""}（左栏「委派执行」可打开看全文）`,
+            textEn: `✅ The executor conversation delivered — review it: ${summary.slice(0, 300)}${summary.length > 300 ? "…" : ""} (open “Delegate executor” in the sidebar for the full transcript)`,
+        });
+        this.flushSnapshot();
+    }
+    /**
+     * 切换计划模式（会话级，只规划不实施）。
+     *  软约束（系统提示词段）+ 硬闸门（写类/旁路工具与非常规 bash 直接拒）双管：
+     *  状态随会话转录落盘（切会话/重载恢复），并即时提示用户当前口径。
+     */
+    async setPlanMode(enabled, conversationId) {
+        const target = conversationId ? this.convs.get(conversationId) : this.conv;
+        if (!target)
+            return;
+        if (target.planMode === enabled) {
+            this.flushSnapshot();
+            return;
+        }
+        target.planMode = enabled;
+        try {
+            // 持久会话：写入转录日志，切会话/重载后回放恢复（与 permission/preset 同口径）。
+            const sm = target.session.sessionManager;
+            sm?.appendCustomEntry?.("plan/mode", { enabled });
+        }
+        catch {
+            // best effort for in-memory sessions
+        }
+        // 动态应用工具门控：开启计划模式时剔除写类工具，关闭时恢复写类工具
+        this.applyToolGating(target.session);
+        // 计划模式有会话准入校验（空白对话也能开，但快照要立刻反映按钮态）。
+        const notice = planModeNoticeText(enabled);
+        this.emit({ type: "notice", level: "info", text: notice.text, textEn: notice.textEn });
+        this.flushSnapshot();
+        // 提示词段随之增减：重建资源让下一轮就带上/去掉计划模式约束。
+        void this.reloadPromptForPlanMode(target);
+    }
+    /**
+     * 提示词重建：切换计划模式后需要让**下一轮**带上/去掉计划模式段
+     * （appendSystemPromptOverride 在资源加载重放时取值）。会话空闲时即时
+     * 重建，用户下一句就生效；重建失败不阻断（硬闸门仍然拦得住）。
+     */
+    async reloadPromptForPlanMode(conv) {
+        try {
+            await conv.session.reload?.();
+            // reload() 重新加载扩展时可能会将工具加回活跃集，重跑一次门控确保写工具被持续剔除
+            this.applyToolGating(conv.session);
+        }
+        catch {
+            // best effort：某些引擎/临时态不支持 reload
+        }
     }
     /** 设置新会话默认权限预设。 */
     async setDefaultPermissionPreset(preset) {
@@ -6350,7 +7181,7 @@ export class ClientSession {
         this.refreshPermission();
         this.flushSnapshot();
     }
-    /** 当前启用的插件 AI 工具定义（provider 快照按 disabledPluginTools 过滤；
+    /** 当前启用的插件 AI 工具定义（provider 快照按 disabledPlugins 与 disabledPluginTools 过滤；
      *  未知/已卸载插件的禁用条目保留但不影响现有工具）。
      *  预设是第二层门控（见 tool-manager.ts 语义总表）：非 standard 预设下插件工具
      *  一律不可用（读写未知，保守处理），此时返回空表，调用方负责从会话移除。 */
@@ -6358,7 +7189,14 @@ export class ClientSession {
         if (!presetAllowsPluginTools(preset))
             return [];
         const off = new Set(normalizeDisabledPluginTools(this.settingsSvc.current.disabledPluginTools));
-        return (this.pluginToolsProvider?.() ?? []).filter((t) => !off.has(t.name)).map(pluginToolToDefinition);
+        const disabledPlugins = new Set(this.settingsSvc.current.disabledPlugins ?? []);
+        return (this.pluginToolsProvider?.() ?? [])
+            .filter((t) => {
+            if (t.pluginId && disabledPlugins.has(t.pluginId))
+                return false;
+            return !off.has(t.name);
+        })
+            .map(pluginToolToDefinition);
     }
     /** 把插件 AI 工具同步进一个已存在的会话（新增/更新/移除；禁用工具同步移除）。
      *  实际 diff 逻辑在 plugins.ts 的 syncPluginToolsIntoSession（可单测）。
@@ -6634,6 +7472,18 @@ export class ClientSession {
      * after the current turn settles, skipping remaining planned tool calls.
      */
     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;
+        }
         // Captured at the START (before any await): the conversation being
         // addressed by this prompt. See the naming block below — a concurrent
         // switch/new_chat while prompt() is in flight must never target a
@@ -6641,6 +7491,54 @@ export class ClientSession {
         const conv = this.conv;
         const promptAc = new AbortController();
         conv.activePromptAc = promptAc;
+        if (conv.planMode === true) {
+            this.applyToolGating(conv.session);
+        }
+        // 审查者模式（自动委派）：本对话只审阅 —— 用户这条 prompt 直接转给常驻执行
+        // 对话执行，主会话这一轮**不跑模型**。接在 promptAc 之后、draft 清理之前：
+        // 转走的内容不该把主对话的草稿也清掉（用户可能还想在主对话里追一句）。
+        // 计划模式优先（那边直接返回 false）。
+        if (await this.dispatchToDelegate(conv, text)) {
+            conv.presetLocked = true;
+            return;
+        }
+        // 目标审查回合进行中：纯文本插话顺延到 verdict 落定后（steer 进去会污染
+        // verdict，一次插话烧掉整个目标；followUp 由 SDK 排在整轮结束后才送达，
+        // 本来就安全所以只拦 steer）。斜杠命令直通（原生配置类不进模型）；带附件 /
+        // 图片的不顺延（附件引用只在发送瞬间有效）→ 响亮拒绝，草稿保留在输入框。
+        // 判定抽成纯函数（server/goal-review-gate.ts），单测见 goal-review-gate.test.ts。
+        if (shouldDeferPromptForReview({
+            queue,
+            text,
+            hasAttachments: !!attachments && attachments.length > 0,
+            awaitingVerdict: conv?.awaitingVerdict != null,
+        })) {
+            const gc = conv;
+            (gc.deferredPrompts ??= []).push(text);
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: "审查回合进行中，你的消息已排队（审查结束后自动发送，不会打断审查）。",
+                textEn: "A review round is running; your message is queued and will be sent automatically when it ends (without interrupting the review).",
+            });
+            this.flushSnapshot();
+            return;
+        }
+        if (!queue &&
+            !text.trim().startsWith("/") &&
+            !!attachments &&
+            attachments.length > 0 &&
+            conv?.awaitingVerdict != null) {
+            // 带附件的插话不顺延也不 steer：直接拒绝，用户稍后重发（草稿还在输入框）。
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: "审查回合进行中：带附件/图片的消息请等审查结束后再发（文本草稿已保留）。",
+                textEn: "A review round is running; please resend messages with attachments/images after it ends (your draft is kept).",
+            });
+            this.flushSnapshot();
+            return;
+        }
         // 输入框内容被消费（发送/斜杠执行）→ 清掉该会话存过的草稿（best-effort）。
         // 快捷短语发送（不碰输入框）同样清：客户端发送成功后会把当前草稿重存回来。
         // clear() 同时记录 clear 时间戳水位：清掉之后才 landing 的旧 draft_update
@@ -6942,6 +7840,12 @@ export class ClientSession {
                 // 立刻要有它（此刻还在流式输出，不能等 agent_end 的防抖刷新）。
                 this.emitConversations();
             }
+            // 置换守卫：从这一刻起进入异步前置（附件构建 + 影子快照）——在它们完成前
+            // 对话既不 streaming 也没有新消息落盘，displaceActive() 会把它误判成
+            // 空闲对话并销毁 runtime，导致投递中的消息被静默丢弃。放在所有同步校验 /
+            // 原生斜杠命令拦截之后：原生命令（/new, /cwd 等）不进投递流程且可能
+            // 立即切换会话，若提前置位会被 displaceActive 误判为有消息投递而报错通知。
+            conv.promptInFlight = true;
             // Attach files as independent nextTurn context messages (asides) so the
             // user message stays clean; they render as separate attachment cards.
             const asides = await buildAttachmentMessages({
@@ -6982,6 +7886,16 @@ export class ClientSession {
                 return;
             }
             conv.activePromptAc = undefined;
+            // 前置阶段（附件 / 影子快照）期间用户可能已经切走或新建了对话：消息仍然
+            // 落在本对话里，指给用户看，免得「发出去的消息不见了」。
+            if (conv.id !== this.activeId) {
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `消息已投递到「${conv.title}」——你刚切换了对话，它不在当前对话里`,
+                    textEn: `Message delivered to "${conv.title}" — you switched conversations before it landed`,
+                });
+            }
             if (s.isStreaming) {
                 // queue=true (补充 button) → followUp: the message is delivered only
                 // after the whole run finishes — the agent finishes what it started,
@@ -7030,6 +7944,11 @@ export class ClientSession {
                 textEn: `Failed to send prompt: ${err.message}`,
             });
         }
+        finally {
+            // 无论走哪条出口（斜杠命令 / quiesce 拒绝 / 中止 / 抛错 / 正常落定），
+            // 投递窗口都结束了；留着 true 会让这条对话永远不被置换。
+            conv.promptInFlight = false;
+        }
         // The active conversation (captured at prompt start — see above) has been
         // continued since it was opened — it must not be dismissed when the user
         // switches away. (Also bumps the per-project "most recently active"
@@ -7529,8 +8448,8 @@ export class ClientSession {
                 this.emit({
                     type: "notice",
                     level: "warning",
-                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先打开某个对话并离开（不继续对话）以移出列表`,
-                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list.`,
+                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先移出不需要的对话（打开后离开不继续对话即移出；钉住的对话需先取消钉住）`,
+                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list; pinned chats must be unpinned first.`,
                 });
                 return false;
             }
@@ -7901,11 +8820,22 @@ export class ClientSession {
                 openTerminals: conv.terminals.countBlockingLive(),
                 listed: conv.listed,
                 promptedSinceActive: conv.promptedSinceActive,
+                pinned: conv.pinned,
+                // 投递中的消息（附件构建 / 影子快照阶段）：见 Conversation.promptInFlight。
+                promptInFlight: Boolean(conv.promptInFlight),
                 hasActiveSubagentRun: () => hasActiveSubagentRun({ sessionId: conv.session.sessionFile }),
                 hasPendingWake: () => hasPendingWaitSubscription({ sessionId: conv.session.sessionFile }),
             });
         if (retained) {
             conv.listed = true;
+            if (conv.promptInFlight && !conv.session.isStreaming) {
+                this.emit({
+                    type: "notice",
+                    level: "info",
+                    text: `「${conv.title}」的消息正在投递，已为你保留该对话`,
+                    textEn: `"${conv.title}" is still sending your message — kept in the running list`,
+                });
+            }
             return null;
         }
         return conv;
@@ -7917,6 +8847,20 @@ export class ClientSession {
         const conv = this.convs.get(id);
         if (!conv || id === this.activeId)
             return;
+        // 正在投递的消息（附件构建 / 影子快照阶段）必须先打断：否则 prompt() 醒来
+        // 后会把用户消息写进已销毁的 runtime，静默丢失。
+        if (conv.activePromptAc) {
+            conv.activePromptAc.abort();
+            conv.activePromptAc = undefined;
+        }
+        // 角色轮等待者：对话被移出 → 等它的循环收到 gone（否则要等到超时）。
+        const waiters = this.turnEndWaiters.get(id);
+        if (waiters) {
+            this.turnEndWaiters.delete(id);
+            // 先摘表再逐个唤醒：回调里的自删不会弄脏迭代。
+            for (const fn of waiters)
+                fn("gone");
+        }
         // 对话真关闭（dismiss/释放）→ 放掉它的认领。过户不走这里（对话换个会话
         // 继续，owner 不变，认领继续有效），所以只在此处释放。
         try {
@@ -8310,6 +9254,7 @@ export class ClientSession {
                     return pq ? { hasQuestion: true, questionId: pq.id, questionTitle: pq.title } : {};
                 })(),
                 parentId: conv.parentId,
+                ...(conv.pinned ? { pinned: true } : {}),
                 ...(conv.forkFrom ? { forkFrom: conv.forkFrom } : {}),
             });
         }
@@ -8355,30 +9300,97 @@ export class ClientSession {
      * pushSessions() and searchSessions() share this fridge — opening the
      * panel warms it, then every keystroke inside the TTL is free.
      */
-    sessionInfosCache = null;
-    static SESSION_INFO_CACHE_TTL = 3000;
-    /** 最近项目列表缓存：pushProjects 的全量扫盘（SessionManager.listAll +
-     *  existsSync 逐个校验）昂贵，切项目/新对话/跨客户端通知时频繁触发 ——
-     *  TTL 内直接复用并把当前 cwd 合并进去，不反复扫盘。 */
-    projectsCache = null;
-    static PROJECTS_CACHE_TTL = 15_000;
-    projectsInFlight = null;
+    /** 最近项目列表缓存：跨客户端共享静态缓存，TTL 窗口内直接复用。 */
+    static projectsCache = null;
+    static PROJECTS_CACHE_TTL = 60_000;
+    static projectsInFlight = null;
+    /** 会话单文件 stat 缓存（path -> { mtime, size, info }）：避免对未修改的会话文件重复读取与 JSON 解析。 */
+    static sessionFileCache = new Map();
+    /** 会话列表缓存（按 cwdKey 隔离，30s TTL）。 */
+    static sessionInfosCache = new Map();
+    static sessionInfosInFlight = new Map();
+    static SESSION_INFO_CACHE_TTL = 30_000;
     async loadSessionInfos() {
         const now = Date.now();
-        const c = this.sessionInfosCache;
-        if (c && c.cwd === this.cwd && now - c.at < ClientSession.SESSION_INFO_CACHE_TTL) {
+        const cwdKey = normalizePathKey(this.cwd);
+        const c = ClientSession.sessionInfosCache.get(cwdKey);
+        if (c && now - c.at < ClientSession.SESSION_INFO_CACHE_TTL) {
             return c.infos;
         }
-        const infos = await SessionManager.list(this.cwd, piSessionsRoot());
-        this.sessionInfosCache = { cwd: this.cwd, infos, at: now };
-        return infos;
+        const inFlight = ClientSession.sessionInfosInFlight.get(cwdKey);
+        if (inFlight)
+            return inFlight;
+        const run = (async () => {
+            try {
+                const sessionDir = piSessionsRoot()
+                    ? resolve(piSessionsRoot())
+                    : SessionManager.create(this.cwd).getSessionDir();
+                if (!existsSync(sessionDir))
+                    return [];
+                const dirEntries = await fsPromises.readdir(sessionDir);
+                const files = dirEntries.filter((f) => f.endsWith(".jsonl"));
+                if (files.length === 0)
+                    return [];
+                // Stat files to detect modified/new files (takes only ~8ms for 600+ files)
+                const stats = await Promise.all(files.map(async (f) => {
+                    const fp = join(sessionDir, f);
+                    try {
+                        const st = await fsPromises.stat(fp);
+                        return { path: fp, mtime: st.mtimeMs, size: st.size };
+                    }
+                    catch {
+                        return null;
+                    }
+                }));
+                const validStats = stats.filter((s) => s !== null);
+                validStats.sort((a, b) => b.mtime - a.mtime);
+                const candidates = validStats.slice(0, 200);
+                const results = await Promise.all(candidates.map(async (file) => {
+                    const cached = ClientSession.sessionFileCache.get(file.path);
+                    if (cached && cached.mtime === file.mtime && cached.size === file.size) {
+                        return cached.info;
+                    }
+                    const info = await parseSessionInfoFast(file.path, file.mtime);
+                    if (info) {
+                        ClientSession.sessionFileCache.set(file.path, {
+                            mtime: file.mtime,
+                            size: file.size,
+                            info,
+                        });
+                    }
+                    return info;
+                }));
+                const validInfos = results.filter((info) => info !== null);
+                validInfos.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+                ClientSession.sessionInfosCache.set(cwdKey, { infos: validInfos, at: Date.now() });
+                return validInfos;
+            }
+            catch {
+                try {
+                    const fallback = await SessionManager.list(this.cwd, piSessionsRoot());
+                    ClientSession.sessionInfosCache.set(cwdKey, { infos: fallback, at: Date.now() });
+                    return fallback;
+                }
+                catch {
+                    return [];
+                }
+            }
+            finally {
+                ClientSession.sessionInfosInFlight.delete(cwdKey);
+            }
+        })();
+        ClientSession.sessionInfosInFlight.set(cwdKey, run);
+        return run;
     }
     /** Session files on disk changed (delete / new-transcript) — drop the brief
      *  TTL fridge so the NEXT listing re-reads the directory instead of serving
      *  the pre-mutation snapshot (delete-then-refresh commonly runs inside the
      *  window, which would re-push the just-removed session). */
-    invalidateSessionInfos() {
-        this.sessionInfosCache = null;
+    invalidateSessionInfos(filePath) {
+        ClientSession.sessionInfosCache.clear();
+        if (filePath) {
+            ClientSession.sessionFileCache.delete(resolve(filePath));
+        }
     }
     /** Push the persisted session list to the client (client-requested). */
     async refreshSessions() {
@@ -8482,7 +9494,7 @@ export class ClientSession {
             }
             if (holder) {
                 // Same source the history panel uses (refreshSessions): newest first.
-                const infos = await SessionManager.list(this.cwd, piSessionsRoot());
+                const infos = await this.loadSessionInfos();
                 const next = infos
                     .filter((s) => resolve(s.path) !== abs)
                     .sort((a, b) => b.modified.getTime() - a.modified.getTime())[0];
@@ -8550,7 +9562,7 @@ export class ClientSession {
             // Bust the brief session-info fridge: refreshSessions() below usually
             // lands inside its 3s TTL and would otherwise re-serve a listing that
             // still contains the deleted transcript.
-            this.invalidateSessionInfos();
+            this.invalidateSessionInfos(abs);
             await this.refreshSessions();
         }
         catch (err) {
@@ -8583,7 +9595,7 @@ export class ClientSession {
             const mgr = SessionManager.open(abs);
             mgr.appendSessionInfo(trimmed);
             this.setConversationTitleForFile(abs, trimmed);
-            this.invalidateSessionInfos();
+            this.invalidateSessionInfos(abs);
             await this.refreshSessions();
         }
         catch (err) {
@@ -8595,6 +9607,55 @@ export class ClientSession {
             });
         }
     }
+    /** 钉住 / 取消钉住某个对话（左栏右键菜单）。钉住后切走也不从「运行的对话」
+     *  释放（见 shouldRetainActive 的 pinned 判据，最高优先级）；取消钉住不立即
+     *  释放，下一次自然置换时按常规规则处理。*/
+    async setConversationPinned(id, pinned) {
+        const conv = this.convs.get(id);
+        if (!conv) {
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: "该对话不存在或已关闭",
+                textEn: "This conversation does not exist or is already closed",
+            });
+            return;
+        }
+        // 子代理本来就永久豁免置换（displaceActive 开头即返回），钉子对它们无意义。
+        if (conv.isSubagent) {
+            this.emit({
+                type: "notice",
+                level: "info",
+                text: "子代理对话始终保留在运行列表，无需钉住",
+                textEn: "Subagent chats always stay in the running list — no need to pin",
+            });
+            return;
+        }
+        if (pinned === !!conv.pinned) {
+            this.emitConversations();
+            return;
+        }
+        if (pinned) {
+            conv.pinned = true;
+            // 立即进入运行列表（含空白对话）：listed 一旦置位，shownInRunningList 即放行。
+            conv.listed = true;
+        }
+        else {
+            delete conv.pinned;
+        }
+        this.emitConversations();
+        this.flushSnapshot();
+        this.emit({
+            type: "notice",
+            level: "info",
+            text: pinned
+                ? `已钉住对话「${conv.title}」，切换其他对话不会将它移出运行列表`
+                : `已取消钉住对话「${conv.title}」，下次切换离开时按常规规则处理`,
+            textEn: pinned
+                ? `Pinned "${conv.title}" — switching away keeps it in the running list`
+                : `Unpinned "${conv.title}" — it will be handled by the usual rules on the next switch`,
+        });
+    }
     /** Rename a live conversation by id: retitle in memory AND persist a
      *  session_info entry to its transcript so History matches immediately. */
     async renameConversation(id, name) {
@@ -8660,6 +9721,7 @@ export class ClientSession {
             // Dismiss 口径：只看“用过”的用户终端（AI bash 不钉住，见上）。
             openTerminals: conv.terminals.countUserBlockingLive(),
             listed: false,
+            promptInFlight: Boolean(conv.promptInFlight),
             promptedSinceActive: false,
             hasActiveSubagentRun: () => hasActiveSubagentRun({ sessionId: conv.session.sessionFile }),
             hasPendingWake: () => hasPendingWaitSubscription({ sessionId: conv.session.sessionFile }),
@@ -8842,6 +9904,7 @@ export class ClientSession {
             openTerminals: 0,
             listed: conv.listed,
             promptedSinceActive: conv.promptedSinceActive,
+            promptInFlight: Boolean(conv.promptInFlight),
             hasActiveSubagentRun: () => hasActiveSubagentRun({ sessionId: conv.session.sessionFile }),
             hasPendingWake: () => hasPendingWaitSubscription({ sessionId: conv.session.sessionFile }),
         })) {
@@ -9090,6 +10153,7 @@ export class ClientSession {
             // Dismiss 口径：只看“用过”的用户终端（issue #181，AI bash 不钉住）。
             openTerminals: conv.terminals.countUserBlockingLive(),
             listed: false,
+            promptInFlight: Boolean(conv.promptInFlight),
             promptedSinceActive: false,
             hasActiveSubagentRun: () => hasActiveSubagentRun({ sessionId: conv.session.sessionFile }),
             hasPendingWake: () => hasPendingWaitSubscription({ sessionId: conv.session.sessionFile }),
@@ -9234,8 +10298,8 @@ export class ClientSession {
                 this.emit({
                     type: "notice",
                     level: "warning",
-                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先打开某个对话并离开（不继续对话）以移出列表`,
-                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list.`,
+                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先移出不需要的对话（打开后离开不继续对话即移出；钉住的对话需先取消钉住）`,
+                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list; pinned chats must be unpinned first.`,
                 });
                 return;
             }
@@ -9324,6 +10388,21 @@ export class ClientSession {
         // 兜底：getEntry 查整棵树
         return found ?? conv.session.sessionManager.getEntry(messageId) ?? null;
     }
+    /**
+     * 获取被某个压缩卡片折叠的历史消息（issue #398，按需惰性加载）。
+     */
+    getCompactedMessages(compactionMessageId, targetConvId) {
+        const targetConv = (targetConvId ? this.convs.get(targetConvId) : this.conv) ?? this.conv;
+        const sm = targetConv.session.sessionManager;
+        const result = getCompactedMessages(sm, compactionMessageId, (m) => this.uiMessageKey(targetConv, m).n);
+        this.emit({
+            type: "compacted_messages_result",
+            compactionMessageId,
+            conversationId: targetConv.id,
+            messages: result.messages,
+            error: result.error,
+        });
+    }
     /**
      * Fork a NEW branch conversation from a specific historical message position.
      * Truncates the transcript before (or at) that message as the context of the
@@ -9420,8 +10499,8 @@ export class ClientSession {
                 this.emit({
                     type: "notice",
                     level: "warning",
-                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先打开某个对话并离开（不继续对话）以移出列表`,
-                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list.`,
+                    text: `当前项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先移出不需要的对话（打开后离开不继续对话即移出；钉住的对话需先取消钉住）`,
+                    textEn: `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list; pinned chats must be unpinned first.`,
                 });
                 return;
             }
@@ -9681,16 +10760,16 @@ export class ClientSession {
      */
     async pushProjects() {
         const now = Date.now();
-        const cached = this.projectsCache;
+        const cached = ClientSession.projectsCache;
         // TTL 命中：直接复用（把当前 cwd 合并进去，刚 remember 的新项目也可见）。
         if (cached && now - cached.at < ClientSession.PROJECTS_CACHE_TTL) {
             this.emit({ type: "projects", projects: this.withCurrentCwd(cached.projects, now) });
             return;
         }
         // 已有扫描在跑：搭车等它，不要并发扫两遍盘。
-        if (this.projectsInFlight) {
+        if (ClientSession.projectsInFlight) {
             try {
-                const projects = await this.projectsInFlight;
+                const projects = await ClientSession.projectsInFlight;
                 if (projects)
                     this.emit({ type: "projects", projects: this.withCurrentCwd(projects, Date.now()) });
             }
@@ -9699,43 +10778,31 @@ export class ClientSession {
             }
             return;
         }
+        // 执行轻量磁盘发现（仅读会话文件首行头部获取 cwd，不解析全部消息历史）
+        const sessionRoots = [resolve(this.agentDir, "sessions")];
+        const extra = piSessionsRoot();
+        if (extra)
+            sessionRoots.push(resolve(extra));
         const run = (async () => {
             try {
-                const saved = this.stateStore.get(this.clientId);
-                const removedProjects = new Set(this.stateStore.getRemovedProjects(this.clientId).map(normalizePathKey));
-                const map = new Map();
-                for (const p of saved.projects)
-                    map.set(p.path, p.lastUsed);
-                const all = await SessionManager.listAll(piSessionsRoot());
-                for (const s of all) {
-                    if (s.cwd) {
-                        const t = s.modified.getTime();
-                        const prev = map.get(s.cwd);
-                        if (prev === undefined || t > prev)
-                            map.set(s.cwd, t);
-                    }
-                }
-                // Only keep directories that still exist — a deleted/unmounted workspace
-                // is useless in the picker. Tombstoned entries (explicitly removed by
-                // the user) stay hidden even though session files still mention them.
-                const projects = [...map.entries()]
-                    .filter(([path]) => !removedProjects.has(normalizePathKey(path)) && existsSync(path))
-                    .map(([path, lastUsed]) => ({ path, lastUsed }))
-                    .sort((a, b) => b.lastUsed - a.lastUsed)
-                    .slice(0, 20);
-                this.projectsCache = { at: Date.now(), projects };
-                this.emit({ type: "projects", projects });
-                return projects;
+                const discovered = await discoverRecentProjectsFromDisk(sessionRoots, 30);
+                this.stateStore.mergeDiscoveredProjects(discovered);
+                const merged = this.stateStore.getRecentProjects(this.clientId);
+                ClientSession.projectsCache = { at: Date.now(), projects: merged };
+                const result = this.withCurrentCwd(merged, Date.now());
+                this.emit({ type: "projects", projects: result });
+                return merged;
             }
             catch {
-                this.emit({ type: "projects", projects: [] });
-                return null;
+                const fallback = this.withCurrentCwd(this.stateStore.getRecentProjects(this.clientId), Date.now());
+                this.emit({ type: "projects", projects: fallback });
+                return fallback;
             }
             finally {
-                this.projectsInFlight = null;
+                ClientSession.projectsInFlight = null;
             }
         })();
-        this.projectsInFlight = run;
+        ClientSession.projectsInFlight = run;
         await run;
     }
     /** 缓存命中时把当前 cwd 并进去：命中则刷新 lastUsed 重排，未命中则补到首位
@@ -9756,7 +10823,7 @@ export class ClientSession {
     }
     /** 最近项目缓存失效（用户显式移除项目后，下一次推送必须重扫）。 */
     invalidateProjectsCache() {
-        this.projectsCache = null;
+        ClientSession.projectsCache = null;
     }
     /** List a workspace directory (relative to the configured cwd). */
     async listFiles(relPath) {
@@ -10493,8 +11560,13 @@ export function checkPluginCwd(cwd) {
     }
     return { ok: true, abs };
 }
+/** 插件/调度伪客户端：sink 常驻（fire-and-forget 的空函数），不能按浏览器存活判断。 */
+export function isPseudoClientId(id) {
+    return id.startsWith("plugin:") || id.startsWith("scheduler:");
+}
 export class AgentService {
     cwd;
+    static isPseudoClientId = isPseudoClientId;
     /** index.ts 注入：SDK 工具执行事件的插件转发钩子，attach 时拷贝到每个新会话。 */
     onToolEvent = undefined;
     /** index.ts 注入：bash/read 插件拦截钩子，attach 时拷贝到每个新会话。 */
@@ -10808,10 +11880,16 @@ export class AgentService {
                 continue;
             // issue #291：跳过无浏览器连接的残骸（非伪客户端 sinkCount=0 = 断连留存）。
             // 伪客户端（scheduler:/plugin:）不走浏览器，sinkCount 永远为 0，保留。
-            if (!AgentService.isPseudoClientId(clientId) && cs.sinkCount() === 0)
+            const isPseudo = AgentService.isPseudoClientId(clientId);
+            if (!isPseudo && cs.sinkCount() === 0)
                 continue;
-            for (const r of cs.streamingSummariesAll())
-                out.push({ ...r, owner: clientId });
+            for (const r of cs.streamingSummariesAll()) {
+                out.push({
+                    ...r,
+                    owner: clientId,
+                    ...(isPseudo ? { pseudo: true } : {}),
+                });
+            }
         }
         return out;
     }
@@ -11086,10 +12164,7 @@ export class AgentService {
             service: toServiceInfo(launchOrigin()),
         };
     }
-    /** 插件/调度伪客户端：sink 常驻（fire-and-forget 的空函数），不能按浏览器存活判断。 */
-    static isPseudoClientId(id) {
-        return id.startsWith("plugin:") || id.startsWith("scheduler:");
-    }
+    // （原 private static isPseudoClientId 已抽到模块级导出并挂为 static 属性）
     /**
      * 浏览器重启认领：给 fresh clientId 找一个可接管的断开残留会话（返回旧 id）。
      * 有别的在线浏览器时返回 null（issue #10 隔离优先）。
@@ -11186,7 +12261,7 @@ export class AgentService {
             return;
         }
         if (AgentService.isPseudoClientId(ownerId)) {
-            fail("定时任务/插件会话不支持过户", "Scheduler/plugin sessions cannot be taken over.");
+            fail("定时任务/插件会话不支持过户 —— 报告会自动落回绑定的对话，可在后台任务面板查看进度", "Scheduler/plugin sessions cannot be taken over — reports are saved to the bound conversation automatically; check progress in the Background Tasks panel.");
             return;
         }
         const source = this.clients.get(ownerId);
@@ -11212,7 +12287,7 @@ export class AgentService {
         const movedMains = briefs.filter((b) => moveSet.has(b.id) && !b.isSubagent && !b.isEphemeral).length;
         const openInProject = target.takeoverBriefs().filter((b) => b.cwd === main.cwd && !b.isSubagent && !b.isEphemeral).length + movedMains;
         if (openInProject > MAX_OPEN_CONVERSATIONS) {
-            fail(`目标项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先打开某个对话并离开（不继续对话）以移出列表`, `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list.`);
+            fail(`目标项目运行的对话已达上限（${MAX_OPEN_CONVERSATIONS} 个），请先移出不需要的对话（打开后离开不继续对话即移出；钉住的对话需先取消钉住）`, `This project already has the max open conversations (${MAX_OPEN_CONVERSATIONS}). Open one and leave it (without continuing) to remove it from the list; pinned chats must be unpinned first.`);
             return;
         }
         try {
@@ -11266,7 +12341,7 @@ export class AgentService {
         if (ownerId === targetId)
             return; // 自己的问卷走本地通道，不需要预告
         if (AgentService.isPseudoClientId(ownerId)) {
-            fail("定时任务/插件会话的问卷不支持跨页作答", "Scheduler/plugin session questions cannot be answered cross-page.");
+            fail("定时任务/插件会话的问卷不支持跨页作答 —— 报告会自动落回绑定的对话，可在后台任务面板查看进度", "Scheduler/plugin session questions cannot be answered cross-page — reports are saved to the bound conversation automatically; check progress in the Background Tasks panel.");
             return;
         }
         const source = this.clients.get(ownerId);