@tea-agent/loop-agent 0.39.0-next.11 → 0.39.0-next.13

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+### 改进
+
+- Operator Chat 恢复工具对齐真实能力：系统提示改用 `dagReport` / `dagRerunPlan` / `dagRerun` / `standaloneTaskRerun` / `workerTaskRetry` 真名，不再写 `operator_*` 或把 `dagResume` 当成模型可执行项；`dagDoctor` / `dagStatus` / `workerPoolDoctor` 改为 typed `runId`/`taskId`，不再让模型猜 CLI `args[]`。ADR 0013 自定义 base prompt 上限由 1900 统一调整为 2500（2026-08-18，废止 0.8×2498 比例），预算用于写清节点续跑 / 整单重生 / Worker 重排队分流，以及多轮迭代恢复纪律（先一句话总结上一轮错误、修根因不修症状、禁止原样重交、同错两轮后停下报告）。
+
+- 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 调用）

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.37.0",
-  "gitSha": "7bf68166795e6687e3e804901a8a6ceda3a46825",
-  "builtAt": "2026-08-18T13:08:32.390Z"
+  "gitSha": "ef39870bd2294f451bb85ef7a6ee599ebcd887a4",
+  "builtAt": "2026-08-18T16:37:19.124Z"
 }

package/dist/shared/operator/capabilities.js

