pi-web-ui 0.98.0 → 0.99.0

package/CHANGELOG.md

@@ -12,13 +12,41 @@
 
 暂无未发布内容。
 
+## [0.99.0] — 2026-10-03
+
+### Added
+
+- **手机端边缘横滑抽屉手势** —— 从屏幕左/右边缘向内横滑拉出左侧会话面板或右侧工具面板，手势支持全行程实时跟手跟随、常驻遮罩层透明度渐显，并具备横向主导轴向识别与代码块/宽表格横向滚动元素避让。回归：`swipe-drawer.test.ts`、`swipe-drawer-ui-test`。
+- **侧边图标停靠栏竖轴对齐（#443）** —— 侧边停靠栏（`SideDock`）支持「靠上 / 居中 / 靠下」三档竖轴对齐模式，三段贴边药丸自适应内容高度，并在设置页「界面布局」对齐选项及拖拽式图标编辑模式中打通。回归：`ui-layout-edit.test.ts`、`side-dock-align-ui-test`。
+
+### Fixed
+
+- **任务计划跨会话隔离防串台** —— `PlanManager` 架构重构：按持久化 `sessionId` 独立落盘至 `<dataDir>/plans.json`，而运行时按 `conversationId` 存入只活在进程内存的临时缓存，启动与载入时严格过滤易变短 ID（`c\d+`），绑定新会话时主动清理旧内存缓存，杜绝服务重启或短 ID 复用导致新会话被上一会话的任务串台附体。回归：`plan-state.test.ts`。
+- **工具契约与运行时脱节修复（#462、#537）** —— 落地三处未对齐的契约细节：`eval` 将 `python` 别名统一归一为 `py`，非法语言显式抛错提示候选；`patch` 真正接入 schema 声明的 `timeout`（1-300s）超时控制并通过 Promise.race 竞速；`bash` 的 `head`/`tail` 参数严密钳制在 schema 上限 5000 以内，防止异常大数冲垮工具结果缓冲与转录。
+- **目标模式 `stopDelegated` 串行化与时序窗口（#464、#536）** —— `stopDelegated` 改为按会话串行化队列执行，`setGoal`/`clearGoal`/`stopAllGoals` 增加 `await` 落定，解决满员边缘重设目标时旧执行者尚未完全移出、同步名额检查误报「名额已满」的问题。
+
+### Changed
+
+- **抽出 CollapsibleHead 公共壳组件（#476、#539）** —— 提取统一的 `CollapsibleHead` 组件，将 `ThinkingBlock`、`ToolCallBlock` 及 `Message`（附件卡/压缩摘要/技能卡）五处内联的可折叠区块头骨架代码收敛统一，键控行为与 ARIA 规范保持一致。
+- **清理 memoizeWithTtl 死码并为手写 TTL 补充注释（#470、#538）** —— 移除全仓零消费的 `memoizeWithTtl` 死码，并为 `agent-service` 的 `piCliProbe`（安装后即时失效）与 `model-enrich` 的 `catalogCache`（双键异步 fetch）补充语义注释。
+
+<!-- auto-i18n:start -->
+
+### i18n
+
+- 前端新增 key（3）：`uiLayoutAlignTop`、`uiLayoutAlignMiddle`、`uiLayoutAlignBottom`
+
+<!-- auto-i18n:end -->
+
 ## [0.98.0] — 2026-10-03
 
 ### Added
 
 - **聊天内容引用（#430）** —— 选中消息里的文字或代码，点浮动按钮即可把原文作为引用卡片加进输入框：支持多条引用、展开查看、逐条移除与重复去重，发送后能在历史消息里回看，编辑重问时保留。标准引擎与 DSH 引擎的消息序列化、草稿恢复、流式提问都已适配。回归：`quote-selection.test.ts`、`text-quote.test.ts`、`dsh-edit-quotes.test.ts`、`quote-selection-ui-test.mjs`。
