@@ -137,6 +137,18 @@ Click **Agent** in the chat toolbar and pick a folder — that becomes the model
 - A per-turn step limit (25 tool-result → model-continuation round trips) stops a model from looping indefinitely without producing a final answer.
 - The trust list for "always allow" is in-memory only — closing and reopening a chat resets it.
 
+**Preview & Rollback:**
+- A pending `write_file` call shows a real **line-by-line diff** against the file's current content (or a "new file" badge if it doesn't exist yet) instead of a raw argument dump, so you can see exactly what would change before clicking Allow.
+- **Undo last edit** reverts the most recent applied `write_file` — restoring the previous content, or deleting the file if the edit created it. Undo history is per-workspace, capped at the last 20 writes, and lives only in memory for the running session (not a durable version history).
+
+**Quick actions:** if the workspace has `test`/`lint`/`format` scripts in its `package.json`, **Run Tests**, **Lint**, and **Format** buttons appear in the toolbar — they run the corresponding `npm` script directly (reusing the same sandboxing as `run_command`) and drop the output into the chat, without going through the model.
+
+**MCP (Model Context Protocol) servers:** add external MCP servers in Settings to give Agent mode extra tools — anything from a database query tool to a browser-automation server. Two transports are supported:
+- **stdio** — launches a local command (e.g. `npx -y @modelcontextprotocol/server-filesystem /some/path`) and speaks JSON-RPC over its stdin/stdout.
+- **HTTP** — connects to a remote MCP server's "Streamable HTTP" endpoint.
+
+Enabled servers reconnect automatically on launch; each server's tools appear in Agent mode's tool list prefixed with the server's name, going through the exact same Allow/Deny approval flow as built-in tools. (SSE and plain WebSocket transports aren't implemented — SSE is the legacy MCP HTTP transport, now superseded by Streamable HTTP, and WebSocket isn't part of the MCP spec itself.)
+
 **Model choice matters.** Agent mode works with whatever model you point it at, but only actually produces tool calls if that model was trained for function/tool calling — a model without that training will just chat normally and never call a tool. The Settings model browser flags models with reliable tool-calling support with a 🔧 **Tool calling** badge (e.g. the Qwen3 family, Llama 3.1+, Mistral Nemo, Qwen2.5-Coder, Devstral).
 
 ## Building from source
 
@@ -2,7 +2,16 @@ import { describe, it, expect, beforeEach } from "vitest";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { readFile, writeFile, listDir, searchFiles, executeTool, runCommand } from "./agent-tools";
+import {
+    readFile,
+    writeFile,
+    listDir,
+    searchFiles,
+    executeTool,
+    runCommand,
+    rollbackLastWrite,
+    detectProjectScripts,
+} from "./agent-tools";
 
 describe("agent-tools", () => {
     let workspace: string;
@@ -71,6 +80,61 @@ describe("agent-tools", () => {
         });
     });
 
