pi-web-ui 0.96.1 → 0.98.0

package/dist/server/agent-service.js

@@ -14,13 +14,16 @@
 // 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 { appendFileSync, existsSync, readFileSync, renameSync, rmSync, statSync, mkdirSync, watch, writeFileSync, } from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import { appendFileSync, existsSync, readFileSync, rmSync, statSync, mkdirSync, watch, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, delimiter, dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { writeAtomicSync } from "./atomic-file.js";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, createEditToolDefinition, createLocalBashOperations, createWriteToolDefinition, getAgentDir, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { BgServerTracker } from "./bg-servers.js";
@@ -34,7 +37,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 +52,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, readPlanFromSession } 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";
@@ -59,7 +67,7 @@ import { makeEditSoftTool } from "./edit-soft-tool.js";
 // 覆盖 SDK 内置 read：路径是目录时列出目录条目（行为开关 readDirEnabled，默认开）。
 // 覆盖定义与「与扩展同名工具共存」的注入辅助分在两个文件（后者的依据见 tool-overrides.ts）。
 import { makeReadDirTool, withReadDirSupport } from "./read-tool.js";
-import { installToolOverrides, } from "./tool-overrides.js";
+import { installToolOverrides, syncSubagentOverride, } from "./tool-overrides.js";
 // 展示文件给用户（present_files）：图片/视频内联、文本开预览弹窗、本地打开按钮。
 import { makePresentFilesTool } from "./present-files-tool.js";
 // 主动压缩上下文工具（compact_context）：AI 主动根据当前问题精简上下文并自主控制范围。
@@ -75,15 +83,17 @@ 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";
 import { sameSessionFile } from "./scheduler-tasks.js";
 import { buildAttachmentMessages, parseModelSpec } from "./attachments.js";
+import { formatQuotedPrompt, readTextQuote } from "./text-quote.js";
 import { buildVisionBridgePrompt, findVisionModels, transcribeImages } from "./vision-bridge.js";
 import { isNotRepoError, scmCommitContext } from "./scm.js";
 import { buildCommitMsgInput, buildCommitMsgPrompt, sanitizeCommitMessage } from "./scm-commitmsg.js";
-import { BUILTIN_SOUL, DEFAULT_PROMPT_TEMPLATE, buildToolsSchemaText, estimatePromptTokens, renderPromptTemplate, resolveSectionTexts, } from "./prompt-composer.js";
+import { BUILTIN_SOUL, DEFAULT_PROMPT_TEMPLATE, buildToolsSchemaText, estimatePromptTokens, renderPromptTemplate, resolveSectionTexts, splitExtensionWrap, } from "./prompt-composer.js";
 import { launchOrigin, toServiceInfo } from "./launch-origin.js";
 import { findEntryByUiId, serializeMessage, serializeStreamingMessage, stripTransientRetryErrors, } from "./serialize.js";
 import { loadCommands, saveCommandsFile, TerminalManager } from "./terminals.js";