-- **侧边图标停靠栏改为布局内槽位 + 拖拽式图标编辑模式（#443）** —— `SideDock` 不再是 `position:fixed` 贴边浮层，而是 `.layout` 里的 flex 子项：面板与主区主动向它让出宽度，不再压住面板里的按钮；该侧没有图标时整条不渲染（连宽度都不占）。想要旧行为可在「设置 → 界面布局 → 侧边图标悬浮显示」（`uiLayout.sideDockFloat`）打开。新增**图标编辑模式**（顶栏「⋯」→「编辑图标」）：用 pointer 事件把顶栏、底栏、左右侧边栏四个栏与「待放回」托盘里的条目直接拖进同一份 `uiLayout`（order/align/slots/hidden），与设置页布局互通；「⋯」溢出菜单因此改为顶栏有任意条目时常驻（否则进不去编辑面板）。回归：`ui-layout-edit.test.ts`、`host-icon.test.ts`、`ui-layout-ui-test`（真 Chrome）。
-- **顶栏/底栏条目可移动到上下左右 + 全屏预览增强** —— 条目右键菜单新增「移至顶部 / 底部 / 左侧 / 右侧」，左右侧边停靠栏可折叠展开，偏好持久化；文件全屏预览同步增强。
+- **图标编辑模式：拖拽调整四个栏的布局（#443）** —— 顶栏「⋯」→「编辑图标」进入。顶栏 / 底栏 / 左侧边栏 / 右侧边栏四个栏与「待放回」托盘同处一面板，把条目从一个栏拖到另一个栏、或拖回托盘，即直接改写同一份 `uiLayout`（order / align / slots / hidden），与设置页的布局选项实时互通；内置条目的图标名登记在 `host-icon.tsx`（否则编辑面板里只剩文字）。拖拽用 pointer 事件而非 HTML5 DnD（DnD 在触屏上不触发）。「⋯」溢出菜单因此改为顶栏有任意条目时常驻——否则用户根本进不来。回归：`ui-layout-edit.test.ts`、`host-icon.test.ts`、`ui-layout-ui-test`（真 Chrome）。
+- **顶栏/底栏条目可移动到上下左右（右键路径）** —— 条目右键菜单新增「移至顶部 / 底部 / 左侧 / 右侧」，与上面的拖拽是同一份 `uiLayout` 的两个入口；左右侧边停靠栏可折叠展开，偏好持久化。
+- **侧边图标停靠栏改为布局内槽位（#443）** —— `SideDock` 不再是 `position:fixed` 贴边浮层，而是 `.layout` 里的 flex 子项：面板与主区主动向它让出宽度，不再压住面板里的按钮；该侧没有图标时整条不渲染（连宽度都不占）。想要旧行为可在「设置 → 界面布局 → 侧边图标悬浮显示」（`uiLayout.sideDockFloat`）打开。
+- **全屏预览增强** —— 预览头双击（避开按钮 / 链接 / 输入框）切换全屏；图片预览点击图片即关闭（`clickToCloseImage`）；HTML 预览工具条新增「在新标签页打开」外链（`openInNewTab`）；不需要编辑栏时页脚不再占位。
 - **子代理 `wait_all` 阻塞上限可配（#449）** —— 上限从硬编码 60 秒提升到 0.8×看门狗（默认约 16 分钟），可用 `PI_WEB_SUBAGENT_WAIT_CAP_SECONDS` 覆盖：长子代理任务不再被迫每 60 秒重发一次 `wait_all` 烧轮次。
 - **任务计划跨重启/跨刷新持久化** —— 计划不再只活在内存：按 `sessionId` 落盘到 `<dataDir>/plans.json`，并随会话转录（`plan/update` custom entry）一起走；重建会话时按「落盘文件 → 转录 → 历史 `plan_update` 工具调用」三重兼容顺序回放，旧会话也能找回看板。回归：`plan-state.test.ts`。
 - **任务看板折叠态精简为单行状态条** —— 折叠时只留「标题 + 进度徽标 + 当前步骤」，进度以底边 2px 细线呈现（零额外高度）；「净室执行 / 复制 Markdown / 清空」收进展开态，「开始实施」在两种状态都可达。
