atom-lite 0.1.0 → 0.5.1

package/CHANGELOG.md

@@ -5,6 +5,63 @@ All notable changes to this project are documented here.
 The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+## [0.5.0] - 2026-11-05
+
+### Added
+
+- Unmodified Pi coding-agent extension support: discovery, project trust,
+  in-process loading via `jiti`, extension tools, commands, events, and
+  session entries, plus ADR-0011 and the extensions guide.
+- `/extensions doctor` diagnostics, `/steer` mid-turn injection, and
+  message queuing during active turns.
+- Continuous dimmed thinking blocks in the TUI.
+
+## [0.4.1] - 2026-11-04
+
+### Fixed
+
+- npm publish retry after staged 0.4.0 conflict.
+
+## [0.4.0] - 2026-11-04
+
+### Added
+
+- Extension discovery and manifest parsing (`src/extensions/discovery.ts`).
+- Project trust gating and extension loader lifecycle with `/extensions`.
+- `/export` for sessions.
+- Markdown rendering for assistant responses and unified diff summaries in tool boxes.
+- Literal edit replacement handling.
+- Escape to cancel an active turn.
+- TUI mouse capture fixes.
+
+### Fixed
+
+- Mouse capture sequence and startup ordering for TUI mouse support.
+
+[0.4.0]: https://github.com/beast-ofcourse/atom-lite/releases/tag/v0.4.0
+
+## [0.3.1] - 2026-11-04
+
+### Added
+
+- MCP client over stdio: user-config-only `mcpServers`, lazy connections, tool
+  discovery and execution as `mcp__<server>__<tool>`, refresh on
+  `tools/list_changed`, `/mcp` and `/mcp reconnect`, and `/doctor` health.
+- Session picker and search (`/sessions`, `/search`), resume in place, and
+  `/session rename`.
+- Command palette (`ctrl+p`), semantic theme registry, and TUI mouse support.
+- Configuration reference and documentation index.
+
+### Fixed
+
+- Ollama provider profiles now forward the `think` option to the adapter.
+
+[0.3.1]: https://github.com/beast-ofcourse/atom-lite/releases/tag/v0.3.1
+
 ## [0.1.0] - 2026-11-04
 
 ### Added

package/README.md

