pi-web-ui 0.95.0 → 0.96.1

package/dist/server/approval-rules.js

@@ -30,7 +30,21 @@
  *    - 内存缓存 + 文件 mtime 感知，支持直接编辑 JSON 文件热生效。
  */
 import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
-import { dirname, isAbsolute, resolve, sep } from "node:path";
+import { dirname, resolve, sep } from "node:path";
+/**
+ * 跨平台判定 target 路径是否严格位于 root 目录内部或就是 root 本身。
+ * 针对 Windows 盘符大小写不敏感及正反斜杠统一进行规范化，防止 .. 路径穿越逃逸。
+ */
+export function isPathInsideRoot(target, root) {
+    const normTarget = resolve(target);
+    const normRoot = resolve(root);
+    if (process.platform === "win32") {
+        const lowerTarget = normTarget.toLowerCase();
+        const lowerRoot = normRoot.toLowerCase();
+        return (lowerTarget === lowerRoot || lowerTarget.startsWith(lowerRoot + sep) || lowerTarget.startsWith(lowerRoot + "/"));
+    }
+    return normTarget === normRoot || normTarget.startsWith(normRoot + sep);
+}
 /**
  * 极简 glob 转 RegExp（只支持 * 单段、? 单字符、** 跨段）。
  * 纯函数，支持正反斜杠统一归一为 /。
@@ -66,6 +80,22 @@ export function globToRegex(pattern) {
     }
     return new RegExp(`^${re}$`, "i");
 }
+/**
+ * 从工具参数里取「这次调用动的是哪个文件」。SDK 内置 read/write/edit 用 `path`，read 还有
+ * `file_path` 别名，部分扩展（如 pi-better-edit 的 edit）用 `file` —— 三种都认，否则叠在
+ * 扩展实现之上的权限沙箱与审批规则会静默放行（取不到 → 空串 → 被判成工作区内）。
+ */
+export function extractTargetPath(params) {
+    if (!params || typeof params !== "object")
+        return "";
+    const obj = params;
+    for (const key of ["path", "file_path", "file"]) {
+        const value = obj[key];
+        if (typeof value === "string" && value.trim())
+            return value;
+    }
+    return "";
+}
 /**
  * 从工具参数对象中提取待检查文本。
  */