@@ -94,6 +122,7 @@
 - **`release-notes.mjs --write-changelog` 替换串改函数形式（#498, #515）** —— i18n 文案含 `$&`、`` $` `` 等替换模式时不再静默写坏 `CHANGELOG.md`。
 
 <!-- auto-i18n:start -->
+
 ### i18n
 
 - 前端新增 key（26）：`openInNewTab`、`clickToCloseImage`、`compactedHistoryNotFound`、`uiLayoutSideDockFloat`、`uiIconEdit`、`uiIconEditTitle`、`uiIconEditHint`、`uiIconEditTray`、`uiIconEditDropHere`、`uiLayoutSidebarLeft`、`uiLayoutSidebarRight`、`uiLayoutPosition`、`uiLayoutPosTop`、`uiLayoutPosBottom`、`uiLayoutPosLeft`、`uiLayoutPosRight`、`moveToTop`、`moveToBottom`、`moveToLeft`、`moveToRight`、`sideDockCollapse`、`sideDockExpand`、`quoteSelection`、`quoteText`、`quoteSource`、`removeQuote`
@@ -104,7 +133,6 @@
 - 服务端文案变更（2）：`markers.todo.dep.blocks.updated`、`subagents.wait.pending`
 - 服务端删除 key（1）：`markers.todo.list.empty`
 
-
 ## [0.97.0] — 2026-09-26
 
 ### Added
