pi-web-ui 0.67.0 → 0.68.1

package/dist/server/agent-service.js

@@ -27,7 +27,7 @@ import { GoalService } from "./goal-service.js";
 import { MarkerService } from "./marker-service.js";
 import { SlashCommandsService, parseSlash } from "./slash-commands.js";
 import { ModelAdminService } from "./model-admin.js";
-import { FilesService, workspacePath } from "./files-service.js";
+import { FilesService, MACHINE_ROOT, workspacePath } from "./files-service.js";
 import { isExtensionDisabled, isExtensionEnabled, ClientStateStore } from "./client-state.js";
 import { SubagentTemplatesStore } from "./subagent-templates.js";
 import { applyHeadTail, makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, TERMINAL_TOOL_NAMES, } from "./terminals.js";
@@ -36,7 +36,7 @@ import { makeEditSoftTool, SOFT_EDIT_TOOL_NAME } from "./edit-soft-tool.js";
 import { makeSubagentTools, subagentTitle, } from "./subagents.js";
 import { buildAttachmentMessages } from "./attachments.js";
 import { BUILTIN_SOUL, DEFAULT_PROMPT_TEMPLATE, renderPromptTemplate, resolveSectionTexts, } from "./prompt-composer.js";
-import { serializeMessage, serializeStreamingMessage } from "./serialize.js";
+import { serializeMessage, serializeStreamingMessage, stripTransientRetryErrors, } from "./serialize.js";
 import { loadCommands, saveCommandsFile, TerminalManager } from "./terminals.js";
 const SNAPSHOT_INTERVAL_MS = 60;
 /** While assistant deltas are flowing, live rendering is carried by
@@ -296,6 +296,37 @@ function extractAssistantTextFromContent(content) {
         .join("\n");
 }
 export { workspacePath };
+/** 轨迹事件 payload 封顶（可直接广播/持久化，不撑爆 storage.json）。 */
+const RUN_TASK_CAP = 500;
+const RUN_ARGS_CAP = 4000;
+const RUN_RESULT_CAP = 4000;
+function truncRun(s, cap) {
+    return s.length <= cap ? s : `${s.slice(0, cap)}\n… [truncated]`;
+}
+/** 从 SDK tool result 里抠可读文本预览（text 块拼接，图片/二进制占位，封顶）。 */
+function previewToolResult(result) {
+    try {
+        const content = result?.content;
+        if (Array.isArray(content)) {
+            const parts = [];
+            for (const c of content) {
+                if (c && typeof c === "object" && c.type === "text") {
+                    parts.push(String(c.text ?? ""));
+                }
+                else {
+                    parts.push("[…]");
+                }
+            }
+            return truncRun(parts.join("\n"), RUN_RESULT_CAP);
+        }
+        if (typeof result === "string")
+            return truncRun(result, RUN_RESULT_CAP);
+        return truncRun(JSON.stringify(result ?? null), RUN_RESULT_CAP);
+    }
+    catch {
+        return "[unserializable result]";
+    }
+}
 /** Hard cap on how long ONE tool call may run before the watchdog aborts the
  *  session. The SDK bash tool has NO default timeout, so a command that never
  *  finishes (servers, watchers, infinite loops) would otherwise hang the whole
@@ -494,6 +525,12 @@ export class ClientSession {
     /** index.ts 注入（经 AgentService 拷贝到每个新会话）：把 SDK 工具执行事件转发给
      *  插件（PluginManager.emitToolEvent）。未设置时不做任何事。 */
     onToolEvent = undefined;
+    /** index.ts 注入：把运行轨迹事件转发给插件（PluginManager.emitRunEvent，
+     *  轨迹视图插件靠它聚合时间线）。未设置时不做任何事。 */
+    onRunEvent = undefined;
+    /** index.ts 注入：当前打开对话变了（切历史会话/切 running 对话/新对话）时
+     *  通知插件（PluginManager.emitConversationChanged）——轨迹视图靠它重拉。 */
+    onConversationChanged = undefined;
     /** index.ts 注入：读取插件当前注册的 AI 工具（attach 时拷贝到每个新会话）。 */
     pluginToolsProvider = undefined;
     /** index.ts 注入：读取插件当前注册的斜杠命令（目录展示 + prompt 拦截执行）。 */