@@ -151,6 +161,25 @@ export class QuiesceRejectedError extends Error {
 /** 自家内联扩展名（组合模板渲染，见 prompt-composer.ts）。SDK 以其
  *  "<inline:<name>>" 作为 path；扩展白名单/禁用过滤必须放行它。 */
 const INLINE_PERSONA_EXT = "<inline:pi-webui-persona>";
+/** 本次 run 的 SDK 原始提示词 + 早前扩展的首尾增补（见 splitExtensionWrap）。
+ *  导出仅为单测（tests/unit/persona-prompt-chain.test.ts）可达。
+ *  systemPromptOptions 就是 runner 里那个共享可变对象，forceSystemPrompt 有值即
+ *  说明前面有扩展替换过提示词；临时清掉再读 event.systemPrompt 就拿到原始基线
+ *  （公开字段，不碰 SDK 内部）。没人动过时零开销，直接返回当前文本。 */
+export function splitAgentStartPrompt(event) {
+    const current = event.systemPrompt;
+    const opts = event.systemPromptOptions;
+    const forced = opts?.forceSystemPrompt;
+    if (!opts || typeof forced !== "string")
+        return { pre: "", core: current, post: "" };
+    try {
+        opts.forceSystemPrompt = undefined;
+        return splitExtensionWrap(event.systemPrompt, current);
+    }
+    finally {
+        opts.forceSystemPrompt = forced;
+    }
+}
 /** Pi 包文档路径（composer 的 {{pi_docs}} 自动内容用）。随安装位置解析一次。 */
 const PI_DOC_PATHS = (() => {
     try {
@@ -266,6 +295,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 → 直接阻断；
@@ -651,7 +759,7 @@ function wrapEditSoftToolWithPermission(tool, cwd, getPermission, getRoots, getL
 /**
  * 结构化任务执行计划更新工具（plan_update）— Plan Mode / Step State Machine。
  */
-export function makePlanUpdateTool(planManager, getActiveConvId, emit, flushSnapshot) {
+export function makePlanUpdateTool(planManager, getActiveConvTarget, emit, flushSnapshot, onPersist) {
     return {
         name: PLAN_UPDATE_TOOL_NAME,
         label: "plan_update",
@@ -666,7 +774,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.",
                 })),
@@ -674,9 +786,21 @@ export function makePlanUpdateTool(planManager, getActiveConvId, emit, flushSnap
             activeStepId: Type.Optional(Type.String({ description: "ID of the step currently being executed" })),
         }),
         execute: async (toolCallId, params) => {
-            const convId = getActiveConvId();
+            const target = getActiveConvTarget();
+            const convId = typeof target === "string" ? target : target.id;
+            const sessionId = typeof target === "string" ? undefined : target.sessionId;
             const p = params;
-            const plan = planManager.setPlan(convId, p.steps, p.activeStepId);
+            const plan = planManager.setPlan(convId, p.steps, p.activeStepId, sessionId);
+            if (typeof target !== "string" && target.sessionManager) {
+                try {
+                    const sm = target.sessionManager;
+                    sm?.appendCustomEntry?.("plan/update", { plan });
+                }
+                catch {
+                    // 转录追加失败不影响主流程
+                }
+            }
+            onPersist?.(convId, plan);
             emit({
                 type: "plan_updated",
                 conversationId: convId,
@@ -718,6 +842,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 +882,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,
             }),
@@ -1095,6 +1218,14 @@ function pluginToolToDefinition(tool) {
  * unlikely to matter).
  */
 function contentFingerprint(m) {
+    const summary = m.summary;
+    if (typeof summary === "string" && summary.length > 0) {
+        let h = 5381;
+        for (let i = 0; i < summary.length && i < 512; i++) {
+            h = ((h << 5) + h + summary.charCodeAt(i)) >>> 0;
+        }
+        return `sum:${h.toString(36)}:${summary.length}`;
+    }
     const content = m.content;
     if (!Array.isArray(content) || content.length === 0)
         return "empty";
@@ -1169,31 +1300,10 @@ function previewToolResult(result) {
     }
 }
 /**
- * 转录整文件重写的原子落盘：先写同目录临时文件再 rename。转录是 append-only
- * 的唯一事实源，compaction 收尾/清理的整文件重写若中途被打断（进程被杀/断电），
- * 原地 writeFileSync 会留下截断的 JSONL；同目录 rename 是原子的，最坏情况是
- * 旧文件原样保留，绝不会出现半份转录。Windows 下目标被外部占用（阅读器/杀软
- * 锁）时 rename 可能 EPERM —— 退回原地写保住功能（旧行为），不因小概率锁失败丢更新。
+ * 转录整文件重写的原子落盘：先写同目录临时文件再 rename。
  */
 function atomicWriteFileSync(file, data) {
-    const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
-    try {
-        writeFileSync(tmp, data);
-        try {
-            renameSync(tmp, file);
-        }
-        catch {
-            writeFileSync(file, data);
-        }
-    }
-    finally {
-        try {
-            rmSync(tmp, { force: true });
-        }
-        catch {
-            // 临时文件清不掉只能留给下次（同目录 .tmp，不影响转录本身）
-        }
-    }
+    writeAtomicSync(file, data);
 }
 /** Cap on simultaneously open NON-subagent conversations of ONE project (each keeps a full
  *  runtime alive; conversations of other projects keep their own lists).
@@ -1248,18 +1358,17 @@ function conversationTitle(session) {
     }
     return DEFAULT_CONV_TITLE;
 }
-/** 全局搜索的会话匹配：大小写不敏感，命中任一项即算 ——
- *  显示名、当前项目内的文件名片段、首条消息，以及完整转录文本
- *  （SDK 的 allMessagesText 包含每一段 user 与 assistant 消息，AI 输出也在内）。 */
-function sessionMatchesSearch(q, s) {
+/** 全局搜索的会话元信息匹配：大小写不敏感，命中任一项即算 ——
+ *  显示名、当前项目内的文件名片段、首条消息。
+ *  转录全文匹配不在这里：全文单条可达 MB 级，不再随列表缓存常驻（issue #440），
+ *  由 filterSessionsForSearch 按需加载后判定（口径不变：user 与 assistant 消息文本）。 */
+function sessionMatchesMetadata(q, s) {
     if (s.name && s.name.toLowerCase().includes(q))
         return true;
     if (basename(s.path).toLowerCase().includes(q))
         return true;
     if (s.firstMessage.toLowerCase().includes(q))
         return true;
-    if (s.allMessagesText.toLowerCase().includes(q))
-        return true;
     return false;
 }
 /** 抽取一条 AgentMessage 的可搜索文本（user/assistant 的 text 块；
@@ -1283,6 +1392,12 @@ function messageSearchText(m) {
 /** 转录全文扫描/整读的大小上限（16MB，与 readHistorySession 一致）：
  *  超限文件同步 readFileSync 会卡事件循环数百毫秒起，搜索不值得。 */
 const MAX_TRANSCRIPT_SCAN_BYTES = 16 * 1024 * 1024;
+/** 转录全文进入内存/缓存的字符上限（256K 字符）：全文只服务搜索的命中判定
+ *  （issue #440 拆分后按需加载），封顶保证单条 worst case 内存可控（缓存 256 条
+ *  × 256K 字符 ≈ 64MB 上界，且只在搜索活动期间存在）。
+ *  影响面：超长转录在截断点之后的内容不参与「是否命中」判定；命中后的消息级
+ *  定位（collectSessionAnchors）仍扫全文件，不受此上限影响。 */
+const MAX_SEARCH_TEXT_CHARS = 256 * 1024;
 /** 扫描一个会话转录文件，收集文本命中查询的消息锚点（role + timestamp，
  *  按转录顺序，最多 cap 个）。仅 user/assistant 消息参与，与搜索范围一致。
  *  超过大小上限的转录直接跳过（stat 先行，不整读）—— 全局搜索逐会话同步
@@ -1361,6 +1476,253 @@ 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 {
+            // 异步探测（issue #441）：会话根可能在已断连的网络盘上，同步 existsSync 会冻结事件循环。
+            try {
+                await fsPromises.access(root);
+            }
+            catch {
+                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 {
+                                // 异步探测（issue #441）：cwd 可能在已断连的网络盘上。
+                                await fsPromises.access(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 {
+                                // 异步探测（issue #441）：cwd 可能在已断连的网络盘上。
+                                await fsPromises.access(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 重型的全量树解析。
+ *
+ * withAllMessagesText=false（默认，列表路径）时不收集转录全文，allMessagesText 返回空串 ——
+ * 全文单条可达 MB 级，绝不随列表进任何缓存（issue #440）；true（搜索路径）时收集全文并在
+ * MAX_SEARCH_TEXT_CHARS 处截断。
+ */
+async function parseSessionInfoFast(filePath, fileMtime, withAllMessagesText = false) {
+    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 = withAllMessagesText ? [] : null;
+        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;
+        let allMessagesText = "";
+        if (allMessages) {
+            const joined = allMessages.join(" ");
+            allMessagesText = joined.length > MAX_SEARCH_TEXT_CHARS ? joined.slice(0, MAX_SEARCH_TEXT_CHARS) : joined;
+        }
+        return {
+            path: filePath,
+            id,
+            cwd,
+            name,
+            parentSessionPath,
+            created: new Date(headerTime || fileMtime),
+            modified: new Date(modified),
+            messageCount,
+            firstMessage: firstMessage || "(no messages)",
+            allMessagesText,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /** 会话当前模型的 "provider/id"（无模型时 null；软上限按模型覆盖用，issue #229）。 */
 function modelKeyOf(session) {
     const m = session?.model;
@@ -1408,11 +1770,8 @@ export function sameCwd(a, b) {
     const y = String(b ?? "").trim();
     if (!x || !y)
         return false;
-    const norm = (s) => s.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
-    if (norm(x) === norm(y))
-        return true;
     try {
-        return norm(resolve(x)) === norm(resolve(y));
+        return normalizePathKey(x) === normalizePathKey(y);
     }
     catch {
         return false;
@@ -1470,6 +1829,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 +1993,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 +2052,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 +2140,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 +2240,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.
@@ -2096,6 +2545,9 @@ export class ClientSession {
         const handoffMessage = `[Peer Hand-off from ${fromType} subagent (${fromRunId.slice(0, 8)})]:\n\n${payload}`;
         const record = { fromRunId, toRunId, timestamp: Date.now() };
         this.subagentHandoffs.push(record);
+        if (this.subagentHandoffs.length > 50) {
+            this.subagentHandoffs = this.subagentHandoffs.slice(-50);
+        }
         if (!fromConv?.peerHandoffTo) {
             if (fromConv)
                 fromConv.peerHandoffTo = [];
@@ -2587,7 +3039,7 @@ export class ClientSession {
      *  conversationId 记录谁问的：看门狗豁免、快照恢复都靠它。 */
     pendingQuestions = new Map();
     /** 任务计划管理器（Plan Mode / Step State Machine）。 */
-    planManager = new PlanManager();
+    planManager;
     approvalSeq = 0;
     /** 待审批高危工具调用（Human-in-the-Loop: Edit & Run）。 */
     pendingApprovals = new Map();
@@ -2614,6 +3066,7 @@ export class ClientSession {
         this.subagentTemplates = new SubagentTemplatesStore(join(stateStore.dataDir, "subagent-templates.json"));
         this.approvalRules = new ApprovalRulesStore(join(stateStore.dataDir, "approval-rules.json"));
         this.drafts = new ComposerDraftsStore(join(stateStore.dataDir, "composer-drafts.json"));
+        this.planManager = new PlanManager(join(stateStore.dataDir, "plans.json"));
         this.markerSvc = new MarkerService({
             clientId,
             stateStore,
@@ -2661,7 +3114,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 +3126,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 +3148,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,
@@ -2780,6 +3355,57 @@ export class ClientSession {
         }
         await cs.restoreProjectProviderKeysForCwd(cwd);
         await cs.restoreProjectModelForCwd(cwd);
+        if (conv.session.sessionFile && cs.stateStore?.isSessionPinned(cwd, conv.session.sessionFile)) {
+            conv.pinned = true;
+            conv.listed = true;
+        }
+        // 恢复本项目其他已被钉住的会话（重启后常驻运行列表，issue #433）
+        const pinnedPaths = cs.stateStore?.getPinnedSessions(cwd) ?? [];
+        for (const p of pinnedPaths) {
+            if (cs.convs.size >= MAX_OPEN_CONVERSATIONS)
+                break;
+            const normP = normalizePathKey(p);
+            const alreadyOpen = [...cs.convs.values()].some((c) => c.session.sessionFile && normalizePathKey(c.session.sessionFile) === normP);
+            if (alreadyOpen)
+                continue;
+            try {
+                const targetPath = resolve(p);
+                if (!existsSync(targetPath))
+                    continue;
+                cs.repairTranscriptFileBeforeOpen(targetPath);
+                const sm = SessionManager.open(targetPath);
+                const convId = cs.nextConversationId();
+                const terms = cs.makeTerminalManager(convId, cwd);
+                const rt = await createAgentSessionRuntime(cs.makeRuntimeFactory(terms, undefined, convId), {
+                    cwd,
+                    agentDir,
+                    sessionManager: sm,
+                });
+                const pinnedConv = cs.makeConversation(rt, convId, terms);
+                pinnedConv.pinned = true;
+                pinnedConv.listed = true;
+                pinnedConv.promptedSinceActive = true;
+                cs.convs.set(pinnedConv.id, pinnedConv);
+                pinnedConv.unsubscribe = pinnedConv.session.subscribe((event) => cs.onEvent(pinnedConv, event));
+                try {
+                    await pinnedConv.session.bindExtensions({
+                        mode: "rpc",
+                        uiContext: WebUIContext.headless(),
+                        onError: cs.makeExtensionErrorReporter({
+                            text: `会话 ${convId}：`,
+                            textEn: `Conversation ${convId}: `,
+                        }),
+                    });
+                }
+                catch {
+                    // 忽略扩展绑定失败
+                }
+                cs.applyToolGating(pinnedConv.session, pinnedConv.agentPreset);
+            }
+            catch {
+                // best effort
+            }
+        }
         return cs;
     }
     /**
@@ -2829,6 +3455,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/交互/长驻命令挂死整个会话；
@@ -2894,6 +3535,11 @@ export class ClientSession {
                             hidden: true,
                             factory: (pi) => {
                                 pi.on("before_agent_start", (event) => {
+                                    // 我们是链上最后一个 handler：先把早前扩展的首尾增补摘出来（pre/post），
+                                    // 只在 SDK 原始提示词 core 上做事，最后原样套回去——否则返回 systemPrompt
+                                    // 会整体替换，把别的扩展注入的内容（如 <invoked_skill>）一起丢掉。
+                                    const { pre, core, post } = splitAgentStartPrompt(event);
+                                    const rewrap = (next) => pre + next + post;
                                     // 子代理模板 replace（无 SYSTEM.md 时）：默认分支拼好的提示词里
                                     // 把灵魂段换成模板提示词，自动段保留；SYSTEM.md 情形已在
                                     // systemPromptOverride 整体替换，此处边界不存在会自然跳过。
@@ -2901,15 +3547,11 @@ export class ClientSession {
                                         const tplPrompt = pickTemplatePrompt(apply, this.getLang()).trim();
                                         if (apply.promptMode !== "replace" || !tplPrompt)
                                             return undefined;
-                                        const boundary = event.systemPrompt.indexOf("\n\nAvailable tools:");
+                                        const boundary = core.indexOf("\n\nAvailable tools:");
                                         // 边界串是 SDK 提示词的内部格式：版本一变就可能对不上。
                                         // 对不上时不再静默回退默认 persona（模板等于没生效），而是把模板
                                         // 提示词前置拼接——角色约束仍在，只是灵魂段没被精确替换。
-                                        if (boundary === -1) {
-                                            const fallback = `${tplPrompt}\n\n${event.systemPrompt}`;
-                                            return fallback === event.systemPrompt ? undefined : { systemPrompt: fallback };
-                                        }
-                                        const swapped = tplPrompt + event.systemPrompt.slice(boundary);
+                                        const swapped = rewrap(boundary === -1 ? `${tplPrompt}\n\n${core}` : tplPrompt + core.slice(boundary));
                                         return swapped === event.systemPrompt ? undefined : { systemPrompt: swapped };
                                     }
                                     // 主会话：按当前会话归属预设与真正活跃的工具列表组装系统提示词
@@ -2947,7 +3589,8 @@ export class ClientSession {
                                         })),
                                         preset: currentPreset,
                                     });
-                                    return rendered ? { systemPrompt: rendered } : undefined;
+                                    // 不自定义时 rendered 为 undefined：不返回提示词，前面扩展的改动原样保留。
+                                    return rendered ? { systemPrompt: rewrap(rendered) } : undefined;
                                 });
                             },
                         },
@@ -2994,6 +3637,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 +3671,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 +3703,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
@@ -3074,7 +3732,15 @@ export class ClientSession {
                     // 内置标记只读查询工具（todo/svc 状态查询，写操作走内联标记）。
                     makeMarkersListTool(() => this.activeId, this.markerSvc),
                     // 结构化任务计划更新（Plan Mode / Step State Machine）。
-                    makePlanUpdateTool(this.planManager, () => ownerId ?? this.activeId, (msg) => this.emit(msg), () => this.flushSnapshot()),
+                    makePlanUpdateTool(this.planManager, () => {
+                        const id = ownerId ?? this.activeId;
+                        const c = this.convs.get(id);
+                        return {
+                            id,
+                            sessionId: c?.session?.sessionId,
+                            sessionManager: c?.session?.sessionManager,
+                        };
+                    }, (msg) => this.emit(msg), () => this.flushSnapshot()),
                     // 标准引擎的 ask_user_question：模型调用 → 浏览器富渲染问卷（复用 DSH
                     // 的 question_pending/question_answer 协议，前端 DshQuestionDialog）。
                     // DSH 引擎不经此（它走 goal-rpc 的 userQuestions provider）。
@@ -3130,10 +3796,14 @@ export class ClientSession {
                         lang: () => this.getLang(),
                     }),
                     // 高可靠行补丁工具（patch，基于内容哈希与语法块级替换）。
-                    makePatchTool({ cwd: effectiveCwd, ownerId }),
+                    makePatchTool({ cwd: effectiveCwd, ownerId, lang: () => this.getLang() }),
                     // 原生语言服务器工具（lsp，定义跳转/引用/悬停/诊断）。
-                    makeLspTool({ cwd: effectiveCwd, ownerId }),
-                ],
+                    makeLspTool({ cwd: effectiveCwd, ownerId, lang: () => this.getLang() }),
+                ].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）。
@@ -3162,7 +3832,7 @@ export class ClientSession {
     }
     /** Wrap a fresh runtime as a new conversation record. */
     makeConversation(runtime, id, terminals) {
-        return {
+        const conv = {
             id,
             title: conversationTitle(runtime.session),
             isSubagent: false,
@@ -3175,6 +3845,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 +3860,6 @@ export class ClientSession {
             stallNoticed: false,
             goal: this.makeGoalStatus(),
             goalGeneration: 0,
-            goalReviewGeneration: 0,
             wizardRunning: false,
             deltaSeq: 0,
             terminals,
@@ -3204,6 +3875,42 @@ export class ClientSession {
             toolWatchdogs: new Map(),
             workspaceSnapshots: [],
         };
+        this.restorePlan(conv);
+        return conv;
+    }
+    /** 会话计划回放恢复：持久化文件（sessionId）→ 转录 customType → 历史消息三重兜底。 */
+    restorePlan(conv) {
+        const sessionId = conv.session.sessionId;
+        if (sessionId) {
+            const existing = this.planManager.bindSession(conv.id, sessionId);
+            if (existing)
+                return;
+        }
+        // 2. 从 sessionManager entries 回放
+        const smPlan = readPlanFromSession(conv.session.sessionManager);
+        if (smPlan && Array.isArray(smPlan.steps) && smPlan.steps.length > 0) {
+            this.planManager.setPlan(conv.id, smPlan.steps, smPlan.activeStepId, sessionId);
+            return;
+        }
+        // 3. 从已有历史消息中回放最后一次成功的 plan_update 工具调用
+        const msgs = conv.session.agent?.state?.messages;
+        if (Array.isArray(msgs)) {
+            for (let i = msgs.length - 1; i >= 0; i--) {
+                const msg = msgs[i];
+                if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+                    for (const part of msg.content) {
+                        const p = part;
+                        if (p?.type === "tool_use" &&
+                            p.name === "plan_update" &&
+                            Array.isArray(p.input?.steps) &&
+                            p.input.steps.length > 0) {
+                            this.planManager.setPlan(conv.id, p.input.steps, p.input.activeStepId ?? null, sessionId);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
     }
     /** Summaries of conversations currently streaming — captured at shutdown
      *  so the next attach can reopen them and continue their runs. */
@@ -3411,9 +4118,13 @@ export class ClientSession {
             });
         };
     }
-    /** (Re)attach event plumbing to the ACTIVE conversation's session. */
-    async bindSession() {
-        const conv = this.conv;
+    /** (Re)attach event plumbing to a conversation's session. 默认绑当前活跃对话；
+     *  forceReset 重建非活跃对话（子代理/角色对话）时必须显式传入该对话，
+     *  否则重建后的会话永远拿不回事件订阅（issue #484）。
+     *  **public**：过户（take_over_conversation）后由 ClientSessionPool 对 **其它页面** 的
+     *  ClientSession 调用（切会话只重建 runtime，订阅得重新挂上，见 idle-takeover-test）。 */
+    async bindSession(target) {
+        const conv = target ?? this.conv;
         conv.unsubscribe?.();
         conv.session = conv.runtime.session;
         await conv.session.bindExtensions({
@@ -3598,6 +4309,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,
@@ -3647,7 +4361,7 @@ export class ClientSession {
         }
     }
     /** 插件扩展点 v2（供 conversationSearcher）：运行中对话标题 + 历史会话全文匹配，返回前 N 个 {id,title}。
-     *  复用 searchSessions 的 sessionMatchesSearch 判定（含转录全文），只读不 emit。 */
+     *  复用 searchSessions 的匹配口径（元信息 + 按需加载的转录全文），只读不 emit。 */
     async searchForPlugins(query, limit = 20) {
         const q = query.trim().toLowerCase();
         if (!q)
@@ -3661,9 +4375,8 @@ export class ClientSession {
         }
         try {
             const infos = await this.loadSessionInfos();
-            for (const s of infos) {
-                if (!sessionMatchesSearch(q, s))
-                    continue;
+            const matched = await ClientSession.filterSessionsForSearch(q, infos);
+            for (const s of matched) {
                 out.push({
                     id: s.path,
                     title: (s.name?.trim() || s.firstMessage.trim() || basename(s.path)).slice(0, 60),
@@ -3885,6 +4598,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 +4859,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 +4889,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
@@ -4437,7 +5160,41 @@ export class ClientSession {
         // 一次扫描同时收齐「当前转写里的全部缓存键」（live 集合，供
         // pruneMessageCache 精确回收死条目）与各自的序列化结果。
         const live = new Set();
-        let rawMessages = conv.session.agent.state.messages
+        let agentMessages = conv.session.agent.state.messages;
+        // issue #448: 多次压缩后 SDK state.messages 只保留最后一次压缩卡片。
+        // 从当前分支祖先链中提取前序未展示的历史 compaction 并正序置前，
+        // 使前端能逐段回溯展开历史折叠内容。
+        if (conv.session.sessionManager?.getBranch) {
+            try {
+                const branch = conv.session.sessionManager.getBranch();
+                const compEntries = branch.filter((e) => e.type === "compaction");
+                if (compEntries.length > 1) {
+                    const existingCompKeys = new Set(agentMessages
+                        .filter((m) => m.role === "compactionSummary")
+                        .map((m) => `${m.timestamp}:${m.summary ?? ""}`));
+                    const missingComps = [];
+                    for (const ce of compEntries) {
+                        const ts = ce.timestamp ? new Date(ce.timestamp).getTime() : 0;
+                        const key = `${ts}:${ce.summary ?? ""}`;
+                        if (!existingCompKeys.has(key)) {
+                            missingComps.push({
+                                role: "compactionSummary",
+                                summary: ce.summary ?? "",
+                                tokensBefore: ce.tokensBefore,
+                                timestamp: ts,
+                            });
+                        }
+                    }
+                    if (missingComps.length > 0) {
+                        agentMessages = [...missingComps, ...agentMessages];
+                    }
+                }
+            }
+            catch {
+                // 获取分支异常不影响当前渲染
+            }
+        }
+        let rawMessages = agentMessages
             .map((m) => {
             const k = this.uiMessageKey(conv, m);
             live.add(k.cacheKey);
@@ -4596,11 +5353,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,
@@ -5033,7 +5796,16 @@ export class ClientSession {
     }
     updatePlan(steps, activeStepId, conversationId) {
         const convId = conversationId ?? this.activeId;
-        const plan = this.planManager.setPlan(convId, steps, activeStepId);
+        const conv = this.convs.get(convId);
+        const sessionId = conv?.session?.sessionId;
+        const plan = this.planManager.setPlan(convId, steps, activeStepId, sessionId);
+        try {
+            const sm = conv?.session?.sessionManager;
+            sm?.appendCustomEntry?.("plan/update", { plan });
+        }
+        catch {
+            // ignore
+        }
         this.emit({
             type: "plan_updated",
             conversationId: convId,
@@ -5041,6 +5813,58 @@ export class ClientSession {
         });
         this.flushSnapshot();
     }
+    updatePlanStep(stepId, patch, conversationId) {
+        const convId = conversationId ?? this.activeId;
+        const plan = this.planManager.updateStep(convId, stepId, patch);
+        this.emit({
+            type: "plan_updated",
+            conversationId: convId,
+            plan,
+        });
+        this.flushSnapshot();
+    }
+    deletePlanStep(stepId, conversationId) {
+        const convId = conversationId ?? this.activeId;
+        const plan = this.planManager.deleteStep(convId, stepId);
+        this.emit({
+            type: "plan_updated",
+            conversationId: convId,
+            plan,
+        });
+        this.flushSnapshot();
+    }
+    addPlanStep(step, afterStepId, conversationId) {
+        const convId = conversationId ?? this.activeId;
+        const plan = this.planManager.addStep(convId, step, afterStepId);
+        this.emit({
+            type: "plan_updated",
+            conversationId: convId,
+            plan,
+        });
+        this.flushSnapshot();
+    }
+    /** 「✨ 净室执行（Clean-session Handoff）」：
+     *  关闭源会话的计划闸门，新建隔离会话，在新会话中原子设置计划步骤、可选迁移目标，并触发实施轮 prompt。 */
+    async planCleanHandoff(steps, promptText) {
+        const sourceConv = this.conv;
+        if (sourceConv?.planMode) {
+            await this.setPlanMode(false, sourceConv.id);
+        }
+        const sourceGoal = sourceConv?.goal?.goal;
+        await this.newChat();
+        const targetConv = this.conv;
+        this.planManager.setPlan(targetConv.id, steps);
+        if (sourceGoal) {
+            try {
+                await this.goalSvc.setGoal(sourceGoal, { targetConvId: targetConv.id, autoStart: false });
+            }
+            catch {
+                // 目标迁移失败不阻塞实施
+            }
+        }
+        this.flushSnapshot();
+        await this.prompt(promptText);
+    }
     /** 关闭所有挂起提问（dispose 时清理）：以「取消」解析，避免模型挂死。 */
     cancelPendingQuestions() {
         for (const [, p] of this.pendingQuestions) {
@@ -5048,6 +5872,35 @@ export class ClientSession {
         }
         this.pendingQuestions.clear();
     }
+    /** #487：结算指定会话的挂起提问/审批（按 conversationId 精确匹配）。
+     *  abort/移除/重建会话后残留的条目会让 isWaitingOnUser 恒真——stall 失联
+     *  检测被永久豁免，且问卷/审批弹窗跨轮残留。dispose 口径范本：提问以
+     *  「取消」解析、审批以「拒绝」解析并广播 tool_approval_resolved。 */
+    settlePendingsForConv(convId) {
+        for (const [id, q] of this.pendingQuestions) {
+            if (q.conversationId !== convId)
+                continue;
+            this.pendingQuestions.delete(id);
+            try {
+                q.resolve(null);
+            }
+            catch {
+                // 单个结算异常不影响其余清理
+            }
+        }
+        for (const [id, a] of this.pendingApprovals) {
+            if (a.conversationId !== convId)
+                continue;
+            this.pendingApprovals.delete(id);
+            try {
+                a.resolve({ decision: "deny", reason: "运行已停止" });
+            }
+            catch {
+                // 单个结算异常不影响其余清理
+            }
+            this.emit({ type: "tool_approval_resolved", id });
+        }
+    }
     /** 关闭所有挂起审批（dispose 时清理）：以「拒绝」解析，避免等答复的
      *  Promise 与对应 runtime 泄漏（会话没了，审批弹窗永远不会有人点）。 */
     cancelPendingApprovals() {
@@ -5405,6 +6258,7 @@ export class ClientSession {
      * 主动检查已安装界面插件（<dataDir>/plugins）的更新状态并向客户端推送。
      */
     async checkPluginUpdates(manual = false) {
+        this.updatesAllCache = null;
         const lang = () => this.getLang();
         try {
             const updates = await checkPluginUpdates(this.stateStore.dataDir, undefined, lang);
@@ -5532,11 +6386,12 @@ export class ClientSession {
                 }));
                 this.lastPluginUpdates = list;
                 this.emit({ type: "plugin_updates", updates: list });
+                const fmtVer = (v) => (v ? (/^[vV]/.test(v) ? v : `v${v}`) : null);
                 pluginItems = pluginUpdates.map((p) => ({
                     name: p.name ? `${p.name} (${p.id})` : p.id,
                     kind: "plugin",
-                    current: p.version ? `v${p.version}` : (p.localSha ?? "unknown"),
-                    latest: p.latestVersion ? `v${p.latestVersion}` : (p.remoteSha ?? null),
+                    current: fmtVer(p.version) ?? p.localSha ?? "unknown",
+                    latest: fmtVer(p.latestVersion) ?? p.remoteSha ?? null,
                     latestPublishedAt: null,
                     upToDate: !p.updatable,
                     error: p.error,
@@ -5699,6 +6554,8 @@ export class ClientSession {
             this.flushSnapshot();
         },
         refreshSessions: () => this.refreshSessions(),
+        setPlanMode: (enabled) => this.setPlanMode(enabled),
+        getPlanMode: () => this.conv?.planMode === true,
         afterReload: () => {
             // /reload 同样重读磁盘 settings.json——重放重试覆盖 + 软上限覆盖 + 终端门控。
             this.applyRetryOverrides();
@@ -6018,24 +6875,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 +7034,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 +7066,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 +7088,24 @@ 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);
+        const ownerId = conv?.id;
+        syncSubagentOverride(session, disabled.has("subagent"), () => ownerId
+            ? makeSubagentTools(withSubagentOwner(this.subagentHost, ownerId), undefined, ownerId)[0]
+            : makeSubagentTools(this.subagentHost)[0]);
         this.syncPluginTools(session, targetPreset);
         this.sessionStatsCache = null;
         this.cachedBaseTokens = null;
@@ -6269,8 +7176,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();
@@ -6296,42 +7203,239 @@ export class ClientSession {
     /** 推送权限选项表 + 默认权限。 */
     async refreshPermission() {
         this.emit({
-            type: "dsh_permission",
-            options: PI_PERMISSION_OPTIONS,
-            defaultPreset: this.settingsSvc.current.defaultPermissionPreset ?? "workspace-write-never",
+            type: "dsh_permission",
+            options: PI_PERMISSION_OPTIONS,
+            defaultPreset: this.settingsSvc.current.defaultPermissionPreset ?? "workspace-write-never",
+        });
+    }
+    /** 切换当前会话的权限预设（热生效）。 */
+    async setPermissionPreset(preset) {
+        const hit = PI_PERMISSION_OPTIONS.find((p) => p.value === preset);
+        if (!hit) {
+            this.emit({
+                type: "notice",
+                level: "warning",
+                text: `未知权限预设「${preset}」`,
+                textEn: `Unknown permission preset "${preset}"`,
+            });
+            return;
+        }
+        if (this.conv.permissionPreset === hit.value) {
+            return;
+        }
+        this.conv.permissionPreset = hit.value;
+        try {
+            // 持久会话：将权限变更写入会话转录日志，切会话/切项目重载时不丢失
+            const sm = this.conv.session.sessionManager;
+            sm?.appendCustomEntry?.("permission/preset", { preset: hit.value });
+        }
+        catch {
+            // best effort for in-memory sessions
+        }
+        this.emit({
+            type: "notice",
+            level: "info",
+            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();
     }
-    /** 切换当前会话的权限预设（热生效）。 */
-    async setPermissionPreset(preset) {
-        const hit = PI_PERMISSION_OPTIONS.find((p) => p.value === preset);
-        if (!hit) {
-            this.emit({
-                type: "notice",
-                level: "warning",
-                text: `未知权限预设「${preset}」`,
-                textEn: `Unknown permission preset "${preset}"`,
-            });
+    /**
+     * 切换计划模式（会话级，只规划不实施）。
+     *  软约束（系统提示词段）+ 硬闸门（写类/旁路工具与非常规 bash 直接拒）双管：
+     *  状态随会话转录落盘（切会话/重载恢复），并即时提示用户当前口径。
+     */
+    async setPlanMode(enabled, conversationId) {
+        const target = conversationId ? this.convs.get(conversationId) : this.conv;
+        if (!target)
             return;
-        }
-        if (this.conv.permissionPreset === hit.value) {
+        if (target.planMode === enabled) {
+            this.flushSnapshot();
             return;
         }
-        this.conv.permissionPreset = hit.value;
+        target.planMode = enabled;
         try {
-            // 持久会话：将权限变更写入会话转录日志，切会话/切项目重载时不丢失
-            const sm = this.conv.session.sessionManager;
-            sm?.appendCustomEntry?.("permission/preset", { preset: hit.value });
+            // 持久会话：写入转录日志，切会话/重载后回放恢复（与 permission/preset 同口径）。
+            const sm = target.session.sessionManager;
+            sm?.appendCustomEntry?.("plan/mode", { enabled });
         }
         catch {
             // best effort for in-memory sessions
         }
-        this.emit({
-            type: "notice",
-            level: "info",
-            text: `当前会话权限已切换为「${hit.name}」`,
-            textEn: `Current session permission switched to "${hit.name}"`,
-        });
+        // 动态应用工具门控：开启计划模式时剔除写类工具，关闭时恢复写类工具
+        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 +7454,7 @@ export class ClientSession {
         this.refreshPermission();
         this.flushSnapshot();
     }
-    /** 当前启用的插件 AI 工具定义（provider 快照按 disabledPluginTools 过滤；
+    /** 当前启用的插件 AI 工具定义（provider 快照按 disabledPlugins 与 disabledPluginTools 过滤；
      *  未知/已卸载插件的禁用条目保留但不影响现有工具）。
      *  预设是第二层门控（见 tool-manager.ts 语义总表）：非 standard 预设下插件工具
      *  一律不可用（读写未知，保守处理），此时返回空表，调用方负责从会话移除。 */
@@ -6358,7 +7462,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 +7745,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 +7764,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,8 +8113,21 @@ 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.
+            // SDK 的流式队列只消费用户消息；引用须与对应队列项一起入队和撤回。
+            const streamingQuotes = s.isStreaming
+                ? (attachments ?? [])
+                    .filter((a) => a.mode === "quote")
+                    .map((a) => readTextQuote(a.quote))
+                    .filter((q) => q !== null)
+                : [];
             const asides = await buildAttachmentMessages({
                 cwd: this.cwd,
                 clientId: this.clientId,
@@ -6952,9 +8136,17 @@ export class ClientSession {
                 session: this.session,
                 // issue #91：附件/视觉桥文案按客户端 UI 语言出中英（英文默认）。
                 getLang: () => this.getLang(),
-            }, attachments);
+            }, streamingQuotes.length ? attachments?.filter((a) => a.mode !== "quote") : attachments);
             if (promptAc.signal.aborted) {
                 conv.activePromptAc = undefined;
+                // #492：displacement（新对话顶替/会话被移出）在 prompt 前置阶段 abort 时
+                // 原本静默 return——消息凭空消失、草稿已清，用户毫无回执。
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `消息未送达：该对话已被关闭或运行已被停止`,
+                    textEn: `Message not delivered: the conversation was closed or the run was stopped`,
+                });
                 return;
             }
             for (const aside of asides) {
@@ -6979,9 +8171,26 @@ export class ClientSession {
             }
             if (promptAc.signal.aborted) {
                 conv.activePromptAc = undefined;
+                // #492：同上——影子快照阶段的 abort 也必须给回执，不能静默黑洞。
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: `消息未送达：该对话已被关闭或运行已被停止`,
+                    textEn: `Message not delivered: the conversation was closed or the run was stopped`,
+                });
                 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,
@@ -6993,12 +8202,12 @@ export class ClientSession {
                 // Enter-during-streaming semantic (docs/usage: Enter queues a
                 // steering message); followUp would wait for the whole run
                 // to finish, which users perceive as ordinary queueing.
-                await s.prompt(text, {
+                await s.prompt(formatQuotedPrompt(text, streamingQuotes), {
                     streamingBehavior: queue ? "followUp" : "steer",
                 });
             }
             else {
-                await s.prompt(text);
+                await s.prompt(formatQuotedPrompt(text, streamingQuotes));
             }
             // 关联快照与本次 prompt 产生的用户消息 entry
             if (snapshotRef) {
@@ -7030,6 +8239,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"
@@ -7187,7 +8401,23 @@ export class ClientSession {
             this.flushSnapshot();
             return;
         }
-        const { steering, followUp } = s.clearQueue();
+        let steering;
+        let followUp;
+        try {
+            ({ steering, followUp } = s.clearQueue());
+        }
+        catch (err) {
+            // #491：runtime 被 forceReset 置换等半死状态下 clearQueue 可能抛错——
+            // 回退到本地显示镜像移除，等 queue_update 对账；绝不把 reject 的 Promise
+            // 扔回给 dispatch（无兜底 handler 时 unhandledRejection 直接崩进程）。
+            console.error("[agent-service] clearQueue failed while removing a queued message:", err);
+            const next = removeQueuedByIndexOrText(local, text, index);
+            if (next.length !== local.length) {
+                local.splice(0, local.length, ...next);
+            }
+            this.flushSnapshot();
+            return;
+        }
         // 气泡 ✕ 对应的是「第几个气泡」（index），不是「哪段文本」：同一文本排队两次时
         // 按文本只会删掉第一条，点第二个气泡却删掉第一个。用 index 定位，位置对不上
         // （队列在点击与执行之间变化）或旧客户端没发 index 时回落到第一处文本匹配。
@@ -7325,6 +8555,9 @@ export class ClientSession {
     }
     /** Interrupt a run: abort, with a force-reset fallback on timeout. */
     async interruptRun(conv, reason) {
+        // #487：停下就结算该会话的挂起提问/审批——残留条目让 isWaitingOnUser 恒真
+        // （stall 失联检测被永久豁免），弹窗也会跨轮残留；dispose 语义已范本化。
+        this.settlePendingsForConv(conv.id);
         if (!this.conversationStreaming(conv) && conv.session.isIdle) {
             return;
         }
@@ -7398,6 +8631,11 @@ export class ClientSession {
             conv.toolStartTimes.clear();
             disposeEvalSession(conv.id);
             await conv.runtime.dispose();
+            // #485：dispose 挂起期间会话可能已被强行关闭移出（forceDismiss 走
+            // removeConversation）——此时绝不能幽灵重建，否则新 runtime 挂在已脱离
+            // this.convs 的 conv 对象上，无人持有、永不回收。
+            if (!this.convs.has(conv.id))
+                return;
             // #280：dispose 丢弃了内存里的在飞状态（未落盘的工具结果蒸发），
             // 文件尾可能留下一个悬空 toolCall——先补合成 toolResult 再重建，
             // 否则重建后的 prompt 会把非法转录链喂给 provider（零落盘黑洞）。
@@ -7429,6 +8667,17 @@ export class ClientSession {
                 sessionManager: m,
             }), async () => (ownFile && existsSync(ownFile) ? ownFile : undefined));
             const runtime = opened.runtime;
+            // #485：openManagerAndRuntime 的长 await 期间会话被移出的同一守卫——
+            // 刚建好的 runtime 无人认领，就地 dispose 防止扩展宿主子进程泄漏。
+            if (!this.convs.has(conv.id)) {
+                try {
+                    await runtime.dispose();
+                }
+                catch {
+                    // 已被移除的会话：dispose 失败无处上报，best-effort。
+                }
+                return;
+            }
             if (opened.repair) {
                 for (const n of this.transcriptRepairNotices(opened.repair))
                     this.emit(n);
@@ -7462,7 +8711,10 @@ export class ClientSession {
                 text: reason,
                 textEn: `${reason} (forced reset: run did not terminate)`,
             });
-            await this.bindSession();
+            // #484：把订阅重挂到**被重建的那个对话**上。非活跃对话（子代理/角色
+            // 对话）此前永远走 bindSession() → 只给活跃对话挂订阅，重建后该对话
+            // 的所有 SDK 事件失聪：快照冻结、看门狗不再布防、turnEndWaiters 死等。
+            await this.bindSession(conv);
             this.emitConversations();
             void this.pushSlashCommands();
         }
@@ -7529,8 +8781,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;
             }
@@ -7865,6 +9117,9 @@ export class ClientSession {
     }
     displaceActive() {
         const conv = this.conv;
+        // 正在过户给其他会话：绝不就地释放（runtime/终端等整体搬迁给 target）。
+        if (conv.transferring)
+            return null;
         // 子代理不受切换关闭影响（见上）。
         if (conv.isSubagent) {
             conv.listed = true;
@@ -7901,11 +9156,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 +9183,22 @@ export class ClientSession {
         const conv = this.convs.get(id);
         if (!conv || id === this.activeId)
             return;
+        // #487：会话没了，挂起的提问/审批永远等不到人点——按 dispose 口径就地结算。
+        this.settlePendingsForConv(id);
+        // 正在投递的消息（附件构建 / 影子快照阶段）必须先打断：否则 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 {
@@ -7981,21 +9263,37 @@ export class ClientSession {
         const convs = [...this.convs.values()].filter((c) => set.has(c.id));
         if (convs.length === 0)
             return { ok: false, reason: "missing" };
-        if (set.has(this.activeId)) {
-            const remaining = [...this.convs.values()].find((c) => !set.has(c.id) && !c.isSubagent) ??
-                [...this.convs.values()].find((c) => !set.has(c.id));
-            if (remaining) {
-                await this.switchConversation(remaining.id);
-            }
-            else if (!(await this.newChat())) {
-                return { ok: false, reason: "empty" };
+        for (const conv of convs)
+            conv.transferring = true;
+        try {
+            if (set.has(this.activeId)) {
+                const remaining = [...this.convs.values()].find((c) => !set.has(c.id) && !c.isSubagent) ??
+                    [...this.convs.values()].find((c) => !set.has(c.id));
+                if (remaining) {
+                    await this.switchConversation(remaining.id);
+                }
+                else if (!(await this.newChat())) {
+                    return { ok: false, reason: "empty" };
+                }
             }
         }
+        finally {
+            for (const conv of convs)
+                delete conv.transferring;
+        }
         for (const conv of convs) {
             this.convs.delete(conv.id);
             this.clearAllToolWatchdogs(conv);
             conv.unsubscribe?.();
             conv.unsubscribe = undefined;
+            // issue #457: 唤醒角色轮等待者与目标审查等待者，避免会话搬走后原会话循环永久卡死
+            const waiters = this.turnEndWaiters.get(conv.id);
+            if (waiters) {
+                this.turnEndWaiters.delete(conv.id);
+                for (const fn of waiters)
+                    fn("gone");
+            }
+            this.goalSvc.notifyTakeover(conv);
         }
         const questions = [];
         for (const [qid, p] of this.pendingQuestions) {
@@ -8310,6 +9608,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 +9654,223 @@ 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;
+    /**
+     * 会话单文件元信息缓存（path -> { mtime, size, info }）：避免对未修改的会话文件
+     * 重复读取与 JSON 解析。LRU 上限（issue #440）：静态 Map 跨项目共享，原先没有任何
+     * 上限/TTL —— 删除、更名、被挤出 200 名额的文件只要曾进过缓存就永久驻留，长驻
+     * 服务 + 多项目重度使用下 RSS 单调上涨。
+     *
+     * 上限 512 的依据：单项目单轮扫描只取最新 200 个候选，512 ≈ 2.5 倍余量，足够容纳
+     * 多个最近活跃项目的热集；且拆分后（issue #440）条目只含元信息不含转录全文
+     * （单条 KB 级），总占用恒定且极小 —— 上限防的是「无界累积」，不是单条重量。
+     *
+     * LRU 淘汰语义：把 Map 当 LRU 用（Map 迭代序 = 插入序）—— 命中即 delete+set 重插
+     * 到最新端，写入超上限从最旧端淘汰。mtime/size 未变的条目命中即复用（行为与原先
+     * 一致），变化的条目由调用方重新解析后经 store 覆盖（也落到最新端）。
+     */
+    static sessionFileCache = new Map();
+    static SESSION_FILE_CACHE_MAX = 512;
+    /**
+     * 转录全文缓存（path -> { text, at }）：仅供 searchSessions / searchForPlugins 的
+     * 全文命中判定按需加载（issue #440 拆分）。与列表缓存分离的原因：列表路径
+     * （pushSessions / 插件列表 / 删除后切换）只需要元信息，而全文单条可达 MB 级，
+     * 随列表常驻会让每个曾进过列表的文件都占住内存。
+     *
+     * 容量依据：256 ≥ 单项目候选上限 200，键入查询的其余按键在 TTL 窗口内全程免读盘；
+     * 单条在 parseSessionInfoFast 里按 MAX_SEARCH_TEXT_CHARS（256K 字符）封顶。
+     * TTL 只在访问时判断（无定时器），每次载入顺手清扫过期项 —— 搜索空闲后不长期
+     * 占内存。删除/更名经 invalidateSessionInfos 同步清理。
+     */
+    static sessionTextCache = new Map();
+    static SESSION_TEXT_CACHE_MAX = 256;
+    static SESSION_TEXT_CACHE_TTL = 30_000;
+    /** sessionFileCache LRU 读取：命中即重插到最新端（续期），未命中返回 undefined。 */
+    static sessionFileCacheLookup(key) {
+        const entry = ClientSession.sessionFileCache.get(key);
+        if (!entry)
+            return undefined;
+        ClientSession.sessionFileCache.delete(key);
+        ClientSession.sessionFileCache.set(key, entry);
+        return entry;
+    }
+    /** sessionFileCache LRU 写入：新/更新条目放最新端，超上限从最旧端淘汰。 */
+    static sessionFileCacheStore(key, entry) {
+        ClientSession.sessionFileCache.delete(key);
+        ClientSession.sessionFileCache.set(key, entry);
+        while (ClientSession.sessionFileCache.size > ClientSession.SESSION_FILE_CACHE_MAX) {
+            const oldest = ClientSession.sessionFileCache.keys().next();
+            if (oldest.done)
+                break;
+            ClientSession.sessionFileCache.delete(oldest.value);
+        }
+    }
+    /** sessionTextCache 读取：TTL 内命中即重插续期；过期即清并按未命中处理。 */
+    static sessionTextCacheLookup(key, now) {
+        const entry = ClientSession.sessionTextCache.get(key);
+        if (!entry)
+            return undefined;
+        ClientSession.sessionTextCache.delete(key);
+        if (now - entry.at >= ClientSession.SESSION_TEXT_CACHE_TTL)
+            return undefined;
+        ClientSession.sessionTextCache.set(key, entry);
+        return entry.text;
+    }
+    /** sessionTextCache 写入：放最新端，超上限从最旧端淘汰。 */
+    static sessionTextCacheStore(key, text, at) {
+        ClientSession.sessionTextCache.delete(key);
+        ClientSession.sessionTextCache.set(key, { text, at });
+        while (ClientSession.sessionTextCache.size > ClientSession.SESSION_TEXT_CACHE_MAX) {
+            const oldest = ClientSession.sessionTextCache.keys().next();
+            if (oldest.done)
+                break;
+            ClientSession.sessionTextCache.delete(oldest.value);
+        }
+    }
+    /** 惰性清扫 sessionTextCache 过期项：TTL 只在访问时判断，没有定时器兜底，
+     *  靠每次全文载入顺手扫一遍，保证搜索空闲后全文不会无限期滞留内存。 */
+    static sessionTextCacheSweep(now) {
+        for (const [key, entry] of ClientSession.sessionTextCache) {
+            if (now - entry.at >= ClientSession.SESSION_TEXT_CACHE_TTL)
+                ClientSession.sessionTextCache.delete(key);
+        }
+    }
+    /**
+     * 转录全文按需加载（搜索专用）：TTL 缓存命中直接回；未命中读盘提取全文
+     * （与 parseSessionInfoFast 同口径：user/assistant 消息文本，MAX_SEARCH_TEXT_CHARS
+     * 截断）。解析失败回空串且不缓存 —— 与列表路径一样下次重试。
+     */
+    static async loadSessionSearchText(filePath) {
+        const now = Date.now();
+        ClientSession.sessionTextCacheSweep(now);
+        const hit = ClientSession.sessionTextCacheLookup(filePath, now);
+        if (hit !== undefined)
+            return hit;
+        const info = await parseSessionInfoFast(filePath, 0, true);
+        const text = info?.allMessagesText ?? "";
+        if (text)
+            ClientSession.sessionTextCacheStore(filePath, text, now);
+        return text;
+    }
+    /**
+     * searchSessions / searchForPlugins 共用的全文匹配：先比元信息（零 IO，覆盖绝大多数
+     * 按标题/文件名/首条消息的查询），元信息未命中的会话再按需加载转录全文判定
+     * （小容量短 TTL 缓存，见 sessionTextCache）。保序返回命中子集。
+     * issue #440：全文不再随列表缓存常驻，改在这里按需加载。
+     */
+    static async filterSessionsForSearch(q, infos) {
+        const flags = await Promise.all(infos.map(async (s) => {
+            if (sessionMatchesMetadata(q, s))
+                return true;
+            const text = await ClientSession.loadSessionSearchText(s.path);
+            return text.toLowerCase().includes(q);
+        }));
+        return infos.filter((_, i) => flags[i]);
+    }
+    /** 会话列表缓存（按 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 results = await Promise.all(validStats.map(async (file) => {
+                    const cached = ClientSession.sessionFileCacheLookup(file.path);
+                    if (cached && cached.mtime === file.mtime && cached.size === file.size) {
+                        return cached.info;
+                    }
+                    // 列表路径不收集转录全文（issue #440）——全文只在搜索时按需加载
+                    const info = await parseSessionInfoFast(file.path, file.mtime);
+                    if (info) {
+                        ClientSession.sessionFileCacheStore(file.path, {
+                            mtime: file.mtime,
+                            size: file.size,
+                            info,
+                        });
+                    }
+                    return info;
+                }));
+                const validInfos = results.filter((info) => info !== null);
+                // issue #438：扁平布局（PI_CODING_AGENT_SESSION_DIR）下根目录顶层直接是**所有项目**
+                // 共享的 .jsonl，所属 cwd 是文件内字段；不过滤的话其他项目的会话会混进本项目
+                // 「历史会话」列表，点开即把整个工作区切走。与 SessionManager.list(cwd, ...) 的
+                // fallback 及 discoverRecentProjectsFromDisk 同口径：normalizePathKey（Windows
+                // 大小写/斜杠归一）。空 cwd 的损坏文件须排除——normalizePathKey("") 会 resolve 到
+                // process.cwd()，恰好等于本项目时会把垃圾文件误收进来。
+                const ownInfos = validInfos.filter((info) => info.cwd !== "" && normalizePathKey(info.cwd) === cwdKey);
+                // 200 名额只在 cwd 过滤**之后**分配：扁平布局下若先截断，本项目会话可能被
+                // 其他项目的文件挤出列表。截断仍按上面的 mtime 降序序取（Promise.all 保序），
+                // 与原有选集口径一致；非扁平布局每-cwd 子目录内文件全属本项目，过滤幂等。
+                const candidates = ownInfos.slice(0, 200);
+                candidates.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+                ClientSession.sessionInfosCache.set(cwdKey, { infos: candidates, at: Date.now() });
+                return candidates;
+            }
+            catch {
+                try {
+                    const fallback = await SessionManager.list(this.cwd, piSessionsRoot());
+                    // 统一口径：列表缓存一律不带转录全文（issue #440），搜索按需另行加载
+                    const stripped = fallback.map((s) => ({ ...s, allMessagesText: "" }));
+                    ClientSession.sessionInfosCache.set(cwdKey, { infos: stripped, at: Date.now() });
+                    return stripped;
+                }
+                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) {
+            const abs = resolve(filePath);
+            ClientSession.sessionFileCache.delete(abs);
+            // 全文缓存一并清（issue #440）：文件已删/更名，正文不该再被搜索命中
+            ClientSession.sessionTextCache.delete(abs);
+        }
     }
     /** Push the persisted session list to the client (client-requested). */
     async refreshSessions() {
@@ -8402,7 +9894,7 @@ export class ClientSession {
             const infos = await this.loadSessionInfos();
             // 隐藏「被 fork 掉的父会话」，历史列表只保留每条 fork 链最新的链尾会话
             // （全文搜索 searchSessions 保留全部会话，不受此影响）。
-            const normSessionPath = (p) => String(p).replace(/\\/g, "/").replace(/\/$/, "").toLowerCase();
+            const normSessionPath = (p) => normalizePathKey(p);
             const forkedParentPaths = new Set();
             for (const info of infos) {
                 if (typeof info.parentSessionPath === "string" && info.parentSessionPath) {
@@ -8417,6 +9909,7 @@ export class ClientSession {
                 : infos;
             const sessions = new Map();
             for (const s of visibleInfos) {
+                const isPinned = this.stateStore?.isSessionPinned(this.cwd, s.path);
                 sessions.set(s.path, {
                     path: s.path,
                     name: s.name,
@@ -8424,6 +9917,7 @@ export class ClientSession {
                     messageCount: s.messageCount,
                     modified: s.modified.getTime(),
                     source: "web",
+                    ...(isPinned ? { pinned: true } : {}),
                 });
             }
             const sorted = [...sessions.values()].sort((a, b) => b.modified - a.modified).slice(0, 200); // newest first — the panel shows recent history
@@ -8482,7 +9976,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];
@@ -8538,6 +10032,8 @@ export class ClientSession {
                 return;
             }
             rmSync(abs, { force: true });
+            // 转录删了，钉住记录一起清理（issue #433）。
+            this.stateStore?.cleanPinnedSession(abs);
             // 转录删了，sidecar 再留着就是孤儿，一起清掉（不存在不报错）。
             removeTouchSidecar(abs);
             // 转录删了，未发送草稿再留着就是孤儿，一起清掉。
@@ -8550,7 +10046,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 +10079,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 +10091,82 @@ 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;
+            if (conv.session.sessionFile) {
+                this.stateStore?.setSessionPinned(conv.cwd, conv.session.sessionFile, true);
+            }
+        }
+        else {
+            delete conv.pinned;
+            if (conv.session.sessionFile) {
+                this.stateStore?.setSessionPinned(conv.cwd, conv.session.sessionFile, false);
+            }
+        }
+        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`,
+        });
+    }
+    /** 钉住 / 取消钉住历史会话（持久化并在运行中/历史列表生效）。 */
+    async pinSession(path, pinned) {
+        const targetPath = resolve(path);
+        this.stateStore?.setSessionPinned(this.cwd, targetPath, pinned);
+        // 如果当前已在运行列表中，同步其 pinned 状态
+        for (const conv of this.convs.values()) {
+            if (conv.session.sessionFile && resolve(conv.session.sessionFile) === targetPath) {
+                if (pinned) {
+                    conv.pinned = true;
+                    conv.listed = true;
+                }
+                else {
+                    delete conv.pinned;
+                }
+                break;
+            }
+        }
+        this.emitConversations();
+        this.flushSnapshot();
+        await this.refreshSessions();
+    }
     /** 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 +10232,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 +10415,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 +10664,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 +10809,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;
             }
@@ -9243,6 +10818,10 @@ export class ClientSession {
             // Deliberately resumed — must not be dismissed when the user later
             // switches away without sending a new message.
             conv.promptedSinceActive = true;
+            if (this.stateStore?.isSessionPinned(targetCwd, targetPath)) {
+                conv.pinned = true;
+                conv.listed = true;
+            }
             this.noticeInterruptedCompaction(conv);
             this.convs.set(conv.id, conv);
             this.activeId = conv.id;
@@ -9251,6 +10830,10 @@ export class ClientSession {
             if (displaced)
                 this.removeConversation(displaced.id);
             await this.bindSession();
+            // #436：转录回放恢复的 planMode 在 runtime 工厂的 applyToolGating 时还读不到
+            //（conv 尚未进 this.convs，planModeOf 落空）——注册后统一补一次门控，让
+            // 计划模式的写类/旁路工具剥离对重开的会话同样生效。下同（forkSession/setCwd）。
+            this.applyToolGating(conv.session, conv.agentPreset);
             this.cwd = targetCwd;
             // 打开的历史会话可能属于另一个项目 —— 工作区跟随面（roots/文件树/
             // 历史列表/命令目录/最近项目）必须跟着切，否则 UI 停在旧项目。
@@ -9324,6 +10907,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 +11018,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;
             }
@@ -9430,6 +11028,9 @@ export class ClientSession {
             if (displaced)
                 this.removeConversation(displaced.id);
             await this.bindSession();
+            // #436：同 switchSession —— 派生出的会话若从转录回放恢复了 planMode，
+            // 工厂里的门控当时读不到它，注册后补一次。
+            this.applyToolGating(newConv.session, newConv.agentPreset);
             if (prevModel && this.sharedModelRuntime) {
                 try {
                     const pm = prevModel;
@@ -9598,7 +11199,8 @@ export class ClientSession {
         if (this.quiesceBlocked())
             return;
         const trimmed = text.trim();
-        if (!trimmed) {
+        const hasAttachments = Boolean(attachments && attachments.length > 0);
+        if (!trimmed && !hasAttachments) {
             this.emit({
                 type: "notice",
                 level: "warning",
@@ -9681,16 +11283,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 +11301,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 = await 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(await 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 +11346,7 @@ export class ClientSession {
     }
     /** 最近项目缓存失效（用户显式移除项目后，下一次推送必须重扫）。 */
     invalidateProjectsCache() {
-        this.projectsCache = null;
+        ClientSession.projectsCache = null;
     }
     /** List a workspace directory (relative to the configured cwd). */
     async listFiles(relPath) {
@@ -9768,8 +11358,9 @@ export class ClientSession {
     }
     /** 全局搜索：在当前工作区的会话转录全文里做大小写不敏感匹配 ——
      *  不止首条消息，而是每一段 user 与 assistant 文本（AI 输出也在内）。
-     *  结果经 session_search_results 回推（reqId 匹配）；复用 loadSessionInfos()
-     *  缓存，避免每个按键都重新解析全部转录文件。 */
+     *  结果经 session_search_results 回推（reqId 匹配）；元信息复用 loadSessionInfos()
+     *  缓存，转录全文按需加载（issue #440，小容量短 TTL 缓存），避免每个按键都重新
+     *  解析全部转录文件、也不让全文长期驻留内存。 */
     async searchSessions(query, reqId) {
         const q = query.trim().toLowerCase();
         if (!q) {
@@ -9778,11 +11369,12 @@ export class ClientSession {
         }
         try {
             const infos = await this.loadSessionInfos();
-            const results = infos
-                .filter((s) => sessionMatchesSearch(q, s))
+            const matched = await ClientSession.filterSessionsForSearch(q, infos);
+            const results = matched
                 .sort((a, b) => b.modified.getTime() - a.modified.getTime())
                 .slice(0, 50)
                 .map((s) => {
+                const isPinned = this.stateStore?.isSessionPinned(this.cwd, s.path);
                 const base = {
                     path: s.path,
                     name: s.name,
@@ -9790,6 +11382,7 @@ export class ClientSession {
                     messageCount: s.messageCount,
                     modified: s.modified.getTime(),
                     source: "web",
+                    ...(isPinned ? { pinned: true } : {}),
                 };
                 // 命中会话里再定位具体消息（供点击跳转）；仅元数据命中则无锚点
                 return { ...base, anchors: collectSessionAnchors(s.path, q) };
@@ -9918,26 +11511,6 @@ export class ClientSession {
             await this.setCwd(created);
         }
     }
-    async cycleModel() {
-        try {
-            const result = await this.session.cycleModel();
-            if (result?.model) {
-                const mid = `${result.model.provider}/${result.model.id}`;
-                await this.restoreKeyForModel(mid, this.cwd);
-                // Remember per-project like setModel — cycling is also a model switch.
-                this.rememberProjectModel(mid);
-            }
-        }
-        catch (err) {
-            this.emit({
-                type: "notice",
-                level: "error",
-                text: `切换模型失败：${err.message}`,
-                textEn: `Failed to switch model: ${err.message}`,
-            });
-        }
-        this.flushSnapshot();
-    }
     /**
      * Path completion for the cwd input: expand ~/relative paths, list the parent
      * directory, and return prefix matches (dirs first, capped).
@@ -10085,6 +11658,9 @@ export class ClientSession {
                     }
                 }
                 await this.bindSession();
+                // #436：同 switchSession —— 续聊最近会话若从转录回放恢复了 planMode，
+                // 工厂里的门控当时读不到它，注册后补一次。
+                this.applyToolGating(conv.session, conv.agentPreset);
                 if (resumeSkipped) {
                     this.emit(resumeSkipped.isStreaming
                         ? {
@@ -10373,24 +11949,6 @@ export class ClientSession {
         }
         this.flushSnapshot();
     }
-    cycleThinking() {
-        try {
-            const nextLevel = this.session.cycleThinkingLevel({ persist: true });
-            const cur = this.session.model;
-            if (cur && nextLevel) {
-                this.session.settingsManager.setModelThinkingLevel(cur.provider, cur.id, nextLevel);
-            }
-        }
-        catch (err) {
-            this.emit({
-                type: "notice",
-                level: "error",
-                text: `切换思考强度失败：${err.message}`,
-                textEn: `Failed to switch thinking level: ${err.message}`,
-            });
-        }
-        this.flushSnapshot();
-    }
     /** Push the user command list (.pi/commands.json) to the client. */
     async listCommands() {
         const { commands, path, warning, warningEn } = await loadCommands(this.cwd);
@@ -10493,8 +12051,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 +12371,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 +12655,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 +12752,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 +12778,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 {
@@ -11243,6 +12809,7 @@ export class AgentService {
                 textEn: `"${main.title}" was moved to this page — pick up right where it left off.`,
             });
             await target.switchConversation(newMainId);
+            await target.bindSession();
         }
         catch (err) {
             fail(`过户失败：${err.message}`, `Takeover failed: ${err.message}`);
@@ -11266,7 +12833,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);