pi-web-ui 0.86.1 → 0.87.0

package/dist/server/agent-service.js

@@ -18,6 +18,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { createRequire } from "node:module";
 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 { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashToolDefinition, createLocalBashOperations, getAgentDir, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
@@ -32,10 +33,11 @@ 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, MACHINE_ROOT, workspacePath } from "./files-service.js";
+import { FilesService, MACHINE_ROOT, desktopDirWire, workspacePath } from "./files-service.js";
 import { isExtensionDisabled, isExtensionEnabled, normalizeRetryMaxAttempts, normalizeSkillList, ClientStateStore, } from "./client-state.js";
 import { bilingual, pick, resolveServerLang } from "./i18n.js";
 import { SubagentTemplatesStore, pickTemplatePrompt } from "./subagent-templates.js";
+import { ComposerDraftsStore } from "./composer-drafts.js";
 import { applyHeadTail, makePersistentTerminalTools, makeTerminalBashTool, stripAnsi, TERMINAL_TOOLS_GUIDANCE, } from "./terminals.js";
 import { applyAgentToolsGating, ASK_USER_QUESTION_TOOL_NAME, BROWSER_PAGE_TOOL_NAME, effectiveDisabledAgentTools, isTerminalGuidanceOn, MARKERS_LIST_TOOL_NAME, } from "./tool-manager.js";
 import { WebUIContext } from "./webui-context.js";
@@ -50,6 +52,12 @@ import { launchOrigin, toServiceInfo } from "./launch-origin.js";
 import { serializeMessage, serializeStreamingMessage, stripTransientRetryErrors, } from "./serialize.js";
 import { loadCommands, saveCommandsFile, TerminalManager } from "./terminals.js";
 const SNAPSHOT_INTERVAL_MS = 60;
+/** 服务进程所在机器的用户主目录（wire 格式）：进程内不变，模块加载时求值一次，
+ *  快照热路径直接引用（右栏 🏠 一键直达，见 protocol.ts 的 UiState.homeDir）。 */
+const HOME_WIRE = homedir().replace(/\\/g, "/");
+/** 桌面目录（wire 格式）：进程内不变（见 files-service.ts 的 desktopDirWire），
+ *  不存在则空串 → 前端不渲染 🖥️。 */
+const DESKTOP_WIRE = desktopDirWire(HOME_WIRE);
 /** While assistant deltas are flowing, live rendering is carried by
  *  message_delta — full snapshots become pure reconciliation checkpoints, so
  *  send them on a slow event-driven cadence (see flushSnapshot call-sites:
@@ -962,6 +970,10 @@ export class ClientSession {
         conv.listed = true;
         conv.title = subagentTitle(prompt);
         this.convs.set(conv.id, conv);
+        // 子代理会话同样订阅 SDK 事件：否则 onEvent 永不触发，点开查看时没有
+        // message_delta 流式增量、快照也不刷新，只能靠切走切回时的 flushSnapshot
+        // 看到新内容（dismiss/释放流程本来就会 unsubscribe，不泄漏）。
+        conv.unsubscribe = conv.session.subscribe((event) => this.onEvent(conv, event));
         // 子代理不走 bindSession——这里同样注入面板的重试次数覆盖。
         this.applyRetryOverrides();
         // 扩展绑定（rpc 模式）；用 headless 的 Web UI context：
@@ -1368,6 +1380,8 @@ export class ClientSession {
     watchTimer = null;
     /** 子代理模板库（全局共享，<dataDir>/subagent-templates.json）。 */
     subagentTemplates;
+    /** 未发送输入框草稿（全局共享，<dataDir>/composer-drafts.json，按 sessionId 键入，见 server/composer-drafts.ts）。 */
+    drafts;
     /** 内置标记服务（todo/notify/svc/rename 等，可全局/分组开关）。 */
     markerSvc;
     // -----------------------------------------------------------------------
