pi-web-ui 0.97.0 → 0.99.0

package/dist/server/markers/builtins/notify.js

@@ -3,10 +3,12 @@
  */
 import { getServerBlock, pick } from "../../i18n.js";
 const NOTIFY_GUIDANCE_ZH = [
-    "- [[notify:<级别>:<内容>]] 仅向用户显示一个非打断性提醒，不会进入正文。级别为 info|warning|success|error。",
+    // #499：guidance 只能承诺协议真实支持的级别——success 从未存在于 notice 协议
+    // （protocol.ts 仅 info|warning|error），按指引用 success 会被静默降级成 info。
+    "- [[notify:<级别>:<内容>]] 仅向用户显示一个非打断性提醒，不会进入正文。级别为 info|warning|error。",
 ];
 const NOTIFY_GUIDANCE_EN = [
-    "- [[notify:<level>:<message>]] shows a non-interruptive notice to the user only; it never enters the reply text. Levels: info|warning|success|error.",
+    "- [[notify:<level>:<message>]] shows a non-interruptive notice to the user only; it never enters the reply text. Levels: info|warning|error.",
 ];
 /** 语言感知的 notify guidance（issue #91）：en 用英译、zh 用中文，默认英文。 */
 export function getNotifyGuidance(lang = "en") {

package/dist/server/markers/builtins/rename.js

@@ -10,7 +10,6 @@
  *         不需要额外状态。
  */
 import { getServerBlock, pick } from "../../i18n.js";
-export const RENAME_NAMESPACE = "conv";
 function extractTitle(token) {
     // args[0] 是主标题；kwargs 兼容 text/name/title
     const fromArgs = token.args.join(" ").trim();

package/dist/server/markers/builtins/todo.js

@@ -15,30 +15,6 @@ function parseId(raw) {
     const n = Number(raw);
     return Number.isInteger(n) && n > 0 ? n : null;
 }
-function formatStatus(s) {
-    switch (s) {
-        case "pending":
-            return "pending";
-        case "in_progress":
-            return "in_progress";
-        case "completed":
-            return "completed";
-        default:
-            return s;
-    }
-}
-export function describeTodos(state, includeDeleted = false, lang = "en") {
-    const visible = state.tasks.filter((t) => includeDeleted || t.status !== "deleted");
-    if (visible.length === 0)
-        return pick(lang, "[todo] （空）", "[todo] (empty)", "markers.todo.list.empty");
-    return visible
-        .map((t) => {
-        const form = t.status === "in_progress" && t.activeForm ? ` (${t.activeForm})` : "";
-        const deps = t.blockedBy.length ? ` ⛓ ${t.blockedBy.join(",")}` : "";
-        return `[${formatStatus(t.status)}] #${t.id} ${t.subject}${form}${deps}`;
-    })
-        .join("\n");
-}
 const TODO_GUIDANCE_ZH = [
     "- 标记语法：[[todo:new:<主题>]] 新建；[[todo:set:<id>,completed|in_progress|pending]] 状态；[[todo:remove:<id>]] 删除；[[todo:dep:<id>,blocks=<依赖id,逗号分隔>]] 设依赖。",
     "- 状态变化全部用上面的 [[todo:...]] 内联标记表达，不会中断回答，无需等待返回。",
@@ -64,7 +40,9 @@ export const todoMarker = {
         const op = token.op;
         switch (op) {
             case "new": {
-                const subject = token.args[0]?.trim();
+                // #499：subject 是唯一「整段自由文本」参数——args.join 还原含逗号的主题，
+                // 否则 `[[todo:new:修复登录页,同步改注册页]]` 的后半段被静默丢弃。
+                const subject = token.args.join(",").trim();
                 if (!subject)
                     return {
                         applied: false,
@@ -179,7 +157,9 @@ export const todoMarker = {
                 const depsText = deps.length ? deps.join(",") : lang === "zh" ? "（无）" : "(none)";
                 return {
                     applied: true,
-                    feedback: pick(lang, `#${id} 依赖：${depsText}`, `#${id} blocks: ${depsText}`, "markers.todo.dep.blocks.updated", { id: id, depsText: depsText }),
+                    feedback: pick(lang, `#${id} 依赖：${depsText}`, 
+                    // #499：实现是 blockedBy（deps 先完成）——原英文 "blocks" 把依赖方向说反了。
+                    `#${id} is blocked by: ${depsText}`, "markers.todo.dep.blocks.updated", { id: id, depsText: depsText }),
                 };
             }
             default:

package/dist/server/markers/marker.js

@@ -2,8 +2,6 @@
  * marker.ts — 通用内联标记核心抽象（内置版）。
  * 复刻自 pi-marker-tools，保持相同解析语义，便于 AI 无缝迁移。
  */
-export const MARKER_OPEN = "[[";
-export const MARKER_CLOSE = "]]";
 // ---------------------------------------------------------------------------
 // 解析器
 // ---------------------------------------------------------------------------
@@ -38,16 +36,3 @@ export function parseMarkers(text) {
     }
     return tokens;
 }
-export function stripMarkers(text) {
-    return text.replace(TOKEN_RE, () => "");
-}
-export function replaceToken(text, raw, replacement) {
-    return text.split(raw).join(replacement);
-}
-export function serializeToken(token) {
-    const parts = [token.tool, token.op, ...token.args];
-    const kwargs = Object.entries(token.kwargs)
-        .sort(([a], [b]) => (a < b ? -1 : 1))
-        .map(([k, v]) => `${k}=${v}`);
-    return `${MARKER_OPEN}${[...parts, ...kwargs].join(":")}${MARKER_CLOSE}`;
-}

package/dist/server/markers/registry.js

@@ -11,9 +11,6 @@ export function getMarker(name) {
 export function allMarkers() {
     return [...registry.values()];
 }
-export function lookupToken(name) {
-    return registry.get(name);
-}
 export function collectGuidance(disabled = new Set(), lang = "en") {
     const out = [];
     for (const m of allMarkers()) {

package/dist/server/markers/store.js

@@ -23,9 +23,6 @@ export function loadStateFromBranch(branch, namespace) {
     }
     return latest?.state;
 }
-export function hasStateInBranch(branch, namespace) {
-    return loadStateFromBranch(branch, namespace) !== undefined;
-}
 /** 追加快照：优先走 sessionManager.appendCustomEntry，否则回退到回调。 */
 export function appendSnapshot(mgr, namespace, state, fallbackSave) {
     const snapshot = {

package/dist/server/mcp-hot-reload.js

@@ -31,15 +31,22 @@ export function createMcpHotReload(deps) {
     let debounce = null;
     let poller = null;
     let watcher = null;
-    /** 读一次磁盘：指纹 + 清单（`servers` 为 null = 坏配置）。文件不在按「没有服务器」算。 */
+    /** 读一次磁盘：指纹 + 清单（`servers` 为 null = 坏配置/读失败）。文件不在按「没有服务器」算。 */
     function readOnce() {
         let raw;
         try {
             raw = readFileSync(file, "utf8");
         }
-        catch {
-            // 读不到（文件/目录不在）→ 空配置：删掉 mcp.json 就是「关掉全部 MCP 服务器」。
-            return { fp: "empty", servers: {} };
+        catch (err) {
+            // 不变量 3 只覆盖「文件不在」：删掉 mcp.json = 关掉全部 MCP 服务器。
+            // #497：EBUSY/EACCES 等临时读失败（OneDrive/杀毒独占、权限误改）既不是
+            // 坏配置也不是删除意图——按坏配置口径走（servers: null → 保留在跑的
+            // 服务器 + 一次性提示），否则会把在跑的 MCP 服务器全杀还报「成功 0 个」。
+            const code = err?.code;
+            if (code === "ENOENT")
+                return { fp: "empty", servers: {} };
+            log(`[mcp] mcp.json 读取失败（${code ?? String(err)}），按坏配置处理：保留在跑的 MCP 服务器`);
+            return { fp: `unreadable:${code ?? "unknown"}`, servers: null };
         }
         const parsed = parseMcpConfig(raw);
         if (!parsed)
@@ -54,7 +61,7 @@ export function createMcpHotReload(deps) {
         applied = fp;
         if (!servers) {
             log("[mcp] mcp.json 解析失败，保留在跑的 MCP 服务器");
-            deps.onNotice?.("warning", "mcp.json 解析失败，已保留当前 MCP 服务器（改好保存后会自动重载）", "Failed to parse mcp.json — keeping the running MCP servers (saving a valid file reloads automatically)");
+            deps.onNotice?.("warning", "mcp.json 解析/读取失败，已保留当前 MCP 服务器（恢复可读后会自动重载）", "Failed to parse/read mcp.json — keeping the running MCP servers (it reloads automatically once readable)");
             return "invalid";
         }
         const summary = await deps.reload();

package/dist/server/model-admin.js

@@ -11,8 +11,9 @@
  * 经 ModelAdminHost 与 ClientSession 解耦（同 settings/goal/slash 服务模式）。
  * UI 文案直接中文（服务端 notice 约定）。apiKey/headers 绝不下发浏览器。
  */
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { writeJsonAtomicSync } from "./atomic-file.js";
 import { enrichBatch } from "./model-enrich.js";
 import { pick } from "./i18n.js";
 import { ProviderOAuthFlowManager } from "./provider-oauth-flow.js";
@@ -65,12 +66,9 @@ export function graduateOverlayModels(providers, official) {
     }
     return graduated;
 }
-/** 原子写 JSON（tmp + rename）：进程崩溃不留半截文件——裸 writeFileSync 中途被
- *  杀会把整份配置截断，下次读盘即空表。tmp 名带 pid，避免同机多进程互踩。 */
+/** 原子写 JSON（tmp + rename）：进程崩溃不留半截文件。 */
 function atomicWriteJson(path, data) {
-    const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n");
-    renameSync(tmp, path);
+    writeJsonAtomicSync(path, data);
 }
 /** Strip // and /* *\/ comments without touching string literals (URLs contain //). */
 function stripJsonComments(src) {
@@ -378,13 +376,8 @@ export class ModelAdminService {
         return out;
     }
     writeProviderKeys(data) {
-        mkdirSync(this.host.agentDir, { recursive: true });
-        // 原子写（tmp+rename）：崩溃不留半截 JSON；0o600 限权防本机其他用户读密钥
-        //（Windows 忽略 mode 无害，POSIX 生效）。
-        const path = this.providerKeysPath();
-        const tmp = `${path}.${process.pid}.tmp`;
-        writeFileSync(tmp, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
-        renameSync(tmp, path);
+        // 原子写（tmp+rename）：崩溃不留半截 JSON。
+        writeJsonAtomicSync(this.providerKeysPath(), data);
     }
     /** 解析失败的配置文件改名留存为 <name>.corrupt-<timestamp>。改名失败（占用/
      *  跨盘等）也不抛——留存是尽力而为，绝不能阻塞主流程。 */
@@ -1461,7 +1454,15 @@ export class ModelAdminService {
             }
             const fetched = await ModelAdminService.probeModelsEndpoint(baseUrl, saved.apiKey, saved.authHeader === true ? true : undefined, saved.api, saved.headers, lang);
             // Merge: manual values win; fetched fills blanks and appends new ids.
-            const prev = new Map((saved.models ?? []).map((m) => [m.id, m]));
+            // #486：probe 是数秒级网络 await，期间用户可能已在设置面板编辑同一服务商——
+            // 以盘上最新条目为合并基准（旧快照 saved 只提供探测参数），否则刷新会用
+            // 旧快照整表覆盖，静默回滚并发编辑（删除的模型复活、手动新增丢失）。
+            const fresh = this.readModelsConfig().providers[pid];
+            if (!fresh) {
+                // probe 期间服务商被删除：不再写回，避免用旧快照复活已删除的条目。
+                return done(false, { error: "provider deleted during refresh" });
+            }
+            const prev = new Map((fresh.models ?? []).map((m) => [m.id, m]));
             let added = 0;
             for (const f of fetched) {
                 const cur = prev.get(f.id);
@@ -1478,11 +1479,11 @@ export class ModelAdminService {
             const merged = [...prev.values()].sort((a, b) => a.id.localeCompare(b.id));
             await this.saveModelConfig(pid, {
                 providerId: pid,
-                name: saved.name,
-                api: saved.api,
-                baseUrl: saved.baseUrl,
+                name: fresh.name,
+                api: fresh.api,
+                baseUrl: fresh.baseUrl,
                 // apiKey/headers 不回传浏览器——saveModelConfig 会保留旧值
-                authHeader: saved.authHeader === true ? true : undefined,
+                authHeader: fresh.authHeader === true ? true : undefined,
                 models: merged,
             });
             this.host.emit({

package/dist/server/model-enrich.js

@@ -156,12 +156,11 @@ async function fetchJson(fetchFn, url, maxBytes, timeoutMs, signal) {
             signal.removeEventListener("abort", onAbort);
     }
 }
+// 手写 TTL 缓存而非通用 memoize：双键（openrouter/modelsdev）共享一个 Map，
+// 且 compute 是 async fetch——单值同步的 memoizeWithTtl 覆盖不了（issue #470 处置说明）。
 /** 目录抓取缓存（24h TTL，进程内；首跑后无感）。 */
 const catalogCache = new Map();
 const CATALOG_TTL_MS = 24 * 3600 * 1000;
-export function clearEnrichCache() {
-    catalogCache.clear();
-}
 export async function getOpenRouterCatalog(fetchFn = fetch, signal) {
     const hit = catalogCache.get("openrouter");
     if (hit && Date.now() - hit.at < CATALOG_TTL_MS)

package/dist/server/patch-tool.js

@@ -11,11 +11,13 @@
 import { resolve } from "node:path";
 import { defineTool } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { applyHashlinePatch, computeFileHash, formatHashlineHeader, formatNumberedLines, globalSnapshotStore, } from "./hashline-engine.js";
+import { pick } from "./i18n.js";
+import { applyHashlinePatch, formatHashlineHeader, globalSnapshotStore, } from "./hashline-engine.js";
 import { getLiveLspDiagnostics } from "./lsp-tool.js";
 export const PATCH_TOOL_NAME = "patch";
 export function makePatchTool(options) {
     const cwd = options.cwd;
+    const getLang = options.lang ?? (() => "en");
     return defineTool({
         name: PATCH_TOOL_NAME,
         promptSnippet: "apply content-hashed, line-anchored patches to workspace files (prevents stale edits, line drift, and indentation hallucination)",
@@ -34,10 +36,13 @@ On divergence the engine attempts a 3-way merge. After success the tool returns
                 description: "The complete Hashline patch text containing one or more [path#TAG] sections with PUT/CUT/REM/MV operations.",
             }),
             timeout: Type.Optional(Type.Number({
-                description: "Optional execution timeout in seconds.",
+                minimum: 1,
+                maximum: 300,
+                description: "Optional execution timeout in seconds (1-300).",
             })),
         }),
         async execute(_callId, params, _signal, _onUpdate, _ctx) {
+            const L = getLang();
             const patchText = typeof params?.patch === "string" ? params.patch : "";
             if (!patchText.trim()) {
                 const emptyReport = {
@@ -47,40 +52,85 @@ On divergence the engine attempts a 3-way merge. After success the tool returns
                     error: "Empty patch",
                 };
                 return {
-                    content: [{ type: "text", text: "Error: No patch content provided." }],
+                    content: [
+                        {
+                            type: "text",
+                            text: pick(L, "错误：未提供任何 patch 补丁内容。", "Error: No patch content provided."),
+                        },
+                    ],
                     details: emptyReport,
                 };
             }
-            const report = applyHashlinePatch(patchText, {
-                cwd,
-                snapshotStore: globalSnapshotStore,
-            });
-            if (!report.ok) {
+            // timeout 此前是死参数：schema 声明了 1-300 秒，execute 从未读取，大补丁
+            // 卡住只能等 20 分钟看门狗（issue #462）。这里用 Promise.race 实现真实
+            // 超时，覆盖 await 长尾（实时 LSP 诊断等）；applyHashlinePatch 是同步
+            // 本地文件操作，同步段无法被中断，race 只能兜异步部分。
+            const timeoutSec = params.timeout ? Math.min(Math.max(1, params.timeout), 300) : null;
+            const finish = async () => {
+                const report = applyHashlinePatch(patchText, {
+                    cwd,
+                    snapshotStore: globalSnapshotStore,
+                });
+                if (!report.ok) {
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: pick(L, `补丁应用失败：\n${report.summary}`, `Patch Failed:\n${report.summary}`),
+                            },
+                        ],
+                        details: report,
+                    };
+                }
+                const textOutput = [report.summary];
+                // 为成功修改的文件输出最新的头部标签，方便 Agent 连续进行下一步修改
+                for (const r of report.results) {
+                    if (r.op !== "deleted" && r.newHash) {
+                        const targetPath = r.newPath || r.filePath;
+                        textOutput.push(pick(L, `\n${targetPath} 的下一处编辑锚点：\`${formatHashlineHeader(targetPath, r.newHash)}\``, `\nNext edit anchor for ${targetPath}: \`${formatHashlineHeader(targetPath, r.newHash)}\``));
+                        try {
+                            const fullPath = resolve(cwd, targetPath);
+                            const diags = await getLiveLspDiagnostics(fullPath, cwd);
+                            if (diags) {
+                                textOutput.push(pick(L, `\n${targetPath} 的实时 LSP 诊断：\n${diags}`, `\nLive LSP diagnostics for ${targetPath}:\n${diags}`));
+                            }
+                        }
+                        catch { }
+                    }
+                }
                 return {
-                    content: [{ type: "text", text: `Patch Failed:\n${report.summary}` }],
+                    content: [{ type: "text", text: textOutput.join("\n") }],
                     details: report,
                 };
+            };
+            if (!timeoutSec)
+                return finish();
+            const timeoutReply = {
+                content: [
+                    {
+                        type: "text",
+                        text: pick(L, `补丁执行超时（${timeoutSec}s）。补丁可能已部分应用，请检查目标文件后重试。`, `Patch execution timed out (${timeoutSec}s). The patch may have been partially applied; check the target files and retry.`),
+                    },
+                ],
+                details: {
+                    ok: false,
+                    summary: `Execution timed out after ${timeoutSec}s`,
+                    results: [],
+                    error: "timeout",
+                },
+            };
+            let timer;
+            try {
+                return await Promise.race([
+                    finish(),
+                    new Promise((resolveTimeout) => {
+                        timer = setTimeout(() => resolveTimeout(timeoutReply), timeoutSec * 1000);
+                    }),
+                ]);
             }
-            const textOutput = [report.summary];
-            // 为成功修改的文件输出最新的头部标签，方便 Agent 连续进行下一步修改
-            for (const r of report.results) {
-                if (r.op !== "deleted" && r.newHash) {
-                    const targetPath = r.newPath || r.filePath;
-                    textOutput.push(`\nNext edit anchor for ${targetPath}: \`${formatHashlineHeader(targetPath, r.newHash)}\``);
-                    try {
-                        const fullPath = resolve(cwd, targetPath);
-                        const diags = await getLiveLspDiagnostics(fullPath, cwd);
-                        if (diags) {
-                            textOutput.push(`\nLive LSP diagnostics for ${targetPath}:\n${diags}`);
-                        }
-                    }
-                    catch { }
-                }
+            finally {
+                clearTimeout(timer);
             }
-            return {
-                content: [{ type: "text", text: textOutput.join("\n") }],
-                details: report,
-            };
         },
     });
 }

package/dist/server/permission-preset.js

@@ -67,3 +67,28 @@ export function readPermissionFromSession(sm) {
     }
     return undefined;
 }
+/**
+ * 从会话 sessionManager entries 回放恢复最后保存的结构化计划状态。
+ * customType 为 "plan/update" 或 "pi-web-ui/plan"，载荷结构为 { plan: PlanState }。
+ */
+export function readPlanFromSession(sm) {
+    try {
+        const mgr = sm;
+        if (typeof mgr?.getEntries !== "function")
+            return null;
+        const entries = mgr.getEntries();
+        for (let i = entries.length - 1; i >= 0; i--) {
+            const e = entries[i];
+            if (e?.type === "custom" &&
+                (e.customType === "plan/update" || e.customType === "pi-web-ui/plan") &&
+                e.data?.plan &&
+                Array.isArray(e.data.plan.steps)) {
+                return e.data.plan;
+            }
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}

package/dist/server/plan-manager.js

@@ -11,16 +11,111 @@
  *    - 模型可通过 customTool `plan_update` 更新
  *    - 客户端也可通过协议消息 `plan_update` 调整
  *    - 状态自动同步到快照 `UiState.plan`
+ *
+ * 存储模型与隔离设计（防新会话串台）：
+ * - 持久化源（plansBySession）：以真实唯一的 SDK sessionId 为主键，落盘至 plans.json。
+ * - 运行时缓存（plansByConv）：以会话槽位 conversationId 为主键，仅存活于进程内存，绝不落盘。
+ * - 历史文件清洗：严格过滤形如 /^c\d+$/ 的易变短 ID，防止服务重启后新会话被上一个会话的任务附体。
  */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 const VALID_STATUSES = new Set(["pending", "in_progress", "done", "failed"]);
+/** 判断是否为易变的临时 conversationId（如 c1, c2, c99 等）。此类短 ID 绝不入持久化文件。 */
+function isEphemeralConvId(id) {
+    return /^c\d+$/.test(id);
+}
 export class PlanManager {
-    plans = new Map();
-    /** 获取指定会话的计划状态。 */
-    getPlan(conversationId) {
-        return this.plans.get(conversationId) ?? null;
+    filePath;
+    /** 按持久化 sessionId 存储的真实计划状态（落盘至 plans.json）。 */
+    plansBySession = new Map();
+    /** 按运行时 conversationId 存储的临时计划缓存（进程内存态，不落盘）。 */
+    plansByConv = new Map();
+    /** conversationId 到 sessionId 的映射。 */
+    convToSession = new Map();
+    constructor(filePath) {
+        this.filePath = filePath;
+        if (filePath) {
+            this.load();
+        }
+    }
+    load() {
+        if (!this.filePath)
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(this.filePath, "utf8"));
+            for (const [key, val] of Object.entries(raw)) {
+                // 严格过滤：形如 c1, c2 的临时 conversationId 绝不作为持久化会话键载入，
+                // 防止服务重启或历史残留时污染新分配的相同 ID 对话。
+                if (isEphemeralConvId(key))
+                    continue;
+                if (val && typeof val === "object" && Array.isArray(val.steps)) {
+                    this.plansBySession.set(key, val);
+                }
+            }
+        }
+        catch {
+            // 文件不存在或格式异常，以空状态起步
+        }
+    }
+    save() {
+        if (!this.filePath)
+            return;
+        try {
+            mkdirSync(dirname(this.filePath), { recursive: true });
+            const obj = {};
+            for (const [k, v] of this.plansBySession.entries()) {
+                // 双重防护：临时 conversationId 绝不落盘
+                if (isEphemeralConvId(k))
+                    continue;
+                obj[k] = v;
+            }
+            const tmp = `${this.filePath}.tmp.${Date.now()}`;
+            writeFileSync(tmp, JSON.stringify(obj, null, 2), "utf8");
+            renameSync(tmp, this.filePath);
+        }
+        catch {
+            // 持久化失败绝不阻断主流程
+        }
+    }
+    /** 绑定 conversationId 与 sessionId。若 sessionId 已有落盘计划，立即恢复给 conversationId。 */
+    bindSession(conversationId, sessionId) {
+        this.convToSession.set(conversationId, sessionId);
+        // 绑定（或重新绑定）session 时，先清除当前 conversationId 上次残留的内存状态
+        this.plansByConv.delete(conversationId);
+        const existing = this.plansBySession.get(sessionId);
+        if (existing) {
+            this.plansByConv.set(conversationId, existing);
+            return existing;
+        }
+        // 绝不从 conversationId 逆向污染全新 sessionId！全新会话以空状态起步。
+        return null;
+    }
+    /** 解绑并清理指定 conversationId 的运行时内存计划与映射（在会话移除/销毁时调用）。 */
+    unbindConversation(conversationId) {
+        this.plansByConv.delete(conversationId);
+        this.convToSession.delete(conversationId);
     }
-    /** 设置/全量更新指定会话的计划。 */
-    setPlan(conversationId, steps, activeStepId) {
+    /** 获取指定会话的计划状态。优先使用 conversationId，若无则回退查找绑定的 sessionId。 */
+    getPlan(id) {
+        const directConv = this.plansByConv.get(id);
+        if (directConv)
+            return directConv;
+        const sessionId = this.convToSession.get(id);
+        if (sessionId) {
+            const bySession = this.plansBySession.get(sessionId);
+            if (bySession) {
+                this.plansByConv.set(id, bySession);
+                return bySession;
+            }
+        }
+        // 兼容以 sessionId 直接查询
+        const directSession = this.plansBySession.get(id);
+        if (directSession)
+            return directSession;
+        return null;
+    }
+    /** 设置/全量更新指定会话的计划（可选绑定 sessionId 进行稳定落盘）。 */
+    setPlan(conversationId, steps, activeStepId, sessionId) {
         const normalizedSteps = (Array.isArray(steps) ? steps : []).map((s, idx) => {
             const status = (VALID_STATUSES.has(s.status) ? s.status : "pending");
             return {
@@ -41,12 +136,23 @@ export class PlanManager {
             activeStepId: effectiveActiveId,
             updatedAt: Date.now(),
         };
-        this.plans.set(conversationId, state);
+        this.plansByConv.set(conversationId, state);
+        const effectiveSessionId = sessionId ?? this.convToSession.get(conversationId);
+        if (effectiveSessionId) {
+            this.convToSession.set(conversationId, effectiveSessionId);
+            if (normalizedSteps.length === 0) {
+                this.plansBySession.delete(effectiveSessionId);
+            }
+            else {
+                this.plansBySession.set(effectiveSessionId, state);
+            }
+            this.save();
+        }
         return state;
     }
     /** 增量更新单个步骤的状态或内容。 */
     updateStep(conversationId, stepId, patch) {
-        const current = this.plans.get(conversationId);
+        const current = this.getPlan(conversationId);
         if (!current)
             return null;
         const idx = current.steps.findIndex((s) => s.id === stepId);
@@ -85,12 +191,92 @@ export class PlanManager {
             activeStepId: nextActive,
             updatedAt: Date.now(),
         };
-        this.plans.set(conversationId, nextState);
+        this.plansByConv.set(conversationId, nextState);
+        const sessId = this.convToSession.get(conversationId);
+        if (sessId) {
+            this.plansBySession.set(sessId, nextState);
+            this.save();
+        }
+        return nextState;
+    }
+    /** 增量删除单个步骤。 */
+    deleteStep(conversationId, stepId) {
+        const current = this.getPlan(conversationId);
+        if (!current)
+            return null;
+        const idx = current.steps.findIndex((s) => s.id === stepId);
+        if (idx === -1)
+            return current;
+        const nextSteps = current.steps.filter((s) => s.id !== stepId);
+        let nextActive = current.activeStepId;
+        if (current.activeStepId === stepId) {
+            const nextPending = nextSteps.find((s) => s.status === "pending" || s.status === "in_progress");
+            nextActive = nextPending ? nextPending.id : null;
+        }
+        const nextState = {
+            steps: nextSteps,
+            activeStepId: nextActive,
+            updatedAt: Date.now(),
+        };
+        this.plansByConv.set(conversationId, nextState);
+        const sessId = this.convToSession.get(conversationId);
+        if (sessId) {
+            this.plansBySession.set(sessId, nextState);
+            this.save();
+        }
+        return nextState;
+    }
+    /** 增量新增步骤。 */
+    addStep(conversationId, step, afterStepId) {
+        const current = this.getPlan(conversationId);
+        const existingSteps = current?.steps ?? [];
+        const normalized = {
+            id: String(step.id ?? `step-${Date.now()}`),
+            title: String(step.title ?? "").slice(0, 200),
+            status: step.status && VALID_STATUSES.has(step.status) ? step.status : "pending",
+        };
+        const description = String(step.description ?? "").slice(0, 1000);
+        if (description)
+            normalized.description = description;
+        let nextSteps;
+        if (afterStepId) {
+            const idx = existingSteps.findIndex((s) => s.id === afterStepId);
+            if (idx !== -1) {
+                nextSteps = [...existingSteps.slice(0, idx + 1), normalized, ...existingSteps.slice(idx + 1)];
+            }
+            else {
+                nextSteps = [...existingSteps, normalized];
+            }
+        }
+        else {
+            nextSteps = [...existingSteps, normalized];
+        }
+        let nextActive = current?.activeStepId ?? null;
+        if (!nextActive && normalized.status === "in_progress") {
+            nextActive = normalized.id;
+        }
+        const nextState = {
+            steps: nextSteps,
+            activeStepId: nextActive,
+            updatedAt: Date.now(),
+        };
+        this.plansByConv.set(conversationId, nextState);
+        const sessId = this.convToSession.get(conversationId);
+        if (sessId) {
+            this.plansBySession.set(sessId, nextState);
+            this.save();
+        }
         return nextState;
     }
     /** 清除指定会话的计划。 */
     clearPlan(conversationId) {
-        this.plans.delete(conversationId);
+        this.plansByConv.delete(conversationId);
+        const sessId = this.convToSession.get(conversationId);
+        if (sessId) {
+            this.plansBySession.delete(sessId);
+            this.convToSession.delete(conversationId);
+        }
+        this.save();
     }
     /** 格式化计划为简洁文本，供模型上下文或诊断使用。 */
     describePlan(conversationId) {