@@ -6,9 +6,9 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-strict-3178C6?logo=typescript&logoColor=white)](https://www.typescriptlang.org)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 
-**Atom-lite** is a local-first, model-agnostic coding agent with an intentionally small harness: one agent loop, exactly four built-in tools (`read`, `write`, `edit`, `bash`), a deterministic conflict-aware scheduler, durable JSONL sessions, and explicit safety boundaries. It runs against local or hosted model providers through interchangeable adapters — no cloud account, telemetry service, or hosted control plane required.
+**Atom-lite** is a local-first, model-agnostic coding agent with an intentionally small harness: one agent loop, four core built-in tools (`read`, `write`, `edit`, `bash`) plus network tools (`webfetch`, `websearch`), a deterministic conflict-aware scheduler, durable JSONL sessions, and explicit safety boundaries. It runs against local or hosted model providers through interchangeable adapters — no cloud account, telemetry service, or hosted control plane required.
 
-> Working title: *ThinAgent*. See [`project-overview.md`](./project-overview.md) for the full architecture blueprint, [`GLOSSARY.md`](./GLOSSARY.md) for domain vocabulary, and [`docs/adr/`](./docs/adr/) for architectural decisions.
+> See [`docs/README.md`](./docs/README.md) for the documentation index and [`docs/adr/`](./docs/adr/) for architectural decisions.
 
 ---
 
@@ -35,13 +35,13 @@
 
 Most coding agents accumulate tools, sub-agents, planning frameworks, retrieval pipelines, and orchestration layers until the harness itself becomes the product. Atom-lite takes the opposite stance:
 
-- **Small core, strong primitives.** The core contains only a provider interface, a session model, a single agent loop, four tools, a scheduler/executor, context-window management, configuration, and a CLI.
+- **Small core, strong primitives.** The core contains only a provider interface, a session model, a single agent loop, four core tools plus two network tools, a scheduler/executor, context-window management, configuration, and a CLI.
 - **The model decides; the runtime enforces.** The model chooses which tool to call and what to do next. The runtime validates arguments, enforces workspace boundaries, applies approval rules, schedules calls safely, and returns accurate results. There is no hard-coded "plan → inspect → edit → test" workflow.
 - **Thin harness, not weak engineering.** Provider-specific formats, streaming failures, concurrent file access, shell timeouts, large outputs, context exhaustion, and session recovery are all handled — they are the reliability layer that makes a small harness useful.
 
 ## Features
 
-- **Four general-purpose tools** — `read`, `write`, `edit`, `bash`. Everything else (search, tests, git, builds) goes through `bash`.
+- **Six built-in tools** — four core tools (`read`, `write`, `edit`, `bash`) plus `webfetch` and `websearch`. Everything else (search, tests, git, builds) goes through `bash`.
 - **Single agent loop** — one agent, one conversation, one tool registry, one control loop. Parallelism lives inside a tool-call batch.
 - **Conflict-aware scheduler** — per-file read/write locks and a global bash barrier. Parallelism is governed by resource conflicts, not applied blindly.
 - **Durable sessions** — append-only JSONL event logs, resumable across CLI restarts, grouped by workspace.
@@ -51,6 +51,7 @@ Most coding agents accumulate tools, sub-agents, planning frameworks, retrieval
 - **Hash guards** — `expected_hash` rejects stale `write`/`edit` operations when the file changed since it was read.
 - **Provider-agnostic** — Ollama, Gemini, and any OpenAI-compatible endpoint (LM Studio, llama.cpp, Kilo AI Gateway, OpenAI, Anthropic, OpenRouter, Groq, Mistral, xAI, …).
 - **Interactive provider/model pickers** — `/provider` adds a provider and stores its key securely; `/model` fuzzy-searches every configured provider's models.
+- **Command palette and themes** — `ctrl+p` fuzzy-searches commands, skills, providers, models, themes, and recent sessions. `/theme` switches between auto, dark, light, and no-colour modes.
 - **Local-first** — runs fully against local providers with no cloud account, telemetry, or hosted database.
 - **Safe path handling** — file tools resolve against the workspace and reject escapes; shell is an explicit, sandbox-aware boundary.
 
@@ -141,13 +142,14 @@ Example `config.json`:
 }
 ```
 
-See [`project-overview.md`](./project-overview.md) for the full configuration shape.
+See [`docs/configuration.md`](./docs/configuration.md) for every field, default, and precedence rule.
 
 ## Usage
 
 ```
 atom-lite [task] [--provider NAME] [--model MODEL] [--continue] [--session ID]