@@ -1401,6 +1415,7 @@ export class ClientSession {
         this.stateStore = stateStore;
         this.roots = stateStore.getWorkspaceRoots(clientId, cwd);
         this.subagentTemplates = new SubagentTemplatesStore(join(stateStore.dataDir, "subagent-templates.json"));
+        this.drafts = new ComposerDraftsStore(join(stateStore.dataDir, "composer-drafts.json"));
         this.markerSvc = new MarkerService({
             clientId,
             stateStore,
@@ -1484,6 +1499,7 @@ export class ClientSession {
                 this.piCheckCache = null;
             },
             pushModels: async () => this.listModels(),
+            onOAuthActivated: (provider) => this.stateStore.deleteProviderEverywhere(provider),
         });
         // Prune dead background tasks every 30s (only spawns netstat/lsof while
         // the list is non-empty). unref: must not keep the process alive.
@@ -1838,6 +1854,7 @@ export class ClientSession {
         // Reconnect: push the built-in provider key list (multi-key grouping in the
         // model picker needs it even before the client asks).
         this.modelAdmin.listProviderKeys();
+        this.modelAdmin.listProviderOAuthFlows();
         // PTYs are conversation-owned and survive a socket reconnect.
         this.pushTerminals();
     }
@@ -2027,6 +2044,153 @@ export class ClientSession {
             return null;
         }
     }
