@tea-agent/loop-agent 0.39.0-next.10 → 0.39.0-next.12

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+### 改进
+
+- Operator Chat 对齐 pi-web：建会话不再传封闭 `tools` 白名单（避免 SDK 把扩展 MCP 工具滤出 registry），创建后 `bindExtensions` 发 `session_start`，再钉激活集。扩展注册的 MCP 工具可被模型调用；`apply_patch` / `full-tools` / `shell` / `coding-chat` 仍排除。
+- 对话侧栏 Plugins 右侧新增只读 MCP 弹窗：展示 `mcp.json` 配置的服务，以及当前会话真正注册/激活的 MCP 工具；没有配置也没有工具时保持真实空态。
+- 对话侧栏原 Packages 入口改名为 Plugins，与 pi-web / Pi 用户面一致；内部仍是 package inventory。
+- 对话进行中底部上下文占用百分比保持常驻：token 用量事件不再冲掉上一帧的 contextUsage，并在回合中持续刷新。
+- 上一轮大量 bash 结束后再发新消息，旧工具条不再整批挂到新气泡下面：无主工具不再丢进最新一组，历史按完整回合裁切，空助手气泡若还挂着工具会留下来当锚点。
+- 侧栏文件树点击目录行直接插入 `@目录/` 引用（箭头单独负责展开/收起）；输入框 @ 补全也列出目录，排在文件前面。
+- 对话进行中点「停止」立即安静下来（乐观停止，对齐 pi-web）：不再等 POST /abort 往返；后端 abort 等待从 8s 降到 2.5s，未终结时由状态对账收敛。
+- 侧栏文件树实时刷新：agent 回合结束、浏览器标签页回到前台、手动点「刷新」时重拉根目录+全部已展开目录（此前手动刷新只拉根目录，子目录永远旧缓存）。
+- Skills / Packages / Models 面板不再把 Pi 的 warning / collision 原文堆在列表上方：改成标题条一颗摘要芯片（如「14 条提示」），点开按「需要处理 / 名称不规范 / 同名未生效」分组，文案用自然语言，路径只显示末两段；名称不规范的技能在列表旁标「提示」，详情里说明「现在这样也能用」。加载失败仍单独成组，可点「再读一次」。
+- Skills / Packages 双栏改为左右各自滚动；资源弹窗挂到 `document.body`，按顶部对话导航的实时高度在剩余视口居中，不再被 sticky 顶栏挡住上沿。
+
 ### 新增
 
 - 前端 plan 唯一机器契约化（JSON-only）：`frontend-plan-pi` / `frontend-plan-revision-pi` 输出收敛为「一行导语 + 唯一 fenced `json` 契约 + 唯一 `openspec-citations` 引用块」，彻底移除「可选 Markdown 说明」；plan.md（`contracts/frontend-plan.md`）改由 prewrite gate 用纯函数 `renderFrontendPlanMarkdown` 确定性渲染（不新增 DAG 节点/不新增 Pi 调用）
@@ -23,6 +36,7 @@
 
 ### 修复
 
+- `frontend-plan-revision-pi` 节点级校验与 merge-patch 输出协议矛盾修复：新增 schemaId `frontend-implementation-contract-revision-patch-v1` 与格式级宽松校验 `validateFrontendRevisionPatchNodeOutput`（至少一个 `openspec-citations` 块 + 剥离引用块后恰好一个 JSON 对象，不做完整契约 schema 校验），revision 节点 `structuredContractOutput.schemaId` 切换（plan-pi 仍为 v1）；node-execution 的 invalid-output retry 指令按 schemaId 分支，patch 协议提示 merge-patch delta + 引用块，消除「prompt 要求 patch、retry 要求完整契约」的 retryable 死循环；gate 仍是唯一权威合并/校验点（零改动）。ADR 0015 补「节点级校验」决策 7
 - `frontend-implementation-contract.schema.json` 的 `uiComponentChoices` items 补 `if/then` 决策语义（`specified` ⇒ `specReference` 必填非 null；`new` ⇒ `specReference` 为 null/缺失）；`frontend-plan-render.ts` 空 `section` 不再渲染尾随 `#`；ADR 0016 增补「门禁边界」小节
 
 ### 文档

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.37.0",
-  "gitSha": "9fc46a3aa984418eaa0796bc9b5abcdd5d43c857",
-  "builtAt": "2026-08-18T07:50:46.364Z"
+  "gitSha": "eae9755e07946ca86dc6ce15fd69e9bb6f0680df",
+  "builtAt": "2026-08-18T13:47:49.649Z"
 }