@@ -1453,7 +1481,8 @@ when?, children?}`，也收 `topbar` / `settings` 这类简写别名）；宿主
 - 0.35.1（2026-08-27）：编辑重问保留附件（#18）+ 全窗口拖放（#19）。
 - 0.29.0（2026-08-23）：全局搜索弹窗（Ctrl+K）+ 消息列表惰性窗口化。
 
-[Unreleased]: https://github.com/xing-shuyin/pi-web-ui/compare/v0.98.0...main
+[Unreleased]: https://github.com/xing-shuyin/pi-web-ui/compare/v0.99.0...main
+[0.99.0]: https://github.com/xing-shuyin/pi-web-ui/releases/tag/v0.99.0
 [0.98.0]: https://github.com/xing-shuyin/pi-web-ui/releases/tag/v0.98.0
 [0.97.0]: https://github.com/xing-shuyin/pi-web-ui/releases/tag/v0.97.0
 [0.96.1]: https://github.com/xing-shuyin/pi-web-ui/releases/tag/v0.96.1

package/dist/server/agent-service.js

@@ -5352,7 +5352,9 @@ export class ClientSession {
             compaction: conv.compactionState ?? null,
             pendingQuestion: this.pendingQuestionForSnapshot(),
             pendingApproval: this.pendingApprovalForSnapshot(),
-            plan: this.planManager.getPlan(this.activeId),
+            // 任务计划看板状态同样是会话级：快照恒给 PlanState 或 null（不用 undefined），
+            // 否则 snapshot_delta 里 key 缺席 → 前端 spread 浅合并会残留上一对话的 plan。
+            plan: this.planManager.getPlan(this.activeId) ?? null,
             // 计划模式是**会话级**开关：快照恒给布尔（不用 undefined），否则
             // snapshot_delta 里 key 缺席 → 前端 spread 合并会残留上一对话的 true。
             planMode: conv?.planMode === true,
@@ -5853,7 +5855,7 @@ export class ClientSession {
         const sourceGoal = sourceConv?.goal?.goal;
         await this.newChat();
         const targetConv = this.conv;
-        this.planManager.setPlan(targetConv.id, steps);
+        this.planManager.setPlan(targetConv.id, steps, undefined, targetConv?.session?.sessionId);
         if (sourceGoal) {
             try {
                 await this.goalSvc.setGoal(sourceGoal, { targetConvId: targetConv.id, autoStart: false });
@@ -6061,6 +6063,8 @@ export class ClientSession {
      * the forked child deadlocks between fork and exec. This applies to
      * asynchronous spawns too — the previous async probe reproduced the hang.
      */
+    // 手写 TTL 缓存而非通用 memoize：安装 pi 后 invalidatePiCliProbe() 要立即
+    // 失效重探，通用 TTL memoize 不带失效通道（issue #470 处置说明）。
     static piCliProbe = null;
     static PI_CLI_PROBE_TTL_MS = 10_000;
     isPiCliInstalled() {
@@ -8741,7 +8745,8 @@ export class ClientSession {
         // this branch normally can't exist — kept as a safety net).
         const isBlank = (c) => {
             try {
-                return c.session.getSessionStats().totalMessages === 0 && c.terminals.list().length === 0;
+                const hasPlan = (this.planManager.getPlan(c.id)?.steps.length ?? 0) > 0;
+                return c.session.getSessionStats().totalMessages === 0 && c.terminals.list().length === 0 && !hasPlan;
             }
             catch {
                 // session being replaced — treat as used so we don't switch onto it
@@ -9208,6 +9213,7 @@ export class ClientSession {
             // ignore
         }
         this.convs.delete(id);
+        this.planManager.unbindConversation(id);
         this.clearAllToolWatchdogs(conv);
         // 关对话 → 连它的 eval 内核（Python/Node 子进程 + 临时沙箱目录）一起回收：
         // 这些进程是 detached 进程组，父进程退出不会自动带走它们。

package/dist/server/eval-tool.js

@@ -523,7 +523,28 @@ export function makeEvalTool(opts) {
         }),
         execute: async (_id, params) => {
             const lang = getLang();
-            const language = params.language ?? "py";
+            let language = params.language ?? "py";
+            if (language === "python")
+                language = "py"; // 常见笔误别名（issue #462）
+            if (language !== "py" && language !== "js" && language !== "ts") {
+                // schema 已声明 enum(["py","js","ts"])（#417），但那只影响提示不拦运行时；
+                // getKernel 的 normLang 只映射 ts，其余任意值会原样建出名为它的 Node 内核，
+                // Python 代码被 node 执行报 JS 语法错且模型无从知道是键写错。
+                const text = pick(lang, `错误：language 仅支持 py / js / ts，收到「${language}」。`, `Error: language must be one of py / js / ts; got "${language}".`);
+                return {
+                    content: [{ type: "text", text }],
+                    details: {
+                        language,
+                        durationMs: 0,
+                        ok: false,
+                        stdout: "",
+                        stderr: "",
+                        result: null,
+                        error: text,
+                        reset: params.reset ?? false,
+                    },
+                };
+            }
             const timeoutSec = Math.min(Math.max(1, params.timeout ?? DEFAULT_TIMEOUT_SECONDS), MAX_TIMEOUT_SECONDS);
             const timeoutMs = timeoutSec * 1000;
             const startTime = Date.now();

package/dist/server/goal-service.js

@@ -532,7 +532,9 @@ export class GoalService {
         conv.goalGeneration += 1;
         // 上一轮目标可能还留着常驻执行者子代理（委托执行）：先停掉再开新的，
         // 否则旧循环会在新目标上继续派活（代次已作废，但角色对话得收）。
-        this.stopDelegated(conv);
+        // await 到 dismiss 完全落定：后面的 spawn 名额检查才不会数到还在收尾的
+        // 旧执行者而误报上限（issue #464；stopDelegated 自身已按会话串行化）。
+        await this.stopDelegated(conv);
         const goal = conv.goal;
         goal.reviewing = false;
         goal.conversationId = goalConversationId;
@@ -1125,7 +1127,8 @@ export class GoalService {
         const conv = this.host.activeConv();
         conv.goalGeneration += 1;
         // 委托执行：停掉在飞的执行者（循环靠代次作废 + 代次守卫退出）。
-        this.stopDelegated(conv);
+        // await 落定，保证旧执行者已移出会话表，后续重设目标不再误报名额（issue #464）。
+        await this.stopDelegated(conv);
         this.resetLoopCounters(conv);
         this.clearGoalFields(conv);
         this.emitGoalStatus();
@@ -1159,14 +1162,15 @@ export class GoalService {
      */
     async stopAllGoals() {
         let stopped = 0;
-        // 直接迭代：stopDelegated 只发 fire-and-forget 的停/收请求，不会同步改这张表
-        // （循环退出是异步的，靠代次守卫），无需快照。
-        for (const convId of this.delegatedLoops.keys()) {
+        // 快照迭代：await stopDelegated 期间，循环退出的回调可能增删这张表。
+        for (const convId of [...this.delegatedLoops.keys()]) {
             const conv = this.host.getConv(convId);
             if (!conv)
                 continue;
             conv.goalGeneration += 1; // 作废在飞回调（循环靠代次守卫退出）
-            this.stopDelegated(conv); // 停执行者 + 唤醒 verdict 等待者 + 清 roles/phase
+            // 逐个 await 停/收落定（stopDelegated 已按会话串行化，issue #464）：
+            // 停执行者 + 唤醒 verdict 等待者 + 清 roles/phase
+            await this.stopDelegated(conv);
             this.resetLoopCounters(conv);
             this.clearGoalFields(conv);
             stopped++;
@@ -1210,6 +1214,8 @@ export class GoalService {
                 }
                 conv.goalGeneration += 1;
                 // 委托执行：手动停止也要把在飞的执行者停掉（否则它还在后台改工作区）。
+                // 本钩子是同步上下文，fire-and-forget 即可：stopDelegated 已按会话
+                // 串行化（issue #464），重设/清除目标的一方会先等这次 dismiss 落定。
                 this.stopDelegated(conv);
                 this.resetLoopCounters(conv);
                 g.conversationId = null;
@@ -1403,7 +1409,24 @@ export class GoalService {
         conv.goal.roles = {};
         return exec?.convId;
     }
-    async stopDelegated(conv) {
+    stopInflight = new Map();
+    /**
+     * 停掉委托执行者（stop + dismiss + 唤醒等待者）。同一会话并发调用时按序串行：
+     * 上一次 stop/dismiss 未落定前，下一次先等它 —— 否则重设目标时旧执行者尚未
+     * 移出会话表，随后 spawn 的名额检查会数到它而误报容量上限（issue #464）。
+     * 同步上下文（onAgentEnd 等钩子）可以继续 fire-and-forget，串行化由这里兜住。
+     */
+    stopDelegated(conv) {
+        const prev = this.stopInflight.get(conv.id);
+        const run = prev ? prev.catch(() => { }).then(() => this.stopDelegatedNow(conv)) : this.stopDelegatedNow(conv);
+        this.stopInflight.set(conv.id, run);
+        void run.finally(() => {
+            if (this.stopInflight.get(conv.id) === run)
+                this.stopInflight.delete(conv.id);
+        });
+        return run;
+    }
+    async stopDelegatedNow(conv) {
         // 排队的启动请求一并作废：setGoal 会在后面按新代次重新排，clearGoal 则不需要。
         this.delegatedPending.delete(conv.id);
         conv.awaitingVerdict = undefined;

package/dist/server/model-enrich.js

@@ -156,6 +156,8 @@ 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;

package/dist/server/patch-tool.js

@@ -61,41 +61,76 @@ On divergence the engine attempts a 3-way merge. After success the tool returns
                     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: pick(L, `补丁应用失败：\n${report.summary}`, `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(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 { }
-                }
+            finally {
+                clearTimeout(timer);
             }