@@ -63,8 +63,6 @@ const officialAction = (action, cli, kind, coverage) => ({
 });
 const OFFICIAL_ACTIONS = [
     ...[
-        ["dagDoctor", "loop-agent dag doctor", "read", "model-callable"],
-        ["dagStatus", "loop-agent dag status", "read", "model-callable"],
         [
             "dagDecisionInspect",
             "loop-agent dag decision inspect",
@@ -284,7 +282,6 @@ const OFFICIAL_ACTIONS = [
             "long-running",
             "advanced",
         ],
-        ["workerPoolDoctor", "agent-worker pool doctor", "read", "model-callable"],
         [
             "workerPoolMarkFailed",
             "agent-worker pool mark-failed",
@@ -1079,7 +1076,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "CONTROLLER_MISMATCH",
                 "INVALID_INPUT",
             ],
-            description: "Consume a single-use execution receipt and execute the reviewed DAG (prefer task advance --approve-gate when gate token present). accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor/operationWait.",
+            description: "Consume a single-use executionId from prepareDagExecution and execute the reviewed DAG. Do not pass a DAG path and do not bash `task advance --approve-gate`. accepted/queued/running/operationId are NOT completion — supervise via operationGet/status/dagReport/dagDoctor/operationWait.",
             inputParams: [
                 {
                     name: "executionId",
@@ -1102,7 +1099,7 @@ export function buildOperatorCapabilitiesDocument() {
             resultSchemaVersion: 1,
             envelopeSchemaVersion: 1,
             requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
-            description: "Read-only R1 subgraph plan (no mutation). Call before dagRerun. Prefer primaryFailure.nodeId from dagReport. If eligible=false (writer/decision/fingerprint, unsafe shell, worker-managed, workspace/controller drift), do not force execute — Worker-owned runs use workerTaskRetry; standalone runs use standaloneTaskRerun or same-task advance after fixing the root cause (contract changes must be adopted first). Returns planHash required by execute.",
+            description: "Read-only check: can this failed run continue from fromNode? Call after dagReport; pass primaryFailure.nodeId. Does not execute. eligible=true returns planHash for dagRerun. eligible=false: Worker/Task Pool Failed → workerTaskRetry; standalone Console run → standaloneTaskRerun after any required contract adopt. Do not call dagRerun or invent a new task.",
             inputParams: [
                 {
                     name: "runId",
@@ -1132,7 +1129,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "BINDING_DRIFT",
                 "INVALID_INPUT",
             ],
-            description: "Execute R1 continuation from effective node. Requires planHash from a fresh dagRerunPlan (eligible=true). Prefer this over new task / standaloneTaskRerun for provider flake and safe downstream failures. Server enforces planHash/binding/fingerprint freshness.",
+            description: "Continue the same DAG from fromNode. Requires a fresh dagRerunPlan with eligible=true and that exact planHash. Prefer this for provider flake / safe downstream failures. Not a full task regenerate (that is standaloneTaskRerun). Server rejects stale planHash or binding drift.",
             inputParams: [
                 {
                     name: "runId",
@@ -1498,7 +1495,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Full standalone task regenerate → validate → execute with parent lineage. Only when node rerun plan is ineligible or primaryRecovery recommends rerun-task; the server checks read-only run facts before accepting. Regeneration reuses the CURRENT contract snapshot: if the failure requires contract changes (e.g. allowing a catalog index path), first update the contract (re-import PRD, or adopt externally-edited sources via `task contract adopt`) BEFORE calling this action, otherwise the regenerated DAG repeats the same failure.",
+            description: "Regenerate the whole standalone DAG from the CURRENT contract, then validate and execute a new run (parent lineage kept). This is NOT continue-from-failed-node — that is dagRerun. Server rejects the call when dagRerunPlan is eligible, when primaryRecovery.humanRequired=true, or when run facts do not recommend rerun-task. Adopt contract changes before calling or the new DAG repeats the same failure.",
             inputParams: [
                 {
                     name: "runId",
@@ -1542,7 +1539,7 @@ export function buildOperatorCapabilitiesDocument() {
                 "INVALID_INPUT",
                 "HUMAN_CONFIRMATION_REQUIRED",
             ],
-            description: "Requeue failed Task Pool task (Failed → Ready) via in-package pool store. Only when read-only validation confirms the task exists in Failed state; the server checks this before accepting.",
+            description: "Requeue a Worker Task Pool task Failed → Ready. Not a DAG node rerun (use dagRerun) and not a standalone DAG regenerate (use standaloneTaskRerun). Confirm with workerPoolDoctor first; server accepts only Failed pool tasks. Pass featureId when known — it must match the pool record.",
             inputParams: [
                 {
                     name: "taskId",
@@ -1568,6 +1565,66 @@ export function buildOperatorCapabilitiesDocument() {
             modelCallable: "always",
             humanConfirmation: "none",
         },
+        {
+            action: "dagDoctor",
+            cli: "loop-agent dag doctor [--run-id <id>] --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Diagnose DAG run health. Omit runId for a repo-wide inventory (active/paused/completed + health issues). Pass runId for one run's liveness, heartbeat, failure node, and recovery hints. Use this to supervise stalls; it does not mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: false,
+                    description: "optional dag run id; omit to inventory all runs, pass to diagnose one run",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "dagStatus",
+            cli: "loop-agent dag status --run-id <id>",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["NOT_FOUND", "INVALID_INPUT"],
+            description: "Read one DAG run's live status, current node, and liveness. Requires runId. Complements dagReport (terminal handoff) and dagDoctor (health diagnosis). Does not mutate the run.",
+            inputParams: [
+                {
+                    name: "runId",
+                    type: "string",
+                    required: true,
+                    description: "dag run id",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
+        {
+            action: "workerPoolDoctor",
+            cli: "agent-worker pool doctor --repo . --json",
+            kind: "read",
+            inputSchemaVersion: 1,
+            resultSchemaVersion: 1,
+            envelopeSchemaVersion: 1,
+            requiredErrorCodes: ["INVALID_INPUT", "NOT_FOUND"],
+            description: "Read-only Task Pool inventory (legacy + v2). Use before workerTaskRetry to confirm the task exists and status is Failed. Optional taskId filters the returned inventory to that task.",
+            inputParams: [
+                {
+                    name: "taskId",
+                    type: "string",
+                    required: false,
+                    description: "optional task id to focus the inventory",
+                },
+            ],
+            modelCallable: "always",
+            humanConfirmation: "none",
+        },
         ...OFFICIAL_ACTIONS,
     ];
     return {

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);
+}