package/dist/worker/console/chat/mcp-inventory.js

@@ -0,0 +1,221 @@
+/**
+ * Read-only MCP inventory for Operator Chat.
+ *
+ * Pi has no built-in MCP catalog. Console projects two real facts:
+ *   1. mcp.json server specs (configured, may or may not have registered tools)
+ *   2. tools already on the live session that look like MCP registrations
+ *
+ * Never fabricate servers or tools. Missing files stay empty.
+ */
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const MCP_CONFIG_NAMES = ["mcp.json"];
+export function isMcpToolName(name) {
+    const lower = name.trim().toLowerCase();
+    return lower === "mcp" || lower.startsWith("mcp_") || lower.startsWith("mcp-");
+}
+export function inferMcpServerName(toolName, knownServers = []) {
+    const name = toolName.trim();
+    if (/^mcp$/i.test(name))
+        return undefined;
+    const rest = name.replace(/^mcp[_-]/i, "");
+    if (!rest || rest === name || knownServers.length === 0)
+        return undefined;
+    const ranked = [...knownServers].sort((left, right) => right.length - left.length);
+    const lower = rest.toLowerCase();
+    return ranked.find((server) => {
+        const key = server.toLowerCase();
+        return lower === key || lower.startsWith(`${key}_`) || lower.startsWith(`${key}-`);
+    });
+}
+export function looksLikeMcpTool(tool) {
+    const name = typeof tool.name === "string" ? tool.name : "";
+    if (!name)
+        return false;
+    if (isMcpToolName(name))
+        return true;
+    const source = `${tool.sourceInfo?.source ?? ""} ${tool.sourceInfo?.path ?? ""}`.toLowerCase();
+    return source.includes("mcp");
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function readEnabled(entry) {
+    return entry.enabled !== false;
+}
+function readTransport(entry) {
+    if (typeof entry.transport === "string" && entry.transport.trim()) {
+        return entry.transport.trim();
+    }
+    if (typeof entry.type === "string" && entry.type.trim()) {
+        return entry.type.trim();
+    }
+    if (typeof entry.url === "string")
+        return "http";
+    if (Array.isArray(entry.command) || typeof entry.command === "string") {
+        return "stdio";
+    }
+    return undefined;
+}
+function readCommand(entry) {
+    if (typeof entry.command === "string" && entry.command.trim()) {
+        const args = Array.isArray(entry.args)
+            ? entry.args.filter((item) => typeof item === "string").join(" ")
+            : "";
+        return args ? `${entry.command} ${args}` : entry.command;
+    }
+    if (Array.isArray(entry.command)) {
+        return entry.command
+            .filter((item) => typeof item === "string")
+            .join(" ")
+            .trim();
+    }
+    return undefined;
+}
+function extractServerMap(parsed) {
+    const root = asRecord(parsed);
+    if (!root)
+        return {};
+    const mcpServers = asRecord(root.mcpServers);
+    if (mcpServers)
+        return mcpServers;
+    const mcp = asRecord(root.mcp);
+    if (mcp)
+        return mcp;
+    const servers = asRecord(root.servers);
+    if (servers)
+        return servers;
+    return {};
+}
+export function parseMcpConfig(raw, scope, configPath) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const servers = [];
+    for (const [name, value] of Object.entries(extractServerMap(parsed))) {
+        if (!name.trim())
+            continue;
+        const entry = asRecord(value) ?? {};
+        const command = readCommand(entry);
+        const url = typeof entry.url === "string" ? entry.url.trim() : undefined;
+        servers.push({
+            name: name.trim(),
+            scope,
+            enabled: readEnabled(entry),
+            ...(readTransport(entry) ? { transport: readTransport(entry) } : {}),
+            ...(command ? { command } : {}),
+            ...(url ? { url } : {}),
+            configPath,
+        });
+    }
+    return servers;
+}
+export function projectSessionMcpTools(tools, activeToolNames = [], knownServers = []) {
+    const active = new Set(activeToolNames.map((name) => name.toLowerCase()));
+    const seen = new Set();
+    const projected = [];
+    for (const tool of tools) {
+        if (!looksLikeMcpTool(tool) || typeof tool.name !== "string")
+            continue;
+        const name = tool.name.trim();
+        if (!name || seen.has(name))
+            continue;
+        seen.add(name);
+        const server = inferMcpServerName(name, knownServers);
+        projected.push({
+            name,
+            description: typeof tool.description === "string" ? tool.description : "",
+            ...(server ? { server } : {}),
+            source: tool.sourceInfo?.source ?? "",
+            scope: tool.sourceInfo?.scope ?? "session",
+            ...(tool.sourceInfo?.path ? { path: tool.sourceInfo.path } : {}),
+            active: active.has(name.toLowerCase()),
+        });
+    }
+    return projected;
+}
+export function assembleMcpInventory(servers, tools) {
+    const byServer = new Map();
+    const unassigned = [];
+    for (const tool of tools) {
+        const key = tool.server?.toLowerCase();
+        if (!key) {
+            unassigned.push(tool);
+            continue;
+        }
+        const list = byServer.get(key) ?? [];
+        list.push(tool);
+        byServer.set(key, list);
+    }
+    const views = servers.map((server) => {
+        const matched = byServer.get(server.name.toLowerCase()) ?? [];
+        byServer.delete(server.name.toLowerCase());
+        const status = !server.enabled
+            ? "disabled"
+            : matched.length > 0
+                ? "loaded"
+                : "configured";
+        return {
+            name: server.name,
+            scope: server.scope,
+            status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: server.transport } : {}),
+            ...(server.command ? { command: server.command } : {}),
+            ...(server.url ? { url: server.url } : {}),
+            configPath: server.configPath,
+            tools: matched,
+        };
+    });
+    for (const [name, matched] of byServer) {
+        views.push({
+            name,
+            scope: "session",
+            status: "loaded",
+            enabled: true,
+            tools: matched,
+        });
+    }
+    return { servers: views, unassignedTools: unassigned };
+}
+async function readConfigFile(filePath) {
+    try {
+        return await readFile(filePath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function loadMcpServerSpecs(options) {
+    const candidates = [
+        { path: path.join(options.agentDir, ...MCP_CONFIG_NAMES), scope: "user" },
+        { path: path.join(options.cwd, ".pi", ...MCP_CONFIG_NAMES), scope: "project" },
+        { path: path.join(options.cwd, ".mcp.json"), scope: "project" },
+    ];
+    const servers = [];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        const raw = await readConfigFile(candidate.path);
+        if (!raw)
+            continue;
+        for (const server of parseMcpConfig(raw, candidate.scope, candidate.path)) {
+            const key = `${server.scope}:${server.name.toLowerCase()}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            servers.push(server);
+        }
+    }
+    return servers;
+}
+export async function readMcpInventory(options) {
+    const servers = await loadMcpServerSpecs(options);
+    const tools = projectSessionMcpTools(options.tools ?? [], options.activeToolNames ?? [], servers.map((server) => server.name));
+    return assembleMcpInventory(servers, tools);
+}

package/dist/worker/console/chat/pi-runtime.js

@@ -151,6 +151,63 @@ export function computeOperatorChatActiveToolNames(session) {
     }
     return extras.length > 0 ? [...baseline, ...extras] : baseline;
 }
+const OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS = Object.freeze([
+    "apply_patch",
+    "apply-patch",
+    "full-tools",
+    "full_tools",
+    "coding-chat",
+    "coding_chat",
+    "shell",
+]);
+function createConsoleExtensionBindings() {
+    return {
+        mode: "rpc",
+        onError: (error) => {
+            const message = error instanceof Error
+                ? error.message
+                : typeof error === "object" &&
+                    error &&
+                    "error" in error &&
+                    typeof error.error === "string"
+                    ? String(error.error)
+                    : String(error);
+            process.stderr.write(`[console] extension: ${message}\n`);
+        },
+        uiContext: {
+            select: async () => undefined,
+            confirm: async () => false,
+            input: async () => undefined,
+            editor: async () => undefined,
+            notify: () => undefined,
+            onTerminalInput: () => () => undefined,
+            setStatus: () => undefined,
+            setWorkingMessage: () => undefined,
+            setWorkingVisible: () => undefined,
+            setWorkingIndicator: () => undefined,
+            setHiddenThinkingLabel: () => undefined,
+            setWidget: () => undefined,
+            setFooter: () => undefined,
+            setHeader: () => undefined,
+            setTitle: () => undefined,
+            custom: async () => undefined,
+            pasteToEditor: () => undefined,
+            setEditorText: () => undefined,
+            getEditorText: () => "",
+            addAutocompleteProvider: () => undefined,
+            setEditorComponent: () => undefined,
+            getEditorComponent: () => undefined,
+        },
+    };
+}
+async function bindSessionExtensions(session) {
+    if (typeof session.bindExtensions !== "function")
+        return;
+    await session.bindExtensions(createConsoleExtensionBindings());
+}
+function pinOperatorChatTools(session) {
+    session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+}
 /**
  * Build Pi custom ToolDefinition objects for every whitelisted operator action.
  * Each tool's execute() routes into the operator action dispatcher (Gate 3).
@@ -505,6 +562,29 @@ export function projectRuntimeSnapshot(input) {
         })),
         diagnostics: pkg.diagnostics.map((diag) => field(diag, 400) ?? ""),
     });
+    const projectMcpTool = (tool) => ({
+        name: field(tool.name, 200) ?? "",
+        description: field(tool.description, 600) ?? "",
+        ...(tool.server ? { server: field(tool.server, 200) } : {}),
+        source: field(tool.source, 200) ?? "",
+        scope: tool.scope,
+        ...(tool.path ? { path: field(tool.path, 400) } : {}),
+        active: tool.active,
+    });
+    const projectMcp = (mcp) => ({
+        servers: mcp.servers.map((server) => ({
+            name: field(server.name, 200) ?? "",
+            scope: server.scope,
+            status: server.status,
+            enabled: server.enabled,
+            ...(server.transport ? { transport: field(server.transport, 80) } : {}),
+            ...(server.command ? { command: field(server.command, 400) } : {}),
+            ...(server.url ? { url: field(server.url, 400) } : {}),
+            ...(server.configPath ? { configPath: field(server.configPath, 400) } : {}),
+            tools: server.tools.map(projectMcpTool),
+        })),
+        unassignedTools: mcp.unassignedTools.map(projectMcpTool),
+    });
     const projectDiagnostic = (diag) => ({
         type: diag.type,
         ...(diag.code ? { code: diag.code } : {}),
@@ -560,6 +640,7 @@ export function projectRuntimeSnapshot(input) {
         skills: input.skills.map(projectSkill),
         extensions: input.extensions.map(projectExtension),
         packages: input.packages.map(projectPackage),
+        mcp: projectMcp(input.mcp ?? { servers: [], unassignedTools: [] }),
         diagnostics: input.diagnostics.map(projectDiagnostic),
         hasBash: input.hasBash,
     };
@@ -903,36 +984,16 @@ export class ConsolePiRuntime {
         const customTools = await this.loadCustomTools();
         if (this.disposedSessions.has(sessionId))
             return;
-        // The SDK filters BOTH built-in tools and customTools against
-        // `tools` (allowed-tool names) inside _refreshToolRegistry:
-        //   isAllowedTool = (!allowedToolNames || allowedToolNames.has(name))
-        //                    && !excludedToolNames.has(name)
-        // Passing only OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS here silently dropped
-        // every custom operator tool (prepareDagExecution / runDag /
-        // operationWait / safe-read / git-status / ...) from the registry, so the
-        // model could only ever see bash/read/write/edit/grep/find/ls. The
-        // allowlist must cover the full tool surface that is later activated via
-        // setActiveToolsByName(computeOperatorChatActiveToolNames(session)) —
-        // operator actions + built-in explore tools + safe explore tools.
-        // Hard write/coding channels stay blocked via excludeTools below (they
-        // are removed even when present in the allowed list).
+        // pi-web parity: do NOT pass `tools`. A closed allowlist becomes
+        // SDK allowedToolNames and filters extension MCP tools out of the
+        // registry before Gate 2 can re-add them. Operator/safe customTools
+        // still register via customTools; non-Pi write channels stay blocked
+        // by excludeTools. After create, bindExtensions emits session_start
+        // so MCP adapters can register, then pin the active set.
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
-            tools: [
-                ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
-                ...OPERATOR_CHAT_ALLOWED_TOOLS,
-                ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
-            ],
-            excludeTools: [
-                "apply_patch",
-                "apply-patch",
-                "full-tools",
-                "full_tools",
-                "coding-chat",
-                "coding_chat",
-                "shell",
-            ],
+            excludeTools: [...OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS],
             ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
@@ -945,7 +1006,8 @@ export class ConsolePiRuntime {
             }
             return;
         }
-        session.setActiveToolsByName(computeOperatorChatActiveToolNames(session));
+        await bindSessionExtensions(session);
+        pinOperatorChatTools(session);
         // Register then re-check dispose race: a concurrent dispose must win.
         this.sessions.set(sessionId, session);
         this.sessionManagers.set(sessionId, init.sessionManager);
@@ -1616,6 +1678,24 @@ export class ConsolePiRuntime {
                 retryable: true,
             });
         }
+        const { readMcpInventory } = await import("./mcp-inventory.js");
+        let mcp = { servers: [], unassignedTools: [] };
+        try {
+            mcp = await readMcpInventory({
+                agentDir: await safeGetAgentDir(this.bindings),
+                cwd: this.options.cwd,
+                tools: session.getAllTools?.() ?? [],
+                activeToolNames: session.getActiveToolNames(),
+            });
+        }
+        catch (error) {
+            diagnostics.push({
+                type: "error",
+                code: "MCP_INVENTORY_FAILED",
+                message: error instanceof Error ? error.message : String(error),
+                retryable: true,
+            });
+        }
         return projectRuntimeSnapshot({
             sessionId,
             revision: this.revisions.get(sessionId) ?? 0,
@@ -1651,6 +1731,7 @@ export class ConsolePiRuntime {
             skills,
             extensions,
             packages,
+            mcp,
             diagnostics,
             hasBash: true,
         });
@@ -1833,29 +1914,15 @@ export class ConsolePiRuntime {
             : undefined;
         assertNoWriteToolInList(OPERATOR_CHAT_ALLOWED_TOOLS);
         const customTools = await this.loadCustomTools();
-        // Same allowlist rationale as materializeSession: the SDK filters
-        // customTools against `tools`, so the allowed names must cover the full
-        // operator + explore surface or every custom tool is silently dropped.
         const { session } = await this.bindings.createSessionFromServices({
             services,
             sessionManager: init.sessionManager,
-            tools: [
-                ...OPERATOR_CHAT_BUILTIN_EXPLORE_TOOLS,
-                ...OPERATOR_CHAT_ALLOWED_TOOLS,
-                ...OPERATOR_CHAT_SAFE_EXPLORE_TOOL_IDS,
-            ],
-            excludeTools: [
-                "apply_patch",
-                "apply-patch",
-                "full-tools",
-                "full_tools",
-                "coding-chat",
-                "coding_chat",
-                "shell",
-            ],
+            excludeTools: [...OPERATOR_CHAT_SESSION_EXCLUDE_TOOLS],
             ...(customTools.length > 0 ? { customTools } : {}),
             ...(resolvedModel ? { model: resolvedModel } : {}),
         });
+        await bindSessionExtensions(session);
+        pinOperatorChatTools(session);
         return {
             session,
             modelRuntime,
@@ -1950,6 +2017,32 @@ export class ConsolePiRuntime {
             if (options?.signal?.aborted) {
                 return;
             }
+            const emitContextUsage = () => {
+                try {
+                    const contextUsage = session.getSessionStats?.()?.contextUsage;
+                    if (!contextUsage)
+                        return;
+                    if (contextUsage.contextWindow <= 0 &&
+                        contextUsage.percent === null &&
+                        contextUsage.tokens === null) {
+                        return;
+                    }
+                    onEvent({
+                        type: "usage",
+                        sessionId,
+                        usage: {
+                            inputTokens: 0,
+                            outputTokens: 0,
+                            totalTokens: 0,
+                            contextUsage,
+                        },
+                    });
+                }
+                catch {
+                    // Stats getter is best-effort; never break the event stream.
+                }
+            };
+            emitContextUsage();
             unsub = session.subscribe((event) => {
                 const mapped = mapSdkEvent(sessionId, event);
                 if (mapped)
@@ -1962,31 +2055,13 @@ export class ConsolePiRuntime {
                     const usage = extractUsageSample(event);
                     if (usage)
                         onEvent({ type: "usage", sessionId, usage });
+                    emitContextUsage();
                 }
-                // Context usage rides the usage event: refresh on agent_settled so the
-                // bar reflects the post-turn context window fill (pi-web parity).
-                if (event.type === "agent_settled") {
-                    try {
-                        const stats = session.getSessionStats?.();
-                        const contextUsage = stats?.contextUsage;
-                        if (contextUsage) {
-                            onEvent({
-                                type: "usage",
-                                sessionId,
-                                usage: {
-                                    inputTokens: 0,
-                                    outputTokens: 0,
-                                    totalTokens: 0,
-                                    ...(contextUsage.tokens === null
-                                        ? {}
-                                        : { contextUsage }),
-                                },
-                            });
-                        }
-                    }
-                    catch {
-                        // Stats getter is best-effort; never break the event stream.
-                    }
+                // Keep the context fill bar live through the turn (pi-web SessionInfoBar).
+                if (event.type === "agent_start" ||
+                    event.type === "agent_settled" ||
+                    event.type === "tool_execution_end") {
+                    emitContextUsage();
                 }
             });
             options?.signal?.addEventListener("abort", onAbort);

package/dist/worker/console/chat/repo-walk.js

@@ -77,6 +77,7 @@ function isBinaryExt(p) {
 export async function walkRepoFiles(repoRoot, options) {
     const skipSensitive = options?.skipSensitive ?? true;
     const maxFiles = options?.maxFiles ?? 5000;
+    const includeDirs = options?.includeDirs ?? false;
     const filter = options?.glob ? globToRe(options.glob) : undefined;
     const out = [];
     async function walk(dir, prefix) {
@@ -96,7 +97,15 @@ export async function walkRepoFiles(repoRoot, options) {
             if (entry.isDirectory()) {
                 if (SKIP_DIRS.has(name))
                     continue;
-                await walk(path.join(dir, name), `${prefix}${name}/`);
+                const dirRelative = `${prefix}${name}/`;
+                if (includeDirs) {
+                    const dirEntry = {
+                        abs: path.join(dir, name),
+                        repoRelative: dirRelative,
+                    };
+                    out.push(dirEntry);
+                }
+                await walk(path.join(dir, name), dirRelative);
                 continue;
             }
             if (!entry.isFile())

package/dist/worker/console/chat/routes.js

@@ -51,7 +51,7 @@ function turnSummary(turn) {
 function isTerminalTurnState(state) {
     return state === "settled" || state === "aborted" || state === "failed";
 }
-const DEFAULT_ABORT_WAIT_MS = 8_000;
+const DEFAULT_ABORT_WAIT_MS = 2_500;
 /** Parse Chat's `<epoch>:<seq>` SSE cursor. Legacy `<sessionId>:<seq>` has
  * the same wire shape; its prefix intentionally fails the current process
  * epoch comparison and triggers safe snapshot recovery (M5.1). */
@@ -1642,16 +1642,27 @@ async function handleChatFiles(res, deps, sessionId, query) {
     if (!(await requireChatSession(res, deps, sessionId)))
         return;
     const q = query.trim().toLowerCase();
-    const files = (await walkRepoFiles(deps.appData.repoRoot, {
+    const walked = await walkRepoFiles(deps.appData.repoRoot, {
         skipSensitive: true,
         maxFiles: 5000,
-    }))
-        .map((entry) => entry.repoRelative)
-        .filter((file) => !isSensitivePath(file) && (!q || file.toLowerCase().includes(q)))
-        .sort((a, b) => a.localeCompare(b))
+        includeDirs: true,
+    });
+    const entries = walked
+        .filter((entry) => !isSensitivePath(entry.repoRelative) &&
+        (!q || entry.repoRelative.toLowerCase().includes(q)))
+        .sort((a, b) => {
+        const aDir = a.repoRelative.endsWith("/");
+        const bDir = b.repoRelative.endsWith("/");
+        if (aDir !== bDir)
+            return aDir ? -1 : 1;
+        return a.repoRelative.localeCompare(b.repoRelative);
+    })
         .slice(0, 50)
-        .map((path) => ({ path }));
-    sendJson(res, 200, { ok: true, files });
+        .map((entry) => ({
+        path: entry.repoRelative,
+        isDir: entry.repoRelative.endsWith("/"),
+    }));
+    sendJson(res, 200, { ok: true, files: entries });
 }
 export async function handleChatCommands(res, deps, sessionId) {
     try {

package/dist/worker/console/chat/turn-process.js

@@ -216,9 +216,6 @@ export function buildTurnProcessGroups(input) {
             current = startGroup(`assistant-${message.id}`);
         current.assistants.push(message);
     }
-    if (groups.length === 0 && input.toolCalls.length > 0) {
-        groups.push(emptyGroup("orphan-tools"));
-    }
     const assigned = new Set();
     const assistantToGroup = new Map();
     for (const group of groups) {
@@ -265,17 +262,12 @@ export function buildTurnProcessGroups(input) {
             const end = next?.user?.createdAt ?? Number.POSITIVE_INFINITY;
             return tool.createdAt >= start && tool.createdAt < end;
         });
+        // Time window only. Never dump unmatched tools onto the latest group:
+        // that is how a previous turn's bash cards jump under a new prompt.
         if (windowGroup) {
             windowGroup.tools.push(tool);
             assigned.add(tool.id);
         }
-        else {
-            const lastGroup = groups.at(-1);
-            if (lastGroup) {
-                lastGroup.tools.push(tool);
-                assigned.add(tool.id);
-            }
-        }
     }
     for (const group of groups) {
         group.tools.sort((a, b) => {
@@ -292,6 +284,14 @@ export function buildTurnProcessGroups(input) {
     }
     return groups;
 }
+/** Keep the most recent complete turns. Slice groups, never raw messages. */
+export function selectRecentTurnGroups(groups, limit) {
+    if (limit <= 0)
+        return [];
+    if (groups.length <= limit)
+        return [...groups];
+    return groups.slice(-limit);
+}
 export function processGroupSummary(tools, options) {
     const count = tools.length;
     const thinkingCount = options?.thinkingCount ?? 0;