@@ -78,7 +108,7 @@ export function extractRuleFieldValue(field, toolName, params) {
         return String(obj.command ?? "");
     }
     if (field === "path") {
-        return String(obj.path ?? "");
+        return extractTargetPath(params);
     }
     if (field === "params") {
         try {
@@ -106,9 +136,10 @@ export function matchApprovalRule(rule, toolName, params, cwd, workspaceRoots =
         const targetPath = extractRuleFieldValue("path", toolName, params);
         if (!targetPath)
             return false;
-        const abs = isAbsolute(targetPath) ? targetPath : resolve(cwd, targetPath);
+        // 无论相对或绝对路径，统一经 resolve(cwd, targetPath) 规范化并消除 ".."
+        const abs = resolve(cwd, targetPath);
         const allRoots = [resolve(cwd), ...workspaceRoots.map((r) => resolve(r))];
-        const inside = allRoots.some((r) => abs === r || abs.startsWith(r + sep));
+        const inside = allRoots.some((r) => isPathInsideRoot(abs, r));
         return !inside;
     }
     // 3. 提取字段文本
@@ -176,7 +207,7 @@ export const DEFAULT_APPROVAL_RULES = [
         tools: ["bash"],
         field: "command",
         match: "regex",
-        value: "\\brm\\s+-[a-zA-Z0-9]*[rf][a-zA-Z0-9]*\\s+((\\/)|(~)|(\\.\\.)|(\\*)|(\\.\\/))",
+        value: "\\brm\\s+((-[a-zA-Z0-9]*[rf][a-zA-Z0-9]*|--recursive|--force)\\s+)+(((\\/)|(~)|(\\.\\.)|(\\*)|(\\.\\/))|[a-zA-Z]:[\\\\/])",
         action: "ask",
         label: "递归/强制删除 (rm -rf)",
         labelEn: "Recursive/force delete (rm -rf)",
@@ -191,12 +222,12 @@ export const DEFAULT_APPROVAL_RULES = [
         tools: ["bash"],
         field: "command",
         match: "regex",
-        value: "\\b(del|rmdir)\\s+\\/[fsq]",
+        value: "\\b(del|rmdir|rd)\\s+[/\\-][fsq]",
         action: "ask",
-        label: "Windows 强制删除 (del/rmdir)",
-        labelEn: "Windows force delete (del/rmdir)",
-        reason: "检测到高风险的 Windows 强制/递归删除目录命令 (del/rmdir /s /q)",
-        reasonEn: "Detected high-risk Windows force/recursive deletion command (del/rmdir /s /q)",
+        label: "Windows 强制删除 (del/rmdir/rd)",
+        labelEn: "Windows force delete (del/rmdir/rd)",
+        reason: "检测到高风险的 Windows 强制/递归删除目录命令 (del/rmdir/rd /s /q)",
+        reasonEn: "Detected high-risk Windows force/recursive deletion command (del/rmdir/rd /s /q)",
         categoryId: "bash.win-del",
         builtin: true,
     },
@@ -515,6 +546,21 @@ export class ApprovalRulesStore {
             ids.add(r.id);
             normalized.push(r);
         }
+        // 内置规则是安全底线：整表替换绝不能把它们裁掉（旧客户端 / 并发竞态都
+        // 可能送来缺内置规则的清单）。缺失的按默认定义补种、追加到队尾——与
+        // load/resetBuiltin 同口径；插队首会改变用户 allow 规则的 first-match
+        // 语义。id 命中内置定义的一律强制 builtin 标记（同 upsert 的保护），
+        // 防止 remove() 的内置不可删保护被绕过。
+        for (const def of DEFAULT_APPROVAL_RULES) {
+            if (!ids.has(def.id)) {
+                normalized.push({ ...def, tools: [...def.tools] });
+                ids.add(def.id);
+            }
+            else {
+                const i = normalized.findIndex((r) => r.id === def.id);
+                normalized[i].builtin = true;
+            }
+        }
         this.rules = normalized;
         this.persist();
         return null;

package/dist/server/attachment-store.js

@@ -7,9 +7,9 @@
  *  - 浏览器通过 `/api/attachment/:hash` 经 HTTP 访问，带永久强缓存（immutable）；
  *  - 避免快照和消息列表随会话进行出现数兆字节 base64 的膨胀。
  */
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { mkdirSync, existsSync, readdirSync } from "node:fs";
-import { readFile, writeFile, stat } from "node:fs/promises";
+import { readFile, rename, rm, writeFile, stat } from "node:fs/promises";
 import { join, extname } from "node:path";
 let storeDir = "";
 /** 初始化附件存储目录（服务启动时调用）。 */
@@ -53,7 +53,22 @@ export async function saveAttachment(buffer, mimeType = "application/octet-strea
     const fileName = `${hash}${ext}`;
     const filePath = join(storeDir, fileName);
     if (!existsSync(filePath)) {
-        await writeFile(filePath, buffer);
+        // 原地 writeFile 有两个问题：a) 同 hash 并发写时两个 writeFileSync
+        // 交错会留下半个文件；b) 读方（/api/attachment/:hash）可能在写完前就命中。
+        // 因此先写私有 tmp 再 rename（同目录内原子生效）。POSIX rename 原子覆盖；
+        // Windows 目标已存在时报 EEXIST/EPERM —— 内容寻址同 hash 即同内容，
+        // 并发对手落盘视为成功。tmp 命名带 uuid，绝不与真实附件名冲突。
+        const tmpPath = `${filePath}.${randomUUID()}.tmp`;
+        try {
+            await writeFile(tmpPath, buffer);
+            await rename(tmpPath, filePath);
+        }
+        catch (err) {
+            await rm(tmpPath, { force: true }).catch(() => { });
+            const code = err.code;
+            if (code !== "EEXIST" && code !== "EPERM")
+                throw err;
+        }
     }
     return {
         hash,
@@ -75,7 +90,9 @@ export async function findAttachment(hash) {
         return null;
     try {
         const files = readdirSync(storeDir);
-        const match = files.find((f) => f.startsWith(hash));
+        // 跳过原子写（tmp + rename）崩溃时可能残留的 .tmp —— 前缀同为 hash，
+        // 若被命中会拿到错误的后缀与 MIME。
+        const match = files.find((f) => f.startsWith(hash) && !f.endsWith(".tmp"));
         if (!match)
             return null;
         const filePath = join(storeDir, match);

package/dist/server/attachments.js

@@ -4,8 +4,20 @@ import { isAbsoluteWirePath, wireToAbs } from "./files-service.js";
 import { buildVisionBridgePrompt, findVisionModels, transcribeImages } from "./vision-bridge.js";
 import { saveAttachment } from "./attachment-store.js";
 /** 跨快照的视觉转写缓存：批次 hash（名称 + base64 头 + 提示词）→ 转写文本。
- *  编辑重问重发相同图片不再重复耗视觉 token。进程级共享即可。 */
+ *  编辑重问重发相同图片不再重复耗视觉 token。进程级共享即可。
+ *  长驻进程下无界 Map 会随图片种类缓慢吃内存（单条转写可达数十 KB），
+ *  超过 VISION_BRIDGE_CACHE_MAX 按插入序 FIFO 淘汰最旧。 */
+const VISION_BRIDGE_CACHE_MAX = 256;
 const visionBridgeCache = new Map();
+function cacheVisionTranscript(key, value) {
+    visionBridgeCache.set(key, value);
+    if (visionBridgeCache.size > VISION_BRIDGE_CACHE_MAX) {
+        // Map 迭代序 = 插入序，第一个 key 即最旧。
+        const oldest = visionBridgeCache.keys().next().value;
+        if (oldest !== undefined)
+            visionBridgeCache.delete(oldest);
+    }
+}
 /** "provider/id" 解析；非法格式返回 null。 */
 export function parseModelSpec(spec) {
     if (!spec)
@@ -194,7 +206,7 @@ export async function buildAttachmentMessages(ctx, attachments) {
                             systemPrompt: buildVisionBridgePrompt(ctx.settings.visionBridgePromptMode, ctx.settings.visionBridgePrompt, vLang),
                             lang: vLang,
                         });
-                        visionBridgeCache.set(batchHash, transcript);
+                        cacheVisionTranscript(batchHash, transcript);
                         ctx.emit({
                             type: "notice",
                             level: "info",
@@ -410,7 +422,22 @@ export async function buildAttachmentMessages(ctx, attachments) {
             // Uploaded files live in a GLOBAL per-user dir (not inside the project
             // or the per-client session store) so browsing a repo never picks up
             // uploaded junk: <dataDir>/uploads/<clientId>/（保留期自动清理，见 uploads.ts）。
-            const { abs, displayName: safeName } = saveUpload(ctx.clientId, att.name ?? "file", buf);
+            // saveUpload 对非法 clientId/displayName 抛错（消毒失败整条拒绝，绝不
+            // 落到别的目录）—— 这里报错跳过该附件，不让一条坏附件中断整条消息。
+            let saved;
+            try {
+                saved = saveUpload(ctx.clientId, att.name ?? "file", buf);
+            }
+            catch (err) {
+                ctx.emit({
+                    type: "notice",
+                    level: "error",
+                    text: `上传文件保存失败，已跳过：${err.message}`,
+                    textEn: `Failed to save uploaded file, skipped: ${err.message}`,
+                });
+                continue;
+            }
+            const { abs, displayName: safeName } = saved;
             // Wire format: forward-slash absolute path (the read tool accepts
             // absolute paths; Windows uses "C:/..." — safe inside the XML-ish tag).
             const wirePath = abs.split(sep).join("/");

package/dist/server/bg-servers.js

@@ -66,7 +66,13 @@ export function shouldTrackBackgroundServer(pid, parents, newPids, serverPid, na
 export class BgServerTracker {
     opts;
     servers = new Map();
-    /** bash 工具开始执行前拍的监听端口快照（tool_execution_start 时设置）。 */
+    /**
+     * bash 工具开始执行前拍的监听端口快照（tool_execution_start 时设置）。
+     * 槽位存「in-flight Promise」而非已解析的 Map：并发 bash 同时开跑时不互相
+     * 覆盖（??= 保住最早的一份——更早的基线只会多算新增，落库有去重兜底），
+     * 也修掉 fire-and-forget 时序竞态（bash 先于快照返回结束 → trackAfterBash
+     * 读到 null 直接漏记，延迟解析的旧快照还会污染下一轮）。
+     */
     listenBefore = null;
     refreshTimer = null;
     constructor(opts) {
@@ -83,20 +89,21 @@ export class BgServerTracker {
             this.refreshTimer = null;
         }
     }
-    /** tool_execution_start(bash)：先记下「前」快照。 */
+    /** tool_execution_start(bash)：先记下「前」快照（快照在途时保留最早的一份）。 */
     snapshotBefore() {
-        void snapshotListeningPorts().then((m) => {
-            this.listenBefore = m;
-        });
+        this.listenBefore ??= snapshotListeningPorts();
     }
     /** After a bash tool run, wait briefly for background servers to bind,
      *  then diff the listening-port snapshot against the pre-run one and
      *  remember anything new — those are servers the agent left running. */
     async trackAfterBash() {
-        const before = this.listenBefore;
+        // 读后清槽：await in-flight 快照（消除 fire-and-forget 的时序竞态），
+        // 并发 bash 共用这份最早的基线，各自结束都能对得上。
+        const beforePromise = this.listenBefore;
         this.listenBefore = null;
-        if (!before)
+        if (!beforePromise)
             return;
+        const before = await beforePromise;
         await new Promise((r) => setTimeout(r, BG_BIND_WAIT_MS));
         const after = await snapshotListeningPorts();
         const fresh = [];
@@ -198,6 +205,22 @@ export class BgServerTracker {
         await this.refresh();
         this.push();
     }
+    /** 杀前复核端口→pid 归属（与 refresh() 同一判定：端口与 pid 都对得上才算我们的）。
+     *  缓存的 pid 可能已过期——原进程退出后端口被无关进程复用时，按缓存 pid 直接
+     *  killPidTree 会误伤无辜进程树。不符的条目剔除并推送，绝不对其开杀。 */
+    async verifyBeforeKill() {
+        const now = await snapshotListeningPorts();
+        let changed = false;
+        // eslint-disable-next-line unicorn/no-useless-spread -- snapshot: handlers may unsubscribe mid-emit
+        for (const [port, v] of [...this.servers]) {
+            if (now.get(port) !== v.pid) {
+                this.servers.delete(port);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.push();
+    }
     /** Kill ONE background server (by port); returns whether anything was killed. */
     async killOne(port) {
         const entry = this.servers.get(port);
@@ -211,6 +234,18 @@ export class BgServerTracker {
             this.opts.flushSnapshot();
             return false;
         }
+        await this.verifyBeforeKill();
+        const verified = this.servers.get(port);
+        if (!verified || verified.pid !== entry.pid) {
+            this.opts.emit({
+                type: "notice",
+                level: "warning",
+                text: `端口 ${port} 已不在原进程（原 pid ${entry.pid}）监听，已跳过并刷新列表`,
+                textEn: `Port ${port} is no longer held by the original process (pid ${entry.pid}); skipped and list refreshed`,
+            });
+            this.opts.flushSnapshot();
+            return false;
+        }
         killPidTree(entry.pid);
         this.servers.delete(port);
         this.push();
@@ -225,6 +260,9 @@ export class BgServerTracker {
     }
     /** Kill every background server the agent started; returns the freed ports. */
     async killAll() {
+        if (this.servers.size === 0)
+            return [];
+        await this.verifyBeforeKill();
         if (this.servers.size === 0)
             return [];
         const killed = [];

package/dist/server/claim-files-tool.js

@@ -12,7 +12,7 @@
 // ---------------------------------------------------------------------------
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { CLAIM_FILES_TOOL_NAME } from "./tool-manager.js";
 import { CLAIM_TTL_MS, resolveClaimPath } from "./claim-store.js";
 /** 工具名（唯一定义在 tool-manager.ts，本模块 re-export 供单测沿用，模式同 present-files-tool.ts）。 */
@@ -30,13 +30,9 @@ export function makeClaimFilesTool(host, lang) {
     return defineTool({
         name: CLAIM_FILES_TOOL_NAME,
         label: "Claim files to avoid parallel conflicts",
-        description: bilingual("Declare which files you are about to edit so parallel runs in the same project can steer clear (advisory only — it never blocks edits). " +
-            "action=claim reserves paths for THIS conversation (first wins; already claimed by others is reported, not overridden); action=release frees yours (no paths = all yours); action=list shows this project's claim table. " +
-            "Claims expire after ~30 min idle (each of your prompts refreshes them) and are released when the conversation closes. " +
-            "Paths must stay inside the project directory. Only pi-engine conversations can claim (no customTool surface on DSH).", "声明你要改哪些文件，让同项目的并行对话绕行（纯建议，不拦任何编辑）。" +
-            "action=claim 把路径记到本对话名下（先到先得；别人已认领的会告诉你，不抢占）；action=release 放掉你自己的（不给 paths = 全放）；action=list 看本项目的认领表。" +
-            "认领闲置约 30 分钟过期（你每次发 prompt 自动续期），对话关闭时释放。" +
-            "路径必须在项目目录内。只有 pi 引擎对话能认领（DSH 无 customTool 注册面）。"),
+        description: "Declare files you are about to edit so parallel runs in the same project steer clear (advisory only — never blocks edits). " +
+            "claim reserves paths for THIS conversation (first wins; conflicts reported, not overridden); release frees yours (no paths = all yours); list shows the project's claim table. " +
+            "Claims expire after ~30 min idle (your prompts refresh them) and release when the conversation closes. Paths must stay inside the project.",
         promptSnippet: "claim files you are about to edit (advisory, first-wins) so parallel runs steer clear",
         parameters: Type.Object({
             action: Type.Optional(Type.String({ description: 'claim = reserve paths; release = free yours; list = show table. Default "list".' })),

package/dist/server/claim-store.js

@@ -212,7 +212,8 @@ export class ClaimStore {
     save() {
         try {
             mkdirSync(dirname(this.file), { recursive: true });
-            const tmp = `${this.file}.tmp`;
+            // tmp 带进程唯一后缀：同机多实例（多 worktree/多开）写同一文件不互踩
+            const tmp = `${this.file}.${process.pid}.tmp`;
             writeFileSync(tmp, JSON.stringify({ version: CLAIMS_FILE_VERSION, tables: Object.fromEntries(this.tables) }));
             renameSync(tmp, this.file);
         }
@@ -280,7 +281,8 @@ export async function mergeTouchSidecar(sessionFile, fresh) {
         return;
     try {
         const merged = unionTouchLists(readTouchSidecar(sessionFile) ?? [], fresh).slice(0, SIDECAR_MAX_ENTRIES);
-        const tmp = `${sidecarPath(sessionFile)}.tmp`;
+        // tmp 带进程唯一后缀（同 client-state.ts 惯例）：避免并发进程互踩
+        const tmp = `${sidecarPath(sessionFile)}.${process.pid}.tmp`;
         writeFileSync(tmp, JSON.stringify({ version: 1, updatedAt: Date.now(), files: merged }));
         renameSync(tmp, sidecarPath(sessionFile));
     }

package/dist/server/client-state.js

@@ -259,6 +259,16 @@ export function normalizeWorkspaceRoots(v) {
     }
     return out;
 }
+/** 跨平台（尤其是 Windows）路径归一化键：统一转绝对路径，并在 Windows 下转小写以消除大小写与正反斜杠差异。 */
+export function normalizePathKey(p) {
+    try {
+        const resolved = resolve(p);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    }
+    catch {
+        return process.platform === "win32" ? p.toLowerCase() : p;
+    }
+}
 /**
  * Persists which workspace each browser client last used + which workspaces it
  * has opened, so a server restart / page reload restores the same project and
@@ -293,6 +303,26 @@ export class ClientStateStore {
         catch {
             this.cache = {};
         }
+        // 历史数据迁移：老版本将 removedProjects 仅记在各自临时 clientId 下，升级后新标签页无法继承。
+        // 启动/加载时自动将所有老 client 的墓碑合并到全局 __settings__，避免重启或新标签页后已删项目复活。
+        let migrated = false;
+        const globalState = (this.cache[ClientStateStore.GLOBAL_SETTINGS_KEY] ??= { projects: [] });
+        const globalSet = new Set((globalState.removedProjects ?? []).map(normalizePathKey));
+        for (const [id, cState] of Object.entries(this.cache)) {
+            if (id !== ClientStateStore.GLOBAL_SETTINGS_KEY && cState.removedProjects?.length) {
+                for (const p of cState.removedProjects) {
+                    const key = normalizePathKey(p);
+                    if (!globalSet.has(key)) {
+                        globalSet.add(key);
+                        (globalState.removedProjects ??= []).push(p);
+                        migrated = true;
+                    }
+                }
+            }
+        }
+        if (migrated) {
+            this.save();
+        }
         return this.cache;
     }
     save() {
@@ -318,11 +348,15 @@ export class ClientStateStore {
         const state = (all[clientId] ??= { projects: [] });
         state.lastCwd = cwd;
         const now = Date.now();
-        state.projects = [{ path: cwd, lastUsed: now }, ...state.projects.filter((p) => p.path !== cwd)].slice(0, 30);
+        const targetKey = normalizePathKey(cwd);
+        state.projects = [
+            { path: cwd, lastUsed: now },
+            ...state.projects.filter((p) => normalizePathKey(p.path) !== targetKey),
+        ].slice(0, 30);
         // Opening the workspace again clears its removal tombstone across all clients and global settings.
         for (const cState of Object.values(all)) {
             if (cState.removedProjects?.length) {
-                cState.removedProjects = cState.removedProjects.filter((p) => p !== cwd);
+                cState.removedProjects = cState.removedProjects.filter((p) => normalizePathKey(p) !== targetKey);
             }
         }
         this.save();
@@ -335,20 +369,21 @@ export class ClientStateStore {
      *  explicitly opens that project again. */
     removeProject(clientId, cwd) {
         const all = this.load();
+        const targetKey = normalizePathKey(cwd);
         const state = (all[clientId] ??= { projects: [] });
-        state.projects = state.projects.filter((p) => p.path !== cwd);
-        if (state.lastCwd === cwd)
+        state.projects = state.projects.filter((p) => normalizePathKey(p.path) !== targetKey);
+        if (state.lastCwd && normalizePathKey(state.lastCwd) === targetKey)
             delete state.lastCwd;
-        const removed = new Set(state.removedProjects ?? []);
-        removed.add(cwd);
-        state.removedProjects = [...removed];
+        const removed = (state.removedProjects ?? []).filter((p) => normalizePathKey(p) !== targetKey);
+        removed.push(cwd);
+        state.removedProjects = removed;
         const globalState = (all[ClientStateStore.GLOBAL_SETTINGS_KEY] ??= { projects: [] });
-        const globalRemoved = new Set(globalState.removedProjects ?? []);
-        globalRemoved.add(cwd);
-        globalState.removedProjects = [...globalRemoved];
+        const globalRemoved = (globalState.removedProjects ?? []).filter((p) => normalizePathKey(p) !== targetKey);
+        globalRemoved.push(cwd);
+        globalState.removedProjects = globalRemoved;
         for (const [id, cState] of Object.entries(all)) {
             if (id !== ClientStateStore.GLOBAL_SETTINGS_KEY && cState.projects) {
-                cState.projects = cState.projects.filter((p) => p.path !== cwd);
+                cState.projects = cState.projects.filter((p) => normalizePathKey(p.path) !== targetKey);
             }
         }
         this.save();
@@ -363,7 +398,16 @@ export class ClientStateStore {
             return clientRemoved;
         if (clientRemoved.length === 0)
             return globalRemoved;
-        return [...new Set([...clientRemoved, ...globalRemoved])];
+        const seen = new Set();
+        const result = [];
+        for (const p of [...clientRemoved, ...globalRemoved]) {
+            const key = normalizePathKey(p);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(p);
+            }
+        }
+        return result;
     }
     /** Last-used goal/review prefs for a client, or undefined if never set. */
     getGoalPrefs(clientId) {
@@ -548,8 +592,13 @@ export class ClientStateStore {
             toolImagesEnabled: settings.toolImagesEnabled ?? cur.toolImagesEnabled ?? true,
             skillsFullText: normalizeSkillList(settings.skillsFullText ?? cur.skillsFullText),
             visionBridgeEnabled: settings.visionBridgeEnabled ?? cur.visionBridgeEnabled ?? true,
-            visionBridgeModel: settings.visionBridgeModel ?? cur.visionBridgeModel ?? null,
-            subagentDefaultModel: settings.subagentDefaultModel ?? cur.subagentDefaultModel ?? null,
+            // 按键存在性合并：null 是合法值（清除语义），`null ?? cur` 会把旧值
+            // 复活到磁盘（设置面板清空后重启又回来）。settings-service 持久化
+            // 时传全量对象，键总在；其他调用方传 partial，键缺 = 保持旧值。
+            visionBridgeModel: "visionBridgeModel" in settings ? (settings.visionBridgeModel ?? null) : (cur.visionBridgeModel ?? null),
+            subagentDefaultModel: "subagentDefaultModel" in settings
+                ? (settings.subagentDefaultModel ?? null)
+                : (cur.subagentDefaultModel ?? null),
             retryMaxAttempts: normalizeRetryMaxAttempts(settings.retryMaxAttempts ?? cur.retryMaxAttempts ?? DEFAULT_RETRY_MAX_ATTEMPTS),
             softCapTokens: normalizeSoftCapTokens(settings.softCapTokens ?? cur.softCapTokens ?? 0),
             softCapByModel: normalizeSoftCapByModel(settings.softCapByModel ?? cur.softCapByModel ?? {}),

package/dist/server/compact-context-tool.js

@@ -11,7 +11,7 @@
 // ---------------------------------------------------------------------------
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { bilingual, pick } from "./i18n.js";
+import { pick } from "./i18n.js";
 import { COMPACT_CONTEXT_TOOL_NAME } from "./tool-manager.js";
 /** 工具名（唯一登记在 tool-manager.ts，在此 re-export 供外部模块引用）。 */
 export { COMPACT_CONTEXT_TOOL_NAME };
@@ -58,13 +58,13 @@ export function buildCompactionInstructions(focus, customSummary) {
 }
 export const CompactContextParams = Type.Object({
     focus: Type.String({
-        description: "Specific focus and requirements for context compaction based on the current issue or task. Clearly specify: 1) The active problem/goal being solved; 2) Crucial context to PRESERVE (key architectural decisions, code changes, conventions, user constraints); 3) Distractions or historical details to REMOVE or aggressively condense (failed attempts, resolved debugging outputs, off-topic discussions).\n根据当前问题/任务制定的上下文压缩重点。请指明：1) 当前正在解决的核心任务或问题；2) 必须保留的核心上下文（架构决策、已确认修改、约定规范等）；3) 应当丢弃或极简概括的无关历史（错误尝试、冗长排查、其他不相关讨论等）。",
+        description: "Compression focus and requirements for the current issue/task. State: 1) the active problem/goal; 2) context to PRESERVE (key decisions, code changes, conventions, user constraints); 3) what to REMOVE or condense (failed attempts, resolved debugging, off-topic history).",
     }),
     keepRecentTokens: Type.Optional(Type.Number({
-        description: "Optional scope of recent tokens to keep uncompacted (e.g. 1000 - 64000). Smaller values (e.g. 3000-8000) compact more aggressively, retaining only immediate context. Larger values retain more recent history. If omitted, the system automatically calculates a reasonable retention scope based on session size.\n可选的近期不压缩保留 token 范围（1000 - 64000）。较小值（如 3000-8000）压缩更彻底，只保留紧贴当前的上下文；较大值保留更多近期操作。不传时系统会根据当前会话规模自动计算合理的保留范围。",
+        description: "Recent tokens to keep uncompacted (1000-64000). Smaller values (e.g. 3000-8000) compact more aggressively. Omit = auto-calculated from session size.",
     })),
     summary: Type.Optional(Type.String({
-        description: "Optional custom structured summary text written directly by you. If provided, this summary will be used as the core basis for the compaction entry.\n可选由你自主直接编写的精炼结构化摘要正文。若提供，系统将以此摘要为核心作为压缩总结。",
+        description: "Custom structured summary written by you; used as the core basis for the compaction entry if provided.",
     })),
 });
 export function makeCompactContextTool(host, lang) {
@@ -72,7 +72,8 @@ export function makeCompactContextTool(host, lang) {
     return defineTool({
         name: COMPACT_CONTEXT_TOOL_NAME,
         label: "Compact conversation context based on current issue",
-        description: bilingual("Compress/compact the conversation context based on the current task or problem. You can specify what context to preserve (key decisions, code structure, requirements related to the current issue) and what to drop or summarize heavily (unrelated explorations, verbose tool outputs, resolved debugging steps). You can also control the compaction scope by setting how many recent tokens to keep untouched. Compaction executes when the current turn/run settles, refreshing the context for subsequent turns.", "根据当前任务或问题主动压缩上下文。你可以自主指定需要保留的关键信息（与当前问题相关的决策、代码结构、核心规范）以及需要丢弃或深度压缩的无关内容（无关探索、冗长输出、已解决的历史排查）。还可以通过指定保留最近的 token 数量来控制压缩范围。压缩将在本轮结束后立即执行，并在后续对话中生效。"),
+        description: "Compress/compact the conversation context around the current task: specify what to preserve (key decisions, code structure, active requirements) and what to drop or heavily summarize (unrelated exploration, verbose outputs, resolved debugging). " +
+            "Optionally control how many recent tokens stay untouched. Compaction executes when the current turn settles, refreshing context for subsequent turns.",
         promptSnippet: "proactively compact conversation context focusing on the current issue",
         promptGuidelines: [
             "Use compact_context when the conversation has grown long, or after extensive debugging/exploration, to focus context strictly on the current problem.",

package/dist/server/composer-drafts.js

@@ -62,6 +62,15 @@ export class ComposerDraftsStore {
             raw = JSON.parse(readFileSync(this.filePath, "utf8"));
         }
         catch {
+            // 坏文件改名留存而非直接覆盖：先有留存，后续 save 落盘的才是新数据
+            //（否则一次解析失败 → 空表 → 下次 save 把全部草稿的原始记录抹掉）。
+            try {
+                renameSync(this.filePath, `${this.filePath}.corrupt-${Date.now()}`);
+                console.warn(`[composer-drafts] 草稿文件解析失败，已改名留存：${this.filePath}（丢草稿可重打，不留坏副本）`);
+            }
+            catch {
+                // 改名失败（占用等）也无妨：空表继续，save 时照常覆盖
+            }
             raw = {};
         }
         const now = Date.now();