+    /** 插件扩展点 v2（只读组装，供 index.ts 注入给 PluginManager 的 conversationLister）。
+     *  本客户端运行中对话（kind:"running"）+ 当前项目历史会话摘要（kind:"history"，最多 50 条）。
+     *  纯数据组装，不 emit、不改任何状态；历史会话读失败时只回运行中部分。 */
+    listRunningForPlugins() {
+        const out = [];
+        for (const conv of this.convs.values()) {
+            let isStreaming = false;
+            try {
+                isStreaming = conv.session.isStreaming;
+            }
+            catch {
+                // 会话替换中——按未跑处理
+            }
+            out.push({ id: conv.id, title: conv.title, cwd: conv.cwd, kind: "running", isStreaming });
+        }
+        return out;
+    }
+    /** 插件扩展点 v2（conversationLister 的历史一半）：当前项目历史会话摘要，最多 50 条。
+     *  复用 refreshSessions/searchSessions 共用的 loadSessionInfos 缓存（3s TTL，不扫两遍盘）。 */
+    async listHistoryForPlugins(limit = 50) {
+        try {
+            const infos = await this.loadSessionInfos();
+            return infos.slice(0, Math.max(0, limit)).map((s) => ({
+                id: s.path,
+                title: (s.name?.trim() || s.firstMessage.trim() || basename(s.path)).slice(0, 60),
+                cwd: this.cwd,
+                kind: "history",
+                isStreaming: false,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    /** 插件扩展点 v2（供 conversationSearcher）：运行中对话标题 + 历史会话全文匹配，返回前 N 个 {id,title}。
+     *  复用 searchSessions 的 sessionMatchesSearch 判定（含转录全文），只读不 emit。 */
+    async searchForPlugins(query, limit = 20) {
+        const q = query.trim().toLowerCase();
+        if (!q)
+            return [];
+        const out = [];
+        for (const conv of this.convs.values()) {
+            if (conv.title.toLowerCase().includes(q))
+                out.push({ id: conv.id, title: conv.title });
+            if (out.length >= limit)
+                return out;
+        }
+        try {
+            const infos = await this.loadSessionInfos();
+            for (const s of infos) {
+                if (!sessionMatchesSearch(q, s))
+                    continue;
+                out.push({
+                    id: s.path,
+                    title: (s.name?.trim() || s.firstMessage.trim() || basename(s.path)).slice(0, 60),
+                });
+                if (out.length >= limit)
+                    break;
+            }
+        }
+        catch {
+            // 读盘失败只回运行中部分
+        }
+        return out;
+    }
+    /** 插件扩展点 v2（供 conversationWriter）：向指定对话投递 prompt，复用现有 prompt 投递路径。
+     *  目标非当前对话时先 switchConversation（复用跨项目切换副作用），再走 this.prompt
+     *  （斜杠拦截/排空门禁/并行提醒/首条命名全在里面）；找不到对话返回 {ok:false,error}。 */
+    async writeForPlugins(id, text) {
+        try {
+            const conv = this.convs.get(id);
+            if (!conv)
+                return { ok: false, error: `未知对话：${id}` };
+            if (!text.trim())
+                return { ok: false, error: "投递文本为空" };
+            if (id !== this.activeId)
+                await this.switchConversation(id);
+            await this.prompt(text);
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    /** 插件扩展点 v2（供 runAborter）：中止指定对话的运行，复用 abort 的 interruptRun 路径
+     *  （abort 卡住/空转时的强制重置语义一并继承）。未在跑时直接 {ok:true}（幂等）。 */
+    async abortForPlugins(id) {
+        try {
+            const conv = this.convs.get(id);
+            if (!conv)
+                return { ok: false, error: `未知对话：${id}` };
+            if (this.conversationStreaming(conv)) {
+                await this.interruptRun(conv, "插件已中止运行");
+                this.flushSnapshot();
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    /** 插件扩展点（供 runSteerer 跨客户端兜底复用）：只在本客户端 conversations 里找对话，
+     *  持有则执行 steer 并返回结果，未持有回 undefined（不碰钩子，无递归）。 */
+    async steerOwnConversation(id, text) {
+        const conv = this.convs.get(id);
+        if (!conv?.session)
+            return undefined;
+        await conv.session.sendUserMessage(text, conv.session.isStreaming ? { deliverAs: "steer" } : undefined);
+        return { ok: true };
+    }
+    /** 插件扩展点（供 runSteerer）：向指定对话插队一条用户消息，复用子代理 steer 的
+     *  sendUserMessage + deliverAs:'steer' 路径（运行时插队；未跑时按普通消息投递）。
+     *  先找本客户端 conversations，找不到再经 steerConversationElsewhere 问其他客户端；
+     *  空文本回 {ok:false}；异常 catch 透传 message。 */
+    async steerForPlugins(conversationId, text) {
+        try {
+            if (!text.trim())
+                return { ok: false, error: "空消息" };
+            const own = await this.steerOwnConversation(conversationId, text);
+            if (own)
+                return own;
+            if (typeof this.steerConversationElsewhere === "function") {
+                const r = await this.steerConversationElsewhere(conversationId, text);
+                if (r)
+                    return r;
+            }
+            return { ok: false, error: `未知对话：${conversationId}` };
+        }
+        catch (err) {
+            return { ok: false, error: err.message };
+        }
+    }
+    /** 插件扩展点 v2（供 modelLister）：复用 listModels 的模型列表映射 {id,provider,vision}。
+     *  与 listModels 唯一差别：不做网络 refresh（插件列表走缓存目录，15s 超时也不等），只读不 emit。 */
+    async listModelsForPlugins() {
+        try {
+            const available = await this.runtime.services.modelRuntime.getAvailable();
+            return available.map((m) => ({
+                id: `${m.provider}/${m.id}`,
+                provider: m.provider,
+                vision: m.input?.includes("image") ?? false,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
     onEvent(conv, event) {
         // Any SDK event proves the run is alive — feeds the stall watchdog below.
         conv.lastSdkEventAt = Date.now();
@@ -2535,7 +2699,7 @@ export class ClientSession {
         return messages;
     }
     /** Build every UiState field EXCEPT messages (the expensive part). */
-    buildLightState(rev) {
+    buildLightState(rev, withDraft = false) {
         const conv = this.conv;
         const state = conv.session.agent.state;
         const model = state.model;
@@ -2587,6 +2751,9 @@ export class ClientSession {
             cwd: this.cwd,
             // 判重：直接读缓存字段，不在快照热路径上重读 client-state。
             workspaceRoots: this.roots,
+            // 用户主目录（右栏 🏠）：进程内不变，模块级求值一次，不在热路径调 homedir()。
+            homeDir: HOME_WIRE,
+            desktopDir: DESKTOP_WIRE,
             sessionId: this.session.sessionId,
             sessionFile: this.session.sessionFile,
             conversationId: this.activeId,
@@ -2610,6 +2777,10 @@ export class ClientSession {
             retry: conv.retryState ?? null,
             compaction: conv.compactionState ?? null,
             pendingQuestion: this.pendingQuestionForSnapshot(),
+            // 未发送草稿只跟全量快照走（切会话/new_chat/get_state）：增量 delta 里
+            // 这个 key 必须整个缺席（不能是显式的 undefined——前端 delta 合并是
+            // {...ui, ...d.state} 整批覆盖，显式 undefined 会把上次全量带回的草稿洗掉）。
+            ...(withDraft ? { draft: this.draftForSnapshot() } : {}),
             tools: state.tools.map((t) => t.name),
             version: ++this.version,
             piConfigured: this.isPiConfigured(),
@@ -2653,7 +2824,7 @@ export class ClientSession {
                 rev,
                 baseRev,
                 appended: cur.slice(prev.length),
-                state: this.buildLightState(rev),
+                state: this.buildLightState(rev, false),
             });
         }
         else {
@@ -2662,7 +2833,9 @@ export class ClientSession {
             this.emittedRev = rev;
             this.emit({
                 type: "snapshot",
-                state: { ...this.buildLightState(rev), messages: cur },
+                // 全量快照一律带草稿（切会话/new_chat/改写分支/重连 get_state 全走这里）；
+                // 60ms 热帧是上面的 snapshot_delta，本来就不带。
+                state: { ...this.buildLightState(rev, true), messages: cur },
             });
         }
     }
@@ -2981,6 +3154,9 @@ export class ClientSession {
      *  - onRunningChanged：本实例流式集合变化时触发，AgentService 借此让其他
      *    客户端重推 conversations（elsewhere 列表近实时）。 */
     findSessionOwner = undefined;
+    /** 插件 steer 跨客户端兜底钩子：attach 时由 AgentService 接线（见 steerElsewhere），
+     *  在其他客户端的 conversations 里找对话并由持有方执行 steer，未持有回 undefined。 */
+    steerConversationElsewhere = undefined;
     /** issue #145：除本客户端外是否有人在跑（扫目录查重前置的无 I/O 判断）。 */
     hasStreamingElsewhere = undefined;
     listProjectRunners = undefined;
@@ -3201,10 +3377,27 @@ export class ClientSession {
         return this.modelAdmin.setProviderApiKey(provider, apiKey);
     }
     async clearProviderApiKey(provider) {
+        const usingOAuth = this.runtime.services.modelRuntime.isUsingOAuth(provider.trim());
         await this.modelAdmin.clearProviderApiKey(provider);
         // The provider is back to unconfigured — drop its key preference in
         // EVERY project, otherwise each project switch re-tries a restore.
-        this.stateStore.deleteProviderEverywhere(provider.trim());
+        if (!usingOAuth)
+            this.stateStore.deleteProviderEverywhere(provider.trim());
+    }
+    startProviderOAuth(provider) {
+        this.modelAdmin.startProviderOAuth(provider);
+    }
+    replyProviderOAuth(flowId, promptId, value) {
+        this.modelAdmin.replyProviderOAuth(flowId, promptId, value);
+    }
+    cancelProviderOAuth(flowId) {
+        this.modelAdmin.cancelProviderOAuth(flowId);
+    }
+    listProviderOAuthFlows() {
+        this.modelAdmin.listProviderOAuthFlows();
+    }
+    logoutProviderOAuth(provider) {
+        return this.modelAdmin.logoutProviderOAuth(provider);
     }
     listProviders() {
         return this.modelAdmin.listProviders();
@@ -3634,6 +3827,14 @@ export class ClientSession {
         // switch/new_chat while prompt() is in flight must never target a
         // different conversation.
         const conv = this.conv;
+        // 输入框内容被消费（发送/斜杠执行）→ 清掉该会话存过的草稿（best-effort）。
+        // 快捷短语发送（不碰输入框）同样清：客户端发送成功后会把当前草稿重存回来。
+        try {
+            this.drafts.clear(conv.session.sessionId);
+        }
+        catch {
+            // ignore
+        }
         try {
             const s = this.session;
             // Native slash commands (see NATIVE_COMMANDS) are executed here and
@@ -3954,6 +4155,32 @@ export class ClientSession {
         }
         this.flushSnapshot();
     }
+    // -----------------------------------------------------------------------
+    // 未发送输入框草稿（issue #166，单中心文件方案，见 server/composer-drafts.ts）
+    // -----------------------------------------------------------------------
+    /** 存指定会话的未发送草稿（`draft_update` 入口，经 DispatchSession.saveDraft）。
+     *  按消息自带的 sessionId 落键（不按 active 会话：切会话时的「离开刷盘」
+     *  晚于服务端的切换到达）。空白新会话的转录还没落盘，但 id 内存里已有。
+     *  存完不推快照：同页的草稿本来就是自己打的；恢复走全量快照的 draft 字段。 */
+    saveDraft(sessionId, text, ts) {
+        try {
+            if (!sessionId)
+                return;
+            this.drafts.save(sessionId, text, ts);
+        }
+        catch {
+            // best-effort：草稿丢了可以重打
+        }
+    }
+    /** 当前活跃对话的草稿（全量快照用；增量 snapshot_delta 传 withDraft=false 不带）。 */
+    draftForSnapshot() {
+        try {
+            return this.drafts.get(this.conv.session.sessionId) ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
     /** Re-push the current list on request (panel opened); prunes dead entries first. */
     async listBgServers() {
         await this.bg.listAndPush();
@@ -4117,7 +4344,8 @@ export class ClientSession {
      *  空白新对话」——/new <prompt> 只在 true 时投递首条提示；false 表示没能进入
      *  新对话（准入关闭 / 同项目对话数达上限 / runtime 创建失败），此时照发会把
      *  首条提示投进用户原本正在用的那个对话里。 */
-    async newChat() {
+    async newChat(_preset) {
+        // _preset: DSH Agent 预设（pi 引擎无此概念，忽略；wire 统一见 protocol new_chat）。
         if (this.quiesceBlocked())
             return false;
         // Reuse an already-open blank conversation instead of piling up new ones
@@ -4687,6 +4915,13 @@ export class ClientSession {
                 }
             }
             rmSync(abs, { force: true });
+            // 转录删了，未发送草稿再留着就是孤儿，一起清掉。
+            try {
+                this.drafts.pruneSessionFile(abs);
+            }
+            catch {
+                // ignore
+            }
             // 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.
@@ -5506,6 +5741,22 @@ export class ClientSession {
     async uploadFile(relDir, name, data) {
         return this.files.uploadFile(relDir, name, data);
     }
+    /** 文件树右键菜单：新建（空文件/空文件夹）。 */
+    async createEntry(dir, name, kind) {
+        return this.files.createEntry(dir, name, kind);
+    }
+    /** 文件树右键菜单：同目录内重命名。 */
+    async renameEntry(path, newName) {
+        return this.files.renameEntry(path, newName);
+    }
+    /** 文件树右键菜单：删除文件/目录。 */
+    async deleteEntry(path) {
+        return this.files.deleteEntry(path);
+    }
+    /** 文件树右键菜单：复制/移动（move=true 即剪切粘贴）。 */
+    async copyEntry(src, destDir, move) {
+        return this.files.copyEntry(src, destDir, move);
+    }
     async makeDir(relPath) {
         return this.files.makeDir(relPath);
     }
@@ -5862,6 +6113,7 @@ export class ClientSession {
     }
     async dispose() {
         this.disposed = true;
+        this.modelAdmin.dispose();
         for (const conv of this.convs.values())
             conv.terminals.killAll();
         if (this.snapshotTimer) {
@@ -5991,6 +6243,24 @@ export class AgentService {
         }
         return null;
     }
+    /** 插件 steer 跨客户端兜底：除请求方外逐个问其他客户端的 conversations，
+     *  找到持有方由其执行 steer（只调 steerOwnConversation，不碰钩子，无递归）；
+     *  都找不到回 undefined，调用方回未知对话。单客户端异常跳过，不影响其他。 */
+    async steerElsewhere(excludeClientId, id, text) {
+        for (const [clientId, cs] of this.clients) {
+            if (clientId === excludeClientId)
+                continue;
+            try {
+                const r = await cs.steerOwnConversation(id, text);
+                if (r)
+                    return r;
+            }
+            catch {
+                // 单客户端坏了继续找下一个
+            }
+        }
+        return undefined;
+    }
     /** issue #145：别处在某 cwd 下正在跑的对话（同项目并行感知用，不含请求方）。 */
     listProjectRunners(cwd, excludeClientId) {
         const out = [];
@@ -6169,6 +6439,7 @@ export class AgentService {
                 cs.listExternalRunning = () => this.listExternalRunning(clientId);
                 cs.notifyExternalClients = (msg) => this.notifyClientsExcept(clientId, msg);
                 cs.onRunningChanged = () => this.pokeExternalRunning(clientId);
+                cs.steerConversationElsewhere = (id, text) => this.steerElsewhere(clientId, id, text);
                 // Make sure the restored/default workspace appears in the project list.
                 this.stateStore.remember(clientId, cwd);
                 if (cwd !== this.cwd) {
@@ -6203,6 +6474,7 @@ export class AgentService {
         cs.listExternalRunning = () => this.listExternalRunning(clientId);
         cs.notifyExternalClients = (msg) => this.notifyClientsExcept(clientId, msg);
         cs.onRunningChanged = () => this.pokeExternalRunning(clientId);
+        cs.steerConversationElsewhere = (id, text) => this.steerElsewhere(clientId, id, text);
         // 插件宿主工作区跟随：初次接入也同步一次（恢复的 lastCwd 可能≠服务启动目录），
         // notifyCwd 幂等去重；此后 set_cwd 成功时由 cs.onCwdChanged 继续驱动。
         cs.onCwdChanged = (abs, roots) => this.onClientCwdChanged?.(abs, roots);
@@ -6250,6 +6522,25 @@ export class AgentService {
     get(clientId) {
         return this.clients.get(clientId);
     }
+    /** 插件扩展点 v2：挑一个最合适的客户端会话供无浏览器调用的插件 API 用
+     *  （conversationLister/Searcher/Writer、modelLister、runAborter）。
+     *  有运行中对话的优先，否则任意残留客户端；一个没有时返回 undefined，
+     *  调用方（index.ts 注入）回退空列表 / {ok:false}，绝不抛错。 */
+    pluginClient() {
+        let fallback;
+        for (const cs of this.clients.values()) {
+            if (!fallback)
+                fallback = cs;
+            try {
+                if (cs.activeConversations() > 0)
+                    return cs;
+            }
+            catch {
+                // 单客户端坏了不影响挑选
+            }
+        }
+        return fallback;
+    }
     async disposeAll() {
         // Record still-streaming conversations BEFORE tearing anything down, so
         // the next attach can tell the user what was lost (SIGTERM / update).

package/dist/server/client-state.js

@@ -357,6 +357,12 @@ export class ClientStateStore {
             reviewDisabledSkills: stored?.reviewDisabledSkills ?? [],
             disabledPlugins: stored?.disabledPlugins ?? [],
             uiLayout: normalizeUiLayout(stored?.uiLayout),
+            defaultAgentPreset: typeof stored?.defaultAgentPreset === "string" && stored.defaultAgentPreset
+                ? stored.defaultAgentPreset
+                : "standard",
+            defaultPermissionPreset: typeof stored?.defaultPermissionPreset === "string" && stored.defaultPermissionPreset
+                ? stored.defaultPermissionPreset
+                : "workspace-write-never",
         };
     }
     /** Persist the settings-panel state (partial merge) — global shared config. */
@@ -395,6 +401,8 @@ export class ClientStateStore {
             uiLayout: normalizeUiLayout(settings.uiLayout ?? cur.uiLayout),
             quickPhrases: settings.quickPhrases ?? cur.quickPhrases ?? [],
             quickPhrasesEnabled: settings.quickPhrasesEnabled ?? cur.quickPhrasesEnabled ?? true,
+            defaultAgentPreset: settings.defaultAgentPreset ?? cur.defaultAgentPreset ?? "standard",
+            defaultPermissionPreset: settings.defaultPermissionPreset ?? cur.defaultPermissionPreset ?? "workspace-write-never",
         };
         this.save();
     }

package/dist/server/composer-drafts.js

@@ -0,0 +1,138 @@
+/**
+ * composer-drafts.ts — 未发送输入框草稿的单中心文件存储（全局 <dataDir>/composer-drafts.json）。
+ *
+ * 设计（issue #166 单中心文件方案）：不进 session JSONL、不按会话建 sidecar，
+ * 全会话的草稿集中在一个文件里，按 **sessionId**（uuidv7，重启稳定）键入。
+ * conversationId 每次重启都变，不能做 key（见 agent-service 的 compaction 注释）。
+ *
+ * - 空白新会话也能存：sessionId 在 SessionManager.create() 时内存里就有了，
+ *   不依赖转录文件落盘（SDK 的 _persist 门控要等首轮 assistant 才写盘）。
+ * - 每会话只留最新一条（last-write-wins，按 ts，比 marker-store 的扫描模式更轻）。
+ * - 与 per-client 的 client-state.json 不同：按 sessionId 全局存，跨标签页可见。
+ * - 文件 I/O 一律 best-effort：持久化故障绝不能弄崩 server（同 subagent-templates）。
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { basename, dirname } from "node:path";
+/** 单条草稿上限字符数：超出截断再存（快照全量下发时携带，太大浪费流量）。 */
+export const DRAFT_TEXT_MAX = 20_000;
+/** 草稿保留期：超过这么久没更新，下次加载时清扫（兜底；正常路径靠 clear/prune）。 */
+export const DRAFT_TTL_MS = 30 * 24 * 3600 * 1000;
+/** 转录文件名 `<timestamp>_<sessionId>.jsonl` → sessionId。
+ *  时间戳里的 `:`/`.` 已被 SDK 换成 `-`（无下划线），取首个 `_` 之后即 sessionId
+ *  （uuidv7 本身也不含下划线）。对不上形状返回 undefined（调用方跳过剪枝）。 */
+export function sessionIdFromTranscriptPath(p) {
+    const base = basename(p);
+    if (!base.endsWith(".jsonl"))
+        return undefined;
+    const noExt = base.slice(0, -".jsonl".length);
+    const i = noExt.indexOf("_");
+    if (i < 0 || i + 1 >= noExt.length)
+        return undefined;
+    return noExt.slice(i + 1);
+}
+/** 归一化待存文本：超长截断；纯空白 → undefined（调用方按「删除」处理，不存空条目）。 */
+export function normalizeDraftText(text) {
+    const t = (text ?? "").slice(0, DRAFT_TEXT_MAX);
+    return t.trim() ? t : undefined;
+}
+function isValidDraft(d) {
+    if (!d || typeof d !== "object")
+        return false;
+    const o = d;
+    return typeof o.text === "string" && typeof o.ts === "number" && typeof o.updatedAt === "number";
+}
+export class ComposerDraftsStore {
+    filePath;
+    cache = null;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    load() {
+        if (this.cache)
+            return this.cache;
+        let raw = {};
+        try {
+            raw = JSON.parse(readFileSync(this.filePath, "utf8"));
+        }
+        catch {
+            raw = {};
+        }
+        const now = Date.now();
+        const kept = {};
+        let pruned = false;
+        for (const [k, v] of Object.entries(raw)) {
+            if (!isValidDraft(v)) {
+                pruned = true;
+                continue;
+            }
+            if (now - v.updatedAt > DRAFT_TTL_MS) {
+                pruned = true;
+                continue;
+            }
+            kept[k] = v;
+        }
+        this.cache = kept;
+        // 读到过期/脏条目才回写：正常加载不碰磁盘。
+        if (pruned)
+            this.persist();
+        return this.cache;
+    }
+    persist() {
+        if (!this.cache)
+            return;
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            const tmp = `${this.filePath}.tmp-${process.pid}`;
+            writeFileSync(tmp, JSON.stringify(this.cache, null, 2) + "\n");
+            renameSync(tmp, this.filePath);
+        }
+        catch {
+            // best-effort：草稿丢了可以重打，server 绝不能因此崩。
+        }
+    }
+    /** 读一条草稿（{text, ts}；没有返回 undefined）。 */
+    get(sessionId) {
+        if (!sessionId)
+            return undefined;
+        const d = this.load()[sessionId];
+        return d ? { text: d.text, ts: d.ts } : undefined;
+    }
+    /** 存一条草稿：空文本 = 删除；同 key 上 ts 更大的才覆盖（last-write-wins，
+     *  `>=` 让同 ts 的重发幂等）。只有实际变化才写盘。 */
+    save(sessionId, text, ts) {
+        if (!sessionId)
+            return;
+        const map = this.load();
+        const norm = normalizeDraftText(text);
+        if (norm === undefined) {
+            if (map[sessionId] !== undefined) {
+                delete map[sessionId];
+                this.persist();
+            }
+            return;
+        }
+        const prev = map[sessionId];
+        if (prev && prev.ts > ts)
+            return;
+        if (prev && prev.ts === ts && prev.text === norm)
+            return;
+        map[sessionId] = { text: norm, ts, updatedAt: Date.now() };
+        this.persist();
+    }
+    /** 发送成功 / 会话删除后清掉（有 key 才写盘）。 */
+    clear(sessionId) {
+        if (!sessionId)
+            return;
+        const map = this.load();
+        if (map[sessionId] !== undefined) {
+            delete map[sessionId];
+            this.persist();
+        }
+    }
+    /** delete_session 用：按转录文件路径反解 sessionId 并清掉（形状对不上就跳过）。 */
+    pruneSessionFile(sessionPath) {
+        const id = sessionIdFromTranscriptPath(sessionPath);
+        if (id)
+            this.clear(id);
+    }
+}