-          [--no-tools] [--json] [--debug] [--version] [--help]
+          [--list-sessions] [--search-sessions QUERY] [--no-tools] [--json]
+          [--debug] [--theme NAME] [--no-color] [--version] [--help]
 ```
 
 | Flag | Description |
@@ -157,12 +159,24 @@ atom-lite [task] [--provider NAME] [--model MODEL] [--continue] [--session ID]
 | `--model MODEL` | Override the model for this run |
 | `--continue` | Resume the most recent session in this workspace |
 | `--session ID` | Resume a specific session |
+| `--list-sessions` | Print the session index and exit |
+| `--search-sessions QUERY` | Print matching sessions with snippets and exit |
 | `--no-tools` | Disable all tools (model-only chat) |
 | `--json` | Non-interactive JSON output |
 | `--debug` | Debug logging |
+| `--theme NAME` | Use `auto`, `dark`, `light`, or `ansi` for this run |
+| `--no-color` | Force the no-colour theme |
 | `--version` | Print version |
 | `--help` | Show help |
 
+In the TUI, type `/help` to see every command grouped by category, or press
+`ctrl+p` for the fuzzy command palette. `/theme` opens a live-preview picker and
+persists your choice to user config; `NO_COLOR` and `--no-color` always win.
+`/sessions` opens a searchable session picker scoped to the current workspace,
+with a toggle for all workspaces, and `/search <query>` prints matching sessions
+with content snippets. Mouse wheel scrolling and click-to-focus are enabled for
+interactive terminals and can be disabled with `ui.mouse: false`.
+
 ## Tools
 
 Four core tools (see [ADR 0001](./docs/adr/0001-four-built-in-tools-only.md)) plus the additive network tools from [ADR 0006](./docs/adr/0006-expanded-toolset.md):
@@ -205,10 +219,37 @@ The selected provider/model is persisted to the user config, so the next session
 - **No secrets in config** — interactive provider setup stores API keys in `~/.config/atom-lite/credentials.json` with `0600` permissions; environment variables still take precedence.
 - **Local-first** — no cloud account, telemetry, or remote control plane required (see [ADR 0004](./docs/adr/0004-local-first-no-cloud-dependency.md)).
 
+## Commands
+
+Type `/help` for the grouped list, or press `ctrl+p` for the fuzzy command
+palette. Common commands:
+
+| Command | Description |
+| --- | --- |
+| `/model [model]` | Show or switch the active model |
+| `/provider [profile]` | Show or switch the active provider |
+| `/effort [low\|medium\|high]` | Set reasoning effort |
+| `/session [rename <title>]` | Show or rename the current session |
+| `/sessions [all]` | Search and resume a session |
+| `/search <query>` | Search sessions by title or content |
+| `/export [path]` | Export the session transcript |
+| `/mcp [reconnect [server]]` | Inspect or reconnect MCP servers |
+| `/extensions` | List discovered extensions and load status |
+| `/compact` | Compact older context |
+| `/clear` | Clear the transcript view |
+| `/approval` | Change approval mode |
+| `/doctor` | Run diagnostics |
+| `/thinking` | Toggle thinking display |
+| `/theme [auto\|dark\|light\|ansi]` | Switch theme |
+| `/skills`, `/skill <name>` | List or load a skill |
+| `/exit` | Exit the TUI |
+
 ## Sessions
 
 Sessions are append-only JSONL event logs recording everything that happened in one conversation. They are resumable across CLI restarts and grouped by workspace. Stored under the session store (see `src/sessions/`). Compaction summarizes older history to stay within the context budget while retaining the full transcript.
 
+The session index derives a title from the first user message unless `/session rename <title>` overrides it, and records the provider, update time, and message count. `/sessions` resumes a session in place: retained messages are replayed into the transcript and a `session_resumed` event is appended. `/search <query>` matches titles, message content, and workspace paths, ranking title hits first. `--list-sessions` and `--search-sessions` print the same index as stable tab-separated rows for scripts.
+
 ## Context management
 
 The context manager builds model input, estimates tokens, and triggers compaction before the context budget is exceeded. It also loads project instructions (e.g. `AGENTS.md`/`CLAUDE.md`-style files) subject to `maxProjectInstructionBytes`.
@@ -232,7 +273,10 @@ Tests live in `tests/` (agent, config, runtime, tools). The project is TypeScrip
 1. Update `version` in `package.json` and add a `CHANGELOG.md` entry.
 2. Run `npm run typecheck && npm test && npm run bench`.
 3. Commit, then tag and push: `git tag vX.Y.Z && git push origin master --tags`.
-4. The `Release` GitHub workflow publishes to npm with provenance and creates the GitHub release. It requires an `NPM_TOKEN` repository secret with publish access.
+4. The `Release` workflow stages the package on npm with provenance and opens a draft GitHub release. It requires an `NPM_TOKEN` repository secret with publish access.
+5. Approve the staged version on npm (Staged Packages tab, or `npm stage approve <stage-id>` with 2FA), then publish the draft release on GitHub.
+
+npm requires a maintainer with 2FA to approve staged releases; CI cannot complete that step.
 
 ## Architecture
 
@@ -246,7 +290,7 @@ src/
   runtime/      # scheduler, approvals
   security/     # paths, process, redaction
   sessions/     # store, events, recovery
-  tools/        # read, write, edit, bash, registry
+  tools/        # read, write, edit, bash, webfetch, websearch, registry
 ```
 
 Key design decisions are recorded as ADRs in [`docs/adr/`](./docs/adr/):
