@testdriverai/mcp 7.11.5-test → 7.11.7-canary

package/mcp-server/dist/server.mjs

@@ -13,6 +13,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { randomUUID } from "crypto";
 import * as http from "http";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
 import * as Sentry from "@sentry/node";
 import * as fs from "fs";
 import * as os from "os";
@@ -23,7 +24,6 @@ import * as core from "./core/actions.js";
 import { NoActiveSessionError } from "./core/actions.js";
 import { resolveE2bTemplateId, resolveOs } from "./env-utils.js";
 import { SessionStartInputSchema } from "./provision-types.js";
-import { sessionManager } from "./session.js";
 // =============================================================================
 // Sentry
 // =============================================================================
@@ -181,17 +181,24 @@ const RESOURCE_URI = "ui://testdriver/mcp-app.html";
 // Resource URI base for serving screenshot blobs (with dynamic IDs)
 const SCREENSHOT_RESOURCE_BASE = "screenshot://testdriver/screenshot";
 const CROPPED_IMAGE_RESOURCE_BASE = "screenshot://testdriver/cropped";
-// Map of image ID -> image data
-const imageStore = new Map();
-// Counter for generating unique image IDs
-let imageIdCounter = 0;
 // Maximum number of images to store (to prevent memory leaks)
 const MAX_STORED_IMAGES = 100;