-            return {
-                content: [{ type: "text", text: textOutput.join("\n") }],
-                details: report,
-            };
         },
     });
 }

package/dist/server/plan-manager.js

@@ -11,13 +11,26 @@
  *    - 模型可通过 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 {
     filePath;
-    plans = new Map();
+    /** 按持久化 sessionId 存储的真实计划状态（落盘至 plans.json）。 */
+    plansBySession = new Map();
+    /** 按运行时 conversationId 存储的临时计划缓存（进程内存态，不落盘）。 */
+    plansByConv = new Map();
+    /** conversationId 到 sessionId 的映射。 */
     convToSession = new Map();
     constructor(filePath) {
         this.filePath = filePath;
@@ -31,8 +44,12 @@ export class PlanManager {
         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.plans.set(key, val);
+                    this.plansBySession.set(key, val);
                 }
             }
         }
@@ -46,7 +63,10 @@ export class PlanManager {
         try {
             mkdirSync(dirname(this.filePath), { recursive: true });
             const obj = {};
-            for (const [k, v] of this.plans.entries()) {
+            for (const [k, v] of this.plansBySession.entries()) {
+                // 双重防护：临时 conversationId 绝不落盘
+                if (isEphemeralConvId(k))
+                    continue;
                 obj[k] = v;
             }
             const tmp = `${this.filePath}.tmp.${Date.now()}`;
@@ -60,32 +80,38 @@ export class PlanManager {
     /** 绑定 conversationId 与 sessionId。若 sessionId 已有落盘计划，立即恢复给 conversationId。 */
     bindSession(conversationId, sessionId) {
         this.convToSession.set(conversationId, sessionId);
-        const existing = this.plans.get(sessionId);
+        // 绑定（或重新绑定）session 时，先清除当前 conversationId 上次残留的内存状态
+        this.plansByConv.delete(conversationId);
+        const existing = this.plansBySession.get(sessionId);
         if (existing) {
-            this.plans.set(conversationId, existing);
+            this.plansByConv.set(conversationId, existing);
             return existing;
         }
-        const convExisting = this.plans.get(conversationId);
-        if (convExisting) {
-            this.plans.set(sessionId, convExisting);
-            this.save();
-            return convExisting;
-        }
+        // 绝不从 conversationId 逆向污染全新 sessionId！全新会话以空状态起步。
         return null;
     }
+    /** 解绑并清理指定 conversationId 的运行时内存计划与映射（在会话移除/销毁时调用）。 */
+    unbindConversation(conversationId) {
+        this.plansByConv.delete(conversationId);
+        this.convToSession.delete(conversationId);
+    }
     /** 获取指定会话的计划状态。优先使用 conversationId，若无则回退查找绑定的 sessionId。 */
-    getPlan(conversationId) {
-        const direct = this.plans.get(conversationId);
-        if (direct)
-            return direct;
-        const sessionId = this.convToSession.get(conversationId);
+    getPlan(id) {
+        const directConv = this.plansByConv.get(id);
+        if (directConv)
+            return directConv;
+        const sessionId = this.convToSession.get(id);
         if (sessionId) {
-            const bySession = this.plans.get(sessionId);
+            const bySession = this.plansBySession.get(sessionId);
             if (bySession) {
-                this.plans.set(conversationId, bySession);
+                this.plansByConv.set(id, bySession);
                 return bySession;
             }
         }
+        // 兼容以 sessionId 直接查询
+        const directSession = this.plansBySession.get(id);
+        if (directSession)
+            return directSession;
         return null;
     }
     /** 设置/全量更新指定会话的计划（可选绑定 sessionId 进行稳定落盘）。 */
@@ -110,13 +136,18 @@ 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);
-            this.plans.set(effectiveSessionId, state);
+            if (normalizedSteps.length === 0) {
+                this.plansBySession.delete(effectiveSessionId);
+            }
+            else {
+                this.plansBySession.set(effectiveSessionId, state);
+            }
+            this.save();
         }
-        this.save();
         return state;
     }
     /** 增量更新单个步骤的状态或内容。 */
@@ -160,17 +191,17 @@ 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.plans.set(sessId, nextState);
+            this.plansBySession.set(sessId, nextState);
+            this.save();
         }
-        this.save();
         return nextState;
     }
     /** 增量删除单个步骤。 */
     deleteStep(conversationId, stepId) {
-        const current = this.plans.get(conversationId);
+        const current = this.getPlan(conversationId);
         if (!current)
             return null;
         const idx = current.steps.findIndex((s) => s.id === stepId);
@@ -187,12 +218,17 @@ 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;
     }
     /** 增量新增步骤。 */
     addStep(conversationId, step, afterStepId) {
-        const current = this.plans.get(conversationId);
+        const current = this.getPlan(conversationId);
         const existingSteps = current?.steps ?? [];
         const normalized = {
             id: String(step.id ?? `step-${Date.now()}`),
@@ -224,15 +260,20 @@ 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;
     }
     /** 清除指定会话的计划。 */
     clearPlan(conversationId) {
-        this.plans.delete(conversationId);
+        this.plansByConv.delete(conversationId);
         const sessId = this.convToSession.get(conversationId);
         if (sessId) {
-            this.plans.delete(sessId);
+            this.plansBySession.delete(sessId);
             this.convToSession.delete(conversationId);
         }
         this.save();

package/dist/server/terminals.js

@@ -1580,28 +1580,35 @@ function cleanBashOutput(raw) {
 /** 一次性 bash 终端序号：非持久调用每次新建一个终端，进程结束后退出、输出
  *  保留在 history 供查阅——故每调用独立 id，避免复用覆盖旧输出。 */
 let oneShotBashSeq = 0;
+/** head / tail 的运行时上限，与 bash 工具参数 schema 的 maximum 5000 一致
+ *  （agent-service.ts）——schema 只影响提示不拦运行时（issue #462）。 */
+const MAX_HEAD_TAIL_LINES = 5000;
 /** 应用 head / tail 参数到输出顶层行（替代 `| head` / `| tail` 管道——管道会
  *  缓冲输出、让可见终端全程哑火，还容易白白触发静默解阻）。两者同时给时先
  *  截头再截尾。 */
 export function applyHeadTail(text, head, tail, lang = "en") {
+    // 入口钳到 schema 上限：此前只判 >0，传 1e9 会把整段缓冲灌进单条工具结果
+    // 并持久化进转录。
+    const headN = head && head > 0 ? Math.min(Math.floor(head), MAX_HEAD_TAIL_LINES) : 0;
+    const tailN = tail && tail > 0 ? Math.min(Math.floor(tail), MAX_HEAD_TAIL_LINES) : 0;
     // 只对真实数据行切片；省略提示行单独存，最后再包回输出，避免提示行在
     // head+tail 组合时被当成数据行参与第二次截取（导致尾部少截一行）。
     let data = text.split("\n");
     let headNote = null;
     let tailNote = null;
-    if (head && head > 0 && data.length > head) {
-        const n = data.length - head;
+    if (headN && data.length > headN) {
+        const n = data.length - headN;
         headNote = pick(lang, `…（后 ${n} 行已省略）`, `…[${n} lines omitted below]…`, "terminals.headtail.omitted.below", {
             n,
         });
-        data = data.slice(0, head);
+        data = data.slice(0, headN);
     }
-    if (tail && tail > 0 && data.length > tail) {
-        const n = data.length - tail;
+    if (tailN && data.length > tailN) {
+        const n = data.length - tailN;
         tailNote = pick(lang, `…（前 ${n} 行已省略）`, `…[${n} lines omitted above]…`, "terminals.headtail.omitted.above", {
             n,
         });
-        data = data.slice(-tail);
+        data = data.slice(-tailN);
     }
     const parts = [];
     if (tailNote)

package/dist/server/update-check.js

@@ -32,21 +32,6 @@ export function compareVersions(a, b) {
     }
     return 0;
 }
-/**
- * Cache a zero-arg function's value for ttlMs. Plain value memoization: the
- * pi probe returns null on failure instead of throwing, so errors thread
- * through as ordinary values and there is nothing to rethrow.
- */
-export function memoizeWithTtl(fn, ttlMs) {
-    let entry = null;
-    return () => {
-        const now = Date.now();
-        if (!entry || now - entry.at >= ttlMs) {
-            entry = { at: now, value: fn() };
-        }
-        return entry.value;
-    };
-}
 /**
  * Parse `pi --version` stdout into a version string, or null. Two-stage:
  * prefer a line that is exactly the version (optional leading "v", optional

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-web-ui",
-	"version": "0.98.0",
+	"version": "0.99.0",
 	"description": "Just open your browser to get all your work done — browser cockpit for AI coding agents (chat, code, files, terminal, Git in one tab)",
 	"license": "MIT",
 	"author": {