@@ -255,11 +299,15 @@ Key design decisions are recorded as ADRs in [`docs/adr/`](./docs/adr/):
 - [0002 — Single agent loop, no sub-agents in v1](./docs/adr/0002-single-agent-loop.md)
 - [0003 — `bash` is a global exclusive barrier](./docs/adr/0003-bash-as-global-exclusive-barrier.md)
 - [0004 — Local-first, no cloud dependency](./docs/adr/0004-local-first-no-cloud-dependency.md)
-- [0005 — OpenTUI for the terminal UI](./docs/adr/0005-opentui-for-terminal-ui.md)
+- [0005 — OpenTUI for the terminal UI](./docs/adr/0005-opentui-for-terminal-ui.md) (superseded by 0007)
+- [0006 — Expanded built-in toolset (webfetch, websearch)](./docs/adr/0006-expanded-toolset.md)
+- [0007 — pi-tui replaces OpenTUI](./docs/adr/0007-pi-tui-replaces-opentui.md)
 
 ## Contributing
 
-Issues and specs live as markdown under `.scratch/` (see [`docs/agents/issue-tracker.md`](./docs/agents/issue-tracker.md)). Domain vocabulary is in [`GLOSSARY.md`](./GLOSSARY.md). Please keep changes consistent with the "small core" principle: new tools require strong justification against ADR 0001.
+Read [`CONTRIBUTING.md`](./CONTRIBUTING.md) before opening a pull request. Issues and specs live as markdown under `.scratch/` (see [`docs/agents/issue-tracker.md`](./docs/agents/issue-tracker.md)). Please keep changes consistent with the "small core" principle: new tools require strong justification against ADR 0001.
+
+Report vulnerabilities privately as described in [`SECURITY.md`](./SECURITY.md).
 
 ## License
 

package/dist/agent/loop.d.ts