+function imageStoreState() {
+    const adapter = core.getAdapterState();
+    let state = adapter.imageStore;
+    if (!state) {
+        state = { images: new Map(), counter: 0 };
+        adapter.imageStore = state;
+    }
+    return state;
+}
 /**
  * Store an image and return its unique resource URI
  */
 function storeImage(data, type) {
-    const id = `${type}-${++imageIdCounter}`;
+    const state = imageStoreState();
+    const imageStore = state.images;
+    const id = `${type}-${++state.counter}`;
     // Clean up old images if we exceed the limit
     if (imageStore.size >= MAX_STORED_IMAGES) {
         // Remove oldest images (first entries in the map)
@@ -215,7 +222,12 @@ function storeImage(data, type) {
  * Get an image by its ID
  */
 function getStoredImage(id) {
-    return imageStore.get(id);
+    return imageStoreState().images.get(id);
+}
+/** Diagnostics for the active connection's image store (used in debug logs). */
+function imageStoreDiagnostics() {
+    const images = imageStoreState().images;
+    return { imageStoreSize: images.size, availableKeys: Array.from(images.keys()) };
 }
 /**
  * Get session info for structured content
@@ -225,7 +237,7 @@ function getSessionData(session) {
         return { id: null, expiresIn: 0 };
     return {
         id: session.sessionId,
-        expiresIn: sessionManager.getTimeRemaining(session.sessionId),
+        expiresIn: core.getSessionTimeRemaining(session.sessionId),
     };
 }
 /**
@@ -372,7 +384,7 @@ function createToolResult(success, textContent, structuredData, generatedCode) {
     let fullText = textContent;
     if (generatedCode && success) {
         // Get the test file from the current session
-        const session = sessionManager.getCurrentSession();
+        const session = core.getCurrentSession();
         const testFile = session?.testFile;
         if (testFile) {
             fullText += `\n\n⚠️ ACTION REQUIRED: Append this code to ${testFile}:\n\`\`\`javascript\n${generatedCode}\n\`\`\``;
@@ -392,7 +404,7 @@ function createToolResult(success, textContent, structuredData, generatedCode) {
     // structuredContent goes to UI (includes imageUrl for display)
     // Always include success flag so UI can display correct status indicator
     // Include generatedCode and testFile in structured data so agents can programmatically handle it
-    const session = sessionManager.getCurrentSession();
+    const session = core.getCurrentSession();
     return {
         content,
         structuredContent: {
@@ -403,80 +415,96 @@ function createToolResult(success, textContent, structuredData, generatedCode) {
         },
     };
 }
-// Create MCP server wrapped with Sentry for automatic tracing
-const server = isSentryEnabled()
-    ? Sentry.wrapMcpServerWithSentry(new McpServer({
-        name: "testdriver",
-        version: version,
-    }))
-    : new McpServer({
-        name: "testdriver",
-        version: version,
+/**
+ * Build a fully-registered MCP server instance (all resources + tools).
+ *
+ * This used to run once at module load against a single shared `server`. It is
+ * now a factory so the HTTP transport can mint one server PER connection — each
+ * bound (via the surrounding {@link core.runInContext}) to its own isolated
+ * {@link core.CoreContext}. That's what stops one Streamable-HTTP client's tool
+ * call from reading another client's sandbox. The stdio host calls this once and
+ * runs it over the global context, so its behavior is unchanged.
+ *
+ * The tool/resource handlers below don't reference any per-connection state
+ * directly — they go through the context-aware helpers (`storeImage`,
+ * `getStoredImage`, `core.*`), which resolve the active context. So a single
+ * copy of the registration code serves every connection correctly.
+ */
+function buildServer() {
+    // Create MCP server wrapped with Sentry for automatic tracing
+    const server = isSentryEnabled()
+        ? Sentry.wrapMcpServerWithSentry(new McpServer({
+            name: "testdriver",
+            version: version,
+        }))
+        : new McpServer({
+            name: "testdriver",
+            version: version,
+        });
+    // =============================================================================
+    // Register UI Resource
+    // =============================================================================
+    registerAppResource(server, RESOURCE_URI, RESOURCE_URI, { mimeType: RESOURCE_MIME_TYPE, description: "TestDriver Screenshot Viewer UI" }, async () => {
+        const htmlPath = path.join(DIST_DIR, "mcp-app.html");
+        if (!fs.existsSync(htmlPath)) {
+            throw new Error(`UI file not found: ${htmlPath}`);
+        }
+        const html = fs.readFileSync(htmlPath, "utf-8");
+        return {
+            contents: [{ uri: RESOURCE_URI, mimeType: RESOURCE_MIME_TYPE, text: html }],
+        };
     });
-// =============================================================================
-// Register UI Resource
-// =============================================================================
-registerAppResource(server, RESOURCE_URI, RESOURCE_URI, { mimeType: RESOURCE_MIME_TYPE, description: "TestDriver Screenshot Viewer UI" }, async () => {
-    const htmlPath = path.join(DIST_DIR, "mcp-app.html");
-    if (!fs.existsSync(htmlPath)) {
-        throw new Error(`UI file not found: ${htmlPath}`);
-    }
-    const html = fs.readFileSync(htmlPath, "utf-8");
-    return {
-        contents: [{ uri: RESOURCE_URI, mimeType: RESOURCE_MIME_TYPE, text: html }],
-    };
-});
-// Register screenshot resource template for serving binary blobs by ID
-server.registerResource("Screenshot", new ResourceTemplate(`${SCREENSHOT_RESOURCE_BASE}/{imageId}`, { list: undefined }), {
-    description: "Screenshot from TestDriver session served as base64 blob",
-    mimeType: "image/png",
-}, async (uri, variables) => {
-    const imageId = variables.imageId;
-    const image = getStoredImage(imageId);
-    if (!image) {
-        throw new Error(`Screenshot not found: ${imageId}. It may have been cleaned up.`);
-    }
-    logger.debug("screenshot resource: Serving screenshot blob", {
-        imageId,
-        blobLength: image.data.length
+    // Register screenshot resource template for serving binary blobs by ID
+    server.registerResource("Screenshot", new ResourceTemplate(`${SCREENSHOT_RESOURCE_BASE}/{imageId}`, { list: undefined }), {
+        description: "Screenshot from TestDriver session served as base64 blob",
+        mimeType: "image/png",
+    }, async (uri, variables) => {
+        const imageId = variables.imageId;
+        const image = getStoredImage(imageId);
+        if (!image) {
+            throw new Error(`Screenshot not found: ${imageId}. It may have been cleaned up.`);
+        }
+        logger.debug("screenshot resource: Serving screenshot blob", {
+            imageId,
+            blobLength: image.data.length
+        });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "image/png",
+                    blob: image.data,
+                }],
+        };
     });
-    return {
-        contents: [{
-                uri: uri.href,
-                mimeType: "image/png",
-                blob: image.data,
-            }],
-    };
-});
-// Register cropped image resource template for serving find operation results by ID
-server.registerResource("CroppedImage", new ResourceTemplate(`${CROPPED_IMAGE_RESOURCE_BASE}/{imageId}`, { list: undefined }), {
-    description: "Cropped image from find operations served as base64 blob",
-    mimeType: "image/png",
-}, async (uri, variables) => {
-    const imageId = variables.imageId;
-    const image = getStoredImage(imageId);
-    if (!image) {
-        throw new Error(`Cropped image not found: ${imageId}. It may have been cleaned up.`);
-    }
-    logger.debug("cropped image resource: Serving cropped image blob", {
-        imageId,
-        blobLength: image.data.length
+    // Register cropped image resource template for serving find operation results by ID
+    server.registerResource("CroppedImage", new ResourceTemplate(`${CROPPED_IMAGE_RESOURCE_BASE}/{imageId}`, { list: undefined }), {
+        description: "Cropped image from find operations served as base64 blob",
+        mimeType: "image/png",
+    }, async (uri, variables) => {
+        const imageId = variables.imageId;
+        const image = getStoredImage(imageId);
+        if (!image) {
+            throw new Error(`Cropped image not found: ${imageId}. It may have been cleaned up.`);
+        }
+        logger.debug("cropped image resource: Serving cropped image blob", {
+            imageId,
+            blobLength: image.data.length
+        });
+        return {
+            contents: [{
+                    uri: uri.href,
+                    mimeType: "image/png",
+                    blob: image.data,
+                }],
+        };
     });
-    return {
-        contents: [{
-                uri: uri.href,
-                mimeType: "image/png",
-                blob: image.data,
-            }],
-    };
-});
-// =============================================================================
-// Tools
-// =============================================================================
-// Session Start
-registerAppTool(server, "session_start", {
-    title: "Session Start",
-    description: `Start a new TestDriver session and provision a sandbox with browser or app.
+    // =============================================================================
+    // Tools
+    // =============================================================================
+    // Session Start
+    registerAppTool(server, "session_start", {
+        title: "Session Start",
+        description: `Start a new TestDriver session and provision a sandbox with browser or app.
 
 ⚠️ IMPORTANT - Test File Parameter:
 When 'testFile' is provided, you MUST append the generated code to that file after EVERY successful action.
@@ -499,81 +527,81 @@ Debug mode (connect to existing sandbox):
 - Provide 'sandboxId' to connect to an existing sandbox (e.g., from a failed test with debugOnFailure: true)
 - Skips provisioning - connects to sandbox in its current state
 - Use this to interactively debug failed tests without re-running from scratch`,
-    inputSchema: SessionStartInputSchema,
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params, extra) => {
-    const startTime = Date.now();
-    const progress = makeProgressReporter(extra);
-    // Resolve OS with priority: explicit param > TD_OS env var > "linux" default
-    // This mirrors the behavior of the Vitest hooks (hooks.mjs) which also reads TD_OS
-    const { os: resolvedOs, warning: osWarning } = resolveOs(params.os);
-    if (osWarning) {
-        logger.warn(`session_start: ${osWarning}`);
-    }
-    else if (!params.os && resolvedOs !== "linux") {
-        logger.info("session_start: Using TD_OS environment variable", { os: resolvedOs });
-    }
-    // Resolve E2B template ID with priority: explicit param > TD_E2B_TEMPLATE_ID env var
-    // This mirrors the behavior of the Vitest hooks (hooks.mjs) which also reads TD_E2B_TEMPLATE_ID
-    const resolvedE2bTemplateId = resolveE2bTemplateId(params.e2bTemplateId);
-    if (!params.e2bTemplateId && resolvedE2bTemplateId) {
-        logger.info("session_start: Using TD_E2B_TEMPLATE_ID environment variable", { e2bTemplateId: resolvedE2bTemplateId });
-    }
-    logger.info("session_start: Starting", {
-        type: params.type,
-        url: params.url,
-        os: resolvedOs,
-        reconnect: params.reconnect,
-        sandboxId: params.sandboxId,
-    });
-    try {
-        // The core owns session creation, SDK init, connect, provisioning and the
-        // initial screenshot. We keep the abort race + heartbeat scaffolding here:
-        // a heartbeat ticks while the long provisioning await is in flight, and the
-        // whole core call is raced against the client's abort signal so cancellation
-        // still returns promptly. Progress messages from the core are forwarded.
-        const stopHeartbeat = progress.heartbeat(params.sandboxId
-            ? `Connecting to existing sandbox ${params.sandboxId}...`
-            : "Starting session...");
-        let result;
-        try {
-            result = await raceAbort(extra.signal, "session_start", core.sessionStart(params, { os: resolvedOs, e2bTemplateId: resolvedE2bTemplateId }, { onProgress: (m) => progress.report(m) }));
+        inputSchema: SessionStartInputSchema,
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params, extra) => {
+        const startTime = Date.now();
+        const progress = makeProgressReporter(extra);
+        // Resolve OS with priority: explicit param > TD_OS env var > "linux" default
+        // This mirrors the behavior of the Vitest hooks (hooks.mjs) which also reads TD_OS
+        const { os: resolvedOs, warning: osWarning } = resolveOs(params.os);
+        if (osWarning) {
+            logger.warn(`session_start: ${osWarning}`);
         }
-        finally {
-            stopHeartbeat();
+        else if (!params.os && resolvedOs !== "linux") {
+            logger.info("session_start: Using TD_OS environment variable", { os: resolvedOs });
         }
-        const duration = Date.now() - startTime;
-        // Set Sentry context once the session id is known.
-        if (result.ok && typeof result.data.sessionId === "string") {
-            setSessionContext(result.data.sessionId, result.data.sandboxId || undefined);
-        }
-        logger.info("session_start: Completed", { duration, ok: result.ok });
-        if (!result.ok) {
-            // Validation / missing-key failures: pass through with duration added.
-            return resultToMcp({ ...result, data: { ...result.data, duration } });
-        }
-        // Reproduce the server's exact success output (text + data) which differs
-        // from the core's neutral text. Images are mapped to resource URIs.
-        const data = { ...result.data, duration };
-        for (const img of result.images ?? []) {
-            const uri = storeImage(img.base64, img.kind);
-            if (img.kind === "cropped")
-                data.croppedImageResourceUri = uri;
-            else
-                data.screenshotResourceUri = uri;
+        // Resolve E2B template ID with priority: explicit param > TD_E2B_TEMPLATE_ID env var
+        // This mirrors the behavior of the Vitest hooks (hooks.mjs) which also reads TD_E2B_TEMPLATE_ID
+        const resolvedE2bTemplateId = resolveE2bTemplateId(params.e2bTemplateId);
+        if (!params.e2bTemplateId && resolvedE2bTemplateId) {
+            logger.info("session_start: Using TD_E2B_TEMPLATE_ID environment variable", { e2bTemplateId: resolvedE2bTemplateId });
         }
-        if (result.data.debugMode) {
-            // Debug (existing-sandbox) success text — preserve original wording.
-            const text = `Connected to existing sandbox (debug mode)
+        logger.info("session_start: Starting", {
+            type: params.type,
+            url: params.url,
+            os: resolvedOs,
+            reconnect: params.reconnect,
+            sandboxId: params.sandboxId,
+        });
+        try {
+            // The core owns session creation, SDK init, connect, provisioning and the
+            // initial screenshot. We keep the abort race + heartbeat scaffolding here:
+            // a heartbeat ticks while the long provisioning await is in flight, and the
+            // whole core call is raced against the client's abort signal so cancellation
+            // still returns promptly. Progress messages from the core are forwarded.
+            const stopHeartbeat = progress.heartbeat(params.sandboxId
+                ? `Connecting to existing sandbox ${params.sandboxId}...`
+                : "Starting session...");
+            let result;
+            try {
+                result = await raceAbort(extra.signal, "session_start", core.sessionStart(params, { os: resolvedOs, e2bTemplateId: resolvedE2bTemplateId }, { onProgress: (m) => progress.report(m) }));
+            }
+            finally {
+                stopHeartbeat();
+            }
+            const duration = Date.now() - startTime;
+            // Set Sentry context once the session id is known.
+            if (result.ok && typeof result.data.sessionId === "string") {
+                setSessionContext(result.data.sessionId, result.data.sandboxId || undefined);
+            }
+            logger.info("session_start: Completed", { duration, ok: result.ok });
+            if (!result.ok) {
+                // Validation / missing-key failures: pass through with duration added.
+                return resultToMcp({ ...result, data: { ...result.data, duration } });
+            }
+            // Reproduce the server's exact success output (text + data) which differs
+            // from the core's neutral text. Images are mapped to resource URIs.
+            const data = { ...result.data, duration };
+            for (const img of result.images ?? []) {
+                const uri = storeImage(img.base64, img.kind);
+                if (img.kind === "cropped")
+                    data.croppedImageResourceUri = uri;
+                else
+                    data.screenshotResourceUri = uri;
+            }
+            if (result.data.debugMode) {
+                // Debug (existing-sandbox) success text — preserve original wording.
+                const text = `Connected to existing sandbox (debug mode)
 Session: ${result.data.sessionId}
 Sandbox: ${result.data.sandboxId}
 Expires in: ${Math.round(params.keepAlive / 1000)}s
 
 You are now connected to the sandbox in its current state. Use find, click, type, etc. to interact.`;
-            return createToolResult(true, text, data, result.code);
-        }
-        // Normal provisioning success — append the EXACT dependency guidance block.
-        const text = `${result.text}
+                return createToolResult(true, text, data, result.code);
+            }
+            // Normal provisioning success — append the EXACT dependency guidance block.
+            const text = `${result.text}
 
 IMPORTANT - If creating a new test project, use these EXACT dependencies in package.json:
 {
@@ -586,414 +614,414 @@ IMPORTANT - If creating a new test project, use these EXACT dependencies in pack
     "test": "vitest"
   }
 }`;
-        return createToolResult(true, text, data, result.code);
-    }
-    catch (error) {
-        // On client cancellation, tear down the half-provisioned session so we
-        // don't leak a connected sandbox. The underlying SDK call may still be
-        // running in the background; best-effort cleanup is all we can do.
-        if (error instanceof ToolAbortError) {
-            logger.info("session_start: Cancelled by client, tearing down session");
+            return createToolResult(true, text, data, result.code);
+        }
+        catch (error) {
+            // On client cancellation, tear down the half-provisioned session so we
+            // don't leak a connected sandbox. The underlying SDK call may still be
+            // running in the background; best-effort cleanup is all we can do.
+            if (error instanceof ToolAbortError) {
+                logger.info("session_start: Cancelled by client, tearing down session");
+                try {
+                    await core.disconnect();
+                }
+                catch (cleanupErr) {
+                    logger.warn("session_start: Cleanup after cancel failed", { error: String(cleanupErr) });
+                }
+                return createToolResult(false, "Session start was cancelled.", { action: "session_start", cancelled: true });
+            }
+            logger.error("session_start: Failed", { error: String(error) });
+            captureException(error, { tags: { tool: "session_start" }, extra: { params } });
+            throw error;
+        }
+    });
+    // Session Status
+    server.registerTool("session_status", {
+        description: "Check the current session status and time remaining",
+        inputSchema: z.object({}),
+    }, async () => {
+        const startTime = Date.now();
+        logger.info("session_status: Checking");
+        const result = core.sessionStatus();
+        const duration = Date.now() - startTime;
+        logger.info("session_status: Completed", {
+            ok: result.ok,
+            sessionId: result.data.sessionId,
+            status: result.data.status,
+            duration,
+        });
+        return resultToMcp({ ...result, data: { ...result.data, duration } });
+    });
+    // Session Extend
+    server.registerTool("session_extend", {
+        description: "Extend the session keepAlive time",
+        inputSchema: z.object({
+            additionalMs: z.number().default(60000).describe("Additional time in ms"),
+        }),
+    }, async (params) => {
+        logger.info("session_extend: Extending", { additionalMs: params.additionalMs });
+        const result = core.sessionExtend(params.additionalMs);
+        if (!result.ok) {
+            logger.warn("session_extend: No active session");
+            return { content: [{ type: "text", text: "No active session" }] };
+        }
+        logger.info("session_extend: Extended", { newExpiry: result.data.newExpiry });
+        // Preserve the original plain content shape (not via createToolResult).
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.text,
+                },
+            ],
+        };
+    });
+    // Find Element
+    registerAppTool(server, "find", {
+        title: "Find Element",
+        description: "Find an element on screen by natural language description",
+        inputSchema: z.object({
+            description: z.string().describe("Natural language description of the element"),
+            timeout: z.number().optional().describe("Timeout in ms for polling"),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params, extra) => {
+        const startTime = Date.now();
+        const progress = makeProgressReporter(extra);
+        logger.info("find: Starting", { description: params.description, timeout: params.timeout });
+        try {
+            logger.debug("find: Calling SDK find");
+            const stopHeartbeat = progress.heartbeat(`Looking for "${params.description}"...`);
+            let result;
             try {
-                await core.disconnect();
+                result = await raceAbort(extra.signal, "find", core.find(params.description, params.timeout));
             }
-            catch (cleanupErr) {
-                logger.warn("session_start: Cleanup after cancel failed", { error: String(cleanupErr) });
+            finally {
+                stopHeartbeat();
             }
-            return createToolResult(false, "Session start was cancelled.", { action: "session_start", cancelled: true });
+            const duration = Date.now() - startTime;
+            logger.info("find: Completed", { description: params.description, found: result.ok, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
+        }
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("find: No active session");
+                return noSessionResult(error);
+            }
+            const cancelled = cancelledResultOrNull(error, "find");
+            if (cancelled)
+                return cancelled;
+            logger.error("find: Failed", { error: String(error), description: params.description });
+            captureException(error, { tags: { tool: "find" }, extra: { description: params.description } });
+            throw error;
         }
-        logger.error("session_start: Failed", { error: String(error) });
-        captureException(error, { tags: { tool: "session_start" }, extra: { params } });
-        throw error;
-    }
-});
-// Session Status
-server.registerTool("session_status", {
-    description: "Check the current session status and time remaining",
-    inputSchema: z.object({}),
-}, async () => {
-    const startTime = Date.now();
-    logger.info("session_status: Checking");
-    const result = core.sessionStatus();
-    const duration = Date.now() - startTime;
-    logger.info("session_status: Completed", {
-        ok: result.ok,
-        sessionId: result.data.sessionId,
-        status: result.data.status,
-        duration,
     });
-    return resultToMcp({ ...result, data: { ...result.data, duration } });
-});
-// Session Extend
-server.registerTool("session_extend", {
-    description: "Extend the session keepAlive time",
-    inputSchema: z.object({
-        additionalMs: z.number().default(60000).describe("Additional time in ms"),
-    }),
-}, async (params) => {
-    logger.info("session_extend: Extending", { additionalMs: params.additionalMs });
-    const result = core.sessionExtend(params.additionalMs);
-    if (!result.ok) {
-        logger.warn("session_extend: No active session");
-        return { content: [{ type: "text", text: "No active session" }] };
-    }
-    logger.info("session_extend: Extended", { newExpiry: result.data.newExpiry });
-    // Preserve the original plain content shape (not via createToolResult).
-    return {
-        content: [
-            {
-                type: "text",
-                text: result.text,
-            },
-        ],
-    };
-});
-// Find Element
-registerAppTool(server, "find", {
-    title: "Find Element",
-    description: "Find an element on screen by natural language description",
-    inputSchema: z.object({
-        description: z.string().describe("Natural language description of the element"),
-        timeout: z.number().optional().describe("Timeout in ms for polling"),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params, extra) => {
-    const startTime = Date.now();
-    const progress = makeProgressReporter(extra);
-    logger.info("find: Starting", { description: params.description, timeout: params.timeout });
-    try {
-        logger.debug("find: Calling SDK find");
-        const stopHeartbeat = progress.heartbeat(`Looking for "${params.description}"...`);
-        let result;
+    // Find All Elements
+    registerAppTool(server, "findall", {
+        title: "Find All Elements",
+        description: "Find all elements on screen matching a natural language description. Returns an array of element references.",
+        inputSchema: z.object({
+            description: z.string().describe("Natural language description of the elements to find"),
+            timeout: z.number().optional().describe("Timeout in ms for polling"),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params, extra) => {
+        const startTime = Date.now();
+        const progress = makeProgressReporter(extra);
+        logger.info("findall: Starting", { description: params.description, timeout: params.timeout });
         try {
-            result = await raceAbort(extra.signal, "find", core.find(params.description, params.timeout));
+            logger.debug("findall: Calling SDK findAll");
+            const stopHeartbeat = progress.heartbeat(`Looking for all "${params.description}"...`);
+            let result;
+            try {
+                result = await raceAbort(extra.signal, "findall", core.findAll(params.description, params.timeout));
+            }
+            finally {
+                stopHeartbeat();
+            }
+            const duration = Date.now() - startTime;
+            logger.info("findall: Completed", { description: params.description, count: result.data.count, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        finally {
-            stopHeartbeat();
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("findall: No active session");
+                return noSessionResult(error);
+            }
+            const cancelled = cancelledResultOrNull(error, "findall");
+            if (cancelled)
+                return cancelled;
+            logger.error("findall: Failed", { error: String(error), description: params.description });
+            captureException(error, { tags: { tool: "findall" }, extra: { description: params.description } });
+            throw error;
         }
-        const duration = Date.now() - startTime;
-        logger.info("find: Completed", { description: params.description, found: result.ok, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("find: No active session");
-            return noSessionResult(error);
+    });
+    // Click
+    registerAppTool(server, "click", {
+        title: "Click Element",
+        description: "Click on a previously found element. Use 'find' first to locate the element.",
+        inputSchema: z.object({
+            elementRef: z.string().describe("Reference to previously found element (required). Get this from a 'find' call."),
+            action: z.enum(["click", "double-click", "right-click"]).default("click"),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("click: Starting", { elementRef: params.elementRef, action: params.action });
+        try {
+            logger.debug("click: Executing click on element", { elementRef: params.elementRef, action: params.action });
+            const result = await core.click(params.elementRef, params.action);
+            const duration = Date.now() - startTime;
+            logger.info("click: Completed", { elementRef: params.elementRef, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        const cancelled = cancelledResultOrNull(error, "find");
-        if (cancelled)
-            return cancelled;
-        logger.error("find: Failed", { error: String(error), description: params.description });
-        captureException(error, { tags: { tool: "find" }, extra: { description: params.description } });
-        throw error;
-    }
-});
-// Find All Elements
-registerAppTool(server, "findall", {
-    title: "Find All Elements",
-    description: "Find all elements on screen matching a natural language description. Returns an array of element references.",
-    inputSchema: z.object({
-        description: z.string().describe("Natural language description of the elements to find"),
-        timeout: z.number().optional().describe("Timeout in ms for polling"),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params, extra) => {
-    const startTime = Date.now();
-    const progress = makeProgressReporter(extra);
-    logger.info("findall: Starting", { description: params.description, timeout: params.timeout });
-    try {
-        logger.debug("findall: Calling SDK findAll");
-        const stopHeartbeat = progress.heartbeat(`Looking for all "${params.description}"...`);
-        let result;
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("click: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("click: Failed", { error: String(error), elementRef: params.elementRef });
+            captureException(error, { tags: { tool: "click" }, extra: { elementRef: params.elementRef, action: params.action } });
+            throw error;
+        }
+    });
+    // Hover
+    registerAppTool(server, "hover", {
+        title: "Hover Element",
+        description: "Hover over a previously found element. Use 'find' first to locate the element.",
+        inputSchema: z.object({
+            elementRef: z.string().describe("Reference to previously found element (required). Get this from a 'find' call."),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("hover: Starting", { elementRef: params.elementRef });
         try {
-            result = await raceAbort(extra.signal, "findall", core.findAll(params.description, params.timeout));
+            logger.debug("hover: Executing hover on element", { elementRef: params.elementRef });
+            const result = await core.hover(params.elementRef);
+            const duration = Date.now() - startTime;
+            logger.info("hover: Completed", { elementRef: params.elementRef, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        finally {
-            stopHeartbeat();
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("hover: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("hover: Failed", { error: String(error), elementRef: params.elementRef });
+            captureException(error, { tags: { tool: "hover" }, extra: { elementRef: params.elementRef } });
+            throw error;
         }
-        const duration = Date.now() - startTime;
-        logger.info("findall: Completed", { description: params.description, count: result.data.count, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("findall: No active session");
-            return noSessionResult(error);
+    });
+    // Wait
+    server.registerTool("wait", {
+        description: "Wait for a specified amount of time",
+        inputSchema: z.object({
+            timeout: z.number().default(3000).describe("Time to wait in milliseconds (default: 3000)"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("wait: Starting", { timeout: params.timeout });
+        try {
+            logger.debug("wait: Waiting", { timeout: params.timeout });
+            const result = await core.wait(params.timeout);
+            const duration = Date.now() - startTime;
+            logger.info("wait: Completed", { timeout: params.timeout, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        const cancelled = cancelledResultOrNull(error, "findall");
-        if (cancelled)
-            return cancelled;
-        logger.error("findall: Failed", { error: String(error), description: params.description });
-        captureException(error, { tags: { tool: "findall" }, extra: { description: params.description } });
-        throw error;
-    }
-});
-// Click
-registerAppTool(server, "click", {
-    title: "Click Element",
-    description: "Click on a previously found element. Use 'find' first to locate the element.",
-    inputSchema: z.object({
-        elementRef: z.string().describe("Reference to previously found element (required). Get this from a 'find' call."),
-        action: z.enum(["click", "double-click", "right-click"]).default("click"),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("click: Starting", { elementRef: params.elementRef, action: params.action });
-    try {
-        logger.debug("click: Executing click on element", { elementRef: params.elementRef, action: params.action });
-        const result = await core.click(params.elementRef, params.action);
-        const duration = Date.now() - startTime;
-        logger.info("click: Completed", { elementRef: params.elementRef, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("click: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("wait: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("wait: Failed", { error: String(error) });
+            captureException(error, { tags: { tool: "wait" }, extra: { timeout: params.timeout } });
+            throw error;
         }
-        logger.error("click: Failed", { error: String(error), elementRef: params.elementRef });
-        captureException(error, { tags: { tool: "click" }, extra: { elementRef: params.elementRef, action: params.action } });
-        throw error;
-    }
-});
-// Hover
-registerAppTool(server, "hover", {
-    title: "Hover Element",
-    description: "Hover over a previously found element. Use 'find' first to locate the element.",
-    inputSchema: z.object({
-        elementRef: z.string().describe("Reference to previously found element (required). Get this from a 'find' call."),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("hover: Starting", { elementRef: params.elementRef });
-    try {
-        logger.debug("hover: Executing hover on element", { elementRef: params.elementRef });
-        const result = await core.hover(params.elementRef);
-        const duration = Date.now() - startTime;
-        logger.info("hover: Completed", { elementRef: params.elementRef, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("hover: No active session");
-            return noSessionResult(error);
+    });
+    // Focus Application
+    server.registerTool("focus_application", {
+        description: "Bring an application window to the foreground",
+        inputSchema: z.object({
+            name: z.string().describe("Name of the application to focus (e.g., 'Google Chrome', 'Visual Studio Code')"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("focus_application: Starting", { name: params.name });
+        try {
+            logger.debug("focus_application: Focusing", { name: params.name });
+            const result = await core.focusApplication(params.name);
+            const duration = Date.now() - startTime;
+            logger.info("focus_application: Completed", { name: params.name, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        logger.error("hover: Failed", { error: String(error), elementRef: params.elementRef });
-        captureException(error, { tags: { tool: "hover" }, extra: { elementRef: params.elementRef } });
-        throw error;
-    }
-});
-// Wait
-server.registerTool("wait", {
-    description: "Wait for a specified amount of time",
-    inputSchema: z.object({
-        timeout: z.number().default(3000).describe("Time to wait in milliseconds (default: 3000)"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("wait: Starting", { timeout: params.timeout });
-    try {
-        logger.debug("wait: Waiting", { timeout: params.timeout });
-        const result = await core.wait(params.timeout);
-        const duration = Date.now() - startTime;
-        logger.info("wait: Completed", { timeout: params.timeout, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("wait: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("focus_application: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("focus_application: Failed", { error: String(error), name: params.name });
+            captureException(error, { tags: { tool: "focus_application" }, extra: { name: params.name } });
+            throw error;
         }
-        logger.error("wait: Failed", { error: String(error) });
-        captureException(error, { tags: { tool: "wait" }, extra: { timeout: params.timeout } });
-        throw error;
-    }
-});
-// Focus Application
-server.registerTool("focus_application", {
-    description: "Bring an application window to the foreground",
-    inputSchema: z.object({
-        name: z.string().describe("Name of the application to focus (e.g., 'Google Chrome', 'Visual Studio Code')"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("focus_application: Starting", { name: params.name });
-    try {
-        logger.debug("focus_application: Focusing", { name: params.name });
-        const result = await core.focusApplication(params.name);
-        const duration = Date.now() - startTime;
-        logger.info("focus_application: Completed", { name: params.name, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("focus_application: No active session");
-            return noSessionResult(error);
+    });
+    // Find and Click
+    registerAppTool(server, "find_and_click", {
+        title: "Find and Click",
+        description: "Find an element and click it in one action",
+        inputSchema: z.object({
+            description: z.string().describe("Natural language description of element"),
+            action: z.enum(["click", "double-click", "right-click"]).default("click"),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params, extra) => {
+        const startTime = Date.now();
+        const progress = makeProgressReporter(extra);
+        logger.info("find_and_click: Starting", { description: params.description, action: params.action });
+        try {
+            logger.debug("find_and_click: Finding element");
+            const stopHeartbeat = progress.heartbeat(`Looking for "${params.description}"...`);
+            let result;
+            try {
+                result = await raceAbort(extra.signal, "find_and_click", core.findAndClick(params.description, params.action));
+            }
+            finally {
+                stopHeartbeat();
+            }
+            const duration = Date.now() - startTime;
+            logger.info("find_and_click: Completed", { description: params.description, found: result.ok, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        logger.error("focus_application: Failed", { error: String(error), name: params.name });
-        captureException(error, { tags: { tool: "focus_application" }, extra: { name: params.name } });
-        throw error;
-    }
-});
-// Find and Click
-registerAppTool(server, "find_and_click", {
-    title: "Find and Click",
-    description: "Find an element and click it in one action",
-    inputSchema: z.object({
-        description: z.string().describe("Natural language description of element"),
-        action: z.enum(["click", "double-click", "right-click"]).default("click"),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params, extra) => {
-    const startTime = Date.now();
-    const progress = makeProgressReporter(extra);
-    logger.info("find_and_click: Starting", { description: params.description, action: params.action });
-    try {
-        logger.debug("find_and_click: Finding element");
-        const stopHeartbeat = progress.heartbeat(`Looking for "${params.description}"...`);
-        let result;
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("find_and_click: No active session");
+                return noSessionResult(error);
+            }
+            const cancelled = cancelledResultOrNull(error, "find_and_click");
+            if (cancelled)
+                return cancelled;
+            logger.error("find_and_click: Failed", { error: String(error), description: params.description });
+            captureException(error, { tags: { tool: "find_and_click" }, extra: { description: params.description, action: params.action } });
+            throw error;
+        }
+    });
+    // Type
+    server.registerTool("type", {
+        description: "Type text into the currently focused field",
+        inputSchema: z.object({
+            text: z.string().describe("Text to type"),
+            secret: z.boolean().default(false).describe("Whether this is sensitive data"),
+            delay: z.number().optional().describe("Delay between keystrokes in ms"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("type: Starting", { textLength: params.text.length, secret: params.secret });
         try {
-            result = await raceAbort(extra.signal, "find_and_click", core.findAndClick(params.description, params.action));
+            logger.debug("type: Typing text");
+            const result = await core.type(params.text, params.secret, params.delay);
+            const duration = Date.now() - startTime;
+            logger.info("type: Completed", { duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        finally {
-            stopHeartbeat();
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("type: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("type: Failed", { error: String(error) });
+            captureException(error, { tags: { tool: "type" }, extra: { textLength: params.text.length, secret: params.secret } });
+            throw error;
         }
-        const duration = Date.now() - startTime;
-        logger.info("find_and_click: Completed", { description: params.description, found: result.ok, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("find_and_click: No active session");
-            return noSessionResult(error);
+    });
+    // Press Keys
+    server.registerTool("press_keys", {
+        description: "Press keyboard keys or shortcuts",
+        inputSchema: z.object({
+            keys: z.array(z.string()).describe("Array of keys to press (e.g., ['ctrl', 'a'])"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("press_keys: Starting", { keys: params.keys });
+        try {
+            logger.debug("press_keys: Pressing keys");
+            const result = await core.pressKeys(params.keys);
+            const duration = Date.now() - startTime;
+            logger.info("press_keys: Completed", { keys: params.keys, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        const cancelled = cancelledResultOrNull(error, "find_and_click");
-        if (cancelled)
-            return cancelled;
-        logger.error("find_and_click: Failed", { error: String(error), description: params.description });
-        captureException(error, { tags: { tool: "find_and_click" }, extra: { description: params.description, action: params.action } });
-        throw error;
-    }
-});
-// Type
-server.registerTool("type", {
-    description: "Type text into the currently focused field",
-    inputSchema: z.object({
-        text: z.string().describe("Text to type"),
-        secret: z.boolean().default(false).describe("Whether this is sensitive data"),
-        delay: z.number().optional().describe("Delay between keystrokes in ms"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("type: Starting", { textLength: params.text.length, secret: params.secret });
-    try {
-        logger.debug("type: Typing text");
-        const result = await core.type(params.text, params.secret, params.delay);
-        const duration = Date.now() - startTime;
-        logger.info("type: Completed", { duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("type: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("press_keys: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("press_keys: Failed", { error: String(error), keys: params.keys });
+            captureException(error, { tags: { tool: "press_keys" }, extra: { keys: params.keys } });
+            throw error;
         }
-        logger.error("type: Failed", { error: String(error) });
-        captureException(error, { tags: { tool: "type" }, extra: { textLength: params.text.length, secret: params.secret } });
-        throw error;
-    }
-});
-// Press Keys
-server.registerTool("press_keys", {
-    description: "Press keyboard keys or shortcuts",
-    inputSchema: z.object({
-        keys: z.array(z.string()).describe("Array of keys to press (e.g., ['ctrl', 'a'])"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("press_keys: Starting", { keys: params.keys });
-    try {
-        logger.debug("press_keys: Pressing keys");
-        const result = await core.pressKeys(params.keys);
-        const duration = Date.now() - startTime;
-        logger.info("press_keys: Completed", { keys: params.keys, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("press_keys: No active session");
-            return noSessionResult(error);
+    });
+    // Scroll
+    server.registerTool("scroll", {
+        description: "Scroll the page or element",
+        inputSchema: z.object({
+            direction: z.enum(["up", "down", "left", "right"]).default("down"),
+            amount: z.number().optional().describe("Amount to scroll in pixels"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("scroll: Starting", { direction: params.direction, amount: params.amount });
+        try {
+            logger.debug("scroll: Scrolling");
+            const result = await core.scroll(params.direction, params.amount);
+            const duration = Date.now() - startTime;
+            logger.info("scroll: Completed", { direction: params.direction, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        logger.error("press_keys: Failed", { error: String(error), keys: params.keys });
-        captureException(error, { tags: { tool: "press_keys" }, extra: { keys: params.keys } });
-        throw error;
-    }
-});
-// Scroll
-server.registerTool("scroll", {
-    description: "Scroll the page or element",
-    inputSchema: z.object({
-        direction: z.enum(["up", "down", "left", "right"]).default("down"),
-        amount: z.number().optional().describe("Amount to scroll in pixels"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("scroll: Starting", { direction: params.direction, amount: params.amount });
-    try {
-        logger.debug("scroll: Scrolling");
-        const result = await core.scroll(params.direction, params.amount);
-        const duration = Date.now() - startTime;
-        logger.info("scroll: Completed", { direction: params.direction, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("scroll: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("scroll: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("scroll: Failed", { error: String(error), direction: params.direction });
+            captureException(error, { tags: { tool: "scroll" }, extra: { direction: params.direction, amount: params.amount } });
+            throw error;
         }
-        logger.error("scroll: Failed", { error: String(error), direction: params.direction });
-        captureException(error, { tags: { tool: "scroll" }, extra: { direction: params.direction, amount: params.amount } });
-        throw error;
-    }
-});
-// Assert - generates code for test files
-server.registerTool("assert", {
-    description: `Make an AI-powered assertion about the current screen state. GENERATES CODE for the test file.
+    });
+    // Assert - generates code for test files
+    server.registerTool("assert", {
+        description: `Make an AI-powered assertion about the current screen state. GENERATES CODE for the test file.
 
 Use this when you want a verification step recorded in the generated test. This will add code like:
   const assertResult = await testdriver.assert("your assertion");
   expect(assertResult).toBeTruthy();
 
 Unlike 'check' which is for your understanding during development, 'assert' creates verification code that runs in CI/CD.`,
-    inputSchema: z.object({
-        assertion: z.string().describe("Natural language assertion to verify"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("assert: Starting", { assertion: params.assertion });
-    try {
-        logger.debug("assert: Running assertion");
-        const result = await core.assert(params.assertion);
-        const duration = Date.now() - startTime;
-        logger.info("assert: Completed", { assertion: params.assertion, passed: result.ok, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("assert: No active session");
-            return noSessionResult(error);
+        inputSchema: z.object({
+            assertion: z.string().describe("Natural language assertion to verify"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("assert: Starting", { assertion: params.assertion });
+        try {
+            logger.debug("assert: Running assertion");
+            const result = await core.assert(params.assertion);
+            const duration = Date.now() - startTime;
+            logger.info("assert: Completed", { assertion: params.assertion, passed: result.ok, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        logger.error("assert: Failed", { error: String(error), assertion: params.assertion });
-        captureException(error, { tags: { tool: "assert" }, extra: { assertion: params.assertion } });
-        throw error;
-    }
-});
-// Check - AI uses this to understand the screen state (DOES NOT generate code)
-registerAppTool(server, "check", {
-    title: "Check Screen State",
-    description: `👁️ THIS IS HOW YOU SEE THE SCREEN. Use this tool whenever you need to understand what's currently displayed.
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("assert: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("assert: Failed", { error: String(error), assertion: params.assertion });
+            captureException(error, { tags: { tool: "assert" }, extra: { assertion: params.assertion } });
+            throw error;
+        }
+    });
+    // Check - AI uses this to understand the screen state (DOES NOT generate code)
+    registerAppTool(server, "check", {
+        title: "Check Screen State",
+        description: `👁️ THIS IS HOW YOU SEE THE SCREEN. Use this tool whenever you need to understand what's currently displayed.
 
 This tool captures a screenshot and returns AI analysis to YOU. Use it to:
 - See what's on the screen right now
@@ -1012,120 +1040,118 @@ Examples:
 Note: This tool does NOT generate test code. Use 'assert' when you want to add a verification step to the test file.
 
 You can optionally provide a reference image URI to compare against a previous state.`,
-    inputSchema: z.object({
-        task: z.string().describe("The task or condition to verify (e.g., 'Did the login succeed?', 'Is the modal visible?')"),
-        referenceImageUri: z.string().optional().describe("Optional screenshot resource URI (e.g., 'screenshot://testdriver/screenshot/screenshot-1') to compare against instead of the automatically captured 'before' screenshot. Use a screenshotResourceUri from a previous action."),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params, extra) => {
-    const startTime = Date.now();
-    const progress = makeProgressReporter(extra);
-    logger.info("check: Starting", { task: params.task, hasReferenceImageUri: !!params.referenceImageUri });
-    try {
-        // Resolve the optional reference image from the image store (a server/UI
-        // concern). The core handles "last screenshot" / current-screenshot
-        // fallback internally when no reference image is passed.
-        let referenceImage;
-        if (params.referenceImageUri) {
-            // Extract image ID from URI (e.g., "screenshot://testdriver/screenshot/screenshot-1" -> "screenshot-1")
-            const uriParts = params.referenceImageUri.split("/");
-            const imageId = uriParts[uriParts.length - 1];
-            logger.info("check: Looking up reference image", {
-                referenceImageUri: params.referenceImageUri,
-                extractedImageId: imageId,
-                imageStoreSize: imageStore.size,
-                availableKeys: Array.from(imageStore.keys()),
-            });
-            const storedImage = getStoredImage(imageId);
-            if (storedImage) {
-                logger.info("check: Found reference image", {
-                    imageId,
-                    dataLength: storedImage.data?.length,
-                    type: storedImage.type,
-                    hasData: !!storedImage.data,
-                });
-                referenceImage = storedImage.data;
-            }
-            else {
-                logger.warn("check: Reference image NOT found in store, falling back to last screenshot", {
+        inputSchema: z.object({
+            task: z.string().describe("The task or condition to verify (e.g., 'Did the login succeed?', 'Is the modal visible?')"),
+            referenceImageUri: z.string().optional().describe("Optional screenshot resource URI (e.g., 'screenshot://testdriver/screenshot/screenshot-1') to compare against instead of the automatically captured 'before' screenshot. Use a screenshotResourceUri from a previous action."),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params, extra) => {
+        const startTime = Date.now();
+        const progress = makeProgressReporter(extra);
+        logger.info("check: Starting", { task: params.task, hasReferenceImageUri: !!params.referenceImageUri });
+        try {
+            // Resolve the optional reference image from the image store (a server/UI
+            // concern). The core handles "last screenshot" / current-screenshot
+            // fallback internally when no reference image is passed.
+            let referenceImage;
+            if (params.referenceImageUri) {
+                // Extract image ID from URI (e.g., "screenshot://testdriver/screenshot/screenshot-1" -> "screenshot-1")
+                const uriParts = params.referenceImageUri.split("/");
+                const imageId = uriParts[uriParts.length - 1];
+                logger.info("check: Looking up reference image", {
                     referenceImageUri: params.referenceImageUri,
-                    imageId,
-                    imageStoreSize: imageStore.size,
-                    availableKeys: Array.from(imageStore.keys()),
+                    extractedImageId: imageId,
+                    ...imageStoreDiagnostics(),
                 });
+                const storedImage = getStoredImage(imageId);
+                if (storedImage) {
+                    logger.info("check: Found reference image", {
+                        imageId,
+                        dataLength: storedImage.data?.length,
+                        type: storedImage.type,
+                        hasData: !!storedImage.data,
+                    });
+                    referenceImage = storedImage.data;
+                }
+                else {
+                    logger.warn("check: Reference image NOT found in store, falling back to last screenshot", {
+                        referenceImageUri: params.referenceImageUri,
+                        imageId,
+                        ...imageStoreDiagnostics(),
+                    });
+                }
+            }
+            progress.report("Capturing screenshot...");
+            const stopHeartbeat = progress.heartbeat(`Checking: "${params.task}"...`);
+            let result;
+            try {
+                result = await raceAbort(extra.signal, "check", core.check(params.task, referenceImage));
+            }
+            finally {
+                stopHeartbeat();
             }
+            const duration = Date.now() - startTime;
+            logger.info("check: Completed", { task: params.task, complete: result.ok, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        progress.report("Capturing screenshot...");
-        const stopHeartbeat = progress.heartbeat(`Checking: "${params.task}"...`);
-        let result;
-        try {
-            result = await raceAbort(extra.signal, "check", core.check(params.task, referenceImage));
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("check: No active session");
+                return noSessionResult(error);
+            }
+            const cancelled = cancelledResultOrNull(error, "check");
+            if (cancelled)
+                return cancelled;
+            logger.error("check: Failed", { error: String(error), task: params.task });
+            captureException(error, { tags: { tool: "check" }, extra: { task: params.task } });
+            throw error;
         }
-        finally {
-            stopHeartbeat();
+    });
+    // Exec
+    server.registerTool("exec", {
+        description: "Execute shell or PowerShell commands in the sandbox",
+        inputSchema: z.object({
+            language: z.enum(["sh", "pwsh"]).default("sh"),
+            code: z.string().describe("Code to execute"),
+            timeout: z.number().default(30000).describe("Timeout in ms"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("exec: Starting", { language: params.language, codeLength: params.code.length, timeout: params.timeout });
+        try {
+            logger.debug("exec: Executing code", { language: params.language });
+            const result = await core.exec(params.language, params.code, params.timeout);
+            const duration = Date.now() - startTime;
+            logger.info("exec: Completed", { language: params.language, outputLength: result.data.output?.length || 0, duration });
+            return resultToMcp({ ...result, data: { ...result.data, duration } });
         }
-        const duration = Date.now() - startTime;
-        logger.info("check: Completed", { task: params.task, complete: result.ok, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("check: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("exec: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("exec: Failed", { error: String(error), language: params.language });
+            captureException(error, { tags: { tool: "exec" }, extra: { language: params.language, codeLength: params.code.length } });
+            throw error;
         }
-        const cancelled = cancelledResultOrNull(error, "check");
-        if (cancelled)
-            return cancelled;
-        logger.error("check: Failed", { error: String(error), task: params.task });
-        captureException(error, { tags: { tool: "check" }, extra: { task: params.task } });
-        throw error;
-    }
-});
-// Exec
-server.registerTool("exec", {
-    description: "Execute shell or PowerShell commands in the sandbox",
-    inputSchema: z.object({
-        language: z.enum(["sh", "pwsh"]).default("sh"),
-        code: z.string().describe("Code to execute"),
-        timeout: z.number().default(30000).describe("Timeout in ms"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("exec: Starting", { language: params.language, codeLength: params.code.length, timeout: params.timeout });
-    try {
-        logger.debug("exec: Executing code", { language: params.language });
-        const result = await core.exec(params.language, params.code, params.timeout);
-        const duration = Date.now() - startTime;
-        logger.info("exec: Completed", { language: params.language, outputLength: result.data.output?.length || 0, duration });
-        return resultToMcp({ ...result, data: { ...result.data, duration } });
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("exec: No active session");
-            return noSessionResult(error);
+    });
+    function parseScreenshotFilename(filename) {
+        // Match pattern: 001-click-before-L42-submit-button.png or 001-click-error-L42-submit-button.png
+        const match = filename.match(/^(\d+)-([a-z]+)-(before|after|error)-L(\d+)-(.+)\.png$/i);
+        if (match) {
+            return {
+                sequence: parseInt(match[1], 10),
+                action: match[2].toLowerCase(),
+                phase: match[3].toLowerCase(),
+                lineNumber: parseInt(match[4], 10),
+                description: match[5],
+            };
         }
-        logger.error("exec: Failed", { error: String(error), language: params.language });
-        captureException(error, { tags: { tool: "exec" }, extra: { language: params.language, codeLength: params.code.length } });
-        throw error;
-    }
-});
-function parseScreenshotFilename(filename) {
-    // Match pattern: 001-click-before-L42-submit-button.png or 001-click-error-L42-submit-button.png
-    const match = filename.match(/^(\d+)-([a-z]+)-(before|after|error)-L(\d+)-(.+)\.png$/i);
-    if (match) {
-        return {
-            sequence: parseInt(match[1], 10),
-            action: match[2].toLowerCase(),
-            phase: match[3].toLowerCase(),
-            lineNumber: parseInt(match[4], 10),
-            description: match[5],
-        };
+        return {};
     }
-    return {};
-}
-// List Local Screenshots - lists screenshots saved to .testdriver directory
-server.registerTool("list_local_screenshots", {
-    description: `List and filter screenshots saved in the .testdriver directory.
+    // List Local Screenshots - lists screenshots saved to .testdriver directory
+    server.registerTool("list_local_screenshots", {
+        description: `List and filter screenshots saved in the .testdriver directory.
 
 Screenshots from auto-screenshot feature use the format: <seq>-<action>-<phase>-L<line>-<description>.png
 Example: 001-click-before-L42-submit-button.png
@@ -1139,213 +1165,213 @@ This tool supports powerful filtering to find specific screenshots:
 - By sequence number range
 
 Returns a list of screenshot paths that can be viewed with the 'view_local_screenshot' tool.`,
-    inputSchema: z.object({
-        directory: z.string().optional().describe("Test file or subdirectory to search (e.g., 'login.test', 'mcp-screenshots'). If not provided, searches all."),
-        line: z.number().optional().describe("Filter by exact line number from test file (e.g., 42 matches L42)"),
-        lineRange: z.object({
-            start: z.number().describe("Start line number (inclusive)"),
-            end: z.number().describe("End line number (inclusive)"),
-        }).optional().describe("Filter by line number range (e.g., { start: 10, end: 20 })"),
-        action: z.string().optional().describe("Filter by action type: click, find, type, assert, provision, scroll, hover, etc."),
-        phase: z.enum(["before", "after", "error"]).optional().describe("Filter by phase: 'before' (pre-action), 'after' (post-action), or 'error' (when action fails)"),
-        pattern: z.string().optional().describe("Regex pattern to match against filename (e.g., 'submit|login' or 'button.*click')"),
-        sequence: z.number().optional().describe("Filter by exact sequence number"),
-        sequenceRange: z.object({
-            start: z.number().describe("Start sequence (inclusive)"),
-            end: z.number().describe("End sequence (inclusive)"),
-        }).optional().describe("Filter by sequence range (e.g., { start: 1, end: 10 })"),
-        limit: z.number().optional().describe("Maximum number of results to return (default: 50)"),
-        sortBy: z.enum(["modified", "sequence", "line"]).optional().describe("Sort by: 'modified' (newest first), 'sequence' (execution order), or 'line' (line number). Default: 'modified'"),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("list_local_screenshots: Starting", { ...params });
-    try {
-        // Find .testdriver directory - check current working directory and common locations
-        const possiblePaths = [
-            path.join(process.cwd(), ".testdriver"),
-            path.join(os.homedir(), ".testdriver"),
-        ];
-        let testdriverDir = null;
-        for (const p of possiblePaths) {
-            if (fs.existsSync(p)) {
-                testdriverDir = p;
-                break;
+        inputSchema: z.object({
+            directory: z.string().optional().describe("Test file or subdirectory to search (e.g., 'login.test', 'mcp-screenshots'). If not provided, searches all."),
+            line: z.number().optional().describe("Filter by exact line number from test file (e.g., 42 matches L42)"),
+            lineRange: z.object({
+                start: z.number().describe("Start line number (inclusive)"),
+                end: z.number().describe("End line number (inclusive)"),
+            }).optional().describe("Filter by line number range (e.g., { start: 10, end: 20 })"),
+            action: z.string().optional().describe("Filter by action type: click, find, type, assert, provision, scroll, hover, etc."),
+            phase: z.enum(["before", "after", "error"]).optional().describe("Filter by phase: 'before' (pre-action), 'after' (post-action), or 'error' (when action fails)"),
+            pattern: z.string().optional().describe("Regex pattern to match against filename (e.g., 'submit|login' or 'button.*click')"),
+            sequence: z.number().optional().describe("Filter by exact sequence number"),
+            sequenceRange: z.object({
+                start: z.number().describe("Start sequence (inclusive)"),
+                end: z.number().describe("End sequence (inclusive)"),
+            }).optional().describe("Filter by sequence range (e.g., { start: 1, end: 10 })"),
+            limit: z.number().optional().describe("Maximum number of results to return (default: 50)"),
+            sortBy: z.enum(["modified", "sequence", "line"]).optional().describe("Sort by: 'modified' (newest first), 'sequence' (execution order), or 'line' (line number). Default: 'modified'"),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("list_local_screenshots: Starting", { ...params });
+        try {
+            // Find .testdriver directory - check current working directory and common locations
+            const possiblePaths = [
+                path.join(process.cwd(), ".testdriver"),
+                path.join(os.homedir(), ".testdriver"),
+            ];
+            let testdriverDir = null;
+            for (const p of possiblePaths) {
+                if (fs.existsSync(p)) {
+                    testdriverDir = p;
+                    break;
+                }
             }
-        }
-        if (!testdriverDir) {
-            logger.warn("list_local_screenshots: .testdriver directory not found");
-            return createToolResult(false, "No .testdriver directory found. Screenshots are saved here during test runs.", { error: "Directory not found" });
-        }
-        const screenshots = [];
-        // Compile regex pattern if provided
-        let regexPattern = null;
-        if (params.pattern) {
-            try {
-                regexPattern = new RegExp(params.pattern, "i");
+            if (!testdriverDir) {
+                logger.warn("list_local_screenshots: .testdriver directory not found");
+                return createToolResult(false, "No .testdriver directory found. Screenshots are saved here during test runs.", { error: "Directory not found" });
             }
-            catch {
-                return createToolResult(false, `Invalid regex pattern: ${params.pattern}`, { error: "Invalid regex" });
+            const screenshots = [];
+            // Compile regex pattern if provided
+            let regexPattern = null;
+            if (params.pattern) {
+                try {
+                    regexPattern = new RegExp(params.pattern, "i");
+                }
+                catch {
+                    return createToolResult(false, `Invalid regex pattern: ${params.pattern}`, { error: "Invalid regex" });
+                }
             }
-        }
-        // Function to recursively find PNG files
-        const findPngFiles = (dir) => {
-            if (!fs.existsSync(dir))
-                return;
-            const entries = fs.readdirSync(dir, { withFileTypes: true });
-            for (const entry of entries) {
-                const fullPath = path.join(dir, entry.name);
-                if (entry.isDirectory()) {
-                    // If a specific directory was requested, only search that one
-                    if (!params.directory || entry.name === params.directory || dir !== testdriverDir) {
-                        findPngFiles(fullPath);
+            // Function to recursively find PNG files
+            const findPngFiles = (dir) => {
+                if (!fs.existsSync(dir))
+                    return;
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        // If a specific directory was requested, only search that one
+                        if (!params.directory || entry.name === params.directory || dir !== testdriverDir) {
+                            findPngFiles(fullPath);
+                        }
+                    }
+                    else if (entry.isFile() && entry.name.toLowerCase().endsWith(".png")) {
+                        const parsed = parseScreenshotFilename(entry.name);
+                        // Apply filters
+                        if (params.line !== undefined && parsed.lineNumber !== params.line)
+                            continue;
+                        if (params.lineRange && (parsed.lineNumber === undefined ||
+                            parsed.lineNumber < params.lineRange.start ||
+                            parsed.lineNumber > params.lineRange.end))
+                            continue;
+                        if (params.action && parsed.action !== params.action.toLowerCase())
+                            continue;
+                        if (params.phase && parsed.phase !== params.phase)
+                            continue;
+                        if (params.sequence !== undefined && parsed.sequence !== params.sequence)
+                            continue;
+                        if (params.sequenceRange && (parsed.sequence === undefined ||
+                            parsed.sequence < params.sequenceRange.start ||
+                            parsed.sequence > params.sequenceRange.end))
+                            continue;
+                        if (regexPattern && !regexPattern.test(entry.name))
+                            continue;
+                        const stats = fs.statSync(fullPath);
+                        screenshots.push({
+                            path: fullPath,
+                            name: entry.name,
+                            modified: stats.mtime,
+                            size: stats.size,
+                            parsed,
+                        });
                     }
                 }
-                else if (entry.isFile() && entry.name.toLowerCase().endsWith(".png")) {
-                    const parsed = parseScreenshotFilename(entry.name);
-                    // Apply filters
-                    if (params.line !== undefined && parsed.lineNumber !== params.line)
-                        continue;
-                    if (params.lineRange && (parsed.lineNumber === undefined ||
-                        parsed.lineNumber < params.lineRange.start ||
-                        parsed.lineNumber > params.lineRange.end))
-                        continue;
-                    if (params.action && parsed.action !== params.action.toLowerCase())
-                        continue;
-                    if (params.phase && parsed.phase !== params.phase)
-                        continue;
-                    if (params.sequence !== undefined && parsed.sequence !== params.sequence)
-                        continue;
-                    if (params.sequenceRange && (parsed.sequence === undefined ||
-                        parsed.sequence < params.sequenceRange.start ||
-                        parsed.sequence > params.sequenceRange.end))
-                        continue;
-                    if (regexPattern && !regexPattern.test(entry.name))
-                        continue;
-                    const stats = fs.statSync(fullPath);
-                    screenshots.push({
-                        path: fullPath,
-                        name: entry.name,
-                        modified: stats.mtime,
-                        size: stats.size,
-                        parsed,
-                    });
-                }
+            };
+            findPngFiles(testdriverDir);
+            // Sort based on sortBy parameter
+            const sortBy = params.sortBy || "modified";
+            if (sortBy === "modified") {
+                screenshots.sort((a, b) => b.modified.getTime() - a.modified.getTime());
             }
-        };
-        findPngFiles(testdriverDir);
-        // Sort based on sortBy parameter
-        const sortBy = params.sortBy || "modified";
-        if (sortBy === "modified") {
-            screenshots.sort((a, b) => b.modified.getTime() - a.modified.getTime());
-        }
-        else if (sortBy === "sequence") {
-            screenshots.sort((a, b) => (a.parsed.sequence ?? Infinity) - (b.parsed.sequence ?? Infinity));
-        }
-        else if (sortBy === "line") {
-            screenshots.sort((a, b) => (a.parsed.lineNumber ?? Infinity) - (b.parsed.lineNumber ?? Infinity));
-        }
-        const duration = Date.now() - startTime;
-        logger.info("list_local_screenshots: Completed", { count: screenshots.length, duration });
-        if (screenshots.length === 0) {
-            const filters = [];
-            if (params.directory)
-                filters.push(`directory=${params.directory}`);
-            if (params.line)
-                filters.push(`line=${params.line}`);
-            if (params.lineRange)
-                filters.push(`lineRange=${params.lineRange.start}-${params.lineRange.end}`);
-            if (params.action)
-                filters.push(`action=${params.action}`);
-            if (params.phase)
-                filters.push(`phase=${params.phase}`);
-            if (params.pattern)
-                filters.push(`pattern=${params.pattern}`);
-            if (params.sequence)
-                filters.push(`sequence=${params.sequence}`);
-            if (params.sequenceRange)
-                filters.push(`sequenceRange=${params.sequenceRange.start}-${params.sequenceRange.end}`);
-            const filterMsg = filters.length > 0 ? ` with filters: ${filters.join(", ")}` : "";
-            return createToolResult(true, `No screenshots found in .testdriver directory${filterMsg}.`, {
+            else if (sortBy === "sequence") {
+                screenshots.sort((a, b) => (a.parsed.sequence ?? Infinity) - (b.parsed.sequence ?? Infinity));
+            }
+            else if (sortBy === "line") {
+                screenshots.sort((a, b) => (a.parsed.lineNumber ?? Infinity) - (b.parsed.lineNumber ?? Infinity));
+            }
+            const duration = Date.now() - startTime;
+            logger.info("list_local_screenshots: Completed", { count: screenshots.length, duration });
+            if (screenshots.length === 0) {
+                const filters = [];
+                if (params.directory)
+                    filters.push(`directory=${params.directory}`);
+                if (params.line)
+                    filters.push(`line=${params.line}`);
+                if (params.lineRange)
+                    filters.push(`lineRange=${params.lineRange.start}-${params.lineRange.end}`);
+                if (params.action)
+                    filters.push(`action=${params.action}`);
+                if (params.phase)
+                    filters.push(`phase=${params.phase}`);
+                if (params.pattern)
+                    filters.push(`pattern=${params.pattern}`);
+                if (params.sequence)
+                    filters.push(`sequence=${params.sequence}`);
+                if (params.sequenceRange)
+                    filters.push(`sequenceRange=${params.sequenceRange.start}-${params.sequenceRange.end}`);
+                const filterMsg = filters.length > 0 ? ` with filters: ${filters.join(", ")}` : "";
+                return createToolResult(true, `No screenshots found in .testdriver directory${filterMsg}.`, {
+                    action: "list_local_screenshots",
+                    count: 0,
+                    directory: testdriverDir,
+                    filters: params,
+                    duration
+                });
+            }
+            const limit = params.limit || 50;
+            const limitedScreenshots = screenshots.slice(0, limit);
+            // Format the list for display with parsed info
+            const screenshotList = limitedScreenshots.map((s, i) => {
+                const relativePath = path.relative(testdriverDir, s.path);
+                const sizeKB = Math.round(s.size / 1024);
+                const timeAgo = formatTimeAgo(s.modified);
+                // Add parsed info if available
+                const parts = [`${i + 1}. ${relativePath}`];
+                const meta = [];
+                if (s.parsed.lineNumber)
+                    meta.push(`L${s.parsed.lineNumber}`);
+                if (s.parsed.action)
+                    meta.push(s.parsed.action);
+                if (s.parsed.phase)
+                    meta.push(s.parsed.phase);
+                meta.push(`${sizeKB}KB`);
+                meta.push(timeAgo);
+                parts.push(`(${meta.join(", ")})`);
+                return parts.join(" ");
+            }).join("\n");
+            const message = screenshots.length > limit
+                ? `Found ${screenshots.length} screenshots (showing ${limit} results, sorted by ${sortBy}):\n\n${screenshotList}`
+                : `Found ${screenshots.length} screenshot(s) (sorted by ${sortBy}):\n\n${screenshotList}`;
+            return createToolResult(true, message, {
                 action: "list_local_screenshots",
-                count: 0,
+                count: screenshots.length,
+                returned: limitedScreenshots.length,
                 directory: testdriverDir,
                 filters: params,
+                sortBy,
+                screenshots: limitedScreenshots.map(s => ({
+                    path: s.path,
+                    relativePath: path.relative(testdriverDir, s.path),
+                    name: s.name,
+                    modified: s.modified.toISOString(),
+                    sizeBytes: s.size,
+                    sequence: s.parsed.sequence,
+                    action: s.parsed.action,
+                    phase: s.parsed.phase,
+                    lineNumber: s.parsed.lineNumber,
+                    description: s.parsed.description,
+                })),
                 duration
             });
         }
-        const limit = params.limit || 50;
-        const limitedScreenshots = screenshots.slice(0, limit);
-        // Format the list for display with parsed info
-        const screenshotList = limitedScreenshots.map((s, i) => {
-            const relativePath = path.relative(testdriverDir, s.path);
-            const sizeKB = Math.round(s.size / 1024);
-            const timeAgo = formatTimeAgo(s.modified);
-            // Add parsed info if available
-            const parts = [`${i + 1}. ${relativePath}`];
-            const meta = [];
-            if (s.parsed.lineNumber)
-                meta.push(`L${s.parsed.lineNumber}`);
-            if (s.parsed.action)
-                meta.push(s.parsed.action);
-            if (s.parsed.phase)
-                meta.push(s.parsed.phase);
-            meta.push(`${sizeKB}KB`);
-            meta.push(timeAgo);
-            parts.push(`(${meta.join(", ")})`);
-            return parts.join(" ");
-        }).join("\n");
-        const message = screenshots.length > limit
-            ? `Found ${screenshots.length} screenshots (showing ${limit} results, sorted by ${sortBy}):\n\n${screenshotList}`
-            : `Found ${screenshots.length} screenshot(s) (sorted by ${sortBy}):\n\n${screenshotList}`;
-        return createToolResult(true, message, {
-            action: "list_local_screenshots",
-            count: screenshots.length,
-            returned: limitedScreenshots.length,
-            directory: testdriverDir,
-            filters: params,
-            sortBy,
-            screenshots: limitedScreenshots.map(s => ({
-                path: s.path,
-                relativePath: path.relative(testdriverDir, s.path),
-                name: s.name,
-                modified: s.modified.toISOString(),
-                sizeBytes: s.size,
-                sequence: s.parsed.sequence,
-                action: s.parsed.action,
-                phase: s.parsed.phase,
-                lineNumber: s.parsed.lineNumber,
-                description: s.parsed.description,
-            })),
-            duration
-        });
-    }
-    catch (error) {
-        logger.error("list_local_screenshots: Failed", { error: String(error) });
-        captureException(error, { tags: { tool: "list_local_screenshots" } });
-        throw error;
+        catch (error) {
+            logger.error("list_local_screenshots: Failed", { error: String(error) });
+            captureException(error, { tags: { tool: "list_local_screenshots" } });
+            throw error;
+        }
+    });
+    // Helper to format time ago
+    function formatTimeAgo(date) {
+        const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
+        if (seconds < 60)
+            return `${seconds}s ago`;
+        const minutes = Math.floor(seconds / 60);
+        if (minutes < 60)
+            return `${minutes}m ago`;
+        const hours = Math.floor(minutes / 60);
+        if (hours < 24)
+            return `${hours}h ago`;
+        const days = Math.floor(hours / 24);
+        return `${days}d ago`;
     }
-});
-// Helper to format time ago
-function formatTimeAgo(date) {
-    const seconds = Math.floor((Date.now() - date.getTime()) / 1000);
-    if (seconds < 60)
-        return `${seconds}s ago`;
-    const minutes = Math.floor(seconds / 60);
-    if (minutes < 60)
-        return `${minutes}m ago`;
-    const hours = Math.floor(minutes / 60);
-    if (hours < 24)
-        return `${hours}h ago`;
-    const days = Math.floor(hours / 24);
-    return `${days}d ago`;
-}
-// View Local Screenshot - view a screenshot from .testdriver directory
-// Returns the image so AI clients that support images can see it
-// Also displays to the user via MCP App
-registerAppTool(server, "view_local_screenshot", {
-    title: "View Local Screenshot",
-    description: `View a screenshot from the .testdriver directory.
+    // View Local Screenshot - view a screenshot from .testdriver directory
+    // Returns the image so AI clients that support images can see it
+    // Also displays to the user via MCP App
+    registerAppTool(server, "view_local_screenshot", {
+        title: "View Local Screenshot",
+        description: `View a screenshot from the .testdriver directory.
 
 Use 'list_local_screenshots' first to see available screenshots, then use this tool to view one.
 
@@ -1356,75 +1382,75 @@ Useful for:
 - Reviewing screenshots from previous test runs
 - Debugging test failures by examining saved screenshots
 - Comparing current screen state to saved screenshots`,
-    inputSchema: z.object({
-        path: z.string().describe("Full path to the screenshot file (from list_local_screenshots)"),
-    }),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async (params) => {
-    const startTime = Date.now();
-    logger.info("view_local_screenshot: Starting", { path: params.path });
-    try {
-        // Validate the path exists and is a PNG
-        if (!fs.existsSync(params.path)) {
-            logger.warn("view_local_screenshot: File not found", { path: params.path });
-            return createToolResult(false, `Screenshot not found: ${params.path}`, { error: "File not found" });
-        }
-        if (!params.path.toLowerCase().endsWith(".png")) {
-            logger.warn("view_local_screenshot: Not a PNG file", { path: params.path });
-            return createToolResult(false, "Only PNG files are supported", { error: "Invalid file type" });
+        inputSchema: z.object({
+            path: z.string().describe("Full path to the screenshot file (from list_local_screenshots)"),
+        }),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async (params) => {
+        const startTime = Date.now();
+        logger.info("view_local_screenshot: Starting", { path: params.path });
+        try {
+            // Validate the path exists and is a PNG
+            if (!fs.existsSync(params.path)) {
+                logger.warn("view_local_screenshot: File not found", { path: params.path });
+                return createToolResult(false, `Screenshot not found: ${params.path}`, { error: "File not found" });
+            }
+            if (!params.path.toLowerCase().endsWith(".png")) {
+                logger.warn("view_local_screenshot: Not a PNG file", { path: params.path });
+                return createToolResult(false, "Only PNG files are supported", { error: "Invalid file type" });
+            }
+            // Security check - only allow files from .testdriver directory
+            const normalizedPath = path.resolve(params.path);
+            if (!normalizedPath.includes(".testdriver")) {
+                logger.warn("view_local_screenshot: Path not in .testdriver", { path: normalizedPath });
+                return createToolResult(false, "Can only view screenshots from .testdriver directory", { error: "Security: path not allowed" });
+            }
+            // Read the file
+            const imageBuffer = fs.readFileSync(params.path);
+            const imageBase64 = imageBuffer.toString("base64");
+            // Store image for MCP App UI display
+            const screenshotResourceUri = storeImage(imageBase64, "screenshot");
+            const stats = fs.statSync(params.path);
+            const sizeKB = Math.round(stats.size / 1024);
+            const fileName = path.basename(params.path);
+            const duration = Date.now() - startTime;
+            logger.info("view_local_screenshot: Completed", { path: params.path, sizeKB, duration });
+            // Return the image content for AI clients that support images
+            // The content array includes both text and image for maximum compatibility
+            const content = [
+                { type: "text", text: `Screenshot: ${fileName} (${sizeKB}KB)` },
+                {
+                    type: "image",
+                    data: imageBase64,
+                    mimeType: "image/png"
+                },
+            ];
+            return {
+                content,
+                structuredContent: {
+                    action: "view_local_screenshot",
+                    success: true,
+                    path: params.path,
+                    fileName,
+                    sizeBytes: stats.size,
+                    modified: stats.mtime.toISOString(),
+                    screenshotResourceUri,
+                    duration
+                },
+            };
         }
-        // Security check - only allow files from .testdriver directory
-        const normalizedPath = path.resolve(params.path);
-        if (!normalizedPath.includes(".testdriver")) {
-            logger.warn("view_local_screenshot: Path not in .testdriver", { path: normalizedPath });
-            return createToolResult(false, "Can only view screenshots from .testdriver directory", { error: "Security: path not allowed" });
+        catch (error) {
+            logger.error("view_local_screenshot: Failed", { error: String(error), path: params.path });
+            captureException(error, { tags: { tool: "view_local_screenshot" }, extra: { path: params.path } });
+            throw error;
         }
-        // Read the file
-        const imageBuffer = fs.readFileSync(params.path);
-        const imageBase64 = imageBuffer.toString("base64");
-        // Store image for MCP App UI display
-        const screenshotResourceUri = storeImage(imageBase64, "screenshot");
-        const stats = fs.statSync(params.path);
-        const sizeKB = Math.round(stats.size / 1024);
-        const fileName = path.basename(params.path);
-        const duration = Date.now() - startTime;
-        logger.info("view_local_screenshot: Completed", { path: params.path, sizeKB, duration });
-        // Return the image content for AI clients that support images
-        // The content array includes both text and image for maximum compatibility
-        const content = [
-            { type: "text", text: `Screenshot: ${fileName} (${sizeKB}KB)` },
-            {
-                type: "image",
-                data: imageBase64,
-                mimeType: "image/png"
-            },
-        ];
-        return {
-            content,
-            structuredContent: {
-                action: "view_local_screenshot",
-                success: true,
-                path: params.path,
-                fileName,
-                sizeBytes: stats.size,
-                modified: stats.mtime.toISOString(),
-                screenshotResourceUri,
-                duration
-            },
-        };
-    }
-    catch (error) {
-        logger.error("view_local_screenshot: Failed", { error: String(error), path: params.path });
-        captureException(error, { tags: { tool: "view_local_screenshot" }, extra: { path: params.path } });
-        throw error;
-    }
-});
-// Screenshot - captures full screen to show user the current state
-// NOTE: This is for SHOWING the user the screen, not for AI understanding.
-// Use 'check' tool for AI to understand screen state.
-registerAppTool(server, "screenshot", {
-    title: "Screenshot",
-    description: `Display a screenshot to the user. This tool does NOT return the image to you (the AI).
+    });
+    // Screenshot - captures full screen to show user the current state
+    // NOTE: This is for SHOWING the user the screen, not for AI understanding.
+    // Use 'check' tool for AI to understand screen state.
+    registerAppTool(server, "screenshot", {
+        title: "Screenshot",
+        description: `Display a screenshot to the user. This tool does NOT return the image to you (the AI).
 
 ⚠️ IMPORTANT: Do NOT use this tool to understand the screen state. The screenshot is ONLY displayed to the human user - you will NOT receive the image or any analysis.
 
@@ -1434,37 +1460,37 @@ If you need to:
 - Understand the current state → use 'check' instead
 
 Only use 'screenshot' when you explicitly want to show something to the human user without needing to see it yourself.`,
-    inputSchema: z.object({}),
-    _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
-}, async () => {
-    const startTime = Date.now();
-    logger.info("screenshot: Starting");
-    try {
-        const result = await core.screenshot();
-        // Store the captured image as a resource URI (kept OUT of AI context — the
-        // MCP app fetches it via resources/read). Preserve the original user-facing
-        // text rather than the core's neutral text.
-        const data = { action: "screenshot" };
-        for (const img of result.images ?? []) {
-            data.screenshotResourceUri = storeImage(img.base64, "screenshot");
+        inputSchema: z.object({}),
+        _meta: { ui: { resourceUri: RESOURCE_URI, expanded: true } },
+    }, async () => {
+        const startTime = Date.now();
+        logger.info("screenshot: Starting");
+        try {
+            const result = await core.screenshot();
+            // Store the captured image as a resource URI (kept OUT of AI context — the
+            // MCP app fetches it via resources/read). Preserve the original user-facing
+            // text rather than the core's neutral text.
+            const data = { action: "screenshot" };
+            for (const img of result.images ?? []) {
+                data.screenshotResourceUri = storeImage(img.base64, "screenshot");
+            }
+            const duration = Date.now() - startTime;
+            data.duration = duration;
+            logger.info("screenshot: Completed", { duration, hasImage: (result.images?.length ?? 0) > 0 });
+            return createToolResult(true, "Screenshot captured and displayed to user", data);
         }
-        const duration = Date.now() - startTime;
-        data.duration = duration;
-        logger.info("screenshot: Completed", { duration, hasImage: (result.images?.length ?? 0) > 0 });
-        return createToolResult(true, "Screenshot captured and displayed to user", data);
-    }
-    catch (error) {
-        if (error instanceof NoActiveSessionError) {
-            logger.warn("screenshot: No active session");
-            return noSessionResult(error);
+        catch (error) {
+            if (error instanceof NoActiveSessionError) {
+                logger.warn("screenshot: No active session");
+                return noSessionResult(error);
+            }
+            logger.error("screenshot: Failed", { error: String(error) });
+            return createToolResult(false, `Screenshot failed: ${error}`, { error: String(error) });
         }
-        logger.error("screenshot: Failed", { error: String(error) });
-        return createToolResult(false, `Screenshot failed: ${error}`, { error: String(error) });
-    }
-});
-// Init - Initialize a new TestDriver project
-server.registerTool("init", {
-    description: `Initialize a new TestDriver project with Vitest SDK examples.
+    });
+    // Init - Initialize a new TestDriver project
+    server.registerTool("init", {
+        description: `Initialize a new TestDriver project with Vitest SDK examples.
 
 This creates:
 - package.json with proper dependencies
@@ -1479,30 +1505,30 @@ This creates:
 - .env file with API key (if provided)
 
 API Key: The apiKey parameter is optional. If not provided, you'll need to manually add TD_API_KEY to the .env file after initialization. The project structure will still be created successfully.`,
-    inputSchema: z.object({
-        directory: z.string().optional().describe("Target directory (defaults to current working directory)"),
-        apiKey: z.string().optional().describe("TestDriver API key (will be saved to .env)"),
-        skipInstall: z.boolean().default(false).describe("Skip npm install step"),
-        skipSampleTest: z.boolean().default(false).describe("Skip scaffolding the example test files (tests/example.test.js + tests/login.js). Useful when an agent writes its own tests."),
-    }),
-}, async (params) => {
-    const startTime = Date.now();
-    const targetDir = params.directory ? path.resolve(params.directory) : process.cwd();
-    logger.info("init: Starting", { targetDir, hasApiKey: !!params.apiKey, skipInstall: params.skipInstall });
-    try {
-        // Import the shared init logic (dynamic import for ESM/CJS compatibility)
-        const initProjectPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "lib", "init-project.js");
-        const { initProject } = await import(pathToFileURL(initProjectPath).href);
-        // Run the shared init logic
-        const result = await initProject({
-            targetDir,
-            apiKey: params.apiKey,
-            skipInstall: params.skipInstall,
-            skipSampleTest: params.skipSampleTest,
-        });
-        const duration = Date.now() - startTime;
-        logger.info("init: Completed", { targetDir, duration, success: result.success });
-        const nextSteps = `
+        inputSchema: z.object({
+            directory: z.string().optional().describe("Target directory (defaults to current working directory)"),
+            apiKey: z.string().optional().describe("TestDriver API key (will be saved to .env)"),
+            skipInstall: z.boolean().default(false).describe("Skip npm install step"),
+            skipSampleTest: z.boolean().default(false).describe("Skip scaffolding the example test files (tests/example.test.js + tests/login.js). Useful when an agent writes its own tests."),
+        }),
+    }, async (params) => {
+        const startTime = Date.now();
+        const targetDir = params.directory ? path.resolve(params.directory) : process.cwd();
+        logger.info("init: Starting", { targetDir, hasApiKey: !!params.apiKey, skipInstall: params.skipInstall });
+        try {
+            // Import the shared init logic (dynamic import for ESM/CJS compatibility)
+            const initProjectPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "lib", "init-project.js");
+            const { initProject } = await import(pathToFileURL(initProjectPath).href);
+            // Run the shared init logic
+            const result = await initProject({
+                targetDir,
+                apiKey: params.apiKey,
+                skipInstall: params.skipInstall,
+                skipSampleTest: params.skipSampleTest,
+            });
+            const duration = Date.now() - startTime;
+            logger.info("init: Completed", { targetDir, duration, success: result.success });
+            const nextSteps = `
 
 📚 Next steps:
 
@@ -1520,36 +1546,61 @@ API Key: The apiKey parameter is optional. If not provided, you'll need to manua
 
 Learn more at https://docs.testdriver.ai/v7/getting-started/
 `;
-        const allMessages = [...result.results, ...result.errors.map((e) => `⚠️ ${e}`)];
-        return createToolResult(result.success, result.success
-            ? `✅ TestDriver project initialized successfully!\n\n${allMessages.join("\n")}${nextSteps}`
-            : `⚠️ TestDriver project initialization completed with errors:\n\n${allMessages.join("\n")}`, {
-            action: "init",
-            targetDir,
-            filesCreated: result.results.length,
-            hasApiKey: !!params.apiKey,
-            errors: result.errors,
-            duration
+            const allMessages = [...result.results, ...result.errors.map((e) => `⚠️ ${e}`)];
+            return createToolResult(result.success, result.success
+                ? `✅ TestDriver project initialized successfully!\n\n${allMessages.join("\n")}${nextSteps}`
+                : `⚠️ TestDriver project initialization completed with errors:\n\n${allMessages.join("\n")}`, {
+                action: "init",
+                targetDir,
+                filesCreated: result.results.length,
+                hasApiKey: !!params.apiKey,
+                errors: result.errors,
+                duration
+            });
+        }
+        catch (error) {
+            logger.error("init: Failed", { error: String(error), targetDir });
+            captureException(error, { tags: { tool: "init" }, extra: { targetDir } });
+            throw error;
+        }
+    });
+    return server;
+}
+/** Read and JSON-parse a request body. Returns undefined for an empty/invalid
+ *  body (GET/DELETE carry none) so callers can treat "no body" uniformly. */
+function readJsonBody(req) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => {
+            if (chunks.length === 0)
+                return resolve(undefined);
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
+            }
+            catch {
+                resolve(undefined);
+            }
         });
-    }
-    catch (error) {
-        logger.error("init: Failed", { error: String(error), targetDir });
-        captureException(error, { tags: { tool: "init" }, extra: { targetDir } });
-        throw error;
-    }
-});
-// =============================================================================
-// HTTP transport (Streamable HTTP, no auth)
-// =============================================================================
+        req.on("error", () => resolve(undefined));
+    });
+}
 /**
  * Serve the MCP server over Streamable HTTP with no authentication.
  *
  * This is what the eve agent (and any other Streamable-HTTP MCP client) connects
- * to. The server holds single-session global state (the active `sdk`, element
- * refs, image store), so we mirror that with a single long-lived MCP transport:
- * the first `initialize` request mints a session id and every subsequent request
- * reuses the same `server` + transport. Concurrent sessions are intentionally not
- * supported — this server provisions one sandbox at a time.
+ * to. Each MCP session gets its OWN transport + server + isolated action context,
+ * keyed by the `mcp-session-id` header:
+ *
+ *  - An `initialize` request (no session id yet) mints a fresh connection: a new
+ *    isolated {@link core.CoreContext}, a server built over it, and a transport
+ *    whose generated session id we store. Every later request carrying that id
+ *    routes back to the same connection and runs inside its context via
+ *    {@link core.runInContext} — so one client's tool call can only ever touch
+ *    its own sandbox / element refs / image store. This is the fix for the
+ *    cross-session bleed: state is per-connection, not process-global.
+ *  - `DELETE` (or transport close) tears the connection down and drops it from
+ *    the map, so a disconnecting client frees its slot and its context is GC'd.
  *
  * No auth is applied here by design (the connection is expected to be local-only
  * or otherwise protected outside the MCP layer). Do not expose this on a public
@@ -1559,29 +1610,80 @@ async function startHttpServer() {
     const host = process.env.TD_MCP_HOST || "127.0.0.1";
     const port = Number(process.env.TD_MCP_PORT || process.env.PORT || 8788);
     const mcpPath = process.env.TD_MCP_PATH || "/mcp";
-    // One transport for the lifetime of the process (single-session design).
-    const transport = new StreamableHTTPServerTransport({
-        sessionIdGenerator: () => randomUUID(),
-    });
-    await server.connect(transport);
+    // Live connections keyed by MCP session id. One entry per connected client.
+    const connections = new Map();
     const httpServer = http.createServer((req, res) => {
-        const url = new URL(req.url || "/", `http://${req.headers.host}`);
-        // Lightweight health check for readiness probes / `eve dev`.
-        if (req.method === "GET" && url.pathname === "/health") {
-            res.writeHead(200, { "content-type": "application/json" });
-            res.end(JSON.stringify({ status: "ok", server: "testdriver", version }));
-            return;
-        }
-        if (url.pathname !== mcpPath) {
-            res.writeHead(404, { "content-type": "application/json" });
-            res.end(JSON.stringify({ error: "Not found", hint: `MCP endpoint is ${mcpPath}` }));
-            return;
-        }
-        // The Streamable HTTP transport handles POST (requests), GET (SSE stream),
-        // and DELETE (session teardown) on the same path. Body parsing is left to
-        // the transport so it can read the raw stream.
-        transport.handleRequest(req, res).catch((error) => {
-            logger.error("http: handleRequest failed", { error: String(error) });
+        void (async () => {
+            const url = new URL(req.url || "/", `http://${req.headers.host}`);
+            // Lightweight health check for readiness probes / `eve dev`.
+            if (req.method === "GET" && url.pathname === "/health") {
+                res.writeHead(200, { "content-type": "application/json" });
+                res.end(JSON.stringify({ status: "ok", server: "testdriver", version, sessions: connections.size }));
+                return;
+            }
+            if (url.pathname !== mcpPath) {
+                res.writeHead(404, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: "Not found", hint: `MCP endpoint is ${mcpPath}` }));
+                return;
+            }
+            const sessionId = req.headers["mcp-session-id"];
+            const sid = Array.isArray(sessionId) ? sessionId[0] : sessionId;
+            // POST bodies must be parsed here (to detect `initialize` and to hand the
+            // transport a pre-parsed body). GET (SSE) and DELETE carry no JSON body.
+            const body = req.method === "POST" ? await readJsonBody(req) : undefined;
+            let connection = sid ? connections.get(sid) : undefined;
+            // A brand-new session: only an `initialize` request may create one.
+            if (!connection) {
+                if (sid) {
+                    // Client presented a session id we don't know — it was torn down or is
+                    // stale. 404 so the client re-initializes (matches SDK stateful mode).
+                    res.writeHead(404, { "content-type": "application/json" });
+                    res.end(JSON.stringify({ error: "Unknown or expired MCP session", sessionId: sid }));
+                    return;
+                }
+                if (!isInitializeRequest(body)) {
+                    res.writeHead(400, { "content-type": "application/json" });
+                    res.end(JSON.stringify({ error: "Bad Request: no MCP session id and not an initialize request" }));
+                    return;
+                }
+                // Mint an isolated context + a server bound to it + a transport.
+                const ctx = core.createIsolatedContext();
+                const mcpServer = buildServer();
+                const transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    onsessioninitialized: (newId) => {
+                        connections.set(newId, { transport, server: mcpServer, ctx });
+                        logger.info("http: MCP session initialized", { sessionId: newId, activeSessions: connections.size });
+                    },
+                });
+                // When the transport closes (client DELETE, network drop, or shutdown),
+                // drop the connection and best-effort tear down its sandbox so a
+                // disconnecting client doesn't leak a live VM.
+                transport.onclose = () => {
+                    const closedId = transport.sessionId;
+                    if (closedId && connections.delete(closedId)) {
+                        logger.info("http: MCP session closed", { sessionId: closedId, activeSessions: connections.size });
+                    }
+                    // Disconnect the SDK inside this connection's context (best-effort).
+                    core.runInContext(ctx, () => { void core.disconnect(); });
+                };
+                await mcpServer.connect(transport);
+                connection = { transport, server: mcpServer, ctx };
+            }
+            // Route the request through THIS connection's transport, inside THIS
+            // connection's action context so every core.* call the handlers make
+            // resolves the right sandbox / refs / image store.
+            const conn = connection;
+            await core.runInContext(conn.ctx, () => conn.transport.handleRequest(req, res, body)).catch((error) => {
+                logger.error("http: handleRequest failed", { error: String(error) });
+                captureException(error, { tags: { phase: "http" } });
+                if (!res.headersSent) {
+                    res.writeHead(500, { "content-type": "application/json" });
+                    res.end(JSON.stringify({ error: "Internal server error" }));
+                }
+            });
+        })().catch((error) => {
+            logger.error("http: request handling failed", { error: String(error) });
             captureException(error, { tags: { phase: "http" } });
             if (!res.headersSent) {
                 res.writeHead(500, { "content-type": "application/json" });
@@ -1594,9 +1696,12 @@ async function startHttpServer() {
         url: `http://${host}:${port}${mcpPath}`,
     });
     const shutdown = async () => {
-        logger.info("Shutting down MCP Server");
+        logger.info("Shutting down MCP Server", { activeSessions: connections.size });
         httpServer.close();
-        await transport.close().catch(() => { });
+        for (const conn of connections.values()) {
+            await conn.transport.close().catch(() => { });
+        }
+        connections.clear();
         await flushSentry();
         process.exit(0);
     };
@@ -1619,6 +1724,10 @@ async function main() {
         await startHttpServer();
         return;
     }
+    // stdio: one long-lived server for the process. It runs over the global
+    // action context (no runInContext wrap), so behavior is unchanged — a single
+    // local CLI client, one sandbox at a time, exactly as before.
+    const server = buildServer();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     logger.info("TestDriver MCP Server running on stdio");