@tea-agent/loop-agent 0.38.0 → 0.38.2

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

@@ -45,24 +45,26 @@ import { RUNTIME_CONTEXT_TEXT_MAX, redactRuntimeText, } from "./runtime-context.
  * Project governance (operator-only policy, allowedPaths/forbiddenPaths,
  * writer writeSet, taskKind routing, verification matrix, DAG recovery
  * commands, closeout) lives in the loaded target-project AGENTS.md. The
- * prompt below covers: Operator identity, the real tool surface (operator_*
- * first + Pi tools, obey AGENTS.md), denied non-Pi runtimes, safe-* probes,
- * init/init-upgrade fallback for uninitialized repos, DAG supervision with
- * 15/30/60s adaptive polling (operationGet/status/dagReport/dagDoctor), R2
- * recovery (fresh eligible dagRerunPlan → dagRerun; ineligible → same-task
- * rerun/advance, resume, Worker retry) and G2 bounded writeSet auto-approval.
+ * prompt below covers: Operator identity, the real tool surface (typed
+ * operator tools first + Pi tools, obey AGENTS.md), denied non-Pi runtimes,
+ * safe-* probes, init/init-upgrade fallback for uninitialized repos, DAG
+ * supervision with 60/90/120/180s adaptive polling
+ * (operationGet/status/dagReport/dagDoctor/operationWait), R2 recovery
+ * (dagReport → dagRerunPlan → dagRerun; ineligible → standaloneTaskRerun or
+ * workerTaskRetry, never dagResume) and G2 bounded writeSet auto-approval.
  *
  * The old Human Gate tutorial paragraphs (prepare + browser Human Gate,
  * "confirmDagConfirmation is a human-only action", the long "Recovery default
  * order" table) are REMOVED — bounded DAGs start and recover autonomously
- * (AC-01: ≤ 1900 chars and ≤ 80% of the 2498-char baseline).
+ * (AC-01: ≤ 2500 chars; 2498-slimming ratio retired 2026-08-18).
  */
 export const OPERATOR_CHAT_SYSTEM_PROMPT_BASE = [
     "You are General Operator Chat.",
-    "Use operator_* tools first. Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for sensitive probes.",
+    "Use operator tools first (dagReport, dagRerunPlan, dagRerun). Pi read/write/edit/bash/grep/find/ls are available; obey repository AGENTS.md. apply_patch, full-tools, shell and coding-chat are denied. Prefer safe-read/safe-grep for probes.",
     "No harness and asked to init: `loop-agent init instructions --repo-root .`, then `loop-agent init --repo-root . --profile full --merge`; verify with doctor, inspect and docs audit. Updates: `loop-agent init upgrade --repo-root . --json` until stable; `loop-agent init check-update` is read-only.",
     "Long DAGs: prepareDagExecution → runDag → operationId. Never foreground-Bash task advance, tail/head pipes or nohup/Start-Process/start; do not end on accepted/queued/running or an operationId — NOT completion. Supervise operationGet/status/dagReport/dagDoctor/operationWait with 60s → 90s → 120s → 180s backoff; reset to 60s on state change; 30-60s re-checks when stall suspected. Every operationWait continuation MUST use afterSeq=previous nextSeq (prefer recommendedNextCall); never reuse an older cursor. Heartbeats are not meaningful progress.",
-    "On failure consume terminal runSummary first. If progress exists, wait; else use a fresh dagRerunPlan; when ineligible use same-task rerun/advance, resume, or Worker retry. A run-failed task without an open gate is terminal: do not re-advance a run-failed task. Before run start, two identical lifecycleState/blocker/revision/DAG-hash observations mean no progress: stop and report after one bounded probe; never loop identical bash/read/grep. Auto-approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "On failure consume terminal runSummary first. If progress exists, wait; else dagReport then dagRerunPlan(fromNode=primaryFailure.nodeId); eligible → dagRerun (node rerun only: reruns the failed subgraph, keeps prior successes). If plan ineligible (unsafe-shell subgraph, binding/workspace drift): Worker Failed → workerTaskRetry; standalone → standaloneTaskRerun after contract adopt (regenerates the whole task, not node continue). Do not call dagResume. A run-failed task without an open gate is terminal: do not re-advance a run-failed task. Before run start, two identical lifecycleState/blocker/revision/DAG-hash observations mean no progress: stop and report after one bounded probe; never loop identical bash/read/grep. Auto-approve only bounded writeSet inside allowedPaths, outside forbiddenPaths, with structured verification.",
+    "Iterate toward the goal in bounded rounds: first summarize the previous round's error in one line (wrong fix, wrong node, or environment), fix its root cause — not the symptom — then rerun the failed node with a fresh plan. Never resubmit an unchanged fix; after two rounds failing the same way, stop and report evidence and remaining routes.",
     "Continue until success, user stop, or no safe recovery remains; then stop and report failure/evidence. Never create a new task for a transient failure or replace repair-pi with direct edits.",
 ].join("\n");
 /** Compose the inspectable system prompt actually injected into Operator Chat. */
@@ -151,6 +153,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).
@@ -169,19 +228,24 @@ async function buildCustomOperatorTools(options) {
         // TypeBox schema is built dynamically; cast through unknown to the builder
         // since Static<TParams> is structural and cannot be statically inferred here.
         const parameters = Type.Object(schema.inputParams.reduce((acc, param) => {
+            // Carry the registry's param description into the tool schema so
+            // the model sees parameter semantics, not just names/types.
+            const desc = param.description?.trim()
+                ? { description: param.description }
+                : {};
             let t;
             switch (param.type) {
                 case "string":
-                    t = Type.String();
+                    t = Type.String(desc);
                     break;
                 case "boolean":
-                    t = Type.Boolean();
+                    t = Type.Boolean(desc);
                     break;
                 case "number":
-                    t = Type.Number();
+                    t = Type.Number(desc);
                     break;
                 case "array":
-                    t = Type.Array(Type.String());
+                    t = Type.Array(Type.String({}), Object.keys(desc).length ? desc : {});
                     break;
                 default:
                     t = Type.Object({}, { additionalProperties: true });
@@ -193,7 +257,7 @@ async function buildCustomOperatorTools(options) {
             name: schema.toolId,
             label: schema.toolId,
             description: `${schema.description} (kind=${schema.kind}; cli: ${schema.cli})`,
-            promptSnippet: `${schema.toolId}: ${schema.description}`,
+            promptSnippet: schema.description,
             parameters: parameters,
             async execute(toolCallId, params) {
                 const decision = authorizeOperatorChatTool(schema.toolId);
@@ -505,6 +569,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 +647,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 +991,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 +1013,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 +1685,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 +1738,7 @@ export class ConsolePiRuntime {
             skills,
             extensions,
             packages,
+            mcp,
             diagnostics,
             hasBash: true,
         });
@@ -1833,29 +1921,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 +2024,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 +2062,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())