@@ -12,6 +12,8 @@ export declare class AgentRuntime {
     private bashConcurrency;
     private toolMap;
     private limits;
+    private extensionDispatch;
+    private steeringQueue;
     private systemPrompt;
     private contextWindow;
     private contextUsed;
@@ -22,9 +24,18 @@ export declare class AgentRuntime {
     getContextUsage(): ContextUsage;
     private emitContextUsage;
     setEffort(effort: string): void;
+    setSteeringQueue(queue: string[]): void;
+    compactSession(session: {
+        messages: Message[];
+        appendMessage(m: Message): void;
+        appendEvent?(partial: any): any;
+    }, focus?: string): Promise<string | null>;
+    /** Replace the toolset, e.g. after MCP discovery or a list_changed refresh. */
+    setTools(tools: AgentRuntimeOptions["tools"]): void;
     getEffort(): string;
     runAgentTurn(input: string, session: {
         messages: Message[];
         appendMessage(m: Message): void;
+        appendEvent?(partial: any): any;
     }, signal: AbortSignal): Promise<string>;
 }

package/dist/agent/loop.js

@@ -1,6 +1,8 @@
 import { DEFAULT_LIMITS } from "../types.js";
 import { executeToolBatch } from "../runtime/scheduler.js";
 import { ContextManager } from "../context/manager.js";
+import { runModelTurn } from "./model-turn.js";
+import { TurnRecorder } from "./turn-recorder.js";
 export class AgentRuntime {
     provider;
     model;
@@ -13,6 +15,8 @@ export class AgentRuntime {
     bashConcurrency;
     toolMap;
     limits;
+    extensionDispatch;
+    steeringQueue;
     systemPrompt;
     contextWindow;
     contextUsed;
@@ -38,6 +42,8 @@ export class AgentRuntime {
                 });
         this.toolMap = new Map(options.tools.map((t) => [t.definition.name, t]));
         this.limits = { ...DEFAULT_LIMITS, ...(options.limits ?? {}) };
+        this.extensionDispatch = options.extensionDispatch;
+        this.steeringQueue = options.steeringQueue;
         this.systemPrompt = options.systemPrompt ?? "You are a coding assistant with tools: read, write, edit, bash, webfetch, websearch.";
         this.contextWindow = options.contextWindow;
         this.contextManager.setModelContextWindow(options.contextWindow);
@@ -76,14 +82,55 @@ export class AgentRuntime {
     setEffort(effort) {
         this.effort = effort;
     }
+    setSteeringQueue(queue) {
+        this.steeringQueue = queue;
+    }
+    async compactSession(session, focus) {
+        const summary = await this.contextManager.compactHistory(this.workspace, session.messages, focus);
+        if (summary) {
+            this.contextManager.setSessionMemory(summary, this.contextManager.getLastCompactionCoveredCount());
+            if (typeof session.appendEvent === "function") {
+                session.appendEvent({
+                    type: "context_compacted",
+                    summary,
+                    coveredCount: this.contextManager.getLastCompactionCoveredCount(),
+                });
+            }
+        }
+        return summary;
+    }
+    /** Replace the toolset, e.g. after MCP discovery or a list_changed refresh. */
+    setTools(tools) {
+        this.tools = tools;
+        this.toolMap = new Map(tools.map((t) => [t.definition.name, t]));
+    }
     getEffort() {
         return this.effort;
     }
     async runAgentTurn(input, session, signal) {
+        // Restore any persisted session memory for resumed sessions.
+        const events = session.events;
+        if (Array.isArray(events)) {
+            const latest = [...events].reverse().find((e) => e?.type === "context_compacted");
+            this.contextManager.setSessionMemory(typeof latest?.summary === "string" ? latest.summary : null, typeof latest?.coveredCount === "number" ? latest.coveredCount : undefined);
+        }
         session.appendMessage({ role: "user", content: [{ type: "text", text: input }] });
+        await this.extensionDispatch?.("turn_start", { type: "turn_start" });
         let totalToolCalls = 0;
+        let forceContinue = false;
         const start = Date.now();
         for (let iteration = 0; iteration < this.limits.maxIterations; iteration++) {
+            forceContinue = false;
+            // Drain any steering messages into the session before the next model turn.
+            if (this.steeringQueue && this.steeringQueue.length > 0) {
+                while (this.steeringQueue.length > 0) {
+                    const msg = this.steeringQueue.shift();
+                    session.appendMessage({
+                        role: "user",
+                        content: [{ type: "text", text: msg }],
+                    });
+                }
+            }
             if (signal.aborted) {
                 throw new Error("USER_CANCELLED");
             }
@@ -96,49 +143,58 @@ export class AgentRuntime {
                 // assistant response reports fresh numbers.
                 this.contextUsed = undefined;
                 this.emitContextUsage();
+                const summary = this.contextManager.consumeCompactionSummary();
+                const coveredCount = this.contextManager.consumeCompactionCoveredCount();
+                if (summary && typeof session.appendEvent === "function") {
+                    session.appendEvent({
+                        type: "context_compacted",
+                        summary,
+                        coveredCount,
+                    });
+                }
             }
-            const request = {
+            let response;
+            let streamedText = "";
+            await this.extensionDispatch?.("before_provider_request", {
+                type: "before_provider_request",
+                messages,
+                tools: this.tools.map((t) => t.definition),
+            });
+            for await (const ev of runModelTurn({
+                provider: this.provider,
                 model: this.model,
                 messages,
                 tools: this.tools.map((t) => t.definition),
+                effort: this.effort,
                 signal,
-                options: { effort: this.effort },
-            };
-            let response;
-            let streamedText = "";
-            if (typeof this.provider.stream === "function") {
-                // Stream tokens as they arrive.
-                for await (const ev of this.provider.stream(request)) {
-                    if (ev.type === "thinking") {
-                        this.onEvent?.({ type: "thinking_delta", text: ev.text });
-                    }
-                    else if (ev.type === "text") {
-                        streamedText += ev.text;
-                        this.onEvent?.({ type: "assistant_delta", text: ev.text });
-                    }
-                    else if (ev.type === "done") {
-                        response = ev.response;
-                    }
+            })) {
+                if (ev.type === "thinking_delta") {
+                    this.onEvent?.({ type: "thinking_delta", text: ev.text });
                 }
-                if (!response) {
-                    // Fallback if stream ended without done
-                    response = {
-                        message: { role: "assistant", content: streamedText ? [{ type: "text", text: streamedText }] : undefined, toolCalls: undefined },
-                        toolCalls: [],
-                        finishReason: "stop",
-                    };
+                else if (ev.type === "assistant_delta") {
+                    streamedText += ev.text;
+                    this.onEvent?.({ type: "assistant_delta", text: ev.text });
+                }
+                else if (ev.type === "assistant_text") {
+                    streamedText = ev.text;
+                    this.onEvent?.({ type: "assistant_text", text: ev.text });
+                }
+                else if (ev.type === "final") {
+                    response = ev.response;
+                    streamedText = ev.streamedText;
                 }
             }
-            else {
-                response = await this.provider.generate(request);
-                const t = response.message.content?.map((p) => (p.type === "text" ? p.text : "")).join("") ?? "";
-                if (t)
-                    this.onEvent?.({ type: "assistant_text", text: t });
-                streamedText = t;
-            }
-            session.appendMessage(response.message);
+            await this.extensionDispatch?.("after_provider_response", {
+                type: "after_provider_response",
+                response,
+            });
+            const recorder = new TurnRecorder({
+                session,
+                onEvent: this.onEvent,
+                extensionDispatch: this.extensionDispatch,
+            });
+            const text = await recorder.recordAssistant(response, streamedText);
             if (response.usage) {
-                this.onEvent?.({ type: "usage", input: response.usage.input, output: response.usage.output });
                 const used = (response.usage.input ?? 0) + (response.usage.output ?? 0);
                 if (used > 0) {
                     // The latest assistant step's prompt + generated tokens is the
@@ -147,14 +203,61 @@ export class AgentRuntime {
                     this.emitContextUsage();
                 }
             }
-            const text = streamedText || (response.message.content?.map((p) => (p.type === "text" ? p.text : "")).join("") ?? "");
             const toolCalls = response.toolCalls ?? [];
             if (toolCalls.length === 0) {
-                this.onEvent?.({ type: "final", text });
+                // turn_end / agent_before_settle continuation handling.
+                let continued = false;
+                const turnResults = await this.extensionDispatch?.("turn_end", {
+                    type: "turn_end",
+                });
+                for (const r of turnResults ?? []) {
+                    if (r && r.continue)
+                        continued = true;
+                }
+                if (continued) {
+                    forceContinue = true;
+                    continue;
+                }
+                const settleResults = await this.extensionDispatch?.("agent_before_settle", { type: "agent_before_settle" });
+                for (const r of settleResults ?? []) {
+                    if (r && r.continue)
+                        continued = true;
+                }
+                if (continued) {
+                    forceContinue = true;
+                    continue;
+                }
+                await this.extensionDispatch?.("agent_settled", {
+                    type: "agent_settled",
+                });
                 return text;
             }
-            for (const c of toolCalls)
-                this.onEvent?.({ type: "tool_call", id: c.id, name: c.name, args: c.arguments });
+            // Emit tool_call events; allow mutation and block decisions.
+            const blocked = new Set();
+            let terminate = false;
+            for (const call of toolCalls) {
+                const payload = {
+                    type: "tool_call",
+                    toolCallId: call.id,
+                    name: call.name,
+                    input: call.arguments,
+                };
+                const results = await this.extensionDispatch?.("tool_call", payload);
+                // Apply in-place mutation.
+                if (payload.input && payload.input !== call.arguments) {
+                    call.arguments = payload.input;
+                }
+                for (const r of results ?? []) {
+                    if (r && typeof r === "object") {
+                        if (r.block)
+                            blocked.add(call.id);
+                        if (r.terminate)
+                            terminate = true;
+                        if (r.input)
+                            call.arguments = r.input;
+                    }
+                }
+            }
             totalToolCalls += toolCalls.length;
             if (totalToolCalls > this.limits.maxToolCalls) {
                 return "TASK_BUDGET_REACHED";
@@ -173,24 +276,112 @@ export class AgentRuntime {
                         stream,
                         text,
                     });
+                    void this.extensionDispatch?.("tool_execution_update", {
+                        type: "tool_execution_update",
+                        toolCallId: call.id,
+                        name: call.name,
+                        stream,
+                        text,
+                    });
                 },
             };
-            const results = await executeToolBatch(toolCalls, this.toolMap, ctx, this.limits.maxParallelToolCalls, signal, undefined, this.bashConcurrency);
-            for (const r of results) {
-                session.appendMessage({
-                    role: "tool",
-                    toolCallId: r.toolCallId,
-                    name: r.name,
-                    content: r.content,
+            // Wrapped tool map emits tool_execution_start/end.
+            const wrappedToolMap = new Map(this.toolMap);
+            for (const [name, tool] of this.toolMap) {
+                wrappedToolMap.set(name, {
+                    ...tool,
+                    execute: async (call, ctx2) => {
+                        await this.extensionDispatch?.("tool_execution_start", {
+                            type: "tool_execution_start",
+                            toolCallId: call.id,
+                            name: call.name,
+                            args: call.arguments,
+                        });
+                        let result;
+                        try {
+                            result = await tool.execute(call, ctx2);
+                        }
+                        catch (err) {
+                            result = {
+                                toolCallId: call.id,
+                                name: call.name,
+                                content: `COMMAND_FAILED: ${err instanceof Error ? err.message : String(err)}`,
+                                isError: true,
+                            };
+                        }
+                        await this.extensionDispatch?.("tool_execution_end", {
+                            type: "tool_execution_end",
+                            toolCallId: call.id,
+                            name: call.name,
+                            result,
+                            isError: result?.isError,
+                        });
+                        return result;
+                    },
+                });
+            }
+            const blockedResults = new Map();
+            for (const call of toolCalls) {
+                if (!blocked.has(call.id))
+                    continue;
+                const reason = "blocked by extension";
+                const r = {
+                    toolCallId: call.id,
+                    name: call.name,
+                    content: reason,
+                    isError: true,
+                };
+                blockedResults.set(call.id, r);
+                await this.extensionDispatch?.("tool_execution_start", {
+                    type: "tool_execution_start",
+                    toolCallId: call.id,
+                    name: call.name,
+                    args: call.arguments,
+                });
+                await this.extensionDispatch?.("tool_execution_end", {
+                    type: "tool_execution_end",
+                    toolCallId: call.id,
+                    name: call.name,
+                    result: r,
+                    isError: true,
                 });
-                this.onEvent?.({
+            }
+            const execCalls = toolCalls.filter((c) => !blocked.has(c.id));
+            const execResults = await executeToolBatch(execCalls, wrappedToolMap, ctx, this.limits.maxParallelToolCalls, signal, undefined, this.bashConcurrency);
+            const resultMap = new Map();
+            for (const r of blockedResults.values())
+                resultMap.set(r.toolCallId, r);
+            for (const r of execResults) {
+                // Emit tool_result event and allow patches.
+                const payload = {
                     type: "tool_result",
                     toolCallId: r.toolCallId,
                     name: r.name,
                     content: r.content,
+                    details: r.details,
+                    structuredContent: r.structuredContent,
                     isError: r.isError,
-                    diff: r.diff,
+                    usage: r.usage,
+                };
+                await this.extensionDispatch?.("tool_result", payload);
+                r.content = payload.content ?? r.content;
+                r.details = payload.details ?? r.details;
+                r.structuredContent = payload.structuredContent ?? r.structuredContent;
+                r.isError = payload.isError ?? r.isError;
+                r.usage = payload.usage ?? r.usage;
+                resultMap.set(r.toolCallId, r);
+            }
+            const orderedResults = toolCalls
+                .map((c) => resultMap.get(c.id))
+                .filter(Boolean);
+            for (const r of orderedResults) {
+                recorder.recordToolResult(r);
+            }
+            if (terminate) {
+                await this.extensionDispatch?.("agent_settled", {
+                    type: "agent_settled",
                 });
+                return text;
             }
         }
         return "TASK_BUDGET_REACHED";