From ce338389687b294879d031e182ab03163426aa7f Mon Sep 17 00:00:00 2001
From: Thomas Marchand <thomas.marchand@tuta.io>
Date: Fri, 2 Jan 2026 17:45:01 +0000
Subject: [PATCH] OpenCode refactor and mission tracking fixes (#14)

* Fix missions staying Active after completion with OpenCode backend

- Add TerminalReason::Completed variant for successful task completion
- Set terminal_reason in OpenCodeAgent on success to trigger auto-complete
- Update control.rs to explicitly handle Completed terminal reason
- Update CLAUDE.md with OpenCode backend documentation

* Improve iOS dashboard UI polish

- Remove harsh input field border, use ultraThinMaterial background with subtle focus glow
- Clean up model selector pills: remove ugly truncated mission IDs, increase padding
- Remove agent working indicator border for cleaner look
- Increase input area bottom padding for better thumb reach

* Add real-time event streaming for OpenCode backend

- Add SSE streaming support to OpenCodeClient via /event endpoint
- Parse and forward OpenCode events (thinking, tool_call, tool_result)
- Update OpenCodeAgent to consume stream and forward to control channel
- Add fallback to blocking mode if SSE connection fails

This enables live UI updates in the dashboard when using OpenCode backend.

* Fix running mission tracking to use actual executing mission ID

Track the mission ID that the main `running` task is actually working on
separately from `current_mission`, which can change when the user creates
a new mission. This ensures ListRunning and GracefulShutdown correctly
identify which mission is being executed.

* Add MCP server for desktop tools and Playwright integration

- Create desktop-mcp binary that exposes i3/Xvfb desktop automation tools
  as an MCP server for use with OpenCode backend
- Add opencode.json with both desktop and Playwright MCP configurations
- Update deployment command to include desktop-mcp binary
- Document available MCP tools in CLAUDE.md

Desktop tools: start_session, stop_session, screenshot, type, click,
mouse_move, scroll, i3_command, get_text

* Document SSH key and desktop-mcp binary in production section

- Add ~/.ssh/cursor as the SSH key for production access
- Add desktop-mcp binary location to production table

* Emphasize bun usage and add gitignore entries

- Add clear instructions to ALWAYS use bun, never npm for dashboard
- Gitignore .playwright-mcp/ directory (local MCP data)
- Gitignore dashboard/package-lock.json (we use bun.lockb)

* Add mission delete and cleanup features to web and iOS dashboards

Backend (Rust):
- Add delete_mission() and delete_empty_untitled_missions() to supabase.rs
- Add DELETE /api/control/missions/:id endpoint with running mission guard
- Add POST /api/control/missions/cleanup endpoint for bulk cleanup

Web Dashboard (Next.js):
- Add deleteMission() and cleanupEmptyMissions() API functions
- Add delete button (trash icon) on hover for each mission row
- Add "Cleanup Empty" button with sparkles icon in filters area
- Fix analytics to compute stats from missions/runs data instead of broken /api/stats

iOS Dashboard (Swift):
- Add deleteMission() and cleanupEmptyMissions() to APIService
- Add delete() HTTP helper method
- Add swipe-to-delete on mission rows (disabled for active missions)
- Add "Cleanup" button with sparkles icon and progress indicator
- Add success banner with auto-dismiss after cleanup

* Fix CancelMission and MCP notification parsing bugs

- CancelMission now uses running_mission_id instead of current_mission
  to correctly identify the executing mission (fixes race condition
  when user creates new mission while another is running)
- MCP server JsonRpcRequest.id field now has #[serde(default)] to
  handle JSON-RPC 2.0 notifications which don't have an id field

* Fix running mission tracking bugs

- delete_mission: Query control actor for actual running missions
  instead of using always-empty running_missions list
- cleanup_empty_missions: Exclude running missions from cleanup to
  prevent deleting missions mid-execution
- get_parallel_config: Query control actor for accurate running count
- Task completion: Save running_mission_id before clearing and use it
  for persist and auto-complete (fixes race when user creates new
  mission while task is running)

All endpoints now use ControlCommand::ListRunning to get accurate
running state from the control actor loop.

* Fix bugbot issues: analytics cost, browser cleanup, title truncation, history append

- Add get_total_cost_cents() to supabase.rs for aggregating all run costs
- Update /api/stats endpoint to return actual total cost from database
- Fix analytics page to use stats endpoint for total cost (not limited to 100 runs)
- Fix desktop_mcp.rs to save browser_pid to session file after launch
- Fix mission title truncation to use safe_truncate_index and append "..."
- Fix mission history to append to existing DB history instead of replacing
  (prevents data loss when CreateMission is called during task execution)

* Fix history context contamination and cumulative thinking content

- Only push to local history if completed mission matches current mission,
  preventing old mission exchanges from contaminating new mission context
- Accumulate thinking content across iterations so frontend replacement
  shows all thinking, matching OpenCode backend behavior

* Fix MCP notifications, orphaned processes, and shutdown persistence

- MCP server no longer sends responses to JSON-RPC notifications (per spec)
- Clean up Xvfb/i3/Chromium processes on partial session startup failure
- Graceful shutdown only persists history if running mission matches current

* Fix partial field selection deserialization in cleanup endpoint

Use PartialMission struct for partial field queries to avoid
deserialization failure when DbMission's required fields are missing.

* Clarify analytics success rate measures missions not tasks

Update labels to "Mission Success Rate" and "X missions completed"
to make it clear the metric is mission-level, not task-level.
---
 .claude/CLAUDE.md                             |   45 +-
 .gitignore                                    |    6 +
 Cargo.toml                                    |    8 +
 dashboard/src/app/analytics/page.tsx          |   29 +-
 dashboard/src/app/control/control-client.tsx  |    3 +-
 dashboard/src/app/history/page.tsx            |   90 +-
 dashboard/src/lib/api.ts                      |   24 +
 .../Services/APIService.swift                 |   46 +-
 .../Views/History/HistoryView.swift           |  145 ++-
 opencode.json                                 |   18 +
 src/agents/leaf/executor.rs                   |   14 +-
 src/api/control.rs                            |  234 +++-
 src/api/routes.rs                             |   11 +-
 src/bin/desktop_mcp.rs                        | 1027 +++++++++++++++++
 src/memory/supabase.rs                        |  117 +-
 15 files changed, 1756 insertions(+), 61 deletions(-)
 create mode 100644 opencode.json
 create mode 100644 src/bin/desktop_mcp.rs

diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
index e2b6fc5..5647e9f 100644
--- a/.claude/CLAUDE.md
+++ b/.claude/CLAUDE.md
@@ -23,14 +23,19 @@ cargo test                      # Run tests
 cargo fmt                       # Format code
 cargo clippy                    # Lint
 
-# Dashboard (uses Bun, NOT npm)
+# Dashboard (uses Bun, NOT npm/yarn/pnpm)
 cd dashboard
-bun install                     # Install deps
+bun install                     # Install deps (NEVER use npm install)
 bun dev                         # Dev server (port 3001)
 bun run build                   # Production build
 
+# IMPORTANT: Always use bun for dashboard, never npm
+# - bun install (not npm install)
+# - bun add <pkg> (not npm install <pkg>)
+# - bun run <script> (not npm run <script>)
+
 # Deployment
-ssh root@95.216.112.253 'cd /root/open_agent && git pull && cargo build --release && cp target/release/open_agent /usr/local/bin/ && systemctl restart open_agent'
+ssh root@95.216.112.253 'cd /root/open_agent && git pull && cargo build --release && cp target/release/open_agent /usr/local/bin/ && cp target/release/desktop-mcp /usr/local/bin/ && systemctl restart open_agent'
 ```
 
 ## Architecture
@@ -87,6 +92,35 @@ OPENCODE_PERMISSIVE=true
 Dashboard → Open Agent API → OpenCode Server → Anthropic API (Claude Max)
 ```
 
+**Desktop Tools with OpenCode:**
+To enable desktop tools (i3, Xvfb, screenshots) when using the OpenCode backend:
+
+1. Build the MCP server: `cargo build --release --bin desktop-mcp`
+2. Ensure `opencode.json` is in the project root with the desktop MCP config
+3. OpenCode will automatically load the tools from the MCP server
+
+The `opencode.json` configures MCP servers for desktop and browser automation:
+```json
+{
+  "mcp": {
+    "desktop": {
+      "type": "local",
+      "command": ["./target/release/desktop-mcp"],
+      "enabled": true
+    },
+    "playwright": {
+      "type": "local",
+      "command": ["npx", "@playwright/mcp@latest"],
+      "enabled": true
+    }
+  }
+}
+```
+
+**Available MCP Tools:**
+- **Desktop tools** (i3/Xvfb): `desktop_start_session`, `desktop_screenshot`, `desktop_click`, `desktop_type`, `desktop_i3_command`, etc.
+- **Playwright tools**: `browser_navigate`, `browser_snapshot`, `browser_click`, `browser_type`, `browser_screenshot`, etc.
+
 ## Model Preferences
 
 **With OpenCode backend:** Use Claude models via your Claude Max subscription.
@@ -205,13 +239,16 @@ pub fn do_thing() -> Result<T, MyError> {
 | Property | Value |
 |----------|-------|
 | Host | `95.216.112.253` |
-| SSH | `ssh root@95.216.112.253` |
+| SSH | `ssh -i ~/.ssh/cursor root@95.216.112.253` |
 | Backend URL | `https://agent-backend.thomas.md` |
 | Dashboard URL | `https://agent.thomas.md` |
 | Binary | `/usr/local/bin/open_agent` |
+| Desktop MCP | `/usr/local/bin/desktop-mcp` |
 | Env file | `/etc/open_agent/open_agent.env` |
 | Service | `systemctl status open_agent` |
 
+**SSH Key:** Use `~/.ssh/cursor` key for production server access.
+
 ## Adding New Components
 
 ### New API Endpoint
diff --git a/.gitignore b/.gitignore
index 60137f4..49dc68c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -34,3 +34,9 @@ lmarena_leaderboard.json
 # OS files
 .DS_Store
 Thumbs.db
+
+# Playwright MCP local data
+.playwright-mcp/
+
+# npm lockfile (we use bun)
+dashboard/package-lock.json
diff --git a/Cargo.toml b/Cargo.toml
index 49391f4..6574b23 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -55,5 +55,13 @@ portable-pty = "0.9"
 tokio-util = { version = "0.7", features = ["io"] }
 chromiumoxide = { version = "0.8.0", features = ["tokio-runtime"] }
 
+[[bin]]
+name = "open_agent"
+path = "src/main.rs"
+
+[[bin]]
+name = "desktop-mcp"
+path = "src/bin/desktop_mcp.rs"
+
 [dev-dependencies]
 tokio-test = "0.4"
diff --git a/dashboard/src/app/analytics/page.tsx b/dashboard/src/app/analytics/page.tsx
index 6dc968f..a1cad4d 100644
--- a/dashboard/src/app/analytics/page.tsx
+++ b/dashboard/src/app/analytics/page.tsx
@@ -3,10 +3,9 @@
 import { useEffect, useState, useMemo } from "react";
 import { toast } from "sonner";
 import {
-  getStats,
   listMissions,
   listRuns,
-  type StatsResponse,
+  getStats,
   type Mission,
   type Run,
 } from "@/lib/api";
@@ -37,23 +36,23 @@ interface StatusBreakdown {
 }
 
 export default function AnalyticsPage() {
-  const [stats, setStats] = useState<StatsResponse | null>(null);
   const [missions, setMissions] = useState<Mission[]>([]);
   const [runs, setRuns] = useState<Run[]>([]);
+  const [totalCostCents, setTotalCostCents] = useState(0);
   const [loading, setLoading] = useState(true);
   const [timeRange, setTimeRange] = useState<"7d" | "30d" | "all">("7d");
 
   useEffect(() => {
     async function fetchData() {
       try {
-        const [statsData, missionsData, runsData] = await Promise.all([
-          getStats(),
+        const [missionsData, runsData, statsData] = await Promise.all([
           listMissions(),
           listRuns(100, 0),
+          getStats(),
         ]);
-        setStats(statsData);
         setMissions(missionsData);
         setRuns(runsData.runs);
+        setTotalCostCents(statsData.total_cost_cents);
       } catch (err) {
         console.error("Failed to fetch analytics:", err);
         toast.error("Failed to load analytics");
@@ -126,6 +125,16 @@ export default function AnalyticsPage() {
     return totalCost / runs.length;
   }, [runs]);
 
+  // Calculate mission stats from actual mission data
+  const missionStats = useMemo(() => {
+    const completed = missions.filter(m => m.status === "completed").length;
+    const failed = missions.filter(m => m.status === "failed" || m.status === "not_feasible").length;
+    const finished = completed + failed;
+    const successRate = finished > 0 ? completed / finished : 1;
+    // Use totalCostCents from stats API (includes ALL runs, not just first 100)
+    return { completed, failed, successRate, totalCost: totalCostCents };
+  }, [missions, totalCostCents]);
+
   // Calculate max single day cost
   const maxDayCost = useMemo(() => {
     return Math.max(...costByDay.map((d) => d.cost), 1);
@@ -193,7 +202,7 @@ export default function AnalyticsPage() {
             <span className="text-xs text-white/50">Total Spent</span>
           </div>
           <div className="text-2xl font-semibold text-white">
-            {formatCents(stats?.total_cost_cents ?? 0)}
+            {formatCents(missionStats.totalCost)}
           </div>
           <div className="text-xs text-white/40 mt-1">
             {formatCents(periodTotalCost)} in selected period
@@ -229,13 +238,13 @@ export default function AnalyticsPage() {
         <div className="bg-white/[0.02] border border-white/[0.06] rounded-xl p-4">
           <div className="flex items-center gap-2 mb-2">
             <CheckCircle className="h-4 w-4 text-emerald-400" />
-            <span className="text-xs text-white/50">Success Rate</span>
+            <span className="text-xs text-white/50">Mission Success Rate</span>
           </div>
           <div className="text-2xl font-semibold text-white">
-            {((stats?.success_rate ?? 1) * 100).toFixed(0)}%
+            {(missionStats.successRate * 100).toFixed(0)}%
           </div>
           <div className="text-xs text-white/40 mt-1">
-            {stats?.completed_tasks ?? 0} completed, {stats?.failed_tasks ?? 0} failed
+            {missionStats.completed} missions completed, {missionStats.failed} failed
           </div>
         </div>
       </div>
diff --git a/dashboard/src/app/control/control-client.tsx b/dashboard/src/app/control/control-client.tsx
index dbf1ae4..8d1e705 100644
--- a/dashboard/src/app/control/control-client.tsx
+++ b/dashboard/src/app/control/control-client.tsx
@@ -1192,7 +1192,8 @@ export default function ControlClient() {
             >;
             updated[existingIdx] = {
               ...existing,
-              content: existing.content + "\n\n---\n\n" + content,
+              // Replace content instead of appending - backend sends cumulative content
+              content,
               done,
             };
             return updated;
diff --git a/dashboard/src/app/history/page.tsx b/dashboard/src/app/history/page.tsx
index 6e660ca..c8d68ff 100644
--- a/dashboard/src/app/history/page.tsx
+++ b/dashboard/src/app/history/page.tsx
@@ -4,7 +4,7 @@ import { useEffect, useState, useRef, useMemo, useCallback } from "react";
 import Link from "next/link";
 import { toast } from "sonner";
 import { cn } from "@/lib/utils";
-import { listMissions, getMissionTree, Mission } from "@/lib/api";
+import { listMissions, getMissionTree, deleteMission, cleanupEmptyMissions, Mission } from "@/lib/api";
 import { ShimmerTableRow } from "@/components/ui/shimmer";
 import { CopyButton } from "@/components/ui/copy-button";
 import { RelativeTime } from "@/components/ui/relative-time";
@@ -24,6 +24,8 @@ import {
   ArrowDown,
   Network,
   X,
+  Trash2,
+  Sparkles,
 } from "lucide-react";
 
 const statusIcons: Record<string, typeof Clock> = {
@@ -117,10 +119,14 @@ export default function HistoryPage() {
   const [previewMissionId, setPreviewMissionId] = useState<string | null>(null);
   const [previewTree, setPreviewTree] = useState<AgentNode | null>(null);
   const [loadingTree, setLoadingTree] = useState(false);
-  
+
   // Track the mission ID being fetched to prevent race conditions
   const fetchingTreeMissionIdRef = useRef<string | null>(null);
 
+  // Delete state
+  const [deletingMissionId, setDeletingMissionId] = useState<string | null>(null);
+  const [cleaningUp, setCleaningUp] = useState(false);
+
   useEffect(() => {
     if (fetchedRef.current) return;
     fetchedRef.current = true;
@@ -193,6 +199,49 @@ export default function HistoryPage() {
     }
   };
 
+  const handleDeleteMission = useCallback(async (missionId: string, e: React.MouseEvent) => {
+    e.preventDefault();
+    e.stopPropagation();
+
+    const mission = missions.find(m => m.id === missionId);
+    if (mission?.status === "active") {
+      toast.error("Cannot delete an active mission");
+      return;
+    }
+
+    setDeletingMissionId(missionId);
+    try {
+      await deleteMission(missionId);
+      setMissions(prev => prev.filter(m => m.id !== missionId));
+      toast.success("Mission deleted");
+    } catch (error) {
+      console.error("Failed to delete mission:", error);
+      toast.error("Failed to delete mission");
+    } finally {
+      setDeletingMissionId(null);
+    }
+  }, [missions]);
+
+  const handleCleanupEmpty = useCallback(async () => {
+    setCleaningUp(true);
+    try {
+      const result = await cleanupEmptyMissions();
+      if (result.deleted_count > 0) {
+        // Refresh the missions list
+        const missionsData = await listMissions().catch(() => []);
+        setMissions(missionsData);
+        toast.success(`Cleaned up ${result.deleted_count} empty mission${result.deleted_count === 1 ? '' : 's'}`);
+      } else {
+        toast.info("No empty missions to clean up");
+      }
+    } catch (error) {
+      console.error("Failed to cleanup missions:", error);
+      toast.error("Failed to cleanup missions");
+    } finally {
+      setCleaningUp(false);
+    }
+  }, []);
+
   const filteredMissions = useMemo(() => {
     const filtered = missions.filter((mission) => {
       if (filter !== "all" && mission.status !== filter) return false;
@@ -262,6 +311,24 @@ export default function HistoryPage() {
             </button>
           ))}
         </div>
+
+        <button
+          onClick={handleCleanupEmpty}
+          disabled={cleaningUp}
+          className={cn(
+            "inline-flex items-center gap-2 px-3 py-2 rounded-lg text-xs font-medium transition-colors",
+            "bg-white/[0.02] border border-white/[0.04] hover:bg-white/[0.04]",
+            "text-white/60 hover:text-white/80",
+            cleaningUp && "opacity-50 cursor-not-allowed"
+          )}
+        >
+          {cleaningUp ? (
+            <Loader className="h-3.5 w-3.5 animate-spin" />
+          ) : (
+            <Sparkles className="h-3.5 w-3.5" />
+          )}
+          Cleanup Empty
+        </button>
       </div>
 
       {/* Content */}
@@ -419,6 +486,25 @@ export default function HistoryPage() {
                               >
                                 <Network className="h-3 w-3" />
                               </button>
+                              <button
+                                onClick={(e) => handleDeleteMission(mission.id, e)}
+                                disabled={deletingMissionId === mission.id || mission.status === "active"}
+                                className={cn(
+                                  "inline-flex items-center gap-1 text-xs transition-colors opacity-0 group-hover:opacity-100",
+                                  deletingMissionId === mission.id
+                                    ? "text-white/30 cursor-not-allowed"
+                                    : mission.status === "active"
+                                    ? "text-white/20 cursor-not-allowed"
+                                    : "text-white/40 hover:text-red-400"
+                                )}
+                                title={mission.status === "active" ? "Cannot delete active mission" : "Delete mission"}
+                              >
+                                {deletingMissionId === mission.id ? (
+                                  <Loader className="h-3 w-3 animate-spin" />
+                                ) : (
+                                  <Trash2 className="h-3 w-3" />
+                                )}
+                              </button>
                               <CopyButton
                                 text={mission.id}
                                 showOnHover
diff --git a/dashboard/src/lib/api.ts b/dashboard/src/lib/api.ts
index 338c41f..b773d66 100644
--- a/dashboard/src/lib/api.ts
+++ b/dashboard/src/lib/api.ts
@@ -396,6 +396,30 @@ export async function setMissionStatus(
   if (!res.ok) throw new Error("Failed to set mission status");
 }
 
+// Delete a mission
+export async function deleteMission(id: string): Promise<{ ok: boolean; deleted: string }> {
+  const res = await apiFetch(`/api/control/missions/${id}`, {
+    method: "DELETE",
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to delete mission: ${text}`);
+  }
+  return res.json();
+}
+
+// Cleanup empty untitled missions
+export async function cleanupEmptyMissions(): Promise<{ ok: boolean; deleted_count: number }> {
+  const res = await apiFetch("/api/control/missions/cleanup", {
+    method: "POST",
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to cleanup missions: ${text}`);
+  }
+  return res.json();
+}
+
 // Resume an interrupted mission
 export async function resumeMission(id: string, cleanWorkspace: boolean = false): Promise<Mission> {
   const res = await apiFetch(`/api/control/missions/${id}/resume`, {
diff --git a/ios_dashboard/OpenAgentDashboard/Services/APIService.swift b/ios_dashboard/OpenAgentDashboard/Services/APIService.swift
index 21ce426..eb12b21 100644
--- a/ios_dashboard/OpenAgentDashboard/Services/APIService.swift
+++ b/ios_dashboard/OpenAgentDashboard/Services/APIService.swift
@@ -105,6 +105,29 @@ final class APIService {
     func cancelMission(id: String) async throws {
         let _: EmptyResponse = try await post("/api/control/missions/\(id)/cancel", body: EmptyBody())
     }
+
+    func deleteMission(id: String) async throws -> Bool {
+        struct DeleteResponse: Decodable {
+            let ok: Bool
+            let deleted: String
+        }
+        let response: DeleteResponse = try await delete("/api/control/missions/\(id)")
+        return response.ok
+    }
+
+    func cleanupEmptyMissions() async throws -> Int {
+        struct CleanupResponse: Decodable {
+            let ok: Bool
+            let deletedCount: Int
+
+            enum CodingKeys: String, CodingKey {
+                case ok
+                case deletedCount = "deleted_count"
+            }
+        }
+        let response: CleanupResponse = try await post("/api/control/missions/cleanup", body: EmptyBody())
+        return response.deletedCount
+    }
     
     // MARK: - Parallel Missions
     
@@ -324,17 +347,32 @@ final class APIService {
         guard let url = URL(string: "\(baseURL)\(path)") else {
             throw APIError.invalidURL
         }
-        
+
         var request = URLRequest(url: url)
         request.httpMethod = "POST"
         request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-        
+
         if authenticated, let token = jwtToken {
             request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
         }
-        
+
         request.httpBody = try JSONEncoder().encode(body)
-        
+
+        return try await execute(request)
+    }
+
+    private func delete<T: Decodable>(_ path: String, authenticated: Bool = true) async throws -> T {
+        guard let url = URL(string: "\(baseURL)\(path)") else {
+            throw APIError.invalidURL
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "DELETE"
+
+        if authenticated, let token = jwtToken {
+            request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization")
+        }
+
         return try await execute(request)
     }
     
diff --git a/ios_dashboard/OpenAgentDashboard/Views/History/HistoryView.swift b/ios_dashboard/OpenAgentDashboard/Views/History/HistoryView.swift
index cf88119..3ac2a2e 100644
--- a/ios_dashboard/OpenAgentDashboard/Views/History/HistoryView.swift
+++ b/ios_dashboard/OpenAgentDashboard/Views/History/HistoryView.swift
@@ -15,7 +15,9 @@ struct HistoryView: View {
     @State private var searchText = ""
     @State private var selectedFilter: StatusFilter = .all
     @State private var errorMessage: String?
-    
+    @State private var isCleaningUp = false
+    @State private var showCleanupResult: String?
+
     private let api = APIService.shared
     private let nav = NavigationState.shared
     
@@ -81,24 +83,79 @@ struct HistoryView: View {
                             .stroke(Theme.border, lineWidth: 1)
                     )
                     
-                    // Filter pills
-                    ScrollView(.horizontal, showsIndicators: false) {
-                        HStack(spacing: 8) {
-                            ForEach(StatusFilter.allCases, id: \.rawValue) { filter in
-                                FilterPill(
-                                    title: filter.rawValue,
-                                    isSelected: selectedFilter == filter
-                                ) {
-                                    withAnimation(.easeInOut(duration: 0.2)) {
-                                        selectedFilter = filter
+                    // Filter pills and cleanup button
+                    HStack(spacing: 12) {
+                        ScrollView(.horizontal, showsIndicators: false) {
+                            HStack(spacing: 8) {
+                                ForEach(StatusFilter.allCases, id: \.rawValue) { filter in
+                                    FilterPill(
+                                        title: filter.rawValue,
+                                        isSelected: selectedFilter == filter
+                                    ) {
+                                        withAnimation(.easeInOut(duration: 0.2)) {
+                                            selectedFilter = filter
+                                        }
+                                        HapticService.selectionChanged()
                                     }
-                                    HapticService.selectionChanged()
                                 }
                             }
                         }
+
+                        // Cleanup button
+                        Button {
+                            Task { await cleanupEmptyMissions() }
+                        } label: {
+                            HStack(spacing: 6) {
+                                if isCleaningUp {
+                                    ProgressView()
+                                        .scaleEffect(0.7)
+                                        .tint(Theme.textSecondary)
+                                } else {
+                                    Image(systemName: "sparkles")
+                                        .font(.caption)
+                                }
+                                Text("Cleanup")
+                                    .font(.caption.weight(.medium))
+                            }
+                            .foregroundStyle(Theme.textSecondary)
+                            .padding(.horizontal, 12)
+                            .padding(.vertical, 8)
+                            .background(.ultraThinMaterial)
+                            .clipShape(Capsule())
+                            .overlay(
+                                Capsule()
+                                    .stroke(Theme.border, lineWidth: 0.5)
+                            )
+                        }
+                        .disabled(isCleaningUp)
+                        .opacity(isCleaningUp ? 0.6 : 1)
                     }
                 }
                 .padding()
+
+                // Cleanup result banner
+                if let result = showCleanupResult {
+                    HStack {
+                        Image(systemName: "checkmark.circle.fill")
+                            .foregroundStyle(Theme.success)
+                        Text(result)
+                            .font(.subheadline)
+                            .foregroundStyle(Theme.textPrimary)
+                        Spacer()
+                        Button {
+                            withAnimation { showCleanupResult = nil }
+                        } label: {
+                            Image(systemName: "xmark")
+                                .font(.caption)
+                                .foregroundStyle(Theme.textTertiary)
+                        }
+                    }
+                    .padding()
+                    .background(Theme.success.opacity(0.1))
+                    .clipShape(RoundedRectangle(cornerRadius: 10))
+                    .padding(.horizontal)
+                    .transition(.move(edge: .top).combined(with: .opacity))
+                }
                 
                 // Content
                 if isLoading {
@@ -145,6 +202,15 @@ struct HistoryView: View {
                                 MissionRow(mission: mission)
                             }
                             .buttonStyle(.plain)
+                            .swipeActions(edge: .trailing, allowsFullSwipe: false) {
+                                if mission.status != .active {
+                                    Button(role: .destructive) {
+                                        Task { await deleteMission(mission) }
+                                    } label: {
+                                        Label("Delete", systemImage: "trash")
+                                    }
+                                }
+                            }
                         }
                     } header: {
                         SectionHeader(
@@ -189,23 +255,70 @@ struct HistoryView: View {
     private func loadData() async {
         isLoading = true
         errorMessage = nil
-        
+
         do {
             async let missionsTask = api.listMissions()
             async let tasksTask = api.listTasks()
             async let runsTask = api.listRuns()
-            
+
             let (missionsResult, tasksResult, runsResult) = try await (missionsTask, tasksTask, runsTask)
-            
+
             missions = missionsResult
             tasks = tasksResult
             runs = runsResult
         } catch {
             errorMessage = error.localizedDescription
         }
-        
+
         isLoading = false
     }
+
+    private func deleteMission(_ mission: Mission) async {
+        do {
+            _ = try await api.deleteMission(id: mission.id)
+            withAnimation {
+                missions.removeAll { $0.id == mission.id }
+            }
+            HapticService.success()
+        } catch {
+            HapticService.error()
+            errorMessage = "Failed to delete mission: \(error.localizedDescription)"
+        }
+    }
+
+    private func cleanupEmptyMissions() async {
+        isCleaningUp = true
+
+        do {
+            let count = try await api.cleanupEmptyMissions()
+            if count > 0 {
+                // Refresh the list
+                let newMissions = try await api.listMissions()
+                withAnimation {
+                    missions = newMissions
+                    showCleanupResult = "Cleaned up \(count) empty mission\(count == 1 ? "" : "s")"
+                }
+                HapticService.success()
+            } else {
+                withAnimation {
+                    showCleanupResult = "No empty missions to clean up"
+                }
+            }
+
+            // Auto-hide the result after 3 seconds
+            Task {
+                try? await Task.sleep(for: .seconds(3))
+                withAnimation {
+                    showCleanupResult = nil
+                }
+            }
+        } catch {
+            HapticService.error()
+            errorMessage = "Cleanup failed: \(error.localizedDescription)"
+        }
+
+        isCleaningUp = false
+    }
 }
 
 // MARK: - Supporting Views
diff --git a/opencode.json b/opencode.json
new file mode 100644
index 0000000..fc8ca81
--- /dev/null
+++ b/opencode.json
@@ -0,0 +1,18 @@
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "desktop": {
+      "type": "local",
+      "command": ["./target/release/desktop-mcp"],
+      "enabled": true,
+      "environment": {
+        "DESKTOP_RESOLUTION": "1920x1080"
+      }
+    },
+    "playwright": {
+      "type": "local",
+      "command": ["npx", "@playwright/mcp@latest"],
+      "enabled": true
+    }
+  }
+}
diff --git a/src/agents/leaf/executor.rs b/src/agents/leaf/executor.rs
index f59c87f..d1a3ad7 100644
--- a/src/agents/leaf/executor.rs
+++ b/src/agents/leaf/executor.rs
@@ -688,6 +688,10 @@ If you cannot perform the requested analysis, use `complete_mission(blocked, rea
         // Track consecutive empty/reasoning-only responses (P0 fix for agent stalls)
         let mut empty_response_count: u32 = 0;
 
+        // Cumulative thinking content - we append each iteration's thinking so the frontend
+        // can replace (not append) and still see all thinking. This matches OpenCode behavior.
+        let mut cumulative_thinking = String::new();
+
         // Track failed tool attempts by category (P3 fix for approach looping)
         let mut failure_tracker = ToolFailureTracker::new();
         
@@ -929,11 +933,19 @@ If you cannot perform the requested analysis, use `complete_mission(blocked, rea
             };
 
             // Emit thinking event if there's content (agent reasoning)
+            // We accumulate thinking content across iterations and send cumulative content,
+            // so the frontend can replace (not append) and still see all thinking.
             if let Some(ref content) = response.content {
                 if !content.is_empty() {
+                    // Append to cumulative with separator if not first
+                    if !cumulative_thinking.is_empty() {
+                        cumulative_thinking.push_str("\n\n---\n\n");
+                    }
+                    cumulative_thinking.push_str(content);
+
                     if let Some(events) = &ctx.control_events {
                         let _ = events.send(AgentEvent::Thinking {
-                            content: content.clone(),
+                            content: cumulative_thinking.clone(),
                             done: response.tool_calls.is_none(),
                             mission_id: ctx.mission_id,
                         });
diff --git a/src/api/control.rs b/src/api/control.rs
index fe5c858..4812074 100644
--- a/src/api/control.rs
+++ b/src/api/control.rs
@@ -1006,11 +1006,144 @@ pub async fn resume_mission(
 /// Get parallel execution configuration.
 pub async fn get_parallel_config(
     State(state): State<Arc<AppState>>,
-) -> Json<serde_json::Value> {
-    Json(serde_json::json!({
+) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
+    // Query actual running count from the control actor
+    // (the running state is tracked in the actor loop, not in shared state)
+    let (tx, rx) = oneshot::channel();
+    state
+        .control
+        .cmd_tx
+        .send(ControlCommand::ListRunning { respond: tx })
+        .await
+        .map_err(|_| {
+            (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "control session unavailable".to_string(),
+            )
+        })?;
+
+    let running = rx.await.map_err(|_| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to get running missions".to_string(),
+        )
+    })?;
+
+    Ok(Json(serde_json::json!({
         "max_parallel_missions": state.control.max_parallel,
-        "running_count": state.control.running_missions.read().await.len(),
-    }))
+        "running_count": running.len(),
+    })))
+}
+
+/// Delete a mission by ID.
+/// Only allows deleting missions that are not currently running.
+pub async fn delete_mission(
+    State(state): State<Arc<AppState>>,
+    Path(mission_id): Path<Uuid>,
+) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
+    // Check if mission is currently running by querying the control actor
+    // (the actual running state is tracked in the actor loop, not in shared state)
+    let (tx, rx) = oneshot::channel();
+    state
+        .control
+        .cmd_tx
+        .send(ControlCommand::ListRunning { respond: tx })
+        .await
+        .map_err(|_| {
+            (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "control session unavailable".to_string(),
+            )
+        })?;
+
+    let running = rx.await.map_err(|_| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to check running missions".to_string(),
+        )
+    })?;
+
+    if running.iter().any(|m| m.mission_id == mission_id) {
+        return Err((
+            StatusCode::CONFLICT,
+            "Cannot delete a running mission. Cancel it first.".to_string(),
+        ));
+    }
+
+    // Get memory system
+    let mem = state.memory.as_ref().ok_or_else(|| {
+        (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "Memory system not available".to_string(),
+        )
+    })?;
+
+    // Delete the mission
+    let deleted = mem
+        .supabase
+        .delete_mission(mission_id)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    if deleted {
+        Ok(Json(serde_json::json!({
+            "ok": true,
+            "deleted": mission_id
+        })))
+    } else {
+        Err((StatusCode::NOT_FOUND, "Mission not found".to_string()))
+    }
+}
+
+/// Delete all empty "Untitled" missions.
+/// Returns the count of deleted missions.
+/// Note: This excludes any currently running missions to prevent data loss.
+pub async fn cleanup_empty_missions(
+    State(state): State<Arc<AppState>>,
+) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
+    // Get currently running mission IDs to exclude from cleanup
+    // (a newly-started mission may have empty history in DB while actively running)
+    let (tx, rx) = oneshot::channel();
+    state
+        .control
+        .cmd_tx
+        .send(ControlCommand::ListRunning { respond: tx })
+        .await
+        .map_err(|_| {
+            (
+                StatusCode::SERVICE_UNAVAILABLE,
+                "control session unavailable".to_string(),
+            )
+        })?;
+
+    let running = rx.await.map_err(|_| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            "Failed to check running missions".to_string(),
+        )
+    })?;
+
+    let running_ids: Vec<Uuid> = running.iter().map(|m| m.mission_id).collect();
+
+    // Get memory system
+    let mem = state.memory.as_ref().ok_or_else(|| {
+        (
+            StatusCode::SERVICE_UNAVAILABLE,
+            "Memory system not available".to_string(),
+        )
+    })?;
+
+    // Delete empty untitled missions, excluding running ones
+    let count = mem
+        .supabase
+        .delete_empty_untitled_missions_excluding(&running_ids)
+        .await
+        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
+
+    Ok(Json(serde_json::json!({
+        "ok": true,
+        "deleted_count": count
+    })))
 }
 
 /// Stream control session events via SSE.
@@ -1718,16 +1851,17 @@ async fn control_actor_loop(
                         // First check parallel runners
                         if let Some(runner) = parallel_runners.get_mut(&mission_id) {
                             runner.cancel();
-                            let _ = events_tx.send(AgentEvent::Error { 
+                            let _ = events_tx.send(AgentEvent::Error {
                                 message: format!("Parallel mission {} cancelled", mission_id),
                                 mission_id: Some(mission_id),
                             });
                             parallel_runners.remove(&mission_id);
                             let _ = respond.send(Ok(()));
                         } else {
-                            // Check if this is the current running mission
-                            let current = current_mission.read().await.clone();
-                            if current == Some(mission_id) {
+                            // Check if this is the currently executing mission
+                            // Use running_mission_id (the actual mission being executed)
+                            // instead of current_mission (which can change when user creates a new mission)
+                            if running_mission_id == Some(mission_id) {
                                 // Cancel the current execution
                                 if let Some(token) = &running_cancel {
                                     token.cancel();
@@ -1862,18 +1996,30 @@ async fn control_actor_loop(
                         let mut interrupted_ids = Vec::new();
 
                         // Handle main mission - use running_mission_id (the actual mission being executed)
+                        // Note: We DON'T persist history here because:
+                        // 1. If current_mission == running_mission_id, history is correct
+                        // 2. If current_mission != running_mission_id (user created new mission),
+                        //    history was cleared and doesn't belong to running_mission_id
+                        // The running mission's history is already in DB from previous exchanges,
+                        // and any in-progress exchange will be lost (acceptable for shutdown).
                         if running.is_some() {
                             if let Some(mission_id) = running_mission_id {
-                                // Persist current history before marking as interrupted
-                                persist_mission_history(&memory, &current_mission, &history).await;
-                                
+                                // Only persist if the running mission is still current mission
+                                // (i.e., user didn't create a new mission while this one was running)
+                                let current_mid = current_mission.read().await.clone();
+                                if current_mid == Some(mission_id) {
+                                    persist_mission_history(&memory, &current_mission, &history).await;
+                                }
+                                // Note: If missions differ, don't persist - the local history
+                                // belongs to current_mission, not running_mission_id
+
                                 if let Some(mem) = &memory {
                                     if let Ok(()) = mem.supabase.update_mission_status(mission_id, "interrupted").await {
                                         interrupted_ids.push(mission_id);
                                         tracing::info!("Marked mission {} as interrupted", mission_id);
                                     }
                                 }
-                                
+
                                 // Cancel execution
                                 if let Some(token) = &running_cancel {
                                     token.cancel();
@@ -1981,17 +2127,67 @@ async fn control_actor_loop(
                 }
             }, if running.is_some() => {
                 if let Some(res) = finished {
+                    // Save the running mission ID before clearing it - we need it for persist and auto-complete
+                    // (current_mission can change if user clicks "New Mission" while task was running)
+                    let completed_mission_id = running_mission_id;
                     running = None;
                     running_cancel = None;
                     running_mission_id = None;
                     match res {
                         Ok((_mid, user_msg, agent_result)) => {
-                            // Append to conversation history.
-                            history.push(("user".to_string(), user_msg));
-                            history.push(("assistant".to_string(), agent_result.output.clone()));
+                            // Only append to local history if this mission is still the current mission.
+                            // If the user created a new mission mid-execution, history was cleared for that new mission,
+                            // and we don't want to contaminate it with the old mission's exchange.
+                            let current_mid = current_mission.read().await.clone();
+                            if completed_mission_id == current_mid {
+                                history.push(("user".to_string(), user_msg.clone()));
+                                history.push(("assistant".to_string(), agent_result.output.clone()));
+                            }
 
-                            // Persist to mission
-                            persist_mission_history(&memory, &current_mission, &history).await;
+                            // Persist to mission using the actual completed mission ID
+                            // (not current_mission, which could have changed)
+                            //
+                            // IMPORTANT: We fetch existing history from DB and append, rather than
+                            // using the local `history` variable, because CreateMission may have
+                            // cleared `history` while this task was running. This prevents data loss.
+                            if let (Some(mem), Some(mid)) = (&memory, completed_mission_id) {
+                                // Fetch existing history from DB
+                                let existing_history: Vec<MissionHistoryEntry> = match mem.supabase.get_mission(mid).await {
+                                    Ok(Some(mission)) => {
+                                        serde_json::from_value(mission.history).unwrap_or_default()
+                                    }
+                                    _ => Vec::new(),
+                                };
+
+                                // Append new messages to existing history
+                                let mut messages: Vec<MissionMessage> = existing_history
+                                    .iter()
+                                    .map(|e| MissionMessage {
+                                        role: e.role.clone(),
+                                        content: e.content.clone(),
+                                    })
+                                    .collect();
+                                messages.push(MissionMessage { role: "user".to_string(), content: user_msg.clone() });
+                                messages.push(MissionMessage { role: "assistant".to_string(), content: agent_result.output.clone() });
+
+                                if let Err(e) = mem.supabase.update_mission_history(mid, &messages).await {
+                                    tracing::warn!("Failed to persist mission history: {}", e);
+                                }
+
+                                // Update title from first user message if not set (only on first exchange)
+                                if existing_history.is_empty() {
+                                    // Use safe_truncate_index for UTF-8 safe truncation, matching persist_mission_history
+                                    let title = if user_msg.len() > 100 {
+                                        let safe_end = crate::memory::safe_truncate_index(&user_msg, 100);
+                                        format!("{}...", &user_msg[..safe_end])
+                                    } else {
+                                        user_msg.clone()
+                                    };
+                                    if let Err(e) = mem.supabase.update_mission_title(mid, &title).await {
+                                        tracing::warn!("Failed to update mission title: {}", e);
+                                    }
+                                }
+                            }
 
                             // P1 FIX: Auto-complete mission if agent execution ended in a terminal state
                             // without an explicit complete_mission call.
@@ -2004,7 +2200,9 @@ async fn control_actor_loop(
                             // - Parallel missions (each has its own DB status)
                             if agent_result.terminal_reason.is_some() {
                                 if let Some(mem) = &memory {
-                                    if let Some(mission_id) = current_mission.read().await.clone() {
+                                    // Use completed_mission_id (the actual mission that just finished)
+                                    // instead of current_mission (which can change when user creates a new mission)
+                                    if let Some(mission_id) = completed_mission_id {
                                         // Check current mission status from DB - only auto-complete if still "active"
                                         let current_status = mem.supabase.get_mission(mission_id).await
                                             .ok()
diff --git a/src/api/routes.rs b/src/api/routes.rs
index 64d6eff..72bb3f1 100644
--- a/src/api/routes.rs
+++ b/src/api/routes.rs
@@ -133,6 +133,9 @@ pub async fn serve(config: Config) -> anyhow::Result<()> {
         .route("/api/control/missions/:id/cancel", post(control::cancel_mission))
         .route("/api/control/missions/:id/resume", post(control::resume_mission))
         .route("/api/control/missions/:id/parallel", post(control::start_mission_parallel))
+        .route("/api/control/missions/:id", axum::routing::delete(control::delete_mission))
+        // Mission cleanup
+        .route("/api/control/missions/cleanup", post(control::cleanup_empty_missions))
         // Parallel execution endpoints
         .route("/api/control/running", get(control::list_running_missions))
         .route("/api/control/parallel/config", get(control::get_parallel_config))
@@ -273,8 +276,12 @@ async fn get_stats(State(state): State<Arc<AppState>>) -> Json<StatsResponse> {
         .filter(|t| t.status == TaskStatus::Failed)
         .count();
 
-    // Calculate total cost (would need to track this properly in production)
-    let total_cost_cents = 0u64; // TODO: Track actual costs
+    // Calculate total cost from runs in database
+    let total_cost_cents = if let Some(mem) = &state.memory {
+        mem.supabase.get_total_cost_cents().await.unwrap_or(0)
+    } else {
+        0
+    };
 
     let finished = completed_tasks + failed_tasks;
     let success_rate = if finished > 0 {
diff --git a/src/bin/desktop_mcp.rs b/src/bin/desktop_mcp.rs
new file mode 100644
index 0000000..2cd54a3
--- /dev/null
+++ b/src/bin/desktop_mcp.rs
@@ -0,0 +1,1027 @@
+//! MCP Server for Desktop Tools
+//!
+//! This binary exposes the Open Agent desktop tools (i3, Xvfb, screenshots, etc.)
+//! as an MCP server that can be used with OpenCode or other MCP-compatible clients.
+//!
+//! Communicates over stdio using JSON-RPC 2.0.
+
+use std::io::{BufRead, BufReader, Write};
+use std::path::PathBuf;
+use std::process::Stdio;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+
+/// Global counter for display numbers to avoid conflicts
+static DISPLAY_COUNTER: AtomicU32 = AtomicU32::new(99);
+
+// =============================================================================
+// JSON-RPC Types
+// =============================================================================
+
+#[derive(Debug, Deserialize)]
+struct JsonRpcRequest {
+    #[allow(dead_code)]
+    jsonrpc: String,
+    /// JSON-RPC 2.0 notifications don't have an id field, so this must be optional
+    #[serde(default)]
+    id: Value,
+    method: String,
+    #[serde(default)]
+    params: Value,
+}
+
+#[derive(Debug, Serialize)]
+struct JsonRpcResponse {
+    jsonrpc: String,
+    id: Value,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    result: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    error: Option<JsonRpcError>,
+}
+
+#[derive(Debug, Serialize)]
+struct JsonRpcError {
+    code: i32,
+    message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    data: Option<Value>,
+}
+
+impl JsonRpcResponse {
+    fn success(id: Value, result: Value) -> Self {
+        Self {
+            jsonrpc: "2.0".to_string(),
+            id,
+            result: Some(result),
+            error: None,
+        }
+    }
+
+    fn error(id: Value, code: i32, message: impl Into<String>) -> Self {
+        Self {
+            jsonrpc: "2.0".to_string(),
+            id,
+            result: None,
+            error: Some(JsonRpcError {
+                code,
+                message: message.into(),
+                data: None,
+            }),
+        }
+    }
+}
+
+// =============================================================================
+// MCP Types
+// =============================================================================
+
+#[derive(Debug, Serialize)]
+struct ToolDefinition {
+    name: String,
+    description: String,
+    #[serde(rename = "inputSchema")]
+    input_schema: Value,
+}
+
+#[derive(Debug, Serialize)]
+struct ToolResult {
+    content: Vec<ToolContent>,
+    #[serde(rename = "isError")]
+    is_error: bool,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+enum ToolContent {
+    #[serde(rename = "text")]
+    Text { text: String },
+    #[serde(rename = "image")]
+    Image { data: String, #[serde(rename = "mimeType")] mime_type: String },
+}
+
+// =============================================================================
+// Desktop Tool Implementations
+// =============================================================================
+
+fn get_resolution() -> String {
+    std::env::var("DESKTOP_RESOLUTION").unwrap_or_else(|_| "1280x720".to_string())
+}
+
+/// Run a command with DISPLAY environment variable set
+fn run_with_display(
+    display: &str,
+    program: &str,
+    args: &[&str],
+) -> Result<(String, String, i32), String> {
+    let output = std::process::Command::new(program)
+        .args(args)
+        .env("DISPLAY", display)
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()
+        .map_err(|e| format!("Failed to execute {}: {}", program, e))?;
+
+    let stdout = String::from_utf8_lossy(&output.stdout).to_string();
+    let stderr = String::from_utf8_lossy(&output.stderr).to_string();
+    let exit_code = output.status.code().unwrap_or(-1);
+
+    Ok((stdout, stderr, exit_code))
+}
+
+fn get_working_dir() -> PathBuf {
+    std::env::var("WORKING_DIR")
+        .map(PathBuf::from)
+        .unwrap_or_else(|_| std::env::current_dir().unwrap_or_else(|_| PathBuf::from(".")))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_start_session
+// -----------------------------------------------------------------------------
+
+/// Helper to kill a process by PID (best effort)
+fn kill_process(pid: u32) {
+    use std::process::Command;
+    let _ = Command::new("kill")
+        .args(["-9", &pid.to_string()])
+        .output();
+}
+
+fn tool_start_session(args: &Value) -> Result<String, String> {
+    let display_num = DISPLAY_COUNTER.fetch_add(1, Ordering::SeqCst);
+    let display_id = format!(":{}", display_num);
+    let resolution = get_resolution();
+
+    // Clean up stale lock files
+    let lock_file = format!("/tmp/.X{}-lock", display_num);
+    let socket_file = format!("/tmp/.X11-unix/X{}", display_num);
+    let _ = std::fs::remove_file(&lock_file);
+    let _ = std::fs::remove_file(&socket_file);
+
+    // Start Xvfb
+    let xvfb_args = format!("{} -screen 0 {}x24", display_id, resolution);
+    let xvfb = std::process::Command::new("Xvfb")
+        .args(xvfb_args.split_whitespace())
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+        .map_err(|e| format!("Failed to start Xvfb: {}. Is Xvfb installed?", e))?;
+
+    let xvfb_pid = xvfb.id();
+
+    // Wait for Xvfb to be ready
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    // Start i3 window manager - cleanup Xvfb on failure
+    let i3 = match std::process::Command::new("i3")
+        .env("DISPLAY", &display_id)
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .spawn()
+    {
+        Ok(i3) => i3,
+        Err(e) => {
+            kill_process(xvfb_pid);
+            return Err(format!("Failed to start i3: {}. Is i3 installed?", e));
+        }
+    };
+
+    let i3_pid = i3.id();
+
+    // Wait for i3 to initialize
+    std::thread::sleep(std::time::Duration::from_millis(500));
+
+    // Create screenshots directory - cleanup on failure
+    let working_dir = get_working_dir();
+    let screenshots_dir = working_dir.join("screenshots");
+    if let Err(e) = std::fs::create_dir_all(&screenshots_dir) {
+        kill_process(i3_pid);
+        kill_process(xvfb_pid);
+        return Err(format!("Failed to create screenshots dir: {}", e));
+    }
+
+    // Optionally launch browser
+    let launch_browser = args.get("launch_browser").and_then(|v| v.as_bool()).unwrap_or(false);
+    let (browser_pid, browser_info) = if launch_browser {
+        let url = args.get("url").and_then(|v| v.as_str()).unwrap_or("about:blank");
+
+        let chromium = match std::process::Command::new("chromium")
+            .args([
+                "--no-sandbox",
+                "--disable-gpu",
+                "--disable-software-rasterizer",
+                "--disable-dev-shm-usage",
+                "--force-renderer-accessibility",
+                url,
+            ])
+            .env("DISPLAY", &display_id)
+            .stdout(Stdio::null())
+            .stderr(Stdio::null())
+            .spawn()
+        {
+            Ok(c) => c,
+            Err(e) => {
+                kill_process(i3_pid);
+                kill_process(xvfb_pid);
+                return Err(format!("Failed to start Chromium: {}", e));
+            }
+        };
+
+        let chromium_pid = chromium.id();
+        std::thread::sleep(std::time::Duration::from_secs(2));
+
+        (Some(chromium_pid), format!(", \"browser\": \"chromium\", \"browser_pid\": {}, \"url\": \"{}\"", chromium_pid, url))
+    } else {
+        (None, String::new())
+    };
+
+    // Save session info (including browser_pid if launched)
+    let session_file = working_dir.join(format!(".desktop_session_{}", display_num));
+    let mut session_info = json!({
+        "display": display_id,
+        "display_num": display_num,
+        "xvfb_pid": xvfb_pid,
+        "i3_pid": i3_pid,
+        "resolution": resolution,
+        "screenshots_dir": screenshots_dir.to_string_lossy()
+    });
+    if let Some(pid) = browser_pid {
+        session_info["browser_pid"] = json!(pid);
+    }
+    if let Err(e) = std::fs::write(&session_file, serde_json::to_string_pretty(&session_info).unwrap()) {
+        if let Some(pid) = browser_pid {
+            kill_process(pid);
+        }
+        kill_process(i3_pid);
+        kill_process(xvfb_pid);
+        return Err(format!("Failed to write session file: {}", e));
+    }
+
+    Ok(format!(
+        "{{\"success\": true, \"display\": \"{}\", \"resolution\": \"{}\", \"xvfb_pid\": {}, \"i3_pid\": {}, \"screenshots_dir\": \"{}\"{}}}",
+        display_id,
+        resolution,
+        xvfb_pid,
+        i3_pid,
+        screenshots_dir.display(),
+        browser_info
+    ))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_stop_session
+// -----------------------------------------------------------------------------
+
+fn tool_stop_session(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let display_num: u32 = display_id
+        .trim_start_matches(':')
+        .parse()
+        .map_err(|_| format!("Invalid display format: {}", display_id))?;
+
+    let working_dir = get_working_dir();
+    let session_file = working_dir.join(format!(".desktop_session_{}", display_num));
+    let mut killed_pids = Vec::new();
+
+    if session_file.exists() {
+        if let Ok(content) = std::fs::read_to_string(&session_file) {
+            if let Ok(session_info) = serde_json::from_str::<Value>(&content) {
+                for pid_key in ["xvfb_pid", "i3_pid", "browser_pid"] {
+                    if let Some(pid) = session_info.get(pid_key).and_then(|v| v.as_u64()) {
+                        let pid = pid as i32;
+                        unsafe { libc::kill(pid, libc::SIGTERM); }
+                        killed_pids.push(pid);
+                    }
+                }
+            }
+        }
+        let _ = std::fs::remove_file(&session_file);
+    }
+
+    // Kill by display pattern (fallback)
+    let _ = std::process::Command::new("pkill")
+        .args(["-f", &format!("Xvfb {}", display_id)])
+        .output();
+
+    // Clean up lock files
+    let lock_file = format!("/tmp/.X{}-lock", display_num);
+    let socket_file = format!("/tmp/.X11-unix/X{}", display_num);
+    let _ = std::fs::remove_file(&lock_file);
+    let _ = std::fs::remove_file(&socket_file);
+
+    Ok(format!(
+        "{{\"success\": true, \"display\": \"{}\", \"killed_pids\": {:?}}}",
+        display_id, killed_pids
+    ))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_screenshot
+// -----------------------------------------------------------------------------
+
+fn tool_screenshot(args: &Value) -> Result<(String, Option<String>), String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    // Wait before taking screenshot if specified
+    let wait_seconds = args.get("wait_seconds").and_then(|v| v.as_f64()).unwrap_or(0.0);
+    if wait_seconds > 0.0 {
+        std::thread::sleep(std::time::Duration::from_secs_f64(wait_seconds));
+    }
+
+    // Generate filename
+    let timestamp = chrono::Utc::now().format("%Y%m%d_%H%M%S");
+    let filename = args.get("filename")
+        .and_then(|v| v.as_str())
+        .map(|s| s.to_string())
+        .unwrap_or_else(|| format!("screenshot_{}.png", timestamp));
+
+    let working_dir = get_working_dir();
+    let screenshots_dir = working_dir.join("screenshots");
+    std::fs::create_dir_all(&screenshots_dir)
+        .map_err(|e| format!("Failed to create screenshots dir: {}", e))?;
+
+    let filepath = screenshots_dir.join(&filename);
+
+    // Build scrot command
+    let mut scrot_args = vec!["-o".to_string(), filepath.to_string_lossy().to_string()];
+
+    // Add region if specified
+    if let Some(region) = args.get("region") {
+        if region.is_object() {
+            let x = region.get("x").and_then(|v| v.as_i64()).unwrap_or(0);
+            let y = region.get("y").and_then(|v| v.as_i64()).unwrap_or(0);
+            let w = region.get("width").and_then(|v| v.as_i64()).unwrap_or(100);
+            let h = region.get("height").and_then(|v| v.as_i64()).unwrap_or(100);
+            scrot_args.push("-a".to_string());
+            scrot_args.push(format!("{},{},{},{}", x, y, w, h));
+        }
+    }
+
+    let scrot_args_refs: Vec<&str> = scrot_args.iter().map(|s| s.as_str()).collect();
+    let (_stdout, stderr, exit_code) = run_with_display(display_id, "scrot", &scrot_args_refs)?;
+
+    if exit_code != 0 {
+        // Try import as fallback
+        let (_, _, import_exit) = run_with_display(
+            display_id,
+            "import",
+            &["-window", "root", filepath.to_string_lossy().as_ref()],
+        )?;
+
+        if import_exit != 0 {
+            return Err(format!("Screenshot failed. scrot error: {}", stderr));
+        }
+    }
+
+    if !filepath.exists() {
+        return Err("Screenshot file was not created".to_string());
+    }
+
+    let metadata = std::fs::metadata(&filepath)
+        .map_err(|e| format!("Failed to read file metadata: {}", e))?;
+
+    // Check if we should return the image data
+    let return_image = args.get("return_image").and_then(|v| v.as_bool()).unwrap_or(false);
+    let image_data = if return_image {
+        let data = std::fs::read(&filepath)
+            .map_err(|e| format!("Failed to read screenshot: {}", e))?;
+        Some(base64::Engine::encode(&base64::engine::general_purpose::STANDARD, &data))
+    } else {
+        None
+    };
+
+    let result = format!(
+        "{{\"success\": true, \"path\": \"{}\", \"size_bytes\": {}}}",
+        filepath.display(),
+        metadata.len()
+    );
+
+    Ok((result, image_data))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_type
+// -----------------------------------------------------------------------------
+
+fn tool_type_text(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let delay_ms = args.get("delay_ms").and_then(|v| v.as_u64()).unwrap_or(12);
+
+    let (command, input) = if let Some(text) = args.get("text").and_then(|v| v.as_str()) {
+        ("type", text.to_string())
+    } else if let Some(key) = args.get("key").and_then(|v| v.as_str()) {
+        ("key", key.to_string())
+    } else {
+        return Err("Either 'text' or 'key' must be provided".to_string());
+    };
+
+    let delay_str = delay_ms.to_string();
+    let (_stdout, stderr, exit_code) = run_with_display(
+        display_id,
+        "xdotool",
+        &[command, "--delay", &delay_str, &input],
+    )?;
+
+    if exit_code != 0 {
+        return Err(format!("xdotool failed: {}", stderr));
+    }
+
+    Ok(format!(
+        "{{\"success\": true, \"command\": \"{}\", \"input\": \"{}\"}}",
+        command,
+        input.replace('\"', "\\\"").replace('\n', "\\n")
+    ))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_click
+// -----------------------------------------------------------------------------
+
+fn tool_click(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let x = args.get("x")
+        .and_then(|v| v.as_i64())
+        .ok_or("Missing 'x' argument")?;
+    let y = args.get("y")
+        .and_then(|v| v.as_i64())
+        .ok_or("Missing 'y' argument")?;
+
+    let button = match args.get("button").and_then(|v| v.as_str()).unwrap_or("left") {
+        "left" => "1",
+        "middle" => "2",
+        "right" => "3",
+        other => return Err(format!("Invalid button: {}", other)),
+    };
+
+    let double = args.get("double").and_then(|v| v.as_bool()).unwrap_or(false);
+    let repeat = if double { "2" } else { "1" };
+
+    // Move to position first
+    let x_str = x.to_string();
+    let y_str = y.to_string();
+    let (_, stderr, exit_code) = run_with_display(
+        display_id,
+        "xdotool",
+        &["mousemove", &x_str, &y_str],
+    )?;
+
+    if exit_code != 0 {
+        return Err(format!("xdotool mousemove failed: {}", stderr));
+    }
+
+    std::thread::sleep(std::time::Duration::from_millis(50));
+
+    // Click
+    let (_, stderr, exit_code) = run_with_display(
+        display_id,
+        "xdotool",
+        &["click", "--repeat", repeat, button],
+    )?;
+
+    if exit_code != 0 {
+        return Err(format!("xdotool click failed: {}", stderr));
+    }
+
+    Ok(format!(
+        "{{\"success\": true, \"x\": {}, \"y\": {}, \"button\": \"{}\", \"double\": {}}}",
+        x, y,
+        args.get("button").and_then(|v| v.as_str()).unwrap_or("left"),
+        double
+    ))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_mouse_move
+// -----------------------------------------------------------------------------
+
+fn tool_mouse_move(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let x = args.get("x")
+        .and_then(|v| v.as_i64())
+        .ok_or("Missing 'x' argument")?;
+    let y = args.get("y")
+        .and_then(|v| v.as_i64())
+        .ok_or("Missing 'y' argument")?;
+
+    let x_str = x.to_string();
+    let y_str = y.to_string();
+    let (_, stderr, exit_code) = run_with_display(
+        display_id,
+        "xdotool",
+        &["mousemove", &x_str, &y_str],
+    )?;
+
+    if exit_code != 0 {
+        return Err(format!("xdotool mousemove failed: {}", stderr));
+    }
+
+    Ok(format!("{{\"success\": true, \"x\": {}, \"y\": {}}}", x, y))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_scroll
+// -----------------------------------------------------------------------------
+
+fn tool_scroll(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let amount = args.get("amount")
+        .and_then(|v| v.as_i64())
+        .ok_or("Missing 'amount' argument")?;
+
+    // Move to position if specified
+    if let (Some(x), Some(y)) = (
+        args.get("x").and_then(|v| v.as_i64()),
+        args.get("y").and_then(|v| v.as_i64()),
+    ) {
+        let x_str = x.to_string();
+        let y_str = y.to_string();
+        let (_, stderr, exit_code) = run_with_display(
+            display_id,
+            "xdotool",
+            &["mousemove", &x_str, &y_str],
+        )?;
+
+        if exit_code != 0 {
+            return Err(format!("xdotool mousemove failed: {}", stderr));
+        }
+
+        std::thread::sleep(std::time::Duration::from_millis(50));
+    }
+
+    // xdotool uses button 4 for scroll up, button 5 for scroll down
+    let (button, clicks) = if amount >= 0 {
+        ("5", amount.unsigned_abs() as usize)
+    } else {
+        ("4", amount.unsigned_abs() as usize)
+    };
+
+    for _ in 0..clicks {
+        let (_, stderr, exit_code) = run_with_display(display_id, "xdotool", &["click", button])?;
+
+        if exit_code != 0 {
+            return Err(format!("xdotool scroll failed: {}", stderr));
+        }
+
+        std::thread::sleep(std::time::Duration::from_millis(20));
+    }
+
+    Ok(format!(
+        "{{\"success\": true, \"amount\": {}, \"direction\": \"{}\"}}",
+        amount,
+        if amount >= 0 { "down" } else { "up" }
+    ))
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_i3_command
+// -----------------------------------------------------------------------------
+
+fn tool_i3_command(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let command = args.get("command")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'command' argument")?;
+
+    let (stdout, stderr, exit_code) = run_with_display(display_id, "i3-msg", &[command])?;
+
+    if exit_code != 0 {
+        return Err(format!("i3-msg failed: {} {}", stdout, stderr));
+    }
+
+    // Parse i3-msg JSON output if present
+    let result = if stdout.trim().starts_with('[') || stdout.trim().starts_with('{') {
+        stdout.trim().to_string()
+    } else {
+        format!("{{\"success\": true, \"output\": \"{}\"}}", stdout.trim().replace('"', "\\\""))
+    };
+
+    Ok(result)
+}
+
+// -----------------------------------------------------------------------------
+// Tool: desktop_get_text (OCR only for simplicity in MCP server)
+// -----------------------------------------------------------------------------
+
+fn tool_get_text(args: &Value) -> Result<String, String> {
+    let display_id = args.get("display")
+        .and_then(|v| v.as_str())
+        .ok_or("Missing 'display' argument")?;
+
+    let working_dir = get_working_dir();
+    let screenshots_dir = working_dir.join("screenshots");
+    std::fs::create_dir_all(&screenshots_dir)
+        .map_err(|e| format!("Failed to create screenshots dir: {}", e))?;
+
+    let screenshot_path = screenshots_dir.join("_ocr_temp.png");
+
+    // Take screenshot
+    let (_, stderr, exit_code) = run_with_display(
+        display_id,
+        "scrot",
+        &["-o", screenshot_path.to_string_lossy().as_ref()],
+    )?;
+
+    if exit_code != 0 {
+        return Err(format!("Failed to take screenshot for OCR: {}", stderr));
+    }
+
+    // Run tesseract
+    let output = std::process::Command::new("tesseract")
+        .args([screenshot_path.to_string_lossy().as_ref(), "stdout", "-l", "eng"])
+        .output()
+        .map_err(|e| format!("Failed to run tesseract: {}", e))?;
+
+    // Clean up temp screenshot
+    let _ = std::fs::remove_file(&screenshot_path);
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        return Err(format!("Tesseract failed: {}", stderr));
+    }
+
+    let text = String::from_utf8_lossy(&output.stdout).to_string();
+    Ok(format!("--- OCR Text ---\n{}", text.trim()))
+}
+
+// =============================================================================
+// Tool Registry
+// =============================================================================
+
+fn get_tool_definitions() -> Vec<ToolDefinition> {
+    vec![
+        ToolDefinition {
+            name: "desktop_start_session".to_string(),
+            description: "Start a virtual desktop session (Xvfb + i3 window manager). Returns the DISPLAY identifier (e.g., ':99') needed for other desktop_* tools. Call this before using any other desktop tools. Optionally launches Chromium browser.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "launch_browser": {
+                        "type": "boolean",
+                        "description": "If true, automatically launch Chromium browser after starting the session (default: false)"
+                    },
+                    "url": {
+                        "type": "string",
+                        "description": "Optional URL to open in Chromium (only used if launch_browser is true)"
+                    }
+                },
+                "required": []
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_stop_session".to_string(),
+            description: "Stop a virtual desktop session. Kills Xvfb and all associated processes.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99') returned by desktop_start_session"
+                    }
+                },
+                "required": ["display"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_screenshot".to_string(),
+            description: "Take a screenshot of the virtual desktop. Use wait_seconds (3-5s recommended) after launching apps to let them render.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "wait_seconds": {
+                        "type": "number",
+                        "description": "Seconds to wait before taking screenshot (default: 0)"
+                    },
+                    "return_image": {
+                        "type": "boolean",
+                        "description": "If true, return the image data as base64 for vision analysis (default: false)"
+                    },
+                    "filename": {
+                        "type": "string",
+                        "description": "Optional filename for the screenshot"
+                    },
+                    "region": {
+                        "type": "object",
+                        "description": "Optional region to capture (x, y, width, height)",
+                        "properties": {
+                            "x": { "type": "integer" },
+                            "y": { "type": "integer" },
+                            "width": { "type": "integer" },
+                            "height": { "type": "integer" }
+                        }
+                    }
+                },
+                "required": ["display"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_type".to_string(),
+            description: "Send keyboard input. Provide 'text' to type characters or 'key' for special keys (Return, Tab, Escape, ctrl+a, alt+F4, etc.).".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "text": {
+                        "type": "string",
+                        "description": "Text to type (provide either 'text' OR 'key', not both)"
+                    },
+                    "key": {
+                        "type": "string",
+                        "description": "Key combination (e.g., 'Return', 'ctrl+a', 'alt+F4')"
+                    },
+                    "delay_ms": {
+                        "type": "integer",
+                        "description": "Delay between keystrokes in milliseconds (default: 12)"
+                    }
+                },
+                "required": ["display"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_click".to_string(),
+            description: "Click at a specific position. Coordinates are in pixels from top-left (0,0).".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "x": {
+                        "type": "integer",
+                        "description": "X coordinate in pixels"
+                    },
+                    "y": {
+                        "type": "integer",
+                        "description": "Y coordinate in pixels"
+                    },
+                    "button": {
+                        "type": "string",
+                        "enum": ["left", "middle", "right"],
+                        "description": "Mouse button (default: 'left')"
+                    },
+                    "double": {
+                        "type": "boolean",
+                        "description": "Double-click (default: false)"
+                    }
+                },
+                "required": ["display", "x", "y"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_mouse_move".to_string(),
+            description: "Move the mouse cursor without clicking.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "x": {
+                        "type": "integer",
+                        "description": "X coordinate"
+                    },
+                    "y": {
+                        "type": "integer",
+                        "description": "Y coordinate"
+                    }
+                },
+                "required": ["display", "x", "y"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_scroll".to_string(),
+            description: "Scroll the mouse wheel. Positive = down, negative = up.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "amount": {
+                        "type": "integer",
+                        "description": "Scroll amount (positive = down, negative = up)"
+                    },
+                    "x": {
+                        "type": "integer",
+                        "description": "Optional: X coordinate to scroll at"
+                    },
+                    "y": {
+                        "type": "integer",
+                        "description": "Optional: Y coordinate to scroll at"
+                    }
+                },
+                "required": ["display", "amount"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_i3_command".to_string(),
+            description: "Execute i3 window manager commands. Use 'exec chromium --no-sandbox' to launch apps, 'split h/v' for layout, 'focus left/right/up/down' for navigation.".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    },
+                    "command": {
+                        "type": "string",
+                        "description": "The i3 command (e.g., 'exec chromium --no-sandbox', 'split h', 'focus right')"
+                    }
+                },
+                "required": ["display", "command"]
+            }),
+        },
+        ToolDefinition {
+            name: "desktop_get_text".to_string(),
+            description: "Extract visible text from the desktop using OCR (Tesseract).".to_string(),
+            input_schema: json!({
+                "type": "object",
+                "properties": {
+                    "display": {
+                        "type": "string",
+                        "description": "The display identifier (e.g., ':99')"
+                    }
+                },
+                "required": ["display"]
+            }),
+        },
+    ]
+}
+
+fn execute_tool(name: &str, args: &Value) -> ToolResult {
+    let result = match name {
+        "desktop_start_session" => tool_start_session(args),
+        "desktop_stop_session" => tool_stop_session(args),
+        "desktop_screenshot" => {
+            match tool_screenshot(args) {
+                Ok((text, Some(image_data))) => {
+                    return ToolResult {
+                        content: vec![
+                            ToolContent::Text { text },
+                            ToolContent::Image {
+                                data: image_data,
+                                mime_type: "image/png".to_string(),
+                            },
+                        ],
+                        is_error: false,
+                    };
+                }
+                Ok((text, None)) => Ok(text),
+                Err(e) => Err(e),
+            }
+        }
+        "desktop_type" => tool_type_text(args),
+        "desktop_click" => tool_click(args),
+        "desktop_mouse_move" => tool_mouse_move(args),
+        "desktop_scroll" => tool_scroll(args),
+        "desktop_i3_command" => tool_i3_command(args),
+        "desktop_get_text" => tool_get_text(args),
+        _ => Err(format!("Unknown tool: {}", name)),
+    };
+
+    match result {
+        Ok(text) => ToolResult {
+            content: vec![ToolContent::Text { text }],
+            is_error: false,
+        },
+        Err(e) => ToolResult {
+            content: vec![ToolContent::Text { text: e }],
+            is_error: true,
+        },
+    }
+}
+
+// =============================================================================
+// MCP Server Main Loop
+// =============================================================================
+
+fn handle_request(request: JsonRpcRequest) -> Option<JsonRpcResponse> {
+    match request.method.as_str() {
+        "initialize" => {
+            Some(JsonRpcResponse::success(request.id, json!({
+                "protocolVersion": "2024-11-05",
+                "serverInfo": {
+                    "name": "desktop-mcp",
+                    "version": "0.1.0"
+                },
+                "capabilities": {
+                    "tools": {
+                        "listChanged": false
+                    }
+                }
+            })))
+        }
+
+        "notifications/initialized" | "initialized" => {
+            // JSON-RPC 2.0: "The Server MUST NOT reply to a Notification"
+            None
+        }
+
+        "tools/list" => {
+            let tools = get_tool_definitions();
+            Some(JsonRpcResponse::success(request.id, json!({
+                "tools": tools
+            })))
+        }
+
+        "tools/call" => {
+            let name = request.params.get("name")
+                .and_then(|v| v.as_str())
+                .unwrap_or("");
+            let args = request.params.get("arguments")
+                .cloned()
+                .unwrap_or(json!({}));
+
+            let result = execute_tool(name, &args);
+            Some(JsonRpcResponse::success(request.id, json!(result)))
+        }
+
+        _ => {
+            Some(JsonRpcResponse::error(request.id, -32601, format!("Method not found: {}", request.method)))
+        }
+    }
+}
+
+fn main() {
+    // Log to stderr so it doesn't interfere with JSON-RPC on stdout
+    eprintln!("[desktop-mcp] Starting MCP server for desktop tools...");
+
+    let stdin = std::io::stdin();
+    let mut stdout = std::io::stdout();
+    let reader = BufReader::new(stdin.lock());
+
+    for line in reader.lines() {
+        let line = match line {
+            Ok(l) => l,
+            Err(e) => {
+                eprintln!("[desktop-mcp] Error reading stdin: {}", e);
+                break;
+            }
+        };
+
+        if line.trim().is_empty() {
+            continue;
+        }
+
+        eprintln!("[desktop-mcp] Received: {}", line);
+
+        let request: JsonRpcRequest = match serde_json::from_str(&line) {
+            Ok(r) => r,
+            Err(e) => {
+                eprintln!("[desktop-mcp] Parse error: {}", e);
+                let response = JsonRpcResponse::error(Value::Null, -32700, "Parse error");
+                let json = serde_json::to_string(&response).unwrap();
+                let _ = writeln!(stdout, "{}", json);
+                let _ = stdout.flush();
+                continue;
+            }
+        };
+
+        // Only send response if it's not a notification (per JSON-RPC 2.0 spec)
+        if let Some(response) = handle_request(request) {
+            let json = serde_json::to_string(&response).unwrap();
+            eprintln!("[desktop-mcp] Sending: {}", json);
+
+            if let Err(e) = writeln!(stdout, "{}", json) {
+                eprintln!("[desktop-mcp] Error writing response: {}", e);
+                break;
+            }
+            let _ = stdout.flush();
+        } else {
+            eprintln!("[desktop-mcp] Notification received, no response sent");
+        }
+    }
+
+    eprintln!("[desktop-mcp] Server shutting down");
+}
diff --git a/src/memory/supabase.rs b/src/memory/supabase.rs
index b454319..90d0df5 100644
--- a/src/memory/supabase.rs
+++ b/src/memory/supabase.rs
@@ -105,9 +105,35 @@ impl SupabaseClient {
             .header("Authorization", format!("Bearer {}", self.service_role_key))
             .send()
             .await?;
-        
+
         Ok(resp.json().await?)
     }
+
+    /// Get total cost across all runs (in cents).
+    pub async fn get_total_cost_cents(&self) -> anyhow::Result<u64> {
+        // Fetch only the total_cost_cents column for efficiency
+        #[derive(serde::Deserialize)]
+        struct CostOnly {
+            total_cost_cents: Option<i64>,
+        }
+
+        let resp = self.client
+            .get(format!(
+                "{}/runs?select=total_cost_cents",
+                self.rest_url()
+            ))
+            .header("apikey", &self.service_role_key)
+            .header("Authorization", format!("Bearer {}", self.service_role_key))
+            .send()
+            .await?;
+
+        let costs: Vec<CostOnly> = resp.json().await?;
+        let total: i64 = costs.iter()
+            .filter_map(|c| c.total_cost_cents)
+            .sum();
+
+        Ok(total.max(0) as u64)
+    }
     
     // ==================== Tasks ====================
     
@@ -686,9 +712,94 @@ impl SupabaseClient {
         
         Ok(())
     }
-    
+
+    /// Delete a mission by ID.
+    /// Returns true if the mission was deleted, false if it didn't exist.
+    pub async fn delete_mission(&self, id: Uuid) -> anyhow::Result<bool> {
+        let resp = self.client
+            .delete(format!("{}/missions?id=eq.{}", self.rest_url(), id))
+            .header("apikey", &self.service_role_key)
+            .header("Authorization", format!("Bearer {}", self.service_role_key))
+            .header("Prefer", "return=representation")
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            let text = resp.text().await?;
+            anyhow::bail!("Failed to delete mission: {}", text);
+        }
+
+        // Check if anything was actually deleted
+        let deleted: Vec<DbMission> = resp.json().await?;
+        Ok(!deleted.is_empty())
+    }
+
+    /// Delete all empty "Untitled" missions (no history, no title set).
+    /// Returns the count of deleted missions.
+    pub async fn delete_empty_untitled_missions(&self) -> anyhow::Result<usize> {
+        self.delete_empty_untitled_missions_excluding(&[]).await
+    }
+
+    /// Delete all empty "Untitled" missions (no history, no title set),
+    /// excluding the specified mission IDs (e.g., currently running missions).
+    /// Returns the count of deleted missions.
+    pub async fn delete_empty_untitled_missions_excluding(&self, exclude_ids: &[Uuid]) -> anyhow::Result<usize> {
+        // Minimal struct for partial field selection - avoids deserialization errors
+        // when querying only id, title, history fields (DbMission has more required fields)
+        #[derive(serde::Deserialize)]
+        struct PartialMission {
+            id: Uuid,
+            #[allow(dead_code)]
+            title: Option<String>,
+            history: serde_json::Value,
+        }
+
+        // First get missions with null or "Untitled Mission" title and empty history
+        let resp = self.client
+            .get(format!(
+                "{}/missions?select=id,title,history&or=(title.is.null,title.eq.Untitled%20Mission)&status=eq.active",
+                self.rest_url()
+            ))
+            .header("apikey", &self.service_role_key)
+            .header("Authorization", format!("Bearer {}", self.service_role_key))
+            .send()
+            .await?;
+
+        if !resp.status().is_success() {
+            let text = resp.text().await?;
+            anyhow::bail!("Failed to query empty missions: {}", text);
+        }
+
+        let missions: Vec<PartialMission> = resp.json().await?;
+
+        // Filter to only those with empty history (history is a JSON array)
+        // and not in the exclude list (e.g., currently running missions)
+        let empty_ids: Vec<Uuid> = missions
+            .into_iter()
+            .filter(|m| {
+                m.history.as_array().map_or(true, |arr| arr.is_empty())
+            })
+            .filter(|m| !exclude_ids.contains(&m.id))
+            .map(|m| m.id)
+            .collect();
+
+        if empty_ids.is_empty() {
+            return Ok(0);
+        }
+
+        // Delete in batches
+        let mut deleted_count = 0;
+        for id in &empty_ids {
+            if self.delete_mission(*id).await? {
+                deleted_count += 1;
+            }
+        }
+
+        Ok(deleted_count)
+    }
+
     // ==================== User Facts ====================
-    
+
     /// Insert a user fact into memory.
     pub async fn insert_user_fact(
         &self,