@@ -726,6 +763,10 @@ export class ClientSession {
     /** 子代理最近一次运行的结局：最后一条 assistant 消息的 errorMessage / stopReason。
      *  报错 > 中止 > 正常，三者互斥；无 assistant 消息时返回空。 */
     subagentRunOutcome(conv) {
+        // 自动重试等待期结局未定：瞬时 error 不算失败，避免向主对话误报
+        // 「子代理运行失败」（耗尽后 auto_retry_end 清旗，真正失败照常通知）。
+        if (conv.retryState)
+            return {};
         try {
             const msgs = conv.session.agent.state.messages;
             for (let i = msgs.length - 1; i >= 0; i--) {
@@ -1456,6 +1497,76 @@ export class ClientSession {
             clearTimeout(t);
         conv.toolWatchdogs.clear();
     }
+    /** 发一条运行轨迹事件给插件（host.onRunEvent 订阅者，如轨迹视图插件）。
+     *  异常隔离——序列化/插件坏了只记日志，绝不影响主流程。 */
+    emitRun(conv, ev) {
+        if (!this.onRunEvent)
+            return;
+        try {
+            this.onRunEvent({ ...ev, conversationId: conv.id, at: Date.now() });
+        }
+        catch (err) {
+            console.error("[agent-service] onRunEvent failed:", err);
+        }
+    }
+    /** 当前打开对话变了 → 通知插件重拉（切历史会话/切 running 对话/新对话）。
+     *  异常隔离——插件坏了只记日志，绝不影响切换流程。 */
+    notifyConversationChanged() {
+        if (!this.onConversationChanged)
+            return;
+        try {
+            this.onConversationChanged();
+        }
+        catch (err) {
+            console.error("[agent-service] onConversationChanged failed:", err);
+        }
+    }
+    /** 插件用：本客户端最近活跃对话的快照（轨迹视图直接显示打开对话的时间线）。
+     *  messages/streamingMessage 为引用稳定的只读缓存对象——调用方只读、不得修改。 */
+    readConversationForPlugins() {
+        try {
+            let target = null;
+            for (const c of this.convs.values()) {
+                if (!target || c.lastActiveAt > target.lastActiveAt)
+                    target = c;
+            }
+            if (!target)
+                return null;
+            const state = target.session.agent.state;
+            let stats = {
+                totalMessages: 0,
+                tokens: { input: 0, output: 0, total: 0 },
+                cost: 0,
+            };
+            try {
+                const s = target.session.getSessionStats();
+                stats = { totalMessages: s.totalMessages, tokens: s.tokens, cost: s.cost };
+            }
+            catch {
+                /* stats 尽力而为 */
+            }
+            let streamingMessage = null;
+            try {
+                streamingMessage = state.streamingMessage ? serializeStreamingMessage(state.streamingMessage) : null;
+            }
+            catch {
+                /* 尽力而为 */
+            }
+            return {
+                conversationId: target.id,
+                title: target.title,
+                at: target.lastActiveAt,
+                isStreaming: target.session.isStreaming,
+                messages: this.messagesOf(target),
+                streamingMessage,
+                stats,
+            };
+        }
+        catch (err) {
+            console.error("[agent-service] readConversationForPlugins failed:", err);
+            return null;
+        }
+    }
     onEvent(conv, event) {
         // Any SDK event proves the run is alive — feeds the stall watchdog below.
         conv.lastSdkEventAt = Date.now();
@@ -1485,7 +1596,26 @@ export class ClientSession {
                 }
                 this.armToolWatchdog(conv, event.toolCallId);
                 // 插件扩展点：工具开始执行（异常由 emitToolEvent 隔离）。
-                this.onToolEvent?.({ phase: "start", toolName: event.toolName, conversationId: conv.id });
+                this.onToolEvent?.({
+                    phase: "start",
+                    toolName: event.toolName,
+                    conversationId: conv.id,
+                    toolCallId: event.toolCallId,
+                });
+                // 轨迹事件：带参数预览（JSON 封顶；超大参数只记截断）。
+                let argsText = "null";
+                try {
+                    argsText = truncRun(JSON.stringify(event.args ?? null), RUN_ARGS_CAP);
+                }
+                catch {
+                    argsText = "[unserializable args]";
+                }
+                this.emitRun(conv, {
+                    type: "tool_start",
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    argsText,
+                });
                 break;
             }
             case "tool_execution_end": {
@@ -1502,6 +1632,16 @@ export class ClientSession {
                     phase: "end",
                     toolName: event.toolName,
                     conversationId: conv.id,
+                    toolCallId: event.toolCallId,
+                    ...(durationMs !== undefined ? { durationMs } : {}),
+                    isError: event.isError,
+                });
+                // 轨迹事件：带结果预览（封顶）+ 耗时/错误标志。
+                this.emitRun(conv, {
+                    type: "tool_end",
+                    toolCallId: event.toolCallId,
+                    toolName: event.toolName,
+                    resultText: previewToolResult(event.result),
                     ...(durationMs !== undefined ? { durationMs } : {}),
                     isError: event.isError,
                 });
@@ -1597,9 +1737,58 @@ export class ClientSession {
                 }
                 break;
             }
+            case "auto_retry_start": {
+                // 大模型 API 瞬时报错，SDK 退避重试：填实重试信息。末尾 error
+                // 消息已被（或即将被）SDK 从 state 摘掉，currentMessages() 凭此旗
+                // 过滤，快照只显示温和的重试条。落盘由底部检查点立即 flush。
+                conv.retryState = {
+                    attempt: event.attempt,
+                    maxAttempts: event.maxAttempts,
+                    delayMs: event.delayMs,
+                    errorMessage: event.errorMessage,
+                };
+                break;
+            }
+            case "auto_retry_end": {
+                // 重试结束：成功 → 新内容照常显示；耗尽 → error 消息留驻，
+                // 快照永久标红。落盘由底部检查点立即 flush。
+                conv.retryState = null;
+                break;
+            }
             // A run finished or a new entry was persisted — keep the session list fresh
             // (new chat + first message, completed turns, compaction, etc.).
             case "agent_end": {
+                // 可重试错误：SDK 随后发 auto_retry_start 并把末尾 error 消息从
+                // state 摘掉。这里先立占位，让本次立即 flush 的快照就不含瞬时红错
+                // ——否则快照先画红、摘掉后又消失，即「红色报错一闪而过」。
+                if (event.willRetry) {
+                    let errorMessage = "";
+                    for (let i = event.messages.length - 1; i >= 0; i--) {
+                        const m = event.messages[i];
+                        if (m.role === "assistant" && typeof m.errorMessage === "string") {
+                            errorMessage = m.errorMessage;
+                            break;
+                        }
+                    }
+                    conv.retryState = { attempt: 0, maxAttempts: 0, delayMs: 0, errorMessage };
+                }
+                else {
+                    // 本轮结束且无后续重试：任何残留占位都是过期的（会话替换、
+                    // 结束信号丢失等），清掉，否则横幅会卡住不消失。
+                    conv.retryState = null;
+                }
+                // 轨迹事件：本轮结束（放最前——aborted 中断路径也会 break，
+                // 轨迹里必须留下「已停止」而不是凭空消失）。
+                try {
+                    const lastAssistant = [...event.messages].reverse().find((m) => {
+                        const a = m;
+                        return a.role === "assistant" && typeof a.stopReason === "string";
+                    });
+                    this.emitRun(conv, lastAssistant?.stopReason ? { type: "run_end", stopReason: lastAssistant.stopReason } : { type: "run_end" });
+                }
+                catch {
+                    /* 轨迹尽力而为 */
+                }
                 this.scheduleSessionsRefresh();
                 this.refreshConversationTitle(conv);
                 // 内联标记不在此兜底扫最后一条 assistant：每条气泡结束已走 message_end
@@ -1659,16 +1848,47 @@ export class ClientSession {
                 break;
             }
             case "message_end": {
+                // 轨迹事件：一条消息定稿（user/assistant 都收；custom display:false
+                // 的 serializeMessage 返回 null 时跳过）。
+                try {
+                    const ui = serializeMessage(event.message, 0);
+                    if (ui)
+                        this.emitRun(conv, { type: "message", message: ui });
+                }
+                catch {
+                    /* 轨迹尽力而为 */
+                }
+                // 每条 assistant 气泡流式结束 → 立即解析其中的内联标记：每个气泡各自
                 // 每条 assistant 气泡流式结束 → 立即解析其中的内联标记：每个气泡各自
                 // 生效（不再等整轮 agent_end），同一轮里先前消息的标记也不再丢。
                 const mm = event.message;
                 if (mm?.role !== "assistant")
                     break;
+                // 非 error 的 assistant 定稿 = 重试周期结束（与 SDK 重置
+                // _retryAttempt 的条件一致）：即使 auto_retry_end 丢失，横幅也不会卡住。
+                if (mm.stopReason !== "error")
+                    conv.retryState = null;
                 const text = extractAssistantTextFromContent(mm.content);
                 if (text && text.includes("[["))
                     void this.markerSvc.handleAssistantText(conv.id, text);
                 break;
             }
+            case "agent_start": {
+                // 轨迹事件：新一轮开始（任务文本由 prompt() 暂存；steer/内部续跑
+                // 无暂存时省略，插件回退为「继续执行」）。
+                const task = conv.pendingTask;
+                conv.pendingTask = undefined;
+                this.emitRun(conv, task ? { type: "run_start", task } : { type: "run_start" });
+                break;
+            }
+            case "turn_start": {
+                this.emitRun(conv, { type: "turn_start" });
+                break;
+            }
+            case "turn_end": {
+                this.emitRun(conv, { type: "turn_end" });
+                break;
+            }
             case "message_update": {
                 // Live assistant-message increment, deliberately OUTSIDE the snapshot
                 // channel: send() drops snapshots under backpressure (big sessions),
@@ -1714,7 +1934,11 @@ export class ClientSession {
         // Snapshot checkpoint policy: deltas carry live rendering during streaming;
         // full snapshots are reconciliation checkpoints taken immediately at
         // run/tool boundaries and on a slow timer otherwise.
-        if (event.type === "agent_end" || event.type === "tool_execution_end" || event.type === "compaction_end") {
+        if (event.type === "agent_end" ||
+            event.type === "tool_execution_end" ||
+            event.type === "compaction_end" ||
+            event.type === "auto_retry_start" ||
+            event.type === "auto_retry_end") {
             this.flushSnapshot();
         }
         else {
@@ -1751,7 +1975,10 @@ export class ClientSession {
     }
     /** Serialize a persisted message with a STABLE id + cached object reference. */
     serializeCached(m) {
-        const conv = this.conv;
+        return this.serializeCachedFor(this.conv, m);
+    }
+    /** serializeCached 的按对话版本（插件快照读非活跃对话用；缓存仍按对话隔离）。 */
+    serializeCachedFor(conv, m) {
         // toolResult messages are keyed by toolCallId; everything else by
         // role+timestamp. A single prompt can emit several same-role messages
         // within the SAME millisecond (multiple attachment asides), so the
@@ -1801,10 +2028,17 @@ export class ClientSession {
      *  Element objects are reference-stable (serializeCached cache), which is
      *  what lets emitSnapshotNow detect append-only growth via identity walk. */
     currentMessages() {
-        const conv = this.conv;
-        const rawMessages = conv.session.agent.state.messages
-            .map((m) => this.serializeCached(m))
+        return this.messagesOf(this.conv);
+    }
+    /** currentMessages 的按对话版本（插件快照读非活跃对话用）。 */
+    messagesOf(conv) {
+        let rawMessages = conv.session.agent.state.messages
+            .map((m) => this.serializeCachedFor(conv, m))
             .filter((m) => m !== null);
+        // 自动重试等待期：SDK 暂留在 state 末尾的 error 气泡只是中间态（随后被
+        // 摘掉重跑），不进快照——成功则用户永远看不到，耗尽才标红。否则 agent_end
+        // 的立即 flush 会先画红、摘掉后又消失（红色一闪而过）。
+        rawMessages = stripTransientRetryErrors(rawMessages, !!conv.retryState);
         // Reuse the previous array when nothing changed: the element objects are
         // cached (reference-stable) anyway, and a stable array reference lets the
         // frontend memoize derived maps instead of rebuilding them every 60ms.
@@ -1843,6 +2077,13 @@ export class ClientSession {
         catch {
             // stats are best-effort
         }
+        // 流式 error 同样是中间态（定稿走 message_end/agent_end）：先藏起
+        // errorMessage，避免红色在 streaming 气泡里闪一下。最终失败会经由
+        // messages 永久标红，不影响告警。
+        let streamingMessage = state.streamingMessage ? serializeStreamingMessage(state.streamingMessage) : null;
+        if (streamingMessage?.stopReason === "error") {
+            streamingMessage = { ...streamingMessage, errorMessage: undefined };
+        }
         return {
             clientId: this.clientId,
             cwd: this.cwd,
@@ -1850,11 +2091,7 @@ export class ClientSession {
             sessionFile: this.session.sessionFile,
             conversationId: this.activeId,
             rev,
-            // The in-progress assistant message lives in state.streamingMessage
-            // (the SDK only pushes it into state.messages at message_end). Surfacing
-            // it here is what makes thinking + text stream into the browser at
-            // ~60ms granularity instead of appearing only when the turn finishes.
-            streamingMessage: state.streamingMessage ? serializeStreamingMessage(state.streamingMessage) : null,
+            streamingMessage,
             isStreaming: this.session.isStreaming,
             model: model
                 ? {
@@ -1870,6 +2107,7 @@ export class ClientSession {
             availableThinkingLevels: this.session.getAvailableThinkingLevels(),
             queue: { steering: conv.queueSteering, followUp: conv.queueFollowUp },
             errorMessage: state.errorMessage,
+            retry: conv.retryState ?? null,
             tools: state.tools.map((t) => t.name),
             version: ++this.version,
             piConfigured: this.isPiConfigured(),
@@ -2607,6 +2845,9 @@ export class ClientSession {
             // is refused until admission reopens.
             if (this.quiesceBlocked())
                 return;
+            // 轨迹用：暂存本轮任务文本，下一轮 agent_start 消费（steer/内部续跑
+            // 不经此处，届时 task 缺省，插件回退为「继续执行」）。
+            conv.pendingTask = text.trim() ? truncRun(text.trim(), RUN_TASK_CAP) : undefined;
             // Name the conversation from its FIRST prompt immediately, before any
             // await: the typed text IS the name. The `conv` reference was captured
             // before the try block, so a concurrent switch/new_chat while prompt()
@@ -3000,6 +3241,8 @@ export class ClientSession {
             // The new runtime re-discovered skills/templates — refresh the catalog
             // so the picker stops showing the previous runtime's list.
             void this.pushSlashCommands();
+            // 新对话即当前打开 → 插件重拉（轨迹视图跟随）。
+            this.notifyConversationChanged();
         }
         catch (err) {
             this.emit({
@@ -3115,6 +3358,8 @@ export class ClientSession {
             void this.listFiles(undefined);
             void this.listCommands();
         }
+        // 当前打开对话变了 → 插件重拉（轨迹视图切会话后即刷新，不等轮询）。
+        this.notifyConversationChanged();
         this.flushSnapshot();
     }
     /** Push every running conversation across ALL projects to the client. The
@@ -3565,6 +3810,8 @@ export class ClientSession {
             this.pushTerminals();
             // The restored conversation has a fresh project-bound resource cache.
             void this.pushSlashCommands();
+            // 切历史会话成功 → 插件重拉（轨迹视图立即显示该会话时间线）。
+            this.notifyConversationChanged();
         }
         catch (err) {
             openedTerminals?.killAll();
@@ -3812,10 +4059,25 @@ export class ClientSession {
     }
     async setCwd(newCwd) {
         try {
-            const { resolve } = await import("node:path");
+            const { resolve, sep } = await import("node:path");
             this.files.unwatchGit(); // stale repo's watcher must not fire across projects
             const fs = await import("node:fs/promises");
-            const abs = resolve(newCwd);
+            const trimmed = newCwd.trim();
+            if (trimmed === MACHINE_ROOT) {
+                // 机器根是虚拟层（盘符列表），不能作工作目录——指引用户选具体目录。
+                this.emit({
+                    type: "notice",
+                    level: "warning",
+                    text: "请选择一个具体目录作为工作目录（此电脑本身不是目录）",
+                    textEn: "Pick a concrete directory as the workspace (This PC itself is not a directory)",
+                });
+                return;
+            }
+            // Windows 裸盘符（"C:"）：resolve 会按该盘当前目录解析，必须显式指到盘根；
+            // 仅 win32 生效——posix 下 "C:" 仍是普通相对路径，避免误伤同名目录。
+            const abs = process.platform === "win32" && /^[A-Za-z]:$/.test(trimmed)
+                ? `${trimmed.toUpperCase()}${sep}`
+                : resolve(trimmed);
             const st = await fs.stat(abs);
             if (!st.isDirectory()) {
                 throw new Error("路径不是目录");
@@ -3900,6 +4162,8 @@ export class ClientSession {
             void this.listFiles(undefined);
             // Commands are per-project (.pi/commands.json in the current cwd).
             void this.listCommands();
+            // 切项目即换了当前打开对话 → 插件重拉。
+            this.notifyConversationChanged();
         }
         catch (err) {
             this.emit({
@@ -4080,6 +4344,10 @@ export class AgentService {
     cwd;
     /** index.ts 注入：SDK 工具执行事件的插件转发钩子，attach 时拷贝到每个新会话。 */
     onToolEvent = undefined;
+    /** index.ts 注入：运行轨迹事件的插件转发钩子，attach 时拷贝到每个新会话。 */
+    onRunEvent = undefined;
+    /** index.ts 注入：对话切换通知钩子，attach 时拷贝到每个新会话。 */
+    onConversationChanged = undefined;
     /** index.ts 注入：读取插件当前注册的 AI 工具（attach 时拷贝到每个新会话）。 */
     pluginToolsProvider = undefined;
     /** index.ts 注入：读取插件当前注册的斜杠命令（attach 时拷贝到每个新会话）。 */
@@ -4142,6 +4410,21 @@ export class AgentService {
             n += cs.pendingMessages();
         return n;
     }
+    /** 插件用：全客户端最近活跃对话的快照（at 最大者即“当前打开的对话”）。 */
+    readConversationForPlugins() {
+        let best = null;
+        for (const cs of this.clients.values()) {
+            try {
+                const s = cs.readConversationForPlugins();
+                if (s && (!best || s.at > best.at))
+                    best = s;
+            }
+            catch {
+                /* 单客户端坏了不影响其他 */
+            }
+        }
+        return best;
+    }
     /** index.ts calls this when a browser socket opens/closes. */
     noteSocketOpen() {
         this.socketCount += 1;
@@ -4217,6 +4500,8 @@ export class AgentService {
         // Forward hooks (set once by index.ts) to every session.
         cs.onQuit = this.onQuit;
         cs.onToolEvent = this.onToolEvent;
+        cs.onRunEvent = this.onRunEvent;
+        cs.onConversationChanged = () => this.onConversationChanged?.();
         cs.pluginToolsProvider = this.pluginToolsProvider;
         cs.pluginCommandsProvider = this.pluginCommandsProvider;
         cs.pluginBgTasksProvider = this.pluginBgTasksProvider;

package/dist/server/attachments.js

@@ -454,9 +454,9 @@ export async function buildAttachmentMessages(ctx, attachments) {
                         content: [
                             {
                                 type: "text",
-                                text: `
-<vision-bridge>
-${transcript}
+                                text: `
+<vision-bridge>
+${transcript}
 </vision-bridge>`,
                             },
                             ...(pathImg

package/dist/server/client-state.js

@@ -211,6 +211,8 @@ export class ClientStateStore {
             visionBridgePromptMode: stored?.visionBridgePromptMode === "replace" ? "replace" : "append",
             visionBridgePrompt: stored?.visionBridgePrompt ?? "",
             subagentDefaultModel: stored?.subagentDefaultModel ?? null,
+            quickPhrases: stored?.quickPhrases ?? [],
+            quickPhrasesEnabled: stored?.quickPhrasesEnabled ?? true,
             reviewPrompt: stored?.reviewPrompt ?? "",
             reviewDisabledSkills: stored?.reviewDisabledSkills ?? [],
             disabledPlugins: stored?.disabledPlugins ?? [],
@@ -242,6 +244,8 @@ export class ClientStateStore {
             reviewPrompt: settings.reviewPrompt ?? cur.reviewPrompt ?? "",
             reviewDisabledSkills: settings.reviewDisabledSkills ?? cur.reviewDisabledSkills ?? [],
             disabledPlugins: settings.disabledPlugins ?? cur.disabledPlugins ?? [],
+            quickPhrases: settings.quickPhrases ?? cur.quickPhrases ?? [],
+            quickPhrasesEnabled: settings.quickPhrasesEnabled ?? cur.quickPhrasesEnabled ?? true,
         };
         this.save();
     }

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

@@ -112,6 +112,8 @@ const DEFAULT_SETTINGS = {
     toolsWrap: true,
     disabledPlugins: [],
     reviewPrompt: "",
+    quickPhrases: [],
+    quickPhrasesEnabled: true,
 };
 // ---------------------------------------------------------------------------
 // DshClientSession — 一个浏览器客户端
@@ -223,6 +225,8 @@ export class DshClientSession {
                 toolsWrap: savedSettings.toolsWrap,
                 disabledPlugins: savedSettings.disabledPlugins ?? [],
                 reviewPrompt: savedSettings.reviewPrompt,
+                quickPhrases: savedSettings.quickPhrases ?? [],
+                quickPhrasesEnabled: savedSettings.quickPhrasesEnabled ?? true,
             };
         }
         // 第一个 conversation = 新会话（每客户端独立 sessionId，避免多标签页/多
@@ -2082,6 +2086,8 @@ export class DshClientSession {
             subagentDefaultTemplates: [],
             subagentDefaultModel: null,
             subagentModels: [],
+            quickPhrases: [...this.settings.quickPhrases],
+            quickPhrasesEnabled: this.settings.quickPhrasesEnabled,
         };
         this.emit({ type: "settings_state", settings });
     }
@@ -2110,6 +2116,15 @@ export class DshClientSession {
             this.settings.disabledPlugins = partial.disabledPlugins;
         if (partial.reviewPrompt !== undefined)
             this.settings.reviewPrompt = partial.reviewPrompt;
+        if (partial.quickPhrases !== undefined) {
+            const seen = new Set();
+            this.settings.quickPhrases = (Array.isArray(partial.quickPhrases) ? partial.quickPhrases : [])
+                .map((p) => String(p).trim().slice(0, 200))
+                .filter((p) => p && !seen.has(p) && (seen.add(p), true))
+                .slice(0, 30);
+        }
+        if (partial.quickPhrasesEnabled !== undefined)
+            this.settings.quickPhrasesEnabled = partial.quickPhrasesEnabled;
         // 持久化（跨重连存活）。
         this.stateStore.saveSettings(this.clientId, {
             promptMode: this.settings.promptMode,
@@ -2124,6 +2139,8 @@ export class DshClientSession {
             toolsWrap: this.settings.toolsWrap,
             disabledPlugins: this.settings.disabledPlugins,
             reviewPrompt: this.settings.reviewPrompt,
+            quickPhrases: this.settings.quickPhrases,
+            quickPhrasesEnabled: this.settings.quickPhrasesEnabled,
         });
         // 仅系统提示词变化才重启运行时（DSH_PERSONA 由 launcher env 注入）；
         // 其他设置（开关/隐藏插件等）只存不回写运行时。

package/dist/server/dsh/runtime/cordis.yml

@@ -1 +1 @@
-[]
+[]