+    describe("rollbackLastWrite", () => {
+        it("returns null when there is nothing to roll back", () => {
+            expect(rollbackLastWrite(workspace)).toBeNull();
+        });
+
+        it("restores the previous content of an overwritten file", () => {
+            writeFile(workspace, "x.txt", "first");
+            writeFile(workspace, "x.txt", "second");
+            const result = rollbackLastWrite(workspace);
+            expect(result).toEqual({ path: "x.txt", restoredContent: true });
+            expect(fs.readFileSync(path.join(workspace, "x.txt"), "utf-8")).toBe("first");
+        });
+
+        it("deletes a file that was newly created by the last write", () => {
+            writeFile(workspace, "new.txt", "content");
+            const result = rollbackLastWrite(workspace);
+            expect(result).toEqual({ path: "new.txt", restoredContent: false });
+            expect(fs.existsSync(path.join(workspace, "new.txt"))).toBe(false);
+        });
+
+        it("only rolls back one write at a time, most recent first", () => {
+            writeFile(workspace, "a.txt", "a1");
+            writeFile(workspace, "b.txt", "b1");
+            rollbackLastWrite(workspace);
+            expect(fs.existsSync(path.join(workspace, "b.txt"))).toBe(false);
+            expect(fs.readFileSync(path.join(workspace, "a.txt"), "utf-8")).toBe("a1");
+        });
+    });
+
+    describe("detectProjectScripts", () => {
+        it("returns an empty object when there is no package.json", () => {
+            expect(detectProjectScripts(workspace)).toEqual({});
+        });
+
+        it("only reports scripts that are actually defined", () => {
+            fs.writeFileSync(
+                path.join(workspace, "package.json"),
+                JSON.stringify({ scripts: { test: "vitest", build: "tsc" } })
+            );
+            expect(detectProjectScripts(workspace)).toEqual({ test: "npm test", lint: undefined, format: undefined });
+        });
+
+        it("reports test, lint, and format scripts together when all are present", () => {
+            fs.writeFileSync(
+                path.join(workspace, "package.json"),
+                JSON.stringify({ scripts: { test: "vitest", lint: "eslint .", format: "prettier --write ." } })
+            );
+            expect(detectProjectScripts(workspace)).toEqual({
+                test: "npm test",
+                lint: "npm run lint",
+                format: "npm run format",
+            });
+        });
+    });
+
     describe("listDir", () => {
         it("lists files and marks directories with a trailing slash", () => {
             fs.writeFileSync(path.join(workspace, "file.txt"), "");
 
@@ -98,13 +98,65 @@ export function readFile(workspaceRoot: string, relativePath: string): string {
         : content;
 }
 
+interface WriteBackup {
+    relativePath: string;
+    // null means the file didn't exist before this write — rollback deletes it.
+    previousContent: string | null;
+}
+
+// Undo history is kept in memory only, per workspace, capped so a long agent
+// session doesn't grow this unboundedly. It's intentionally session-scoped
+// (not written to disk) — Rollback is a quick "oops" safety net for the
+// current run, not a durable version history.
+const MAX_BACKUPS_PER_WORKSPACE = 20;
+const writeBackups = new Map<string, WriteBackup[]>();
+
+function normalizeWorkspaceKey(workspaceRoot: string): string {
+    return path.resolve(workspaceRoot);
+}
+
+function recordBackup(workspaceRoot: string, relativePath: string, previousContent: string | null): void {
+    const key = normalizeWorkspaceKey(workspaceRoot);
+    const stack = writeBackups.get(key) ?? [];
+    stack.push({ relativePath, previousContent });
+    while (stack.length > MAX_BACKUPS_PER_WORKSPACE) stack.shift();
+    writeBackups.set(key, stack);
+}
+
 export function writeFile(workspaceRoot: string, relativePath: string, content: string): { bytesWritten: number } {
     const target = resolveSafePath(workspaceRoot, relativePath);
+    let previousContent: string | null = null;
+    try {
+        previousContent = fs.readFileSync(target, "utf-8");
+    } catch {
+        previousContent = null; // file doesn't exist yet — this write creates it
+    }
     fs.mkdirSync(path.dirname(target), { recursive: true });
     fs.writeFileSync(target, content);
+    recordBackup(workspaceRoot, relativePath, previousContent);
     return { bytesWritten: Buffer.byteLength(content) };
 }
 
+export interface RollbackResult {
+    path: string;
+    restoredContent: boolean; // true = previous content restored, false = newly-created file was deleted
+}
+
+export function rollbackLastWrite(workspaceRoot: string): RollbackResult | null {
+    const key = normalizeWorkspaceKey(workspaceRoot);
+    const stack = writeBackups.get(key);
+    const backup = stack?.pop();
+    if (!backup) return null;
+    const target = resolveSafePath(workspaceRoot, backup.relativePath);
+    if (backup.previousContent === null) {
+        fs.rmSync(target, { force: true });
+        return { path: backup.relativePath, restoredContent: false };
+    }
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, backup.previousContent);
+    return { path: backup.relativePath, restoredContent: true };
+}
+
 export function listDir(workspaceRoot: string, relativePath: string): string[] {
     const target = resolveSafePath(workspaceRoot, relativePath || ".");
     const entries = fs.readdirSync(target, { withFileTypes: true });
@@ -232,6 +284,31 @@ export async function runCommand(workspaceRoot: string, command: string, relativ
     }
 }
 
+export interface ProjectScripts {
+    test?: string;
+    lint?: string;
+    format?: string;
+}
+
+// Backs the Test/Lint/Format quick-action buttons — only npm-style
+// package.json scripts are recognized, which covers the JS/TS projects this
+// app's Agent mode is primarily used against.
+export function detectProjectScripts(workspaceRoot: string): ProjectScripts {
+    const pkgPath = resolveSafePath(workspaceRoot, "package.json");
+    let scripts: Record<string, string> = {};
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8")) as { scripts?: Record<string, string> };
+        scripts = pkg.scripts ?? {};
+    } catch {
+        return {};
+    }
+    return {
+        test: scripts.test ? "npm test" : undefined,
+        lint: scripts.lint ? "npm run lint" : undefined,
+        format: scripts.format ? "npm run format" : undefined,
+    };
+}
+
 export async function executeTool(workspaceRoot: string, name: string, args: Record<string, unknown>): Promise<unknown> {
     switch (name) {
         case "read_file":
 
@@ -11,6 +11,8 @@ import * as secretsStore from "./secrets-store";
 import * as dataTransfer from "./data-transfer";
 import * as rag from "./rag";
 import * as agentTools from "./agent-tools";
+import * as mcpClient from "./mcp-client";
+import type { McpServerConfig } from "./mcp-client";
 import type { AttachedFile } from "./file-reader";
 import * as openaiProvider from "./providers/openai";
 import * as anthropicProvider from "./providers/anthropic";
@@ -190,7 +192,7 @@ function registerIpcHandlers(): void {
             const onToken = (chunk: ChatChunk) => event.sender.send(channel, chunk);
             const controller = new AbortController();
             activeChatRequests.set(requestId, controller);
-            const tools = agentMode ? agentTools.AGENT_TOOLS : undefined;
+            const tools = agentMode ? [...agentTools.AGENT_TOOLS, ...mcpClient.getConnectedTools()] : undefined;
             try {
                 if (provider === "ollama") {
                     await ollama.chat(model, messages, options, onToken, controller.signal, tools);
@@ -345,14 +347,60 @@ function registerIpcHandlers(): void {
             requireString(workspaceRoot, "workspace root");
             requireString(name, "tool name");
             try {
-                return { result: await agentTools.executeTool(workspaceRoot, name, args ?? {}) };
+                const result = mcpClient.isMcpTool(name)
+                    ? await mcpClient.callMcpTool(name, args ?? {})
+                    : await agentTools.executeTool(workspaceRoot, name, args ?? {});
+                return { result };
             } catch (err) {
                 const error = err as Error;
                 logger.error(`Tool execution failed (tool=${name}): ${error.message}`);
                 return { error: error.message };
             }
         }
     );
+
+    ipcMain.handle("agent:rollbackLastWrite", (_event: IpcMainInvokeEvent, workspaceRoot: string) => {
+        requireString(workspaceRoot, "workspace root");
+        return agentTools.rollbackLastWrite(workspaceRoot);
+    });
+
+    ipcMain.handle("agent:detectScripts", (_event: IpcMainInvokeEvent, workspaceRoot: string) => {
+        requireString(workspaceRoot, "workspace root");
+        return agentTools.detectProjectScripts(workspaceRoot);
+    });
+
+    ipcMain.handle("mcp:connect", async (_event: IpcMainInvokeEvent, config: McpServerConfig) => {
+        try {
+            const { tools } = await mcpClient.connectServer(config);
+            return { tools };
+        } catch (err) {
+            const error = err as Error;
+            logger.error(`MCP connect failed (server=${config?.name}): ${error.message}`);
+            return { error: error.message };
+        }
+    });
+
+    ipcMain.handle("mcp:disconnect", (_event: IpcMainInvokeEvent, id: string) => {
+        requireString(id, "server id");
+        mcpClient.disconnectServer(id);
+    });
+
+    ipcMain.handle("mcp:status", () => mcpClient.getServerStatuses());
+}
+
+// Best-effort: connect every enabled MCP server on launch so its tools are
+// available in Agent mode without the user having to manually reconnect each
+// session. A server that fails to start (bad command, unreachable URL) just
+// logs and stays disconnected — it doesn't block app startup.
+async function connectEnabledMcpServers(): Promise<void> {
+    const servers = settingsStore.getSettings().mcpServers ?? [];
+    for (const server of servers.filter((s) => s.enabled)) {
+        try {
+            await mcpClient.connectServer(server);
+        } catch (err) {
+            logger.error(`MCP server "${server.name}" failed to connect on launch: ${(err as Error).message}`);
+        }
+    }
 }
 
 app.whenReady().then(async () => {
@@ -362,6 +410,7 @@ app.whenReady().then(async () => {
     ollama.setHost(settingsStore.getSettings().ollamaHost);
     await ollama.start();
     setupAutoUpdater(() => mainWindow);
+    void connectEnabledMcpServers();
 
     app.on("activate", () => {
         if (BrowserWindow.getAllWindows().length === 0) createWindow();
@@ -370,6 +419,7 @@ app.whenReady().then(async () => {
 
 app.on("window-all-closed", () => {
     ollama.stop();
+    mcpClient.disconnectAll();
     if (process.platform !== "darwin") app.quit();
 });