@shawnowen/comet-mcp 2.3.0 → 2.4.1

package/dist/index.js

@@ -1,20 +1,252 @@
 #!/usr/bin/env node
 // Comet Browser MCP Server
 // Claude Code ↔ Perplexity Comet bidirectional interaction
-// 14 tools: 9 browsing + 1 tab groups + 4 lifecycle
+// 25 tools: 9 browsing + 2 direct interaction + 1 tab groups + 4 lifecycle + 2 orchestration + 5 parity + 2 safe observe (observe + peek)
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { cometClient } from "./cdp-client.js";
-import { cometAI } from "./comet-ai.js";
-// @ts-ignore — .mjs adapter for lifecycle event parity (Spec 078 AC-2)
-import { emitLifecycleEvent, createMCPLifecycleEnvelope } from "../../scripts/lifecycle-mcp-adapter.mjs";
-import { appendFileSync, readFileSync } from "fs";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import { cometClient as globalCometClient } from "./cdp-client.js";
+import { CometAI, cometAI as globalCometAI } from "./comet-ai.js";
+import { sessionRegistry } from "./session-registry.js";
+import { drainMcpAlertQueue, formatAlertsForResponse, dispatchAlert } from "./alert-dispatcher.js";
+import { loadBridgeConfig } from "./bridge-config.js";
+import { BoundSessionError, resolveBoundSession } from "./bound-session.js";
+import { sidecarArtifactStore } from "./sidecar-artifacts.js";
+import { windowBindingStore } from "./window-bindings.js";
+import { createOrReuseDelegateBinding } from "./delegate-binding.js";
+/**
+ * Resolve the current session's CDP client and CometAI, or fall back to globals.
+ * This ensures each agent uses its own isolated tab connection.
+ * Also runs a health check and reconnects if the WebSocket is dead.
+ */
+async function getSessionClients() {
+    const session = sessionRegistry.getCurrent();
+    const client = session?.cdpClient ?? globalCometClient;
+    const ai = session?.cometAI ?? globalCometAI;
+    // Proactive health check — catches dead WebSockets before tool calls fail
+    if (client.isConnected) {
+        await client.ensureHealthyConnection();
+    }
+    return { client, ai };
+}
+async function disconnectCdpClientsAfterTool() {
+    const clients = new Set();
+    const session = sessionRegistry.getCurrent();
+    if (session?.cdpClient)
+        clients.add(session.cdpClient);
+    clients.add(globalCometClient);
+    for (const client of clients) {
+        if (!client.isConnected)
+            continue;
+        try {
+            await client.disconnect();
+        }
+        catch (err) {
+            console.warn(`[comet-bridge] CDP post-tool disconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+// Protocol enforcement (Spec 016, FR-006, T009-T012)
+// Tool safety classification (Spec 034 — MCP Tool Parity, session safety)
+// SAFE_OBSERVE: No session required, read-only, zero side effects
+// BROWSING: Requires active session (comet_connect first), may modify browser state
+// LIFECYCLE/ORCHESTRATION: No session required, infrastructure-level
+const SAFE_OBSERVE_TOOLS = new Set([
+    "comet_observe", // Read-only: /json/list + extension bridge + agent-registry
+]);
+const BROWSING_TOOLS = new Set([
+    "comet_ask",
+    "comet_poll",
+    "comet_stop",
+    "comet_screenshot",
+    "comet_mode",
+    "comet_shortcut",
+    "comet_read_page",
+    "comet_wait_for_idle",
+    "comet_interact",
+    "comet_navigate",
+    "comet_pdf",
+    "comet_scrape",
+    "comet_network",
+    "comet_automate",
+    "comet_domain",
+]);
+const BOUND_ROUTING_TOOLS = new Set([
+    "comet_ask",
+    "comet_poll",
+    "comet_stop",
+    "comet_screenshot",
+    "comet_mode",
+    "comet_shortcut",
+    "comet_read_page",
+    "comet_wait_for_idle",
+    "comet_interact",
+    "comet_navigate",
+    "comet_task_status",
+    "comet_peek",
+    "comet_pdf",
+    "comet_scrape",
+    "comet_network",
+    "comet_automate",
+    "comet_domain",
+]);
+// Tools with DESTRUCTIVE side effects — these are flagged in documentation
+// as "use with caution" because they modify browser state beyond the calling agent's scope
+const DESTRUCTIVE_ACTIONS = new Set([
+    "comet_stop", // Terminates running agent tasks
+    "comet_navigate", // Changes the active tab's URL
+]);
+const tabGroupWarnedSessions = new Set();
+function requireSession(toolName, args) {
+    const config = loadBridgeConfig();
+    if (!config.protocolEnforcement.requireConnectBeforeBrowse)
+        return null;
+    // Safe observe tools never require session
+    if (SAFE_OBSERVE_TOOLS.has(toolName))
+        return null;
+    // comet_tab_groups with action="list" or "list_tabs" is read-only — no session needed
+    if (toolName === "comet_tab_groups") {
+        const action = args?.action;
+        if (action === "list" || action === "list_tabs" || action === "list_archived") {
+            return null; // Read-only tab group queries bypass session requirement
+        }
+    }
+    if (!BROWSING_TOOLS.has(toolName))
+        return null;
+    const session = sessionRegistry.getCurrent();
+    if (!session) {
+        dispatchAlert({
+            type: "PROTOCOL_VIOLATION",
+            message: `Tool "${toolName}" called without active session. Call comet_connect first.`,
+            context: { toolName },
+        });
+        // Suggest safe alternatives
+        const safeAlternative = toolName === "comet_screenshot" || toolName === "comet_read_page"
+            ? `\n\nSafe alternative: Use comet_peek(targetId) to read/screenshot any tab without a session.\nOr use comet_observe(action='snapshot') to see all tabs and groups.`
+            : toolName === "comet_tab_groups"
+                ? `\n\nSafe alternative: comet_tab_groups(action='list') works without a session for read-only queries.`
+                : "";
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Protocol error: No active connection. Call comet_connect first.\n\nRequired sequence:\n1. comet_connect (establish CDP session with agent identity)\n2. ${toolName} (your requested tool)\n\nSuggested action: Call comet_connect with agentId and taskThreadId parameters.${safeAlternative}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+    return null;
+}
+async function requireBoundRouting(toolName, args) {
+    if (!BOUND_ROUTING_TOOLS.has(toolName))
+        return null;
+    try {
+        const resolved = await resolveBoundSession(sessionRegistry.getCurrent(), args);
+        const session = sessionRegistry.getCurrent();
+        if (resolved.binding.targetId && session) {
+            await session?.cdpClient.connect(resolved.binding.targetId);
+        }
+        return null;
+    }
+    catch (err) {
+        if (err instanceof BoundSessionError) {
+            dispatchAlert({
+                type: "PROTOCOL_VIOLATION",
+                message: err.message,
+                context: { toolName, code: err.code, repairAction: err.repairAction },
+            });
+            return {
+                content: [{ type: "text", text: err.toMcpText(toolName) }],
+                isError: true,
+            };
+        }
+        throw err;
+    }
+}
+function getTabGroupWarning(toolName) {
+    const config = loadBridgeConfig();
+    if (!config.protocolEnforcement.warnMissingTabGroup)
+        return "";
+    const session = sessionRegistry.getCurrent();
+    if (!session || session.tabGroupId !== null)
+        return "";
+    if (tabGroupWarnedSessions.has(session.sessionKey))
+        return "";
+    tabGroupWarnedSessions.add(session.sessionKey);
+    return `\n\n⚠️ Warning: No tab group assigned for this session. For multi-agent safety, create a tab group with comet_tab_groups(action='create', title='${session.taskThreadId}').`;
+}
+function assertAgentRuntimeProfileArg(profile) {
+    if (profile === undefined ||
+        profile === null ||
+        profile === "" ||
+        profile === "agent" ||
+        profile === "oe") {
+        return profile === "agent" ? "oe" : profile;
+    }
+    throw new Error(`PROFILE_OWNERSHIP_VIOLATION: profile ${String(profile)} is not an agent-owned Comet runtime profile`);
+}
+// Safe CSS selector escaping — prevents injection via user-supplied selectors (Spec 034 review)
+function safeSelector(sel) {
+    return JSON.stringify(sel);
+}
+// Validate variable name is a safe JS identifier (Spec 034 review — prevents variable name injection)
+function isValidIdentifier(name) {
+    return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+// prettier-ignore
+// @ts-ignore — .mjs adapter for lifecycle event parity (Spec 078 AC-2).
+// Vendored from ../../scripts/ into ./vendor/ by the prebuild step so the
+// published npm package is self-contained (see package.json "prebuild").
+import { emitLifecycleEvent, createMCPLifecycleEnvelope } from "../vendor/lifecycle-mcp-adapter.mjs";
+import { appendFileSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
-import { join } from "path";
-const execFileAsync = promisify(execFile);
+import { join, dirname } from "path";
+// Duplicate process detection (Spec 016, FR-010, T005)
+const PID_FILE_PATH = join(homedir(), ".claude", "comet-browser", "comet-mcp.pid");
+function checkDuplicateProcess() {
+    try {
+        const existingPid = readFileSync(PID_FILE_PATH, "utf-8").trim();
+        if (existingPid) {
+            const existingPidNumber = parseInt(existingPid, 10);
+            if (existingPidNumber === process.pid)
+                return;
+            // Check if the process is still alive
+            let processAlive = false;
+            try {
+                process.kill(existingPidNumber, 0); // signal 0 = existence check
+                processAlive = true;
+            }
+            catch {
+                // Process is dead — stale PID file, safe to overwrite
+            }
+            if (processAlive) {
+                // Process is alive — fail closed so multiple controllers cannot compete.
+                dispatchAlert({
+                    type: "DUPLICATE_PROCESS",
+                    message: `Another comet-mcp process is running (PID ${existingPidNumber}). Current PID: ${process.pid}. Refusing to start a competing controller.`,
+                    context: { existingPid: existingPidNumber, currentPid: process.pid },
+                });
+                throw new Error(`DUPLICATE_PROCESS: comet-mcp PID ${existingPidNumber} already owns ${PID_FILE_PATH}; refusing to start PID ${process.pid}`);
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.startsWith("DUPLICATE_PROCESS:")) {
+            throw err;
+        }
+        // No PID file exists — first run
+    }
+    // Write our PID
+    try {
+        mkdirSync(dirname(PID_FILE_PATH), { recursive: true });
+        writeFileSync(PID_FILE_PATH, String(process.pid));
+    }
+    catch {
+        // Best effort
+    }
+}
+checkDuplicateProcess();
 // JSONL outbox for lifecycle events → orchestration layer
 const OUTBOX_PATH = join(homedir(), "equabot", "agent-chat", "outbox-comet.jsonl");
 const INBOX_PATH = join(homedir(), "equabot", "agent-chat", "inbox-comet.jsonl");
@@ -23,31 +255,138 @@ function appendJsonl(path, obj) {
     try {
         appendFileSync(path, JSON.stringify(obj) + "\n");
     }
-    catch { /* graceful degradation — file may not exist */ }
+    catch (err) {
+        console.warn(`[comet-bridge] JSONL write failed to ${path}: ${err instanceof Error ? err.message : err}`);
+    }
 }
 function readJsonSafe(path) {
     try {
         return JSON.parse(readFileSync(path, "utf-8"));
     }
-    catch {
+    catch (err) {
+        if (err?.code !== "ENOENT") {
+            console.warn(`[comet-bridge] JSON read/parse failed for ${path}: ${err instanceof Error ? err.message : err}`);
+        }
+        return null;
+    }
+}
+async function attachRunIdToCurrentBinding(runId, bindingIdArg) {
+    if (!runId)
         return null;
+    const session = sessionRegistry.getCurrent();
+    const bindingId = bindingIdArg ?? session?.codexBinding?.bindingId;
+    if (!bindingId)
+        return null;
+    const binding = await windowBindingStore.addRunId(bindingId, runId);
+    if (session?.codexBinding?.bindingId === binding.bindingId) {
+        session.codexBinding = binding;
     }
+    return binding;
+}
+async function transitionBindingByRunId(runId, status) {
+    if (!runId)
+        return null;
+    return windowBindingStore.transitionByRunId(runId, status);
 }
 const TOOLS = [
     {
         name: "comet_connect",
-        description: "Connect to Comet browser (auto-starts if needed)",
-        inputSchema: { type: "object", properties: {} },
+        description: "Connect to Comet browser (auto-starts if needed). Creates a NEW tab and tab group " +
+            "for this agent session — never closes existing tabs or interferes with other agents. " +
+            "Always positions browser at full-screen bounds on the top display (agents workspace) while keeping browser tabs visible.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                taskGoal: {
+                    type: "string",
+                    description: "REQUIRED. Describe the purpose of this browser session. Used to name the session and initialize the orchestrator thread.",
+                },
+                agentId: {
+                    type: "string",
+                    description: "Agent identity for tracking (e.g. 'claude-code-main'). Used in tab group name.",
+                },
+                taskThreadId: {
+                    type: "string",
+                    description: "Task thread identifier. Tab group is named after this.",
+                },
+                codexSessionId: {
+                    type: "string",
+                    description: "Codex runtime/session identifier for durable Comet window binding.",
+                },
+                projectThreadId: {
+                    type: "string",
+                    description: "Codex project-thread identifier that owns one active Comet window binding.",
+                },
+                projectThreadFamily: {
+                    type: "string",
+                    description: "Optional worktree/project-thread family for worktree orchestrator scope.",
+                },
+                worktreePath: {
+                    type: "string",
+                    description: "Absolute Codex worktree path used for binding ownership and scope checks.",
+                },
+                repoSlug: {
+                    type: "string",
+                    description: "Repository slug for the Codex session, for example EQUAStart/equa-comet-browser-control.",
+                },
+                branchName: {
+                    type: "string",
+                    description: "Git branch name for the Codex session.",
+                },
+                codexSessionRole: {
+                    type: "string",
+                    enum: ["session_agent", "worktree_orchestrator", "fleet_orchestrator"],
+                    description: "Binding authorization role for this Codex session.",
+                },
+                codexSessionKey: {
+                    type: "string",
+                    description: "Optional explicit Codex binding session key. Defaults to codexSessionId:projectThreadId.",
+                },
+                strictCodexIdentity: {
+                    type: "boolean",
+                    description: "Fail closed when required Codex identity fields cannot be supplied or derived.",
+                },
+                profile: {
+                    type: "string",
+                    enum: ["agent", "oe"],
+                    description: "Agent-owned Comet runtime browser profile. Human-owned profiles such as moon are never valid mutation targets.",
+                },
+                tabGroupColor: {
+                    type: "string",
+                    enum: ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"],
+                    description: "Color for the new tab group (default: blue)",
+                },
+                url: {
+                    type: "string",
+                    description: "Initial URL to open (default: https://www.perplexity.ai/)",
+                },
+            },
+            required: ["taskGoal"],
+        },
     },
     {
         name: "comet_ask",
-        description: "Send a prompt to Comet/Perplexity and wait for the complete response (blocking). Ideal for tasks requiring real browser interaction (login walls, dynamic content, filling forms) or deep research with agentic browsing.",
+        description: "Send a prompt to Comet/Perplexity and wait for the complete response (blocking). Ideal for tasks requiring real browser interaction (login walls, dynamic content, filling forms) or deep research with agentic browsing. " +
+            "Use sidecar: true to keep the current page visible and ask via the Perplexity Assistant sidebar — best for interacting with the active tab (clicking, form filling, reading page content).",
         inputSchema: {
             type: "object",
             properties: {
-                prompt: { type: "string", description: "Question or task for Comet - focus on goals and context" },
+                prompt: {
+                    type: "string",
+                    description: "Question or task for Comet - focus on goals and context",
+                },
                 newChat: { type: "boolean", description: "Start a fresh conversation (default: false)" },
                 timeout: { type: "number", description: "Max wait time in ms (default: 15000 = 15s)" },
+                sidecar: {
+                    type: "boolean",
+                    description: "Use the Perplexity Assistant sidecar instead of navigating to perplexity.ai. " +
+                        "Uses an already-open assistant sidebar without activating Comet or sending OS keyboard shortcuts. " +
+                        "Best for tasks that interact with the active tab: clicking buttons, filling forms, reading page content. (default: false)",
+                },
+                sidecarResultId: {
+                    type: "string",
+                    description: "Optional existing sidecar result artifact ID to refresh or correlate.",
+                },
             },
             required: ["prompt"],
         },
@@ -55,7 +394,19 @@ const TOOLS = [
     {
         name: "comet_poll",
         description: "Check agent status and progress. Call repeatedly to monitor agentic tasks.",
-        inputSchema: { type: "object", properties: {} },
+        inputSchema: {
+            type: "object",
+            properties: {
+                sidecarResultId: {
+                    type: "string",
+                    description: "Return a persisted sidecar result artifact by ID.",
+                },
+                sidecarContextKey: {
+                    type: "string",
+                    description: "Return the latest persisted sidecar result for this binding context.",
+                },
+            },
+        },
     },
     {
         name: "comet_stop",
@@ -93,7 +444,19 @@ const TOOLS = [
             properties: {
                 action: {
                     type: "string",
-                    enum: ["list", "list_tabs", "create", "update", "move", "ungroup", "delete", "save_group", "restore_group", "archive_group", "list_archived"],
+                    enum: [
+                        "list",
+                        "list_tabs",
+                        "create",
+                        "update",
+                        "move",
+                        "ungroup",
+                        "delete",
+                        "save_group",
+                        "restore_group",
+                        "archive_group",
+                        "list_archived",
+                    ],
                     description: "The tab group operation to perform",
                 },
                 tabIds: {
@@ -136,16 +499,16 @@ const TOOLS = [
     },
     {
         name: "comet_shortcut",
-        description: "Trigger a Comet Query Shortcut (e.g. /fact-check, /mailtodo). "
-            + "These are reusable AI prompts with pre-configured modes and sources. "
-            + "Type '/' to discover available shortcuts.",
+        description: "Trigger a Comet Query Shortcut (e.g. /fact-check, /mailtodo). " +
+            "These are reusable AI prompts with pre-configured modes and sources. " +
+            "Type '/' to discover available shortcuts.",
         inputSchema: {
             type: "object",
             properties: {
                 shortcut: {
                     type: "string",
-                    description: "Shortcut name (e.g. 'fact-check', 'mailtodo', 'prep-next-meeting'). "
-                        + "Omit the leading slash — it will be added automatically.",
+                    description: "Shortcut name (e.g. 'fact-check', 'mailtodo', 'prep-next-meeting'). " +
+                        "Omit the leading slash — it will be added automatically.",
                 },
                 context: {
                     type: "string",
@@ -161,17 +524,17 @@ const TOOLS = [
     },
     {
         name: "comet_read_page",
-        description: "Extract content from the current page. Returns structured accessibility tree "
-            + "and/or clean text. Use 'tree' mode for interactive elements (buttons, links, forms), "
-            + "'text' mode for readable content, or 'both' for full extraction.",
+        description: "Extract content from the current page. Returns structured accessibility tree " +
+            "and/or clean text. Use 'tree' mode for interactive elements (buttons, links, forms), " +
+            "'text' mode for readable content, or 'both' for full extraction.",
         inputSchema: {
             type: "object",
             properties: {
                 mode: {
                     type: "string",
                     enum: ["tree", "text", "both"],
-                    description: "Extraction mode: 'tree' = accessibility tree (roles, names, values), "
-                        + "'text' = clean markdown-like text, 'both' = both formats. Default: 'text'.",
+                    description: "Extraction mode: 'tree' = accessibility tree (roles, names, values), " +
+                        "'text' = clean markdown-like text, 'both' = both formats. Default: 'text'.",
                 },
                 maxDepth: {
                     type: "number",
@@ -184,11 +547,105 @@ const TOOLS = [
             },
         },
     },
+    {
+        name: "comet_interact",
+        description: "Directly interact with the current page — click, type, check/uncheck, select, scroll, extract text, or run JavaScript. " +
+            "NO Perplexity AI involved. Executes actions via CDP on the active tab. " +
+            "Use comet_read_page first to find selectors, then comet_interact to act on them. " +
+            "Supports multiple sequential actions in one call.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                actions: {
+                    type: "array",
+                    description: "Ordered list of actions to execute sequentially on the current page.",
+                    items: {
+                        type: "object",
+                        properties: {
+                            action: {
+                                type: "string",
+                                enum: [
+                                    "click",
+                                    "type",
+                                    "fill",
+                                    "press",
+                                    "check",
+                                    "uncheck",
+                                    "select",
+                                    "scroll",
+                                    "wait",
+                                    "extract",
+                                    "evaluate",
+                                ],
+                                description: "click: click element | type: keystroke-by-keystroke | fill: clear + set value | " +
+                                    "press: keyboard key (Enter, Tab, Escape, etc.) | check/uncheck: checkbox toggle | " +
+                                    "select: dropdown option | scroll: scroll page | wait: pause (ms) or wait for selector | " +
+                                    "extract: get element text | evaluate: run arbitrary JS",
+                            },
+                            selector: {
+                                type: "string",
+                                description: "CSS selector for the target element. Supports standard CSS (e.g. '#id', '.class', " +
+                                    "'button[aria-label=\"Submit\"]', 'tr:nth-child(3) td.amount'). " +
+                                    "Use comet_read_page mode='tree' to discover selectors.",
+                            },
+                            value: {
+                                type: "string",
+                                description: "Value for type/fill/select actions. For select, use the option value or visible text.",
+                            },
+                            key: {
+                                type: "string",
+                                description: "Key name for press action (e.g. 'Enter', 'Tab', 'Escape', 'ArrowDown').",
+                            },
+                            script: {
+                                type: "string",
+                                description: "JavaScript to execute for evaluate action. Return value is captured.",
+                            },
+                            direction: {
+                                type: "string",
+                                enum: ["up", "down", "left", "right"],
+                                description: "Scroll direction (default: 'down').",
+                            },
+                            amount: {
+                                type: "number",
+                                description: "Scroll amount in pixels (default: 500).",
+                            },
+                            ms: {
+                                type: "number",
+                                description: "Wait duration in milliseconds (for wait action without selector).",
+                            },
+                            optional: {
+                                type: "boolean",
+                                description: "If true, failure of this action won't abort the remaining actions (default: false).",
+                            },
+                        },
+                        required: ["action"],
+                    },
+                },
+            },
+            required: ["actions"],
+        },
+    },
+    {
+        name: "comet_navigate",
+        description: "Navigate the current tab to a URL. Does NOT open Perplexity — navigates the active tab directly. " +
+            "Use this to go to QBO, Mercury, Google Drive, or any URL before using comet_interact or comet_read_page.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: { type: "string", description: "URL to navigate to." },
+                waitForIdle: {
+                    type: "boolean",
+                    description: "Wait for network idle after navigation (default: true).",
+                },
+            },
+            required: ["url"],
+        },
+    },
     {
         name: "comet_wait_for_idle",
-        description: "Wait for the current page's network activity to settle (no pending requests "
-            + "for a specified duration). Use after navigation or triggering dynamic content loads. "
-            + "Returns a summary of network activity observed.",
+        description: "Wait for the current page's network activity to settle (no pending requests " +
+            "for a specified duration). Use after navigation or triggering dynamic content loads. " +
+            "Returns a summary of network activity observed.",
         inputSchema: {
             type: "object",
             properties: {
@@ -213,6 +670,7 @@ const TOOLS = [
                 runId: { type: "string", description: "Unique run identifier" },
                 taskThreadId: { type: "string", description: "Task-thread identifier" },
                 agentId: { type: "string", description: "Agent identity (optional for single-agent)" },
+                bindingId: { type: "string", description: "Codex window binding to attach this run to" },
                 route: { type: "string", enum: ["mcp", "cli", "http"], description: "Execution channel" },
                 deferred: { type: "boolean", description: "Start in pending state (default: false)" },
             },
@@ -261,12 +719,27 @@ const TOOLS = [
         name: "comet_task_status",
         description: "Get unified status for a Comet browser task. Combines session-manifest.json state, " +
             "extension ring buffer events, and lifecycle metadata into one response. " +
-            "Query by groupId or threadId.",
+            "Query by bindingId, sessionKey, projectThreadId, runId, groupId, or threadId.",
         inputSchema: {
             type: "object",
             properties: {
+                bindingId: { type: "string", description: "Durable Codex window binding ID to check" },
+                sessionKey: { type: "string", description: "Codex session key to check" },
+                projectThreadId: { type: "string", description: "Codex project thread ID to check" },
+                runId: { type: "string", description: "Lifecycle run ID to check" },
+                sidecarResultId: {
+                    type: "string",
+                    description: "Persisted sidecar result artifact ID to include",
+                },
+                sidecarContextKey: {
+                    type: "string",
+                    description: "Sidecar binding context key to include latest result for",
+                },
                 groupId: { type: "number", description: "Tab group ID to check" },
-                threadId: { type: "string", description: "Thread ID to check (returns all sessions for thread)" },
+                threadId: {
+                    type: "string",
+                    description: "Legacy task-thread ID to check (returns sessions in this binding scope)",
+                },
             },
         },
     },
@@ -296,13 +769,268 @@ const TOOLS = [
                     description: "Task IDs this task depends on",
                 },
                 agentId: { type: "string", description: "Agent identity for tracking" },
+                bindingId: { type: "string", description: "Existing binding to reuse for dispatch" },
+                windowId: { type: "number", description: "Explicit Comet window ID for direct binding" },
+                tabGroupId: { type: "number", description: "Explicit tab group ID for direct binding" },
+                groupId: { type: "number", description: "Legacy alias for tabGroupId" },
+                targetId: { type: "string", description: "Explicit CDP target ID for direct binding" },
+                codexSessionId: { type: "string", description: "Codex caller session ID" },
+                projectThreadId: { type: "string", description: "Codex project thread ID" },
+                worktreePath: { type: "string", description: "Codex worktree path" },
+                repoSlug: { type: "string", description: "Repository slug" },
+                branchName: { type: "string", description: "Branch name" },
+                sessionKey: { type: "string", description: "Codex session key" },
+                codexSessionRole: {
+                    type: "string",
+                    enum: ["session_agent", "worktree_orchestrator", "fleet_orchestrator"],
+                    description: "Codex binding role",
+                },
             },
             required: ["threadId", "instruction"],
         },
     },
+    {
+        name: "comet_observe",
+        description: "Passively observe browser state without disrupting active agents. Returns tab groups, " +
+            "agent ownership, activity status, and optionally per-tab thumbnails. " +
+            "Actions: snapshot (full browser state), status (compact ownership table), " +
+            "detail (drill into one group), health (lightweight check).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["snapshot", "status", "detail", "health"],
+                    description: "snapshot: full browser state (all tabs, groups, agents). " +
+                        "status: tab group ownership and activity summary. " +
+                        "detail: deep info on one specific tab group. " +
+                        "health: lightweight browser health check.",
+                },
+                group: {
+                    type: "string",
+                    description: "Tab group name — required for 'detail' action, optional filter for 'snapshot' and 'status'.",
+                },
+                agentId: {
+                    type: "string",
+                    description: "Filter results to a specific agent ID. Optional for 'snapshot' and 'status'.",
+                },
+                urlPattern: {
+                    type: "string",
+                    description: "Filter tabs by URL pattern (substring match). Optional for 'snapshot' and 'detail'.",
+                },
+                thumbnails: {
+                    type: "boolean",
+                    description: "Include per-tab viewport screenshots. Default false. Adds ~100-200ms per tab.",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    // ── Safe observation tool (no session required) ──
+    {
+        name: "comet_peek",
+        description: "Binding-scoped read-only observation of the caller's own bound tab. " +
+            "SAFE: Does not create tabs, close tabs, navigate, or modify any state. " +
+            "Rejects target IDs outside the caller's authorized Codex window binding.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                targetId: {
+                    type: "string",
+                    description: "CDP target ID of the tab to peek at. Get this from comet_observe(action='snapshot').",
+                },
+                action: {
+                    type: "string",
+                    enum: ["screenshot", "read", "info"],
+                    description: "screenshot: capture PNG of the tab. read: extract page text/accessibility tree. info: return URL, title, and load state.",
+                },
+            },
+            required: ["targetId", "action"],
+        },
+    },
+    // ── Parity tools (close gaps with CLI scripts) ──
+    {
+        name: "comet_pdf",
+        description: "Generate a PDF from the current page or a URL. Navigates if a URL is provided, " +
+            "then uses CDP Page.printToPDF. Returns the file path of the saved PDF.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to navigate to before printing. If omitted, prints the current page.",
+                },
+                name: {
+                    type: "string",
+                    description: "Output filename (without .pdf extension). Defaults to page title or timestamp.",
+                },
+                format: {
+                    type: "string",
+                    enum: ["Letter", "Legal", "A4", "A3", "Tabloid"],
+                    description: "Paper size. Default: Letter.",
+                },
+                landscape: { type: "boolean", description: "Landscape orientation. Default: false." },
+                margin: { type: "number", description: "Margin in inches. Default: 0.5." },
+                scale: { type: "number", description: "Scale factor (0.1–2.0). Default: 1." },
+                printBackground: {
+                    type: "boolean",
+                    description: "Include background graphics. Default: true.",
+                },
+                hideSelectors: {
+                    type: "string",
+                    description: "Comma-separated CSS selectors to hide before printing.",
+                },
+            },
+        },
+    },
+    {
+        name: "comet_scrape",
+        description: "Extract structured data from the current page or a URL. Supports CSS selector extraction, " +
+            "table parsing, JSON-LD extraction, list items, and attribute extraction. " +
+            "Optionally auto-scrolls to load lazy content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                url: {
+                    type: "string",
+                    description: "URL to navigate to before scraping. If omitted, scrapes the current page.",
+                },
+                selector: { type: "string", description: "CSS selector to extract content from." },
+                mode: {
+                    type: "string",
+                    enum: ["text", "table", "json-ld", "list", "attr", "multi"],
+                    description: "Extraction mode. text: innerText (default). table: parse <table> as JSON rows. json-ld: extract JSON-LD. list: extract <li> items. attr: extract a specific attribute. multi: all matching elements.",
+                },
+                attr: { type: "string", description: "Attribute name to extract (when mode is 'attr')." },
+                scroll: {
+                    type: "boolean",
+                    description: "Auto-scroll page to load lazy content before scraping. Default: false.",
+                },
+                waitFor: { type: "string", description: "CSS selector to wait for before scraping." },
+            },
+        },
+    },
+    {
+        name: "comet_network",
+        description: "Capture and analyze network traffic on the current page. Enables CDP Network domain, " +
+            "records requests/responses, and optionally intercepts or blocks requests. " +
+            "Actions: capture (record traffic), block (block URL patterns), intercept (mock responses).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                action: {
+                    type: "string",
+                    enum: ["capture", "block", "intercept"],
+                    description: "capture: record traffic for a duration. block: block URL patterns. intercept: mock responses for URL patterns.",
+                },
+                url: {
+                    type: "string",
+                    description: "URL to navigate to before capturing. If omitted, captures on the current page.",
+                },
+                duration: { type: "number", description: "Capture duration in ms. Default: 10000." },
+                filter: { type: "string", description: "URL substring to filter captured requests." },
+                resourceType: {
+                    type: "string",
+                    description: "Filter by resource type: XHR, Fetch, Document, Stylesheet, Image, Script, Font.",
+                },
+                pattern: {
+                    type: "string",
+                    description: "URL pattern to block or intercept (substring match).",
+                },
+                mockResponse: {
+                    type: "string",
+                    description: "JSON string to return for intercepted requests.",
+                },
+                mockStatus: {
+                    type: "number",
+                    description: "HTTP status code for mock responses. Default: 200.",
+                },
+                includeHeaders: {
+                    type: "boolean",
+                    description: "Include request/response headers in capture output. Default: false.",
+                },
+            },
+            required: ["action"],
+        },
+    },
+    {
+        name: "comet_automate",
+        description: "Execute a multi-step browser workflow. Each step is a tool+args object. Supports: " +
+            "navigate, click, fill, type, press, select, wait, screenshot, extract (with variable storage), " +
+            "assert (verify content), evaluate (run JS), and conditional logic (if/loop). " +
+            "Steps execute sequentially; aborts on first failure unless step has optional:true.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                steps: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            tool: {
+                                type: "string",
+                                description: "Step type: navigate, click, fill, type, press, select, wait, screenshot, extract, assert, evaluate, if, loop",
+                            },
+                            selector: { type: "string" },
+                            url: { type: "string" },
+                            value: { type: "string" },
+                            variable: {
+                                type: "string",
+                                description: "Store extracted value in this variable name.",
+                            },
+                            contains: { type: "string", description: "Assert text contains this string." },
+                            expression: { type: "string", description: "JS expression to evaluate." },
+                            condition: { type: "string", description: "JS condition for if/loop." },
+                            then: { type: "array", description: "Steps to run if condition is true." },
+                            items: {
+                                type: "string",
+                                description: "Variable name containing array to loop over.",
+                            },
+                            each: { type: "array", description: "Steps to run for each item." },
+                            optional: {
+                                type: "boolean",
+                                description: "If true, failure doesn't abort the workflow.",
+                            },
+                            name: { type: "string", description: "Screenshot name." },
+                        },
+                        required: ["tool"],
+                    },
+                    description: "Array of workflow steps to execute sequentially.",
+                },
+                verbose: { type: "boolean", description: "Show detailed output per step. Default: false." },
+            },
+            required: ["steps"],
+        },
+    },
+    {
+        name: "comet_domain",
+        description: "Route to a domain-specific playbook for authenticated sites. Handles login checks, " +
+            "navigation patterns, and domain-aware interaction for: QBO (QuickBooks Online), " +
+            "Mercury (banking), GitHub, Google (Drive/Sheets/Docs), and SALT (tax). " +
+            "Checks auth status and provides domain-specific guidance.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                domain: {
+                    type: "string",
+                    enum: ["qbo", "mercury", "github", "google", "salt"],
+                    description: "Target domain playbook.",
+                },
+                action: {
+                    type: "string",
+                    enum: ["check-auth", "navigate", "status"],
+                    description: "check-auth: verify logged in. navigate: go to domain home. status: domain session status.",
+                },
+                path: {
+                    type: "string",
+                    description: "Specific path within the domain (e.g., '/reports' for QBO).",
+                },
+            },
+            required: ["domain"],
+        },
+    },
 ];
-const CC_LIFECYCLE_URL = process.env.COMET_CC_LIFECYCLE_URL
-    || "http://localhost:3001/command-center/api/comet/lifecycle";
+const CC_LIFECYCLE_URL = process.env.COMET_CC_LIFECYCLE_URL || "http://localhost:3001/command-center/api/comet/lifecycle";
 async function callLifecycleEndpoint(payload) {
     const resp = await fetch(CC_LIFECYCLE_URL, {
         method: "POST",
@@ -320,92 +1048,261 @@ const server = new Server({ name: "comet-bridge", version: "2.4.0" }, { capabili
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: TOOLS }));
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
-    try {
-        switch (name) {
-            case "comet_connect": {
-                // Auto-start Comet with debug port (will restart if running without it)
-                const startResult = await cometClient.startComet(9222);
-                // Get all tabs and clean up - close all except one
-                const targets = await cometClient.listTargets();
-                const pageTabs = targets.filter(t => t.type === 'page');
-                // Close extra tabs, keep only one
-                if (pageTabs.length > 1) {
-                    for (let i = 1; i < pageTabs.length; i++) {
-                        try {
-                            await cometClient.closeTab(pageTabs[i].id);
+    // Resolve session-scoped clients for isolation (Spec 034)
+    // Health check runs here — reconnects dead WebSockets before any tool executes
+    const { client: cometClient, ai: cometAI } = await getSessionClients();
+    // Execute handler, then append any queued alerts to the response (Spec 016, FR-011)
+    const result = await (async () => {
+        // Protocol enforcement — check prerequisites before browsing tools (Spec 016, FR-006, T009-T010)
+        const protocolError = requireSession(name, args);
+        if (protocolError)
+            return protocolError;
+        const bindingError = await requireBoundRouting(name, args);
+        if (bindingError)
+            return bindingError;
+        try {
+            switch (name) {
+                case "comet_connect": {
+                    // Spec 037: Require taskGoal for session startup gate
+                    const taskGoal = args?.taskGoal;
+                    if (!taskGoal || taskGoal.trim().length === 0) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: 'Error: taskGoal is required. Describe what this browser session is for.\n\nExample: comet_connect({ taskGoal: "Research Google Drive documents for OTB accounting project" })',
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Spec 034: Use SessionRegistry for isolated, safe connections.
+                    // NEVER closes existing tabs. NEVER kills the browser.
+                    const session = await sessionRegistry.register({
+                        agentId: args?.agentId || undefined,
+                        taskThreadId: args?.taskThreadId || undefined,
+                        url: args?.url || undefined,
+                        tabGroupColor: args?.tabGroupColor || undefined,
+                        port: 9222,
+                        taskGoal: taskGoal.trim(),
+                        codexSessionId: args?.codexSessionId || undefined,
+                        projectThreadId: args?.projectThreadId || undefined,
+                        projectThreadFamily: args?.projectThreadFamily || undefined,
+                        worktreePath: args?.worktreePath || undefined,
+                        repoSlug: args?.repoSlug || undefined,
+                        branchName: args?.branchName || undefined,
+                        codexSessionRole: args?.codexSessionRole || undefined,
+                        codexSessionKey: args?.codexSessionKey || undefined,
+                        strictCodexIdentity: args?.strictCodexIdentity || undefined,
+                        profile: assertAgentRuntimeProfileArg(args?.profile),
+                    });
+                    const groupInfo = session.tabGroupId !== null
+                        ? `tab group: "${session.taskThreadId.slice(0, 50)}" (id: ${session.tabGroupId}, color: ${session.tabGroupColor})`
+                        : "tab group: skipped (extension not available)";
+                    // Spec 037: Send task goal as first prompt to create orchestrator thread
+                    let orchestratorUrl;
+                    try {
+                        const orchestratorPrompt = `Take control of the browser. ${taskGoal.trim()}`;
+                        await session.cometAI.sendPrompt(orchestratorPrompt);
+                        // Poll for URL change (max 10 attempts, 1s apart) instead of hardcoded delay
+                        for (let attempt = 0; attempt < 10; attempt++) {
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            const evalResult = await session.cdpClient.safeEvaluate("window.location.href");
+                            const currentUrl = evalResult?.result?.value;
+                            if (currentUrl &&
+                                !currentUrl.includes("/b/home") &&
+                                currentUrl.includes("perplexity.ai/search/")) {
+                                orchestratorUrl = currentUrl;
+                                session.orchestratorUrl = orchestratorUrl;
+                                sessionRegistry.updateSessionUrl(session.sessionKey, orchestratorUrl);
+                                break;
+                            }
                         }
-                        catch { /* ignore */ }
                     }
+                    catch (goalErr) {
+                        // Non-fatal: session is usable without orchestrator URL
+                        console.warn(`[comet-bridge] Orchestrator thread creation failed: ${goalErr instanceof Error ? goalErr.message : goalErr}`);
+                    }
+                    // Log to orchestration outbox
+                    appendJsonl(OUTBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: session.agentId,
+                        to: "orchestration",
+                        type: "update",
+                        task: session.taskThreadId,
+                        msg: `Connected: agent=${session.agentId}, ${groupInfo}, goal="${session.sessionName}"`,
+                    });
+                    const summary = [
+                        `Agent: ${session.agentId}`,
+                        `Session: ${session.sessionName || session.taskThreadId}`,
+                        `Goal: ${taskGoal.trim()}`,
+                        `Thread: ${session.taskThreadId}`,
+                        orchestratorUrl ? `Orchestrator: ${orchestratorUrl}` : "Orchestrator: initializing...",
+                        groupInfo,
+                        `Display: top (agents workspace, full-screen bounds)`,
+                    ].join("\n");
+                    return { content: [{ type: "text", text: summary }] };
                 }
-                // Get fresh tab list
-                const freshTargets = await cometClient.listTargets();
-                const anyPage = freshTargets.find(t => t.type === 'page');
-                if (anyPage) {
-                    await cometClient.connect(anyPage.id);
-                    // Always navigate to Perplexity home for clean state
-                    await cometClient.navigate("https://www.perplexity.ai/", true);
-                    await new Promise(resolve => setTimeout(resolve, 1500));
-                    return { content: [{ type: "text", text: `${startResult}\nConnected to Perplexity (cleaned ${pageTabs.length - 1} old tabs)` }] };
-                }
-                // No tabs at all - create a new one
-                const newTab = await cometClient.newTab("https://www.perplexity.ai/");
-                await new Promise(resolve => setTimeout(resolve, 2000)); // Wait for page load
-                await cometClient.connect(newTab.id);
-                return { content: [{ type: "text", text: `${startResult}\nCreated new tab and navigated to Perplexity` }] };
-            }
-            case "comet_ask": {
-                let prompt = args?.prompt;
-                const timeout = args?.timeout || 15000; // Default 15s, use poll for longer tasks
-                const newChat = args?.newChat || false;
-                // Validate prompt
-                if (!prompt || prompt.trim().length === 0) {
-                    return { content: [{ type: "text", text: "Error: prompt cannot be empty" }] };
-                }
-                // Normalize prompt - convert markdown/bullets to natural text
-                prompt = prompt
-                    .replace(/^[-*•]\s*/gm, '') // Remove bullet points
-                    .replace(/\n+/g, ' ') // Collapse newlines to spaces
-                    .replace(/\s+/g, ' ') // Collapse multiple spaces
-                    .trim();
-                // For newChat: full reset (same as comet_connect) to handle post-agentic state
-                if (newChat) {
-                    // Clean up extra tabs (fixes CDP state after agentic browsing)
-                    const targets = await cometClient.listTargets();
-                    const pageTabs = targets.filter(t => t.type === 'page');
-                    if (pageTabs.length > 1) {
-                        for (let i = 1; i < pageTabs.length; i++) {
+                case "comet_ask": {
+                    let prompt = args?.prompt;
+                    const timeout = args?.timeout || 15000; // Default 15s, use poll for longer tasks
+                    const newChat = args?.newChat || false;
+                    // Validate prompt
+                    if (!prompt || prompt.trim().length === 0) {
+                        return { content: [{ type: "text", text: "Error: prompt cannot be empty" }] };
+                    }
+                    // Normalize prompt - convert markdown/bullets to natural text
+                    prompt = prompt
+                        .replace(/^[-*•]\s*/gm, "") // Remove bullet points
+                        .replace(/\n+/g, " ") // Collapse newlines to spaces
+                        .replace(/\s+/g, " ") // Collapse multiple spaces
+                        .trim();
+                    const useSidecar = args?.sidecar || false;
+                    // ── Sidecar mode: keep current page, open assistant sidebar, ask there ──
+                    if (useSidecar) {
+                        const boundResolution = await resolveBoundSession(sessionRegistry.getCurrent(), args);
+                        // Capture current page URL for context
+                        let currentPageUrl = "unknown";
+                        try {
+                            const urlRes = await cometClient.evaluate("window.location.href");
+                            currentPageUrl = urlRes.result.value || "unknown";
+                        }
+                        catch {
+                            /* continue */
+                        }
+                        const sidecarArtifact = await sidecarArtifactStore.create({
+                            sidecarContextKey: boundResolution.binding.sidecarContextKey,
+                            bindingId: boundResolution.binding.bindingId,
+                            sessionKey: boundResolution.binding.sessionKey,
+                            projectThreadId: boundResolution.binding.projectThreadId,
+                            windowId: boundResolution.binding.windowId,
+                            targetId: boundResolution.binding.targetId,
+                            prompt,
+                            currentPageUrl,
+                        });
+                        // Attach to an existing sidecar and get a CDP client connected to it.
+                        const sidecarClient = await cometClient.connectToSidecar({
+                            windowId: boundResolution.binding.windowId,
+                            targetId: boundResolution.binding.targetId ?? undefined,
+                        });
+                        if (!sidecarClient) {
+                            await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                status: "failed",
+                                error: "Perplexity sidecar is not already open. Focus-safe automation will not activate Comet or send Option+A.",
+                            });
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "Error: Perplexity sidecar is not already open. Focus-safe automation will not activate Comet or send Option+A through the operator keyboard.",
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        try {
+                            // Create a CometAI instance bound to the sidecar's CDP client
+                            const sidecarAI = new CometAI(sidecarClient);
+                            // Send prompt to the sidecar input
+                            await sidecarAI.sendPrompt(prompt);
+                            await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                status: "working",
+                            });
+                            // Poll sidecar for response completion
+                            const startTime = Date.now();
+                            const stepsCollected = [];
+                            while (Date.now() - startTime < timeout) {
+                                await new Promise((resolve) => setTimeout(resolve, 2000));
+                                const status = await sidecarAI.getAgentStatus();
+                                for (const step of status.steps) {
+                                    if (!stepsCollected.includes(step)) {
+                                        stepsCollected.push(step);
+                                    }
+                                }
+                                if (status.status === "completed" && status.response) {
+                                    await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                        status: "completed",
+                                        response: status.response,
+                                        steps: stepsCollected,
+                                        currentStep: status.currentStep,
+                                    });
+                                    return {
+                                        content: [
+                                            {
+                                                type: "text",
+                                                text: [
+                                                    `[sidecar → ${currentPageUrl}]`,
+                                                    `sidecarContextKey: ${boundResolution.binding.sidecarContextKey}`,
+                                                    `sidecarResultId: ${sidecarArtifact.sidecarResultId}`,
+                                                    "",
+                                                    status.response,
+                                                ].join("\n"),
+                                            },
+                                        ],
+                                    };
+                                }
+                                await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                    status: "working",
+                                    steps: stepsCollected,
+                                    currentStep: status.currentStep,
+                                });
+                            }
+                            // Timed out — return in-progress status
+                            const finalStatus = await sidecarAI.getAgentStatus();
+                            const timedOutArtifact = await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                status: "timed_out",
+                                response: finalStatus.response,
+                                steps: stepsCollected,
+                                currentStep: finalStatus.currentStep,
+                            });
+                            let msg = `Sidecar task in progress on ${currentPageUrl}\n`;
+                            msg += `sidecarContextKey: ${timedOutArtifact.sidecarContextKey}\n`;
+                            msg += `sidecarResultId: ${timedOutArtifact.sidecarResultId}\n`;
+                            msg += `Status: ${finalStatus.status.toUpperCase()}\n`;
+                            if (finalStatus.currentStep)
+                                msg += `Current: ${finalStatus.currentStep}\n`;
+                            if (stepsCollected.length > 0) {
+                                msg += `\nSteps:\n${stepsCollected.map((s) => `  • ${s}`).join("\n")}\n`;
+                            }
+                            msg += `\nUse comet_poll with sidecarResultId to check progress.`;
+                            return { content: [{ type: "text", text: msg }] };
+                        }
+                        catch (err) {
+                            await sidecarArtifactStore.update(sidecarArtifact.sidecarResultId, {
+                                status: "failed",
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                            throw err;
+                        }
+                        finally {
                             try {
-                                await cometClient.closeTab(pageTabs[i].id);
+                                await sidecarClient.disconnect();
+                            }
+                            catch {
+                                /* already disconnected */
                             }
-                            catch { /* ignore */ }
                         }
                     }
-                    // Fresh connect to remaining tab
-                    const freshTargets = await cometClient.listTargets();
-                    const mainTab = freshTargets.find(t => t.type === 'page');
-                    if (mainTab) {
-                        await cometClient.connect(mainTab.id);
-                    }
-                    // Navigate to Perplexity home
-                    await cometClient.navigate("https://www.perplexity.ai/", true);
-                    await new Promise(resolve => setTimeout(resolve, 1500));
-                }
-                else {
-                    // Not newChat - just ensure we're on Perplexity
-                    const tabs = await cometClient.listTabsCategorized();
-                    if (tabs.main) {
-                        await cometClient.connect(tabs.main.id);
-                    }
-                    const urlResult = await cometClient.evaluate('window.location.href');
-                    const currentUrl = urlResult.result.value;
-                    const isOnPerplexity = currentUrl?.includes('perplexity.ai');
-                    if (!isOnPerplexity) {
+                    // ── Standard mode: navigate to Perplexity and ask there ──
+                    // For newChat: navigate the CURRENT connected tab to Perplexity home
+                    // NEVER close other tabs — other agents may be working in them
+                    if (newChat) {
+                        // Navigate the currently connected tab to Perplexity home
                         await cometClient.navigate("https://www.perplexity.ai/", true);
-                        await new Promise(resolve => setTimeout(resolve, 2000));
+                        await new Promise((resolve) => setTimeout(resolve, 1500));
                     }
-                }
-                // Capture old response state BEFORE sending prompt (for follow-up detection)
-                const oldStateResult = await cometClient.evaluate(`
+                    else {
+                        // Not newChat - stay on the bound tab and only navigate that tab if needed.
+                        const urlResult = await cometClient.evaluate("window.location.href");
+                        const currentUrl = urlResult.result.value;
+                        const isOnPerplexity = currentUrl?.includes("perplexity.ai");
+                        if (!isOnPerplexity) {
+                            await cometClient.navigate("https://www.perplexity.ai/", true);
+                            await new Promise((resolve) => setTimeout(resolve, 2000));
+                        }
+                    }
+                    // Capture old response state BEFORE sending prompt (for follow-up detection)
+                    const oldStateResult = await cometClient.evaluate(`
           (() => {
             const proseEls = document.querySelectorAll('[class*="prose"]');
             const lastProse = proseEls[proseEls.length - 1];
@@ -415,17 +1312,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
           })()
         `);
-                const oldState = oldStateResult.result.value;
-                // Send the prompt
-                await cometAI.sendPrompt(prompt);
-                // Wait for completion
-                const startTime = Date.now();
-                const stepsCollected = [];
-                let sawNewResponse = false;
-                while (Date.now() - startTime < timeout) {
-                    await new Promise(resolve => setTimeout(resolve, 2000)); // Poll every 2s
-                    // Check if we have a NEW response (more prose elements or different text)
-                    const currentStateResult = await cometClient.evaluate(`
+                    const oldState = oldStateResult.result.value;
+                    // Send the prompt
+                    await cometAI.sendPrompt(prompt);
+                    // Wait for completion
+                    const startTime = Date.now();
+                    const stepsCollected = [];
+                    let sawNewResponse = false;
+                    while (Date.now() - startTime < timeout) {
+                        await new Promise((resolve) => setTimeout(resolve, 2000)); // Poll every 2s
+                        // Check if we have a NEW response (more prose elements or different text)
+                        const currentStateResult = await cometClient.evaluate(`
             (() => {
               const proseEls = document.querySelectorAll('[class*="prose"]');
               const lastProse = proseEls[proseEls.length - 1];
@@ -435,84 +1332,215 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               };
             })()
           `);
-                    const currentState = currentStateResult.result.value;
-                    // Detect new response
-                    if (!sawNewResponse) {
-                        if (currentState.count > oldState.count ||
-                            (currentState.lastText && currentState.lastText !== oldState.lastText)) {
-                            sawNewResponse = true;
+                        const currentState = currentStateResult.result.value;
+                        // Detect new response
+                        if (!sawNewResponse) {
+                            if (currentState.count > oldState.count ||
+                                (currentState.lastText && currentState.lastText !== oldState.lastText)) {
+                                sawNewResponse = true;
+                            }
                         }
-                    }
-                    const status = await cometAI.getAgentStatus();
-                    // Collect steps
-                    for (const step of status.steps) {
-                        if (!stepsCollected.includes(step)) {
-                            stepsCollected.push(step);
+                        const status = await cometAI.getAgentStatus();
+                        // Failure detection heuristics (Spec 016, FR-002, T017)
+                        if (await cometAI.detectVoiceMode()) {
+                            dispatchAlert({
+                                type: "PERPLEXITY_VOICE_MODE",
+                                message: "Perplexity entered voice/listening mode instead of processing the text prompt.",
+                                consumerId: sessionRegistry.getCurrent()?.agentId ?? null,
+                                sessionKey: sessionRegistry.getCurrent()?.sessionKey ?? null,
+                            });
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "Error: Perplexity entered voice/listening mode instead of processing your prompt.\n\nSuggested action: Retry with newChat: true to get a fresh Perplexity session.",
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        if (status.status === "idle" && (await cometAI.detectIdleNoNavigation())) {
+                            dispatchAlert({
+                                type: "PERPLEXITY_IDLE_NO_NAV",
+                                message: "Task went IDLE without navigating — Perplexity did not process the request.",
+                                consumerId: sessionRegistry.getCurrent()?.agentId ?? null,
+                                sessionKey: sessionRegistry.getCurrent()?.sessionKey ?? null,
+                            });
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: "Error: Task went IDLE without navigating. Perplexity did not process the request.\n\nSuggested action: Retry the task. If persistent, use comet_stop then retry with newChat: true.",
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        // Collect steps
+                        for (const step of status.steps) {
+                            if (!stepsCollected.includes(step)) {
+                                stepsCollected.push(step);
+                            }
+                        }
+                        // Task completed - return result directly (but only if we saw a NEW response)
+                        if (status.status === "completed" && sawNewResponse) {
+                            // Context bleed detection (Spec 016, FR-002, T017)
+                            const urlMatch = prompt.match(/https?:\/\/[^\s"')]+/);
+                            if (urlMatch && (await cometAI.detectContextBleed(urlMatch[0]))) {
+                                dispatchAlert({
+                                    type: "PERPLEXITY_CONTEXT_BLEED",
+                                    message: `Response content appears to be from a different URL than requested (${urlMatch[0]}).`,
+                                    consumerId: sessionRegistry.getCurrent()?.agentId ?? null,
+                                    sessionKey: sessionRegistry.getCurrent()?.sessionKey ?? null,
+                                    context: { requestedUrl: urlMatch[0], actualUrl: status.agentBrowsingUrl },
+                                });
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Error: Context bleed detected — response content appears to be from a different URL than requested.\nRequested: ${urlMatch[0]}\nActual browsing: ${status.agentBrowsingUrl || "unknown"}\n\nSuggested action: Use newChat: true to prevent context from prior conversation bleeding into this task.`,
+                                        },
+                                    ],
+                                    isError: true,
+                                };
+                            }
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: status.response || "Task completed (no response text extracted)",
+                                    },
+                                ],
+                            };
                         }
                     }
-                    // Task completed - return result directly (but only if we saw a NEW response)
-                    if (status.status === 'completed' && sawNewResponse) {
-                        return { content: [{ type: "text", text: status.response || 'Task completed (no response text extracted)' }] };
+                    // Still working after initial wait - return "in progress" (non-blocking)
+                    const finalStatus = await cometAI.getAgentStatus();
+                    let inProgressMsg = `Task in progress (${stepsCollected.length} steps so far).\n`;
+                    inProgressMsg += `Status: ${finalStatus.status.toUpperCase()}\n`;
+                    if (finalStatus.currentStep) {
+                        inProgressMsg += `Current: ${finalStatus.currentStep}\n`;
                     }
+                    if (finalStatus.agentBrowsingUrl) {
+                        inProgressMsg += `Browsing: ${finalStatus.agentBrowsingUrl}\n`;
+                    }
+                    if (stepsCollected.length > 0) {
+                        inProgressMsg += `\nSteps:\n${stepsCollected.map((s) => `  • ${s}`).join("\n")}\n`;
+                    }
+                    inProgressMsg += `\nUse comet_poll to check progress or comet_stop to cancel.`;
+                    return { content: [{ type: "text", text: inProgressMsg }] };
                 }
-                // Still working after initial wait - return "in progress" (non-blocking)
-                const finalStatus = await cometAI.getAgentStatus();
-                let inProgressMsg = `Task in progress (${stepsCollected.length} steps so far).\n`;
-                inProgressMsg += `Status: ${finalStatus.status.toUpperCase()}\n`;
-                if (finalStatus.currentStep) {
-                    inProgressMsg += `Current: ${finalStatus.currentStep}\n`;
-                }
-                if (finalStatus.agentBrowsingUrl) {
-                    inProgressMsg += `Browsing: ${finalStatus.agentBrowsingUrl}\n`;
-                }
-                if (stepsCollected.length > 0) {
-                    inProgressMsg += `\nSteps:\n${stepsCollected.map(s => `  • ${s}`).join('\n')}\n`;
-                }
-                inProgressMsg += `\nUse comet_poll to check progress or comet_stop to cancel.`;
-                return { content: [{ type: "text", text: inProgressMsg }] };
-            }
-            case "comet_poll": {
-                const status = await cometAI.getAgentStatus();
-                // If completed, return the response directly (most useful case)
-                if (status.status === 'completed' && status.response) {
-                    return { content: [{ type: "text", text: status.response }] };
-                }
-                // Still working - return progress info
-                let output = `Status: ${status.status.toUpperCase()}\n`;
-                if (status.agentBrowsingUrl) {
-                    output += `Browsing: ${status.agentBrowsingUrl}\n`;
-                }
-                if (status.currentStep) {
-                    output += `Current: ${status.currentStep}\n`;
+                case "comet_poll": {
+                    const sidecarResultId = args?.sidecarResultId;
+                    const sidecarContextKey = args?.sidecarContextKey;
+                    if (sidecarResultId || sidecarContextKey) {
+                        const artifact = sidecarResultId
+                            ? await sidecarArtifactStore.get(sidecarResultId)
+                            : await sidecarArtifactStore.latestForContext(sidecarContextKey);
+                        if (!artifact) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `No sidecar result artifact found for ${JSON.stringify({ sidecarResultId, sidecarContextKey })}`,
+                                    },
+                                ],
+                            };
+                        }
+                        const resolved = await resolveBoundSession(sessionRegistry.getCurrent(), args);
+                        if (artifact.bindingId !== resolved.binding.bindingId) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `Binding error (OWNERSHIP_VIOLATION) before comet_poll: sidecar result ${artifact.sidecarResultId} belongs to binding ${artifact.bindingId}.`,
+                                    },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        return {
+                            content: [{ type: "text", text: JSON.stringify(artifact, null, 2) }],
+                        };
+                    }
+                    const status = await cometAI.getAgentStatus();
+                    // Failure detection heuristics on poll (Spec 016, FR-002, T018)
+                    if (await cometAI.detectVoiceMode()) {
+                        dispatchAlert({
+                            type: "PERPLEXITY_VOICE_MODE",
+                            message: "Perplexity entered voice/listening mode.",
+                            consumerId: sessionRegistry.getCurrent()?.agentId ?? null,
+                            sessionKey: sessionRegistry.getCurrent()?.sessionKey ?? null,
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: Perplexity entered voice/listening mode.\n\nSuggested action: Retry with newChat: true.",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    if (status.status === "idle" && (await cometAI.detectIdleNoNavigation())) {
+                        dispatchAlert({
+                            type: "PERPLEXITY_IDLE_NO_NAV",
+                            message: "Task went IDLE without navigating.",
+                            consumerId: sessionRegistry.getCurrent()?.agentId ?? null,
+                            sessionKey: sessionRegistry.getCurrent()?.sessionKey ?? null,
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: Task went IDLE without navigating.\n\nSuggested action: Retry the task, or use comet_stop then retry with newChat: true.",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // If completed, return the response directly (most useful case)
+                    if (status.status === "completed" && status.response) {
+                        return { content: [{ type: "text", text: status.response }] };
+                    }
+                    // Still working - return progress info
+                    let output = `Status: ${status.status.toUpperCase()}\n`;
+                    if (status.agentBrowsingUrl) {
+                        output += `Browsing: ${status.agentBrowsingUrl}\n`;
+                    }
+                    if (status.currentStep) {
+                        output += `Current: ${status.currentStep}\n`;
+                    }
+                    if (status.steps.length > 0) {
+                        output += `\nSteps:\n${status.steps.map((s) => `  • ${s}`).join("\n")}\n`;
+                    }
+                    if (status.status === "working") {
+                        output += `\n[Use comet_stop to interrupt, or comet_screenshot to see current page]`;
+                    }
+                    return { content: [{ type: "text", text: output }] };
                 }
-                if (status.steps.length > 0) {
-                    output += `\nSteps:\n${status.steps.map(s => `  • ${s}`).join('\n')}\n`;
+                case "comet_stop": {
+                    const stopped = await cometAI.stopAgent();
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: stopped ? "Agent stopped" : "No active agent to stop",
+                            },
+                        ],
+                    };
                 }
-                if (status.status === 'working') {
-                    output += `\n[Use comet_stop to interrupt, or comet_screenshot to see current page]`;
+                case "comet_screenshot": {
+                    const result = await cometClient.screenshot("png");
+                    return {
+                        content: [{ type: "image", data: result.data, mimeType: "image/png" }],
+                    };
                 }
-                return { content: [{ type: "text", text: output }] };
-            }
-            case "comet_stop": {
-                const stopped = await cometAI.stopAgent();
-                return {
-                    content: [{
-                            type: "text",
-                            text: stopped ? "Agent stopped" : "No active agent to stop",
-                        }],
-                };
-            }
-            case "comet_screenshot": {
-                const result = await cometClient.screenshot("png");
-                return {
-                    content: [{ type: "image", data: result.data, mimeType: "image/png" }],
-                };
-            }
-            case "comet_mode": {
-                const mode = args?.mode;
-                // If no mode provided, show current mode
-                if (!mode) {
-                    const result = await cometClient.evaluate(`
+                case "comet_mode": {
+                    const mode = args?.mode;
+                    // If no mode provided, show current mode
+                    if (!mode) {
+                        const result = await cometClient.evaluate(`
             (() => {
               // Try button group first (wide screen)
               const modes = ['Search', 'Research', 'Labs', 'Learn'];
@@ -534,41 +1562,43 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               return 'search';
             })()
           `);
-                    const currentMode = result.result.value;
-                    const descriptions = {
-                        search: 'Basic web search',
-                        research: 'Deep research with comprehensive analysis',
-                        labs: 'Analytics, visualizations, and coding',
-                        learn: 'Educational content and explanations'
-                    };
-                    let output = `Current mode: ${currentMode}\n\nAvailable modes:\n`;
-                    for (const [m, desc] of Object.entries(descriptions)) {
-                        const marker = m === currentMode ? "→" : " ";
-                        output += `${marker} ${m}: ${desc}\n`;
+                        const currentMode = result.result.value;
+                        const descriptions = {
+                            search: "Basic web search",
+                            research: "Deep research with comprehensive analysis",
+                            labs: "Analytics, visualizations, and coding",
+                            learn: "Educational content and explanations",
+                        };
+                        let output = `Current mode: ${currentMode}\n\nAvailable modes:\n`;
+                        for (const [m, desc] of Object.entries(descriptions)) {
+                            const marker = m === currentMode ? "→" : " ";
+                            output += `${marker} ${m}: ${desc}\n`;
+                        }
+                        return { content: [{ type: "text", text: output }] };
                     }
-                    return { content: [{ type: "text", text: output }] };
-                }
-                // Switch mode
-                const modeMap = {
-                    search: "Search",
-                    research: "Research",
-                    labs: "Labs",
-                    learn: "Learn",
-                };
-                const ariaLabel = modeMap[mode];
-                if (!ariaLabel) {
-                    return {
-                        content: [{ type: "text", text: `Invalid mode: ${mode}. Use: search, research, labs, learn` }],
-                        isError: true,
+                    // Switch mode
+                    const modeMap = {
+                        search: "Search",
+                        research: "Research",
+                        labs: "Labs",
+                        learn: "Learn",
                     };
-                }
-                // Navigate to Perplexity first if not there
-                const state = cometClient.currentState;
-                if (!state.currentUrl?.includes("perplexity.ai")) {
-                    await cometClient.navigate("https://www.perplexity.ai/", true);
-                }
-                // Try both UI patterns: button group (wide) and dropdown (narrow)
-                const result = await cometClient.evaluate(`
+                    const ariaLabel = modeMap[mode];
+                    if (!ariaLabel) {
+                        return {
+                            content: [
+                                { type: "text", text: `Invalid mode: ${mode}. Use: search, research, labs, learn` },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Navigate to Perplexity first if not there
+                    const state = cometClient.currentState;
+                    if (!state.currentUrl?.includes("perplexity.ai")) {
+                        await cometClient.navigate("https://www.perplexity.ai/", true);
+                    }
+                    // Try both UI patterns: button group (wide) and dropdown (narrow)
+                    const result = await cometClient.evaluate(`
           (() => {
             // Strategy 1: Direct button (wide screen)
             const btn = document.querySelector('button[aria-label="${ariaLabel}"]');
@@ -593,11 +1623,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             return { success: false, error: "Mode selector not found" };
           })()
         `);
-                const clickResult = result.result.value;
-                if (clickResult.success && clickResult.needsSelect) {
-                    // Wait for dropdown to open, then select the mode
-                    await new Promise(resolve => setTimeout(resolve, 300));
-                    const selectResult = await cometClient.evaluate(`
+                    const clickResult = result.result.value;
+                    if (clickResult.success && clickResult.needsSelect) {
+                        // Wait for dropdown to open, then select the mode
+                        await new Promise((resolve) => setTimeout(resolve, 300));
+                        const selectResult = await cometClient.evaluate(`
             (() => {
               // Look for dropdown menu items
               const items = document.querySelectorAll('[role="menuitem"], [role="option"], button');
@@ -610,41 +1640,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               return { success: false, error: "Mode option not found in dropdown" };
             })()
           `);
-                    const selectRes = selectResult.result.value;
-                    if (selectRes.success) {
+                        const selectRes = selectResult.result.value;
+                        if (selectRes.success) {
+                            return { content: [{ type: "text", text: `Switched to ${mode} mode` }] };
+                        }
+                        else {
+                            return {
+                                content: [{ type: "text", text: `Failed: ${selectRes.error}` }],
+                                isError: true,
+                            };
+                        }
+                    }
+                    if (clickResult.success) {
                         return { content: [{ type: "text", text: `Switched to ${mode} mode` }] };
                     }
                     else {
-                        return { content: [{ type: "text", text: `Failed: ${selectRes.error}` }], isError: true };
+                        return {
+                            content: [{ type: "text", text: `Failed to switch mode: ${clickResult.error}` }],
+                            isError: true,
+                        };
                     }
                 }
-                if (clickResult.success) {
-                    return { content: [{ type: "text", text: `Switched to ${mode} mode` }] };
-                }
-                else {
-                    return {
-                        content: [{ type: "text", text: `Failed to switch mode: ${clickResult.error}` }],
-                        isError: true,
-                    };
-                }
-            }
-            case "comet_shortcut": {
-                const shortcut = (args?.shortcut).replace(/^\//, "");
-                const context = args?.context;
-                const timeout = args?.timeout || 30000;
-                // Ensure we're on Perplexity
-                const tabs = await cometClient.listTabsCategorized();
-                if (tabs.main) {
-                    await cometClient.connect(tabs.main.id);
-                }
-                const urlResult = await cometClient.evaluate('window.location.href');
-                const currentUrl = urlResult.result.value;
-                if (!currentUrl?.includes('perplexity.ai')) {
-                    await cometClient.navigate("https://www.perplexity.ai/", true);
-                    await new Promise(resolve => setTimeout(resolve, 2000));
-                }
-                // Capture old state for response detection
-                const oldStateResult = await cometClient.evaluate(`
+                case "comet_shortcut": {
+                    const shortcut = (args?.shortcut).replace(/^\//, "");
+                    const context = args?.context;
+                    const timeout = args?.timeout || 30000;
+                    // Ensure we're on Perplexity
+                    const tabs = await cometClient.listTabsCategorized();
+                    if (tabs.main) {
+                        await cometClient.connect(tabs.main.id);
+                    }
+                    const urlResult = await cometClient.evaluate("window.location.href");
+                    const currentUrl = urlResult.result.value;
+                    if (!currentUrl?.includes("perplexity.ai")) {
+                        await cometClient.navigate("https://www.perplexity.ai/", true);
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                    }
+                    // Capture old state for response detection
+                    const oldStateResult = await cometClient.evaluate(`
           (() => {
             const proseEls = document.querySelectorAll('[class*="prose"]');
             const lastProse = proseEls[proseEls.length - 1];
@@ -654,15 +1687,15 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             };
           })()
         `);
-                const oldState = oldStateResult.result.value;
-                // Send the shortcut
-                await cometAI.sendShortcut(shortcut, context);
-                // Poll for response with timeout
-                const startTime = Date.now();
-                let sawNewResponse = false;
-                while (Date.now() - startTime < timeout) {
-                    await new Promise(resolve => setTimeout(resolve, 2000));
-                    const currentStateResult = await cometClient.evaluate(`
+                    const oldState = oldStateResult.result.value;
+                    // Send the shortcut
+                    await cometAI.sendShortcut(shortcut, context);
+                    // Poll for response with timeout
+                    const startTime = Date.now();
+                    let sawNewResponse = false;
+                    while (Date.now() - startTime < timeout) {
+                        await new Promise((resolve) => setTimeout(resolve, 2000));
+                        const currentStateResult = await cometClient.evaluate(`
             (() => {
               const proseEls = document.querySelectorAll('[class*="prose"]');
               const lastProse = proseEls[proseEls.length - 1];
@@ -672,502 +1705,1922 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
               };
             })()
           `);
-                    const currentState = currentStateResult.result.value;
-                    if (!sawNewResponse) {
-                        if (currentState.count > oldState.count ||
-                            (currentState.lastText && currentState.lastText !== oldState.lastText)) {
-                            sawNewResponse = true;
-                        }
-                    }
-                    const status = await cometAI.getAgentStatus();
-                    if (status.status === 'completed' && sawNewResponse) {
-                        return { content: [{ type: "text", text: status.response || 'Shortcut completed (no response text extracted)' }] };
-                    }
-                }
-                // Timed out — return status so user can poll
-                const finalStatus = await cometAI.getAgentStatus();
-                let msg = `Shortcut /${shortcut} in progress (timed out after ${timeout}ms).\n`;
-                msg += `Status: ${finalStatus.status.toUpperCase()}\n`;
-                if (finalStatus.currentStep)
-                    msg += `Current: ${finalStatus.currentStep}\n`;
-                msg += `\nUse comet_poll to check progress.`;
-                return { content: [{ type: "text", text: msg }] };
-            }
-            case "comet_read_page": {
-                const mode = args?.mode || "text";
-                const maxDepth = args?.maxDepth || 5;
-                const maxLength = args?.maxLength || 12000;
-                const parts = [];
-                if (mode === "tree" || mode === "both") {
-                    const tree = await cometClient.getAccessibilityTree(maxDepth, maxLength);
-                    parts.push("## Accessibility Tree\n" + tree);
-                }
-                if (mode === "text" || mode === "both") {
-                    const text = await cometClient.getPageText(maxLength);
-                    parts.push("## Page Text\n" + text);
-                }
-                return { content: [{ type: "text", text: parts.join("\n\n") }] };
-            }
-            case "comet_wait_for_idle": {
-                const idleTime = args?.idleTime || 1500;
-                const timeout = args?.timeout || 15000;
-                const result = await cometClient.waitForNetworkIdle({ idleTime, timeout });
-                const status = result.idle ? "Network idle reached" : "Timeout — network still active";
-                const summary = [
-                    status,
-                    `Waited: ${result.waitedMs}ms`,
-                    `Requests: ${result.totalRequests} total, ${result.totalCompleted} completed, ${result.totalFailed} failed`,
-                    result.pendingRequests > 0 ? `Still pending: ${result.pendingRequests}` : "",
-                ].filter(Boolean).join("\n");
-                return { content: [{ type: "text", text: summary }] };
-            }
-            case "comet_tab_groups": {
-                const { tabGroupsClient } = await import("./tab-groups.js");
-                const action = args?.action;
-                try {
-                    switch (action) {
-                        case "list": {
-                            const groups = await tabGroupsClient.listGroups();
-                            if (groups.length === 0) {
-                                return { content: [{ type: "text", text: "No tab groups found." }] };
+                        const currentState = currentStateResult.result.value;
+                        if (!sawNewResponse) {
+                            if (currentState.count > oldState.count ||
+                                (currentState.lastText && currentState.lastText !== oldState.lastText)) {
+                                sawNewResponse = true;
                             }
-                            const lines = groups.map((g) => `[${g.id}] "${g.title || "(untitled)"}" (${g.color}${g.collapsed ? ", collapsed" : ""})`);
-                            return { content: [{ type: "text", text: `Tab groups:\n${lines.join("\n")}` }] };
                         }
-                        case "list_tabs": {
-                            const tabs = await tabGroupsClient.listTabs();
-                            const lines = tabs.map((t) => `[tab:${t.id}] group:${t.groupId === -1 ? "none" : t.groupId} "${t.title}" ${t.url}`);
-                            return { content: [{ type: "text", text: `Tabs (${tabs.length}):\n${lines.join("\n")}` }] };
-                        }
-                        case "create": {
-                            const tabIds = args?.tabIds;
-                            if (!tabIds || tabIds.length === 0) {
-                                return { content: [{ type: "text", text: "Error: tabIds required for create" }], isError: true };
-                            }
-                            const result = await tabGroupsClient.createGroup({
-                                tabIds,
-                                title: args?.title,
-                                color: args?.color,
-                            });
+                        const status = await cometAI.getAgentStatus();
+                        if (status.status === "completed" && sawNewResponse) {
                             return {
-                                content: [{
+                                content: [
+                                    {
                                         type: "text",
-                                        text: `Created group ${result.groupId}: "${result.group.title || "(untitled)"}" (${result.group.color})`,
-                                    }],
+                                        text: status.response || "Shortcut completed (no response text extracted)",
+                                    },
+                                ],
                             };
                         }
-                        case "update": {
-                            const groupId = args?.groupId;
-                            if (groupId === undefined) {
-                                return { content: [{ type: "text", text: "Error: groupId required for update" }], isError: true };
-                            }
-                            const group = await tabGroupsClient.updateGroup({
-                                groupId,
-                                title: args?.title,
-                                color: args?.color,
-                                collapsed: args?.collapsed,
-                            });
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `Updated group ${group.id}: "${group.title || "(untitled)"}" (${group.color}${group.collapsed ? ", collapsed" : ""})`,
-                                    }],
-                            };
+                    }
+                    // Timed out — return status so user can poll
+                    const finalStatus = await cometAI.getAgentStatus();
+                    let msg = `Shortcut /${shortcut} in progress (timed out after ${timeout}ms).\n`;
+                    msg += `Status: ${finalStatus.status.toUpperCase()}\n`;
+                    if (finalStatus.currentStep)
+                        msg += `Current: ${finalStatus.currentStep}\n`;
+                    msg += `\nUse comet_poll to check progress.`;
+                    return { content: [{ type: "text", text: msg }] };
+                }
+                case "comet_read_page": {
+                    const mode = args?.mode || "text";
+                    const maxDepth = args?.maxDepth || 5;
+                    const maxLength = args?.maxLength || 12000;
+                    const parts = [];
+                    if (mode === "tree" || mode === "both") {
+                        const tree = await cometClient.getAccessibilityTree(maxDepth, maxLength);
+                        parts.push("## Accessibility Tree\n" + tree);
+                    }
+                    if (mode === "text" || mode === "both") {
+                        const text = await cometClient.getPageText(maxLength);
+                        parts.push("## Page Text\n" + text);
+                    }
+                    return { content: [{ type: "text", text: parts.join("\n\n") }] };
+                }
+                case "comet_interact": {
+                    const actions = args?.actions;
+                    if (!actions || actions.length === 0) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: actions array is required and must not be empty." },
+                            ],
+                        };
+                    }
+                    const results = [];
+                    for (const act of actions) {
+                        try {
+                            switch (act.action) {
+                                case "click": {
+                                    if (!act.selector)
+                                        throw new Error("click requires a selector");
+                                    const clicked = await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el) return JSON.stringify({ ok: false, error: 'Element not found: ${act.selector.replace(/'/g, "\\'")}' });
+                      el.scrollIntoView({ block: 'center' });
+                      el.click();
+                      return JSON.stringify({ ok: true, tag: el.tagName, text: (el.textContent || '').trim().substring(0, 80) });
+                    })()
+                  `);
+                                    const clickRes = JSON.parse(clicked.result.value);
+                                    if (!clickRes.ok)
+                                        throw new Error(clickRes.error);
+                                    results.push({
+                                        action: "click",
+                                        success: true,
+                                        result: `Clicked <${clickRes.tag}> "${clickRes.text}"`,
+                                    });
+                                    break;
+                                }
+                                case "type": {
+                                    if (!act.selector)
+                                        throw new Error("type requires a selector");
+                                    if (!act.value)
+                                        throw new Error("type requires a value");
+                                    // Focus the element first
+                                    await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el) throw new Error('Element not found');
+                      el.focus();
+                    })()
+                  `);
+                                    // Type character by character using CDP Input events
+                                    for (const char of act.value) {
+                                        await cometClient.pressKey(char);
+                                        await new Promise((r) => setTimeout(r, 50));
+                                    }
+                                    results.push({
+                                        action: "type",
+                                        success: true,
+                                        result: `Typed ${act.value.length} chars`,
+                                    });
+                                    break;
+                                }
+                                case "fill": {
+                                    if (!act.selector)
+                                        throw new Error("fill requires a selector");
+                                    const fillRes = await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el) return JSON.stringify({ ok: false, error: 'Element not found' });
+                      el.focus();
+                      if (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA') {
+                        const nativeSetter = Object.getOwnPropertyDescriptor(
+                          el.tagName === 'INPUT' ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype, 'value'
+                        )?.set;
+                        if (nativeSetter) nativeSetter.call(el, ${JSON.stringify(act.value || "")});
+                        else el.value = ${JSON.stringify(act.value || "")};
+                        el.dispatchEvent(new Event('input', { bubbles: true }));
+                        el.dispatchEvent(new Event('change', { bubbles: true }));
+                      } else if (el.contentEditable === 'true') {
+                        el.focus();
+                        document.execCommand('selectAll', false, null);
+                        document.execCommand('insertText', false, ${JSON.stringify(act.value || "")});
+                      }
+                      return JSON.stringify({ ok: true });
+                    })()
+                  `);
+                                    const fRes = JSON.parse(fillRes.result.value);
+                                    if (!fRes.ok)
+                                        throw new Error(fRes.error);
+                                    results.push({
+                                        action: "fill",
+                                        success: true,
+                                        result: `Filled with "${(act.value || "").substring(0, 40)}"`,
+                                    });
+                                    break;
+                                }
+                                case "press": {
+                                    const key = act.key || act.value || "Enter";
+                                    if (act.selector) {
+                                        await cometClient.safeEvaluate(`
+                      (() => {
+                        const el = document.querySelector(${JSON.stringify(act.selector)});
+                        if (el) el.focus();
+                      })()
+                    `);
+                                    }
+                                    await cometClient.pressKey(key);
+                                    results.push({ action: "press", success: true, result: `Pressed ${key}` });
+                                    break;
+                                }
+                                case "check":
+                                case "uncheck": {
+                                    if (!act.selector)
+                                        throw new Error(`${act.action} requires a selector`);
+                                    const shouldCheck = act.action === "check";
+                                    const checkRes = await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el) return JSON.stringify({ ok: false, error: 'Element not found' });
+                      const isCheckbox = el.type === 'checkbox' || el.role === 'checkbox' || el.getAttribute('role') === 'checkbox';
+                      if (isCheckbox) {
+                        if (el.checked !== ${shouldCheck}) {
+                          el.click();
+                        }
+                        return JSON.stringify({ ok: true, checked: ${shouldCheck} });
+                      }
+                      // Fallback: just click it (toggle behavior)
+                      el.scrollIntoView({ block: 'center' });
+                      el.click();
+                      return JSON.stringify({ ok: true, clicked: true });
+                    })()
+                  `);
+                                    const cRes = JSON.parse(checkRes.result.value);
+                                    if (!cRes.ok)
+                                        throw new Error(cRes.error);
+                                    results.push({
+                                        action: act.action,
+                                        success: true,
+                                        result: `${act.action}ed: ${act.selector}`,
+                                    });
+                                    break;
+                                }
+                                case "select": {
+                                    if (!act.selector)
+                                        throw new Error("select requires a selector");
+                                    if (!act.value)
+                                        throw new Error("select requires a value");
+                                    const selRes = await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el || el.tagName !== 'SELECT') return JSON.stringify({ ok: false, error: 'SELECT element not found' });
+                      // Try by value first, then by text
+                      let found = false;
+                      for (const opt of el.options) {
+                        if (opt.value === ${JSON.stringify(act.value)} || opt.text === ${JSON.stringify(act.value)}) {
+                          el.value = opt.value;
+                          found = true;
+                          break;
                         }
-                        case "move": {
-                            const groupId = args?.groupId;
-                            const index = args?.index;
-                            if (groupId === undefined || index === undefined) {
-                                return { content: [{ type: "text", text: "Error: groupId and index required for move" }], isError: true };
+                      }
+                      if (!found) return JSON.stringify({ ok: false, error: 'Option not found: ${act.value}' });
+                      el.dispatchEvent(new Event('change', { bubbles: true }));
+                      return JSON.stringify({ ok: true, selected: el.value });
+                    })()
+                  `);
+                                    const sRes = JSON.parse(selRes.result.value);
+                                    if (!sRes.ok)
+                                        throw new Error(sRes.error);
+                                    results.push({
+                                        action: "select",
+                                        success: true,
+                                        result: `Selected: ${sRes.selected}`,
+                                    });
+                                    break;
+                                }
+                                case "scroll": {
+                                    const dir = act.direction || "down";
+                                    const amount = act.amount || 500;
+                                    const dx = dir === "right" ? amount : dir === "left" ? -amount : 0;
+                                    const dy = dir === "down" ? amount : dir === "up" ? -amount : 0;
+                                    if (act.selector) {
+                                        await cometClient.safeEvaluate(`
+                      (() => {
+                        const el = document.querySelector(${JSON.stringify(act.selector)});
+                        if (el) el.scrollBy(${dx}, ${dy});
+                      })()
+                    `);
+                                    }
+                                    else {
+                                        await cometClient.safeEvaluate(`window.scrollBy(${dx}, ${dy})`);
+                                    }
+                                    results.push({
+                                        action: "scroll",
+                                        success: true,
+                                        result: `Scrolled ${dir} ${amount}px`,
+                                    });
+                                    break;
+                                }
+                                case "wait": {
+                                    if (act.selector) {
+                                        // Wait for element to appear
+                                        const waitTimeout = act.ms || 10000;
+                                        const start = Date.now();
+                                        let found = false;
+                                        while (Date.now() - start < waitTimeout) {
+                                            const exists = await cometClient.safeEvaluate(`document.querySelector(${JSON.stringify(act.selector)}) !== null`);
+                                            if (exists.result.value === true) {
+                                                found = true;
+                                                break;
+                                            }
+                                            await new Promise((r) => setTimeout(r, 300));
+                                        }
+                                        if (!found)
+                                            throw new Error(`Timeout waiting for ${act.selector}`);
+                                        results.push({
+                                            action: "wait",
+                                            success: true,
+                                            result: `Found: ${act.selector}`,
+                                        });
+                                    }
+                                    else {
+                                        const ms = act.ms || 1000;
+                                        await new Promise((r) => setTimeout(r, ms));
+                                        results.push({ action: "wait", success: true, result: `Waited ${ms}ms` });
+                                    }
+                                    break;
+                                }
+                                case "extract": {
+                                    if (!act.selector)
+                                        throw new Error("extract requires a selector");
+                                    const extRes = await cometClient.safeEvaluate(`
+                    (() => {
+                      const el = document.querySelector(${JSON.stringify(act.selector)});
+                      if (!el) return JSON.stringify({ ok: false, error: 'Element not found' });
+                      return JSON.stringify({
+                        ok: true,
+                        text: el.innerText?.trim() || '',
+                        value: el.value || '',
+                        tag: el.tagName,
+                        checked: el.checked ?? null,
+                        href: el.href || null,
+                      });
+                    })()
+                  `);
+                                    const eRes = JSON.parse(extRes.result.value);
+                                    if (!eRes.ok)
+                                        throw new Error(eRes.error);
+                                    const extracted = eRes.text || eRes.value || `<${eRes.tag}>`;
+                                    results.push({
+                                        action: "extract",
+                                        success: true,
+                                        result: extracted.substring(0, 2000),
+                                    });
+                                    break;
+                                }
+                                case "evaluate": {
+                                    if (!act.script)
+                                        throw new Error("evaluate requires a script");
+                                    const evalRes = await cometClient.safeEvaluate(`
+                    (() => {
+                      try {
+                        const result = (function() { ${act.script} })();
+                        return JSON.stringify({ ok: true, result: String(result ?? 'undefined').substring(0, 4000) });
+                      } catch (e) {
+                        return JSON.stringify({ ok: false, error: e.message });
+                      }
+                    })()
+                  `);
+                                    const evRes = JSON.parse(evalRes.result.value);
+                                    if (!evRes.ok)
+                                        throw new Error(evRes.error);
+                                    results.push({ action: "evaluate", success: true, result: evRes.result });
+                                    break;
+                                }
+                                default:
+                                    throw new Error(`Unknown action: ${act.action}`);
                             }
-                            const group = await tabGroupsClient.moveGroup(groupId, index);
-                            return { content: [{ type: "text", text: `Moved group ${group.id} to index ${index}` }] };
+                            // Small pause between actions for DOM to settle
+                            await new Promise((r) => setTimeout(r, 100));
                         }
-                        case "ungroup": {
-                            const tabIds = args?.tabIds;
-                            if (!tabIds || tabIds.length === 0) {
-                                return { content: [{ type: "text", text: "Error: tabIds required for ungroup" }], isError: true };
+                        catch (err) {
+                            const errorMsg = err instanceof Error ? err.message : String(err);
+                            results.push({ action: act.action, success: false, error: errorMsg });
+                            if (!act.optional) {
+                                // Abort remaining actions
+                                results.push({
+                                    action: "ABORTED",
+                                    success: false,
+                                    error: `Stopped after ${act.action} failed`,
+                                });
+                                break;
                             }
-                            await tabGroupsClient.ungroupTabs(tabIds);
-                            return { content: [{ type: "text", text: `Ungrouped ${tabIds.length} tab(s)` }] };
                         }
-                        case "delete": {
-                            const groupId = args?.groupId;
-                            if (groupId === undefined) {
-                                return { content: [{ type: "text", text: "Error: groupId required for delete" }], isError: true };
+                    }
+                    const output = results
+                        .map((r) => `${r.success ? "✓" : "✗"} ${r.action}: ${r.result || r.error || ""}`)
+                        .join("\n");
+                    const allSucceeded = results.every((r) => r.success);
+                    return {
+                        content: [{ type: "text", text: output }],
+                        isError: !allSucceeded,
+                    };
+                }
+                case "comet_navigate": {
+                    const url = args?.url;
+                    if (!url) {
+                        return { content: [{ type: "text", text: "Error: url is required" }] };
+                    }
+                    const waitForIdle = args?.waitForIdle !== false; // default true
+                    const navResult = await cometClient.navigate(url, true, waitForIdle);
+                    // Get final URL after any redirects
+                    const finalUrl = await cometClient.safeEvaluate("window.location.href");
+                    const finalUrlStr = finalUrl.result.value || url;
+                    const summary = [
+                        `Navigated to: ${finalUrlStr}`,
+                        navResult.networkIdle !== undefined
+                            ? `Network: ${navResult.networkIdle ? "idle" : "still loading"}`
+                            : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n");
+                    return { content: [{ type: "text", text: summary }] };
+                }
+                case "comet_wait_for_idle": {
+                    const idleTime = args?.idleTime || 1500;
+                    const timeout = args?.timeout || 15000;
+                    const result = await cometClient.waitForNetworkIdle({ idleTime, timeout });
+                    const status = result.idle ? "Network idle reached" : "Timeout — network still active";
+                    const summary = [
+                        status,
+                        `Waited: ${result.waitedMs}ms`,
+                        `Requests: ${result.totalRequests} total, ${result.totalCompleted} completed, ${result.totalFailed} failed`,
+                        result.pendingRequests > 0 ? `Still pending: ${result.pendingRequests}` : "",
+                    ]
+                        .filter(Boolean)
+                        .join("\n");
+                    return { content: [{ type: "text", text: summary }] };
+                }
+                case "comet_tab_groups": {
+                    const { tabGroupsClient } = await import("./tab-groups.js");
+                    const action = args?.action;
+                    try {
+                        switch (action) {
+                            case "list": {
+                                const groups = await tabGroupsClient.listGroups();
+                                if (groups.length === 0) {
+                                    return { content: [{ type: "text", text: "No tab groups found." }] };
+                                }
+                                const lines = groups.map((g) => `[${g.id}] "${g.title || "(untitled)"}" (${g.color}${g.collapsed ? ", collapsed" : ""})`);
+                                return { content: [{ type: "text", text: `Tab groups:\n${lines.join("\n")}` }] };
                             }
-                            const tabs = await tabGroupsClient.listTabs();
-                            const groupTabs = tabs.filter((t) => t.groupId === groupId);
-                            if (groupTabs.length === 0) {
-                                return { content: [{ type: "text", text: `No tabs found in group ${groupId}` }] };
+                            case "list_tabs": {
+                                const tabs = await tabGroupsClient.listTabs();
+                                const lines = tabs.map((t) => `[tab:${t.id}] group:${t.groupId === -1 ? "none" : t.groupId} "${t.title}" ${t.url}`);
+                                return {
+                                    content: [{ type: "text", text: `Tabs (${tabs.length}):\n${lines.join("\n")}` }],
+                                };
                             }
-                            await tabGroupsClient.ungroupTabs(groupTabs.map((t) => t.id));
-                            return {
-                                content: [{
-                                        type: "text",
-                                        text: `Deleted group ${groupId} (ungrouped ${groupTabs.length} tab(s))`,
-                                    }],
-                            };
-                        }
-                        case "save_group": {
-                            const { archiveStore } = await import("./tab-group-archive.js");
-                            const groupId = args?.groupId;
-                            const taskThreadId = args?.taskThreadId;
-                            const closeTabs = args?.closeTabs;
-                            if (groupId === undefined || !taskThreadId) {
-                                return { content: [{ type: "text", text: "Error: groupId and taskThreadId required for save_group" }], isError: true };
+                            case "create": {
+                                const tabIds = args?.tabIds;
+                                if (!tabIds || tabIds.length === 0) {
+                                    return {
+                                        content: [{ type: "text", text: "Error: tabIds required for create" }],
+                                        isError: true,
+                                    };
+                                }
+                                const result = await tabGroupsClient.createGroup({
+                                    tabIds,
+                                    title: args?.title,
+                                    color: args?.color,
+                                });
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Created group ${result.groupId}: "${result.group.title || "(untitled)"}" (${result.group.color})`,
+                                        },
+                                    ],
+                                };
                             }
-                            const group = await tabGroupsClient.getGroup(groupId);
-                            const allTabs = await tabGroupsClient.listTabs();
-                            const groupTabs = allTabs.filter((t) => t.groupId === groupId);
-                            const entry = {
-                                taskThreadId,
-                                title: group.title,
-                                color: group.color,
-                                collapsed: group.collapsed,
-                                urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
-                                archivedAt: new Date().toISOString(),
-                                status: closeTabs ? "archived" : "saved",
-                            };
-                            await archiveStore.save(entry);
-                            if (closeTabs) {
-                                for (const t of groupTabs) {
-                                    try {
-                                        await tabGroupsClient.ungroupTabs([t.id]);
-                                    }
-                                    catch { /* tab may already be closed */ }
+                            case "update": {
+                                const groupId = args?.groupId;
+                                if (groupId === undefined) {
+                                    return {
+                                        content: [{ type: "text", text: "Error: groupId required for update" }],
+                                        isError: true,
+                                    };
                                 }
+                                const group = await tabGroupsClient.updateGroup({
+                                    groupId,
+                                    title: args?.title,
+                                    color: args?.color,
+                                    collapsed: args?.collapsed,
+                                });
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Updated group ${group.id}: "${group.title || "(untitled)"}" (${group.color}${group.collapsed ? ", collapsed" : ""})`,
+                                        },
+                                    ],
+                                };
                             }
-                            return { content: [{ type: "text", text: `Saved ${groupTabs.length} tab(s) for thread ${taskThreadId} (status: ${entry.status})` }] };
-                        }
-                        case "restore_group": {
-                            const { archiveStore } = await import("./tab-group-archive.js");
-                            const taskThreadId = args?.taskThreadId;
-                            if (!taskThreadId) {
-                                return { content: [{ type: "text", text: "Error: taskThreadId required for restore_group" }], isError: true };
+                            case "move": {
+                                const groupId = args?.groupId;
+                                const index = args?.index;
+                                if (groupId === undefined || index === undefined) {
+                                    return {
+                                        content: [{ type: "text", text: "Error: groupId and index required for move" }],
+                                        isError: true,
+                                    };
+                                }
+                                const group = await tabGroupsClient.moveGroup(groupId, index);
+                                return {
+                                    content: [{ type: "text", text: `Moved group ${group.id} to index ${index}` }],
+                                };
                             }
-                            const entry = await archiveStore.restore(taskThreadId);
-                            if (!entry) {
-                                return { content: [{ type: "text", text: `No archive found for thread ${taskThreadId}` }], isError: true };
+                            case "ungroup": {
+                                const tabIds = args?.tabIds;
+                                if (!tabIds || tabIds.length === 0) {
+                                    return {
+                                        content: [{ type: "text", text: "Error: tabIds required for ungroup" }],
+                                        isError: true,
+                                    };
+                                }
+                                await tabGroupsClient.ungroupTabs(tabIds);
+                                return { content: [{ type: "text", text: `Ungrouped ${tabIds.length} tab(s)` }] };
                             }
-                            const tabIds = [];
-                            for (const u of entry.urls) {
-                                const tabId = await tabGroupsClient.createTab(u.url, false);
-                                if (typeof tabId === "number")
-                                    tabIds.push(tabId);
+                            case "delete": {
+                                const groupId = args?.groupId;
+                                if (groupId === undefined) {
+                                    return {
+                                        content: [{ type: "text", text: "Error: groupId required for delete" }],
+                                        isError: true,
+                                    };
+                                }
+                                const tabs = await tabGroupsClient.listTabs();
+                                const groupTabs = tabs.filter((t) => t.groupId === groupId);
+                                if (groupTabs.length === 0) {
+                                    return { content: [{ type: "text", text: `No tabs found in group ${groupId}` }] };
+                                }
+                                await tabGroupsClient.ungroupTabs(groupTabs.map((t) => t.id));
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Deleted group ${groupId} (ungrouped ${groupTabs.length} tab(s))`,
+                                        },
+                                    ],
+                                };
                             }
-                            if (tabIds.length > 0) {
-                                await tabGroupsClient.createGroup({
-                                    tabIds,
-                                    title: entry.title,
-                                    color: entry.color,
-                                });
+                            case "save_group": {
+                                const { archiveStore } = await import("./tab-group-archive.js");
+                                const groupId = args?.groupId;
+                                const taskThreadId = args?.taskThreadId;
+                                const closeTabs = args?.closeTabs;
+                                if (groupId === undefined || !taskThreadId) {
+                                    return {
+                                        content: [
+                                            {
+                                                type: "text",
+                                                text: "Error: groupId and taskThreadId required for save_group",
+                                            },
+                                        ],
+                                        isError: true,
+                                    };
+                                }
+                                const group = await tabGroupsClient.getGroup(groupId);
+                                const allTabs = await tabGroupsClient.listTabs();
+                                const groupTabs = allTabs.filter((t) => t.groupId === groupId);
+                                const entry = {
+                                    taskThreadId,
+                                    title: group.title,
+                                    color: group.color,
+                                    collapsed: group.collapsed,
+                                    urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
+                                    archivedAt: new Date().toISOString(),
+                                    status: closeTabs ? "archived" : "saved",
+                                };
+                                await archiveStore.save(entry);
+                                if (closeTabs) {
+                                    for (const t of groupTabs) {
+                                        try {
+                                            await tabGroupsClient.ungroupTabs([t.id]);
+                                        }
+                                        catch {
+                                            /* tab may already be closed */
+                                        }
+                                    }
+                                }
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Saved ${groupTabs.length} tab(s) for thread ${taskThreadId} (status: ${entry.status})`,
+                                        },
+                                    ],
+                                };
                             }
-                            return { content: [{ type: "text", text: `Restored ${tabIds.length} tab(s) for thread ${taskThreadId}` }] };
-                        }
-                        case "archive_group": {
-                            const { archiveStore } = await import("./tab-group-archive.js");
-                            const groupId = args?.groupId;
-                            const taskThreadId = args?.taskThreadId;
-                            if (groupId === undefined || !taskThreadId) {
-                                return { content: [{ type: "text", text: "Error: groupId and taskThreadId required for archive_group" }], isError: true };
+                            case "restore_group": {
+                                const { archiveStore } = await import("./tab-group-archive.js");
+                                const taskThreadId = args?.taskThreadId;
+                                if (!taskThreadId) {
+                                    return {
+                                        content: [
+                                            { type: "text", text: "Error: taskThreadId required for restore_group" },
+                                        ],
+                                        isError: true,
+                                    };
+                                }
+                                const entry = await archiveStore.restore(taskThreadId);
+                                if (!entry) {
+                                    return {
+                                        content: [
+                                            { type: "text", text: `No archive found for thread ${taskThreadId}` },
+                                        ],
+                                        isError: true,
+                                    };
+                                }
+                                const tabIds = [];
+                                for (const u of entry.urls) {
+                                    const tabId = await tabGroupsClient.createTab(u.url, false);
+                                    if (typeof tabId === "number")
+                                        tabIds.push(tabId);
+                                }
+                                if (tabIds.length > 0) {
+                                    await tabGroupsClient.createGroup({
+                                        tabIds,
+                                        title: entry.title,
+                                        color: entry.color,
+                                    });
+                                }
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Restored ${tabIds.length} tab(s) for thread ${taskThreadId}`,
+                                        },
+                                    ],
+                                };
                             }
-                            const group = await tabGroupsClient.getGroup(groupId);
-                            const allTabs = await tabGroupsClient.listTabs();
-                            const groupTabs = allTabs.filter((t) => t.groupId === groupId);
-                            const entry = {
-                                taskThreadId,
-                                title: group.title,
-                                color: group.color,
-                                collapsed: group.collapsed,
-                                urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
-                                archivedAt: new Date().toISOString(),
-                                status: "archived",
-                            };
-                            await archiveStore.save(entry);
-                            const tabIdsToClose = groupTabs.map((t) => t.id);
-                            if (tabIdsToClose.length > 0) {
-                                await tabGroupsClient.closeTabs(tabIdsToClose);
+                            case "archive_group": {
+                                const { archiveStore } = await import("./tab-group-archive.js");
+                                const groupId = args?.groupId;
+                                const taskThreadId = args?.taskThreadId;
+                                if (groupId === undefined || !taskThreadId) {
+                                    return {
+                                        content: [
+                                            {
+                                                type: "text",
+                                                text: "Error: groupId and taskThreadId required for archive_group",
+                                            },
+                                        ],
+                                        isError: true,
+                                    };
+                                }
+                                const group = await tabGroupsClient.getGroup(groupId);
+                                const allTabs = await tabGroupsClient.listTabs();
+                                const groupTabs = allTabs.filter((t) => t.groupId === groupId);
+                                const entry = {
+                                    taskThreadId,
+                                    title: group.title,
+                                    color: group.color,
+                                    collapsed: group.collapsed,
+                                    urls: groupTabs.map((t) => ({ url: t.url, title: t.title })),
+                                    archivedAt: new Date().toISOString(),
+                                    status: "archived",
+                                };
+                                await archiveStore.save(entry);
+                                const tabIdsToClose = groupTabs.map((t) => t.id);
+                                if (tabIdsToClose.length > 0) {
+                                    await tabGroupsClient.closeTabs(tabIdsToClose);
+                                }
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Archived ${groupTabs.length} tab(s) for thread ${taskThreadId} (tabs closed)`,
+                                        },
+                                    ],
+                                };
                             }
-                            return { content: [{ type: "text", text: `Archived ${groupTabs.length} tab(s) for thread ${taskThreadId} (tabs closed)` }] };
-                        }
-                        case "list_archived": {
-                            const { archiveStore } = await import("./tab-group-archive.js");
-                            const entries = await archiveStore.loadAll();
-                            if (entries.length === 0) {
-                                return { content: [{ type: "text", text: "No archived tab groups." }] };
+                            case "list_archived": {
+                                const { archiveStore } = await import("./tab-group-archive.js");
+                                const entries = await archiveStore.loadAll();
+                                if (entries.length === 0) {
+                                    return { content: [{ type: "text", text: "No archived tab groups." }] };
+                                }
+                                const lines = entries.map((e) => {
+                                    const date = e.archivedAt
+                                        ? new Date(e.archivedAt).toLocaleDateString()
+                                        : "unknown";
+                                    return `[${e.taskThreadId}] "${e.title || "(untitled)"}" (${e.urls.length} tabs, ${e.status}, archived ${date})`;
+                                });
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Archived tab groups (${entries.length}):\n${lines.join("\n")}`,
+                                        },
+                                    ],
+                                };
                             }
-                            const lines = entries.map((e) => {
-                                const date = e.archivedAt ? new Date(e.archivedAt).toLocaleDateString() : "unknown";
-                                return `[${e.taskThreadId}] "${e.title || "(untitled)"}" (${e.urls.length} tabs, ${e.status}, archived ${date})`;
-                            });
-                            return { content: [{ type: "text", text: `Archived tab groups (${entries.length}):\n${lines.join("\n")}` }] };
+                            default:
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: `Unknown action: ${action}. Use: list, list_tabs, create, update, move, ungroup, delete, save_group, restore_group, archive_group, list_archived`,
+                                        },
+                                    ],
+                                    isError: true,
+                                };
                         }
-                        default:
+                    }
+                    catch (tgError) {
+                        const msg = tgError instanceof Error ? tgError.message : String(tgError);
+                        if (msg.includes("extension") ||
+                            msg.includes("service worker") ||
+                            msg.includes("Bridge")) {
                             return {
-                                content: [{ type: "text", text: `Unknown action: ${action}. Use: list, list_tabs, create, update, move, ungroup, delete, save_group, restore_group, archive_group, list_archived` }],
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `Tab Groups Bridge extension not connected.\n\n` +
+                                            `To use tab groups:\n` +
+                                            `1. Open comet://extensions in Comet\n` +
+                                            `2. Enable "Developer mode"\n` +
+                                            `3. Click "Load unpacked" and select the extension/ folder from comet-mcp\n` +
+                                            `4. Try again\n\n` +
+                                            `Error: ${msg}`,
+                                    },
+                                ],
                                 isError: true,
                             };
+                        }
+                        throw tgError;
                     }
                 }
-                catch (tgError) {
-                    const msg = tgError instanceof Error ? tgError.message : String(tgError);
-                    if (msg.includes("extension") || msg.includes("service worker") || msg.includes("Bridge")) {
-                        return {
-                            content: [{
-                                    type: "text",
-                                    text: `Tab Groups Bridge extension not connected.\n\n` +
-                                        `To use tab groups:\n` +
-                                        `1. Open comet://extensions in Comet\n` +
-                                        `2. Enable "Developer mode"\n` +
-                                        `3. Click "Load unpacked" and select the extension/ folder from comet-mcp\n` +
-                                        `4. Try again\n\n` +
-                                        `Error: ${msg}`,
-                                }],
-                            isError: true,
-                        };
-                    }
-                    throw tgError;
-                }
-            }
-            case "comet_lifecycle_start": {
-                const result = await callLifecycleEndpoint({
-                    action: "start",
-                    runId: args?.runId,
-                    taskThreadId: args?.taskThreadId,
-                    agentId: args?.agentId,
-                    route: args?.route || "mcp",
-                    deferred: args?.deferred,
-                });
-                try {
-                    const env = createMCPLifecycleEnvelope({
+                case "comet_lifecycle_start": {
+                    const result = await callLifecycleEndpoint({
+                        action: "start",
                         runId: args?.runId,
                         taskThreadId: args?.taskThreadId,
                         agentId: args?.agentId,
-                        toolName: "comet_lifecycle_start",
+                        route: args?.route || "mcp",
+                        deferred: args?.deferred,
                     });
-                    emitLifecycleEvent("start", env, { persist: true });
+                    const binding = await attachRunIdToCurrentBinding(args?.runId, args?.bindingId);
+                    try {
+                        const env = createMCPLifecycleEnvelope({
+                            runId: args?.runId,
+                            taskThreadId: args?.taskThreadId,
+                            agentId: args?.agentId,
+                            toolName: "comet_lifecycle_start",
+                        });
+                        emitLifecycleEvent("start", env, { persist: true });
+                    }
+                    catch {
+                        /* graceful degradation — HTTP result already persisted */
+                    }
+                    // Bridge to JSONL outbox for orchestration
+                    appendJsonl(OUTBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: "comet-browser",
+                        to: "orchestration",
+                        type: "update",
+                        task: args?.runId,
+                        thread: args?.taskThreadId,
+                        msg: `Lifecycle started: run=${args?.runId}`,
+                        lifecycle: {
+                            action: "start",
+                            runId: args?.runId,
+                            status: "started",
+                            bindingId: binding?.bindingId ?? null,
+                        },
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: binding
+                                    ? `${result}\nBinding attached: ${binding.bindingId}`
+                                    : `${result}\nBinding attached: none`,
+                            },
+                        ],
+                    };
                 }
-                catch { /* graceful degradation — HTTP result already persisted */ }
-                // Bridge to JSONL outbox for orchestration
-                appendJsonl(OUTBOX_PATH, {
-                    ts: Math.floor(Date.now() / 1000),
-                    from: "comet-browser",
-                    to: "orchestration",
-                    type: "update",
-                    task: args?.runId,
-                    thread: args?.taskThreadId,
-                    msg: `Lifecycle started: run=${args?.runId}`,
-                    lifecycle: { action: "start", runId: args?.runId, status: "started" },
-                });
-                return { content: [{ type: "text", text: result }] };
-            }
-            case "comet_lifecycle_complete": {
-                const result = await callLifecycleEndpoint({
-                    action: "complete",
-                    runId: args?.runId,
-                });
-                try {
-                    const env = createMCPLifecycleEnvelope({
+                case "comet_lifecycle_complete": {
+                    const result = await callLifecycleEndpoint({
+                        action: "complete",
                         runId: args?.runId,
-                        toolName: "comet_lifecycle_complete",
                     });
-                    emitLifecycleEvent("complete", env, { persist: true });
+                    const binding = await transitionBindingByRunId(args?.runId, "completed");
+                    try {
+                        const env = createMCPLifecycleEnvelope({
+                            runId: args?.runId,
+                            toolName: "comet_lifecycle_complete",
+                        });
+                        emitLifecycleEvent("complete", env, { persist: true });
+                    }
+                    catch {
+                        /* graceful degradation */
+                    }
+                    // Bridge to JSONL outbox
+                    appendJsonl(OUTBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: "comet-browser",
+                        to: "orchestration",
+                        type: "complete",
+                        task: args?.runId,
+                        msg: `Lifecycle completed: run=${args?.runId}`,
+                        lifecycle: {
+                            action: "complete",
+                            runId: args?.runId,
+                            status: "completed",
+                            bindingId: binding?.bindingId ?? null,
+                        },
+                    });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: binding
+                                    ? `${result}\nBinding transitioned: ${binding.bindingId} -> completed`
+                                    : `${result}\nBinding transitioned: none`,
+                            },
+                        ],
+                    };
                 }
-                catch { /* graceful degradation */ }
-                // Bridge to JSONL outbox
-                appendJsonl(OUTBOX_PATH, {
-                    ts: Math.floor(Date.now() / 1000),
-                    from: "comet-browser",
-                    to: "orchestration",
-                    type: "complete",
-                    task: args?.runId,
-                    msg: `Lifecycle completed: run=${args?.runId}`,
-                    lifecycle: { action: "complete", runId: args?.runId, status: "completed" },
-                });
-                return { content: [{ type: "text", text: result }] };
-            }
-            case "comet_lifecycle_abort": {
-                const result = await callLifecycleEndpoint({
-                    action: "abort",
-                    runId: args?.runId,
-                    reason: args?.reason,
-                });
-                try {
-                    const env = createMCPLifecycleEnvelope({
+                case "comet_lifecycle_abort": {
+                    const result = await callLifecycleEndpoint({
+                        action: "abort",
                         runId: args?.runId,
-                        toolName: "comet_lifecycle_abort",
+                        reason: args?.reason,
+                    });
+                    const binding = await transitionBindingByRunId(args?.runId, "stale");
+                    try {
+                        const env = createMCPLifecycleEnvelope({
+                            runId: args?.runId,
+                            toolName: "comet_lifecycle_abort",
+                        });
+                        emitLifecycleEvent("abort", env, { persist: true });
+                    }
+                    catch {
+                        /* graceful degradation */
+                    }
+                    // Bridge to JSONL outbox
+                    appendJsonl(OUTBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: "comet-browser",
+                        to: "orchestration",
+                        type: "blocked",
+                        task: args?.runId,
+                        msg: `Lifecycle aborted: run=${args?.runId}${args?.reason ? ` reason=${args.reason}` : ""}`,
+                        lifecycle: {
+                            action: "abort",
+                            runId: args?.runId,
+                            status: "aborted",
+                            reason: args?.reason,
+                            bindingId: binding?.bindingId ?? null,
+                        },
                     });
-                    emitLifecycleEvent("abort", env, { persist: true });
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: binding
+                                    ? `${result}\nBinding transitioned: ${binding.bindingId} -> stale`
+                                    : `${result}\nBinding transitioned: none`,
+                            },
+                        ],
+                    };
                 }
-                catch { /* graceful degradation */ }
-                // Bridge to JSONL outbox
-                appendJsonl(OUTBOX_PATH, {
-                    ts: Math.floor(Date.now() / 1000),
-                    from: "comet-browser",
-                    to: "orchestration",
-                    type: "blocked",
-                    task: args?.runId,
-                    msg: `Lifecycle aborted: run=${args?.runId}${args?.reason ? ` reason=${args.reason}` : ""}`,
-                    lifecycle: { action: "abort", runId: args?.runId, status: "aborted", reason: args?.reason },
-                });
-                return { content: [{ type: "text", text: result }] };
-            }
-            case "comet_lifecycle_update": {
-                const result = await callLifecycleEndpoint({
-                    action: "update",
-                    runId: args?.runId,
-                    auditSessionId: args?.auditSessionId,
-                    tabGroupId: args?.tabGroupId,
-                    workflowId: args?.workflowId,
-                    metadata: args?.metadata,
-                });
-                try {
-                    const env = createMCPLifecycleEnvelope({
+                case "comet_lifecycle_update": {
+                    const result = await callLifecycleEndpoint({
+                        action: "update",
                         runId: args?.runId,
-                        toolName: "comet_lifecycle_update",
+                        auditSessionId: args?.auditSessionId,
+                        tabGroupId: args?.tabGroupId,
+                        workflowId: args?.workflowId,
+                        metadata: args?.metadata,
                     });
-                    emitLifecycleEvent("update", env, { persist: true });
+                    try {
+                        const env = createMCPLifecycleEnvelope({
+                            runId: args?.runId,
+                            toolName: "comet_lifecycle_update",
+                        });
+                        emitLifecycleEvent("update", env, { persist: true });
+                    }
+                    catch {
+                        /* graceful degradation */
+                    }
+                    return { content: [{ type: "text", text: result }] };
                 }
-                catch { /* graceful degradation */ }
-                return { content: [{ type: "text", text: result }] };
-            }
-            case "comet_task_status": {
-                const groupId = args?.groupId;
-                const threadId = args?.threadId;
-                if (!groupId && !threadId) {
-                    return { content: [{ type: "text", text: "Error: provide groupId or threadId" }], isError: true };
+                case "comet_task_status": {
+                    const bindingId = args?.bindingId;
+                    const sessionKey = args?.sessionKey;
+                    const projectThreadId = args?.projectThreadId;
+                    const runId = args?.runId;
+                    const sidecarResultId = args?.sidecarResultId;
+                    const sidecarContextKey = args?.sidecarContextKey;
+                    const groupId = args?.groupId;
+                    const threadId = args?.threadId;
+                    if (!bindingId &&
+                        !sessionKey &&
+                        !projectThreadId &&
+                        !runId &&
+                        !sidecarResultId &&
+                        !sidecarContextKey &&
+                        !groupId &&
+                        !threadId) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: provide bindingId, sessionKey, projectThreadId, runId, sidecarResultId, sidecarContextKey, groupId, or threadId",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const sidecarArtifact = sidecarResultId
+                        ? await sidecarArtifactStore.get(sidecarResultId)
+                        : sidecarContextKey
+                            ? await sidecarArtifactStore.latestForContext(sidecarContextKey)
+                            : null;
+                    const authorizedBinding = sidecarArtifact
+                        ? await resolveBoundSession(sessionRegistry.getCurrent(), {
+                            bindingId: sidecarArtifact.bindingId,
+                        })
+                        : null;
+                    const manifest = readJsonSafe(MANIFEST_PATH);
+                    const sessions = manifest?.sessions || [];
+                    let liveTabCountsByGroupId = new Map();
+                    try {
+                        const { tabGroupsClient } = await import("./tab-groups.js");
+                        const liveTabs = await tabGroupsClient.listTabs();
+                        liveTabCountsByGroupId = liveTabs.reduce((counts, tab) => {
+                            if (typeof tab.groupId === "number" && tab.groupId !== -1) {
+                                counts.set(tab.groupId, (counts.get(tab.groupId) ?? 0) + 1);
+                            }
+                            return counts;
+                        }, new Map());
+                    }
+                    catch {
+                        /* Extension data unavailable; fall back to manifest-only status. */
+                    }
+                    // Filter sessions. Multiple query keys narrow the result; they do not broaden it.
+                    const matched = sessions.filter((s) => {
+                        const checks = [];
+                        if (bindingId)
+                            checks.push(s.codexBinding?.bindingId === bindingId);
+                        if (sessionKey)
+                            checks.push(s.sessionKey === sessionKey);
+                        if (projectThreadId)
+                            checks.push(s.codexBinding?.projectThreadId === projectThreadId);
+                        if (runId) {
+                            checks.push(Array.isArray(s.codexBinding?.runIds) && s.codexBinding.runIds.includes(runId));
+                        }
+                        if (groupId !== undefined)
+                            checks.push(s.tabGroupId === groupId);
+                        if (threadId)
+                            checks.push(s.taskThreadId === threadId);
+                        return checks.length > 0 && checks.every(Boolean);
+                    });
+                    if (matched.length === 0) {
+                        if (sidecarArtifact) {
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: JSON.stringify({
+                                            bindingId: authorizedBinding?.binding.bindingId,
+                                            sidecarArtifact,
+                                        }, null, 2),
+                                    },
+                                ],
+                            };
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `No sessions found for binding-scoped query ${JSON.stringify({ bindingId, sessionKey, projectThreadId, runId, sidecarResultId, sidecarContextKey, groupId, threadId })}`,
+                                },
+                            ],
+                        };
+                    }
+                    // Try to get recent ring buffer events via CDP
+                    let recentEvents = [];
+                    try {
+                        const { tabGroupsClient } = await import("./tab-groups.js");
+                        // Reuse the tab groups client's CDP path to find service worker
+                        const response = await fetch(`http://127.0.0.1:9222/json/list`);
+                        const targets = (await response.json());
+                        const sw = targets.find((t) => t.type === "service_worker" && t.webSocketDebuggerUrl);
+                        if (sw) {
+                            // We can't easily eval here without ws, so skip ring buffer in MCP context
+                            // Ring buffer events are aggregated by comet-event-aggregator.py instead
+                        }
+                    }
+                    catch {
+                        /* CDP not available */
+                    }
+                    const result = matched.map((s) => ({
+                        bindingId: s.codexBinding?.bindingId ?? null,
+                        sessionKey: s.sessionKey,
+                        groupId: s.tabGroupId,
+                        threadId: s.taskThreadId,
+                        status: s.agent?.status || "unknown",
+                        agentId: s.agentId || s.agent?.id || null,
+                        tabs: typeof s.tabGroupId === "number" && liveTabCountsByGroupId.has(s.tabGroupId)
+                            ? liveTabCountsByGroupId.get(s.tabGroupId)
+                            : s.tabs?.length || 0,
+                        metrics: s.metrics || {},
+                        links: s.links || {},
+                        sidecarArtifact: sidecarArtifact?.bindingId === s.codexBinding?.bindingId ? sidecarArtifact : null,
+                        lastActivity: s.metrics?.lastActivityAt || null,
+                    }));
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: JSON.stringify(result.length === 1 ? result[0] : result, null, 2),
+                            },
+                        ],
+                    };
                 }
-                const manifest = readJsonSafe(MANIFEST_PATH);
-                const sessions = manifest?.sessions || [];
-                // Filter sessions
-                const matched = sessions.filter((s) => {
-                    if (groupId !== undefined && s.groupId === groupId)
-                        return true;
-                    if (threadId && s.threadId === threadId)
-                        return true;
-                    return false;
-                });
-                if (matched.length === 0) {
-                    return { content: [{ type: "text", text: `No sessions found for ${groupId ? `groupId=${groupId}` : `threadId=${threadId}`}` }] };
+                case "comet_delegate": {
+                    const threadId = args?.threadId;
+                    const instruction = args?.instruction;
+                    const priority = args?.priority || "P3";
+                    const urls = args?.urls || [];
+                    const dependsOn = args?.dependsOn || [];
+                    const agentId = args?.agentId || "comet-mcp";
+                    if (!threadId || !instruction) {
+                        return {
+                            content: [{ type: "text", text: "Error: threadId and instruction are required" }],
+                            isError: true,
+                        };
+                    }
+                    const taskId = `comet-${Date.now()}`;
+                    const priorityColors = {
+                        P1: "red",
+                        P2: "yellow",
+                        P3: "blue",
+                        P4: "grey",
+                    };
+                    const color = priorityColors[priority] || "blue";
+                    // 1. Write to inbox-comet.jsonl
+                    appendJsonl(INBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: "comet-delegate",
+                        to: "comet-browser",
+                        task: taskId,
+                        type: "instruction",
+                        thread: threadId,
+                        priority,
+                        msg: instruction,
+                        browser_task: {
+                            thread_id: threadId,
+                            group_name: threadId.slice(0, 50),
+                            color,
+                            priority,
+                            urls,
+                            depends_on: dependsOn,
+                        },
+                    });
+                    // 2. Start lifecycle tracking
+                    let lifecycleResult = "skipped";
+                    try {
+                        lifecycleResult = await callLifecycleEndpoint({
+                            action: "start",
+                            runId: taskId,
+                            taskThreadId: threadId,
+                            agentId,
+                            route: "mcp",
+                        });
+                    }
+                    catch {
+                        /* CC-SO may not be running */
+                    }
+                    // 3. Create/reuse the Codex window binding directly.
+                    const currentSession = sessionRegistry.getCurrent();
+                    const bindingDispatch = await createOrReuseDelegateBinding({
+                        taskId,
+                        threadId,
+                        agentId,
+                        currentBinding: currentSession?.codexBinding ?? null,
+                        bindingId: args?.bindingId,
+                        codexSessionId: args?.codexSessionId ??
+                            currentSession?.codexIdentity?.codexSessionId,
+                        projectThreadId: args?.projectThreadId ?? threadId,
+                        projectThreadFamily: args?.projectThreadFamily ??
+                            currentSession?.codexIdentity?.projectThreadFamily,
+                        worktreePath: args?.worktreePath ??
+                            currentSession?.codexIdentity?.worktreePath,
+                        repoSlug: args?.repoSlug ?? currentSession?.codexIdentity?.repoSlug,
+                        branchName: args?.branchName ?? currentSession?.codexIdentity?.branchName,
+                        sessionKey: args?.sessionKey ?? currentSession?.codexIdentity?.sessionKey,
+                        role: args?.codexSessionRole ?? currentSession?.codexIdentity?.role,
+                        windowId: args?.windowId,
+                        tabGroupId: args?.tabGroupId ?? args?.groupId,
+                        targetId: args?.targetId,
+                    });
+                    // 4. Bridge to outbox
+                    appendJsonl(OUTBOX_PATH, {
+                        ts: Math.floor(Date.now() / 1000),
+                        from: "comet-browser",
+                        to: "orchestration",
+                        type: "update",
+                        task: taskId,
+                        thread: threadId,
+                        msg: `Delegated: ${instruction.slice(0, 100)}`,
+                        lifecycle: { action: "start", runId: taskId, status: "dispatched" },
+                    });
+                    const summary = [
+                        `Task delegated successfully.`,
+                        `  Task ID: ${taskId}`,
+                        `  Thread: ${threadId}`,
+                        `  Priority: ${priority} (color: ${color})`,
+                        `  URLs: ${urls.length > 0 ? urls.join(", ") : "(from thread metadata)"}`,
+                        `  Lifecycle: ${lifecycleResult === "skipped" ? "skipped (CC-SO unavailable)" : "started"}`,
+                        `  Binding ID: ${bindingDispatch.bindingId ?? "none"}`,
+                        `  Window ID: ${bindingDispatch.windowId ?? "none"}`,
+                        `  Tab Group ID: ${bindingDispatch.tabGroupId ?? "none"}`,
+                        `  Dispatch: ${bindingDispatch.dispatchStatus}`,
+                    ].join("\n");
+                    return { content: [{ type: "text", text: summary }] };
                 }
-                // Try to get recent ring buffer events via CDP
-                let recentEvents = [];
-                try {
-                    const { tabGroupsClient } = await import("./tab-groups.js");
-                    // Reuse the tab groups client's CDP path to find service worker
-                    const response = await fetch(`http://127.0.0.1:9222/json/list`);
-                    const targets = (await response.json());
-                    const sw = targets.find((t) => t.type === "service_worker" && t.webSocketDebuggerUrl);
-                    if (sw) {
-                        // We can't easily eval here without ws, so skip ring buffer in MCP context
-                        // Ring buffer events are aggregated by comet-event-aggregator.py instead
+                case "comet_observe": {
+                    const { getHealth, getSnapshot, getStatus, getDetail, formatHealth, formatSnapshot } = await import("./observer.js");
+                    const observeAction = args?.action;
+                    const observeIdentity = sessionRegistry.getCurrent()?.codexIdentity;
+                    const observeFilters = {
+                        group: args?.group,
+                        agentId: args?.agentId,
+                        urlPattern: args?.urlPattern,
+                        thumbnails: args?.thumbnails || false,
+                        codexIdentity: observeIdentity,
+                    };
+                    switch (observeAction) {
+                        case "health": {
+                            const health = await getHealth();
+                            const isErr = !health.running;
+                            return {
+                                content: [{ type: "text", text: formatHealth(health) }],
+                                ...(isErr ? { isError: true } : {}),
+                            };
+                        }
+                        case "snapshot": {
+                            const snapshot = await getSnapshot(observeFilters);
+                            if (!snapshot.browser.cdpConnected) {
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "Comet browser is not running. Start with: node scripts/session.mjs start --profile oe",
+                                        },
+                                    ],
+                                    isError: true,
+                                };
+                            }
+                            return { content: [{ type: "text", text: formatSnapshot(snapshot) }] };
+                        }
+                        case "status": {
+                            const statusText = await getStatus(observeFilters);
+                            const isStatusErr = statusText.includes("not running");
+                            return {
+                                content: [{ type: "text", text: statusText }],
+                                ...(isStatusErr ? { isError: true } : {}),
+                            };
+                        }
+                        case "detail": {
+                            if (!observeFilters.group) {
+                                return {
+                                    content: [
+                                        {
+                                            type: "text",
+                                            text: "The 'detail' action requires a 'group' parameter (tab group name).",
+                                        },
+                                    ],
+                                    isError: true,
+                                };
+                            }
+                            const detailText = await getDetail(observeFilters.group, observeFilters);
+                            const isDetailErr = detailText.includes("not found") || detailText.includes("not running");
+                            return {
+                                content: [{ type: "text", text: detailText }],
+                                ...(isDetailErr ? { isError: true } : {}),
+                            };
+                        }
+                        default:
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `Unknown observe action: ${observeAction}. Use: snapshot, status, detail, or health.`,
+                                    },
+                                ],
+                                isError: true,
+                            };
                     }
                 }
-                catch { /* CDP not available */ }
-                const result = matched.map((s) => ({
-                    groupId: s.groupId,
-                    groupName: s.groupName,
-                    groupColor: s.groupColor,
-                    threadId: s.threadId,
-                    status: s.agent?.status || "unknown",
-                    agentId: s.agent?.id || null,
-                    tabs: s.tabs?.length || 0,
-                    metrics: s.metrics || {},
-                    links: s.links || {},
-                    lastActivity: s.metrics?.lastActivityAt || null,
-                }));
-                return { content: [{ type: "text", text: JSON.stringify(result.length === 1 ? result[0] : result, null, 2) }] };
-            }
-            case "comet_delegate": {
-                const threadId = args?.threadId;
-                const instruction = args?.instruction;
-                const priority = args?.priority || "P3";
-                const urls = args?.urls || [];
-                const dependsOn = args?.dependsOn || [];
-                const agentId = args?.agentId || "comet-mcp";
-                if (!threadId || !instruction) {
-                    return { content: [{ type: "text", text: "Error: threadId and instruction are required" }], isError: true };
+                // ── Safe observation (no session required) ──
+                case "comet_peek": {
+                    const peekTargetId = args?.targetId;
+                    const peekAction = args?.action;
+                    if (!peekTargetId || !peekAction) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: targetId and action are required. Use comet_observe(action='snapshot') to find target IDs.",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    // Resolve the WebSocket URL for this target — raw HTTP, no session needed
+                    const peekTargetsResp = await fetch(`http://127.0.0.1:9222/json/list`);
+                    if (!peekTargetsResp.ok) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: "Error: Cannot connect to CDP on port 9222. Is Comet browser running?",
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const peekTargets = (await peekTargetsResp.json());
+                    const peekTarget = peekTargets.find((t) => t.id === peekTargetId);
+                    if (!peekTarget) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Error: Target ID '${peekTargetId}' not found. Use comet_observe(action='snapshot') to list current targets.`,
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    if (peekAction === "info") {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Tab Info (read-only peek)\nTitle: ${peekTarget.title}\nURL: ${peekTarget.url}\nType: ${peekTarget.type}\nTarget ID: ${peekTarget.id}`,
+                                },
+                            ],
+                        };
+                    }
+                    // Temporarily attach to target for screenshot/read — then immediately disconnect
+                    const peekCDP = await (await import("chrome-remote-interface")).default({
+                        target: peekTarget.webSocketDebuggerUrl,
+                    });
+                    try {
+                        if (peekAction === "screenshot") {
+                            await peekCDP.Page.enable();
+                            const ssResult = (await Promise.race([
+                                peekCDP.Page.captureScreenshot({ format: "png" }),
+                                new Promise((_, reject) => setTimeout(() => reject(new Error("Screenshot timeout (3s)")), 3000)),
+                            ]));
+                            const peekOutputDir = join(homedir(), ".claude", "comet-browser", "output");
+                            mkdirSync(peekOutputDir, { recursive: true });
+                            const peekPath = join(peekOutputDir, `peek-${Date.now()}.png`);
+                            writeFileSync(peekPath, Buffer.from(ssResult.data, "base64"));
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `Screenshot saved: ${peekPath}\nTab: ${peekTarget.title}\nURL: ${peekTarget.url}`,
+                                    },
+                                ],
+                            };
+                        }
+                        if (peekAction === "read") {
+                            await peekCDP.Runtime.enable();
+                            const readResult = await peekCDP.Runtime.evaluate({
+                                expression: `(() => {
+                  const title = document.title;
+                  const url = window.location.href;
+                  const text = document.body?.innerText?.substring(0, 10000) || '';
+                  const links = Array.from(document.querySelectorAll('a[href]')).slice(0, 20).map(a => ({ text: a.innerText.trim().substring(0, 50), href: a.href }));
+                  return JSON.stringify({ title, url, text, links });
+                })()`,
+                                returnByValue: true,
+                            });
+                            const pageData = JSON.parse(readResult.result.value);
+                            return {
+                                content: [
+                                    {
+                                        type: "text",
+                                        text: `Page Content (read-only peek)\nTitle: ${pageData.title}\nURL: ${pageData.url}\n\n${pageData.text.substring(0, 5000)}${pageData.text.length > 5000 ? "\n\n... (truncated)" : ""}`,
+                                    },
+                                ],
+                            };
+                        }
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Unknown peek action: ${peekAction}. Use: screenshot, read, or info.`,
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    finally {
+                        try {
+                            await peekCDP.close();
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
                 }
-                const taskId = `comet-${Date.now()}`;
-                const priorityColors = { P1: "red", P2: "yellow", P3: "blue", P4: "grey" };
-                const color = priorityColors[priority] || "blue";
-                // 1. Write to inbox-comet.jsonl
-                appendJsonl(INBOX_PATH, {
-                    ts: Math.floor(Date.now() / 1000),
-                    from: "comet-delegate",
-                    to: "comet-browser",
-                    task: taskId,
-                    type: "instruction",
-                    thread: threadId,
-                    priority,
-                    msg: instruction,
-                    browser_task: {
-                        thread_id: threadId,
-                        group_name: threadId.slice(0, 50),
-                        color,
-                        priority,
-                        urls,
-                        depends_on: dependsOn,
-                    },
-                });
-                // 2. Start lifecycle tracking
-                let lifecycleResult = "skipped";
-                try {
-                    lifecycleResult = await callLifecycleEndpoint({
-                        action: "start",
-                        runId: taskId,
-                        taskThreadId: threadId,
-                        agentId,
-                        route: "mcp",
+                // ── Parity tools ──
+                case "comet_pdf": {
+                    const pdfUrl = args?.url;
+                    const pdfName = args?.name;
+                    const pdfFormat = args?.format || "Letter";
+                    const pdfLandscape = args?.landscape || false;
+                    const pdfMargin = args?.margin ?? 0.5;
+                    const pdfScale = args?.scale || 1;
+                    const pdfPrintBg = args?.printBackground !== false;
+                    const pdfHideSelectors = args?.hideSelectors;
+                    // Navigate if URL provided
+                    if (pdfUrl) {
+                        await cometClient.navigate(pdfUrl, true, true);
+                    }
+                    // Hide elements if requested
+                    if (pdfHideSelectors) {
+                        const selectors = pdfHideSelectors.split(",").map((s) => s.trim());
+                        for (const sel of selectors) {
+                            await cometClient.evaluate(`document.querySelectorAll(${safeSelector(sel)}).forEach(el => el.style.display = 'none')`);
+                        }
+                    }
+                    // Paper dimensions in inches
+                    const paperSizes = {
+                        Letter: { width: 8.5, height: 11 },
+                        Legal: { width: 8.5, height: 14 },
+                        A4: { width: 8.27, height: 11.69 },
+                        A3: { width: 11.69, height: 16.54 },
+                        Tabloid: { width: 11, height: 17 },
+                    };
+                    const paper = paperSizes[pdfFormat] || paperSizes.Letter;
+                    // Use CDP Page.printToPDF
+                    const cdp = cometClient.protocol;
+                    const pdfResult = await cdp.send("Page.printToPDF", {
+                        landscape: pdfLandscape,
+                        printBackground: pdfPrintBg,
+                        scale: pdfScale,
+                        paperWidth: paper.width,
+                        paperHeight: paper.height,
+                        marginTop: pdfMargin,
+                        marginBottom: pdfMargin,
+                        marginLeft: pdfMargin,
+                        marginRight: pdfMargin,
                     });
+                    // Save to output directory
+                    const outputDir = join(homedir(), ".claude", "comet-browser", "output");
+                    mkdirSync(outputDir, { recursive: true });
+                    const titleResult = await cometClient.evaluate("document.title");
+                    const pageTitle = titleResult.result.value || "page";
+                    const safeName = pdfName || pageTitle.replace(/[^a-zA-Z0-9-_]/g, "_").substring(0, 60);
+                    const outputPath = join(outputDir, `${safeName}-${Date.now()}.pdf`);
+                    const pdfBuffer = Buffer.from(pdfResult.data, "base64");
+                    writeFileSync(outputPath, pdfBuffer);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `PDF saved: ${outputPath}\nFormat: ${pdfFormat}${pdfLandscape ? " (landscape)" : ""}\nSize: ${(pdfBuffer.length / 1024).toFixed(1)} KB`,
+                            },
+                        ],
+                    };
                 }
-                catch { /* CC-SO may not be running */ }
-                // 3. Dispatch via session-controller.mjs
-                let dispatchResult = "skipped";
-                const controllerPath = join(homedir(), ".claude", "comet-browser", "session-controller.mjs");
-                try {
-                    const dispatchArgs = ["dispatch", "--thread", threadId];
-                    if (agentId)
-                        dispatchArgs.push("--agent", agentId);
-                    const { stdout } = await execFileAsync("node", [controllerPath, ...dispatchArgs], { timeout: 15000 });
-                    dispatchResult = stdout.trim();
+                case "comet_scrape": {
+                    const scrapeUrl = args?.url;
+                    const scrapeSelector = args?.selector;
+                    const scrapeMode = args?.mode || "text";
+                    const scrapeAttr = args?.attr;
+                    const scrapeScroll = args?.scroll || false;
+                    const scrapeWaitFor = args?.waitFor;
+                    // Navigate if URL provided
+                    if (scrapeUrl) {
+                        await cometClient.navigate(scrapeUrl, true, true);
+                    }
+                    // Wait for selector if specified
+                    if (scrapeWaitFor) {
+                        const waitStart = Date.now();
+                        while (Date.now() - waitStart < 10000) {
+                            const found = await cometClient.evaluate(`!!document.querySelector(${safeSelector(scrapeWaitFor)})`);
+                            if (found.result.value)
+                                break;
+                            await new Promise((r) => setTimeout(r, 300));
+                        }
+                    }
+                    // Auto-scroll for lazy loading
+                    if (scrapeScroll) {
+                        await cometClient.evaluate(`
+              (async () => {
+                let totalHeight = 0;
+                const distance = 500;
+                while (totalHeight < document.body.scrollHeight && totalHeight < 50000) {
+                  window.scrollBy(0, distance);
+                  totalHeight += distance;
+                  await new Promise(r => setTimeout(r, 200));
                 }
-                catch (e) {
-                    dispatchResult = `failed: ${e instanceof Error ? e.message : e}`;
+                window.scrollTo(0, 0);
+              })()
+            `);
+                        await new Promise((r) => setTimeout(r, 500));
+                    }
+                    // Safe selector strings for browser evaluation
+                    const safeSel = safeSelector(scrapeSelector || "body");
+                    const safeAttrName = safeSelector(scrapeAttr || "href");
+                    let extractionScript;
+                    switch (scrapeMode) {
+                        case "table":
+                            extractionScript = `
+                (() => {
+                  const table = document.querySelector(${safeSelector(scrapeSelector || "table")});
+                  if (!table) return { error: 'No table found' };
+                  const rows = [...table.querySelectorAll('tr')];
+                  const headers = [...rows[0]?.querySelectorAll('th, td')].map(c => c.innerText.trim());
+                  const data = rows.slice(1).map(row => {
+                    const cells = [...row.querySelectorAll('td, th')].map(c => c.innerText.trim());
+                    return headers.length ? Object.fromEntries(headers.map((h, i) => [h, cells[i] || ''])) : cells;
+                  });
+                  return { rows: data.length, headers, data };
+                })()`;
+                            break;
+                        case "json-ld":
+                            extractionScript = `
+                (() => {
+                  const scripts = [...document.querySelectorAll('script[type="application/ld+json"]')];
+                  const data = scripts.map(s => { try { return JSON.parse(s.textContent); } catch { return null; } }).filter(Boolean);
+                  return { count: data.length, data };
+                })()`;
+                            break;
+                        case "list":
+                            extractionScript = `
+                (() => {
+                  const sel = ${safeSelector(scrapeSelector || "ul li, ol li")};
+                  const items = [...document.querySelectorAll(sel)].map(el => el.innerText.trim());
+                  return { count: items.length, items };
+                })()`;
+                            break;
+                        case "attr":
+                            extractionScript = `
+                (() => {
+                  const sel = ${safeSel};
+                  const attr = ${safeAttrName};
+                  const els = [...document.querySelectorAll(sel)];
+                  const values = els.map(el => el.getAttribute(attr)).filter(Boolean);
+                  return { count: values.length, attribute: attr, values };
+                })()`;
+                            break;
+                        case "multi":
+                            extractionScript = `
+                (() => {
+                  const sel = ${safeSelector(scrapeSelector || "p")};
+                  const els = [...document.querySelectorAll(sel)];
+                  const items = els.map(el => ({ tag: el.tagName, text: el.innerText.trim().substring(0, 500) }));
+                  return { count: items.length, items };
+                })()`;
+                            break;
+                        default: // text
+                            extractionScript = `
+                (() => {
+                  const sel = ${safeSel};
+                  const el = document.querySelector(sel);
+                  if (!el) return { error: 'Selector not found: ' + sel };
+                  return { tag: el.tagName, text: el.innerText.trim().substring(0, 10000) };
+                })()`;
+                    }
+                    const scrapeResult = await cometClient.evaluate(extractionScript);
+                    const scrapeData = scrapeResult.result.value;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: typeof scrapeData === "string" ? scrapeData : JSON.stringify(scrapeData, null, 2),
+                            },
+                        ],
+                    };
                 }
-                // 4. Bridge to outbox
-                appendJsonl(OUTBOX_PATH, {
-                    ts: Math.floor(Date.now() / 1000),
-                    from: "comet-browser",
-                    to: "orchestration",
-                    type: "update",
-                    task: taskId,
-                    thread: threadId,
-                    msg: `Delegated: ${instruction.slice(0, 100)}`,
-                    lifecycle: { action: "start", runId: taskId, status: "dispatched" },
-                });
-                const summary = [
-                    `Task delegated successfully.`,
-                    `  Task ID: ${taskId}`,
-                    `  Thread: ${threadId}`,
-                    `  Priority: ${priority} (color: ${color})`,
-                    `  URLs: ${urls.length > 0 ? urls.join(", ") : "(from thread metadata)"}`,
-                    `  Lifecycle: ${lifecycleResult === "skipped" ? "skipped (CC-SO unavailable)" : "started"}`,
-                    `  Dispatch: ${dispatchResult}`,
-                ].join("\n");
-                return { content: [{ type: "text", text: summary }] };
+                case "comet_network": {
+                    const netAction = args?.action || "capture";
+                    const netUrl = args?.url;
+                    const netDuration = args?.duration || 10000;
+                    const netFilter = args?.filter;
+                    const netResourceType = args?.resourceType;
+                    const netPattern = args?.pattern;
+                    const netMockResponse = args?.mockResponse;
+                    const netMockStatus = args?.mockStatus || 200;
+                    const netIncludeHeaders = args?.includeHeaders || false;
+                    // CDP.Client extends EventEmitter at runtime but types don't expose on/once/removeListener.
+                    // Scoped cast for event methods — only used in this network handler.
+                    const cdp = cometClient.protocol;
+                    if (netAction === "block") {
+                        if (!netPattern) {
+                            return {
+                                content: [{ type: "text", text: "Error: 'pattern' is required for block action." }],
+                                isError: true,
+                            };
+                        }
+                        await cdp.send("Network.enable");
+                        await cdp.send("Network.setBlockedURLs", { urls: [netPattern] });
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Blocking requests matching: ${netPattern}\nUse comet_network(action='block', pattern='') to clear.`,
+                                },
+                            ],
+                        };
+                    }
+                    if (netAction === "intercept") {
+                        if (!netPattern) {
+                            return {
+                                content: [
+                                    { type: "text", text: "Error: 'pattern' is required for intercept action." },
+                                ],
+                                isError: true,
+                            };
+                        }
+                        await cdp.send("Fetch.enable", {
+                            patterns: [{ urlPattern: `*${netPattern}*`, requestStage: "Response" }],
+                        });
+                        // Set up a one-shot interceptor
+                        const interceptPromise = new Promise((resolve) => {
+                            const timeout = setTimeout(() => resolve("No matching request within 30s"), 30000);
+                            cdp.once("Fetch.requestPaused", async (params) => {
+                                clearTimeout(timeout);
+                                const body = netMockResponse || '{"mocked":true}';
+                                const headers = [
+                                    { name: "Content-Type", value: "application/json" },
+                                    { name: "Access-Control-Allow-Origin", value: "*" },
+                                ];
+                                await cdp.send("Fetch.fulfillRequest", {
+                                    requestId: params.requestId,
+                                    responseCode: netMockStatus,
+                                    responseHeaders: headers,
+                                    body: Buffer.from(body).toString("base64"),
+                                });
+                                resolve(`Intercepted: ${params.request.url}\nResponded with status ${netMockStatus}`);
+                            });
+                        });
+                        const interceptResult = await interceptPromise;
+                        await cdp.send("Fetch.disable");
+                        return { content: [{ type: "text", text: interceptResult }] };
+                    }
+                    // capture action
+                    if (netUrl) {
+                        await cometClient.navigate(netUrl, true, true);
+                    }
+                    await cdp.send("Network.enable");
+                    const captured = [];
+                    const responseMap = new Map();
+                    const onRequest = (params) => {
+                        if (netFilter && !params.request.url.includes(netFilter))
+                            return;
+                        if (netResourceType && params.type?.toLowerCase() !== netResourceType.toLowerCase())
+                            return;
+                        captured.push({
+                            requestId: params.requestId,
+                            method: params.request.method,
+                            url: params.request.url,
+                            type: params.type,
+                            ...(netIncludeHeaders ? { requestHeaders: params.request.headers } : {}),
+                        });
+                    };
+                    const onResponse = (params) => {
+                        responseMap.set(params.requestId, {
+                            status: params.response.status,
+                            mimeType: params.response.mimeType,
+                            ...(netIncludeHeaders ? { responseHeaders: params.response.headers } : {}),
+                        });
+                    };
+                    cdp.on("Network.requestWillBeSent", onRequest);
+                    cdp.on("Network.responseReceived", onResponse);
+                    await new Promise((r) => setTimeout(r, netDuration));
+                    cdp.removeListener("Network.requestWillBeSent", onRequest);
+                    cdp.removeListener("Network.responseReceived", onResponse);
+                    await cdp.send("Network.disable"); // Clean up CDP domain state after capture
+                    // Merge responses into captured requests
+                    for (const req of captured) {
+                        const resp = responseMap.get(req.requestId);
+                        if (resp) {
+                            req.status = resp.status;
+                            req.mimeType = resp.mimeType;
+                            if (resp.responseHeaders)
+                                req.responseHeaders = resp.responseHeaders;
+                        }
+                        delete req.requestId;
+                    }
+                    const summary = `Captured ${captured.length} requests over ${netDuration}ms${netFilter ? ` (filter: ${netFilter})` : ""}`;
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${summary}\n\n${JSON.stringify(captured.slice(0, 50), null, 2)}${captured.length > 50 ? `\n\n... and ${captured.length - 50} more` : ""}`,
+                            },
+                        ],
+                    };
+                }
+                case "comet_automate": {
+                    const autoSteps = args?.steps;
+                    const autoVerbose = args?.verbose || false;
+                    if (!autoSteps || autoSteps.length === 0) {
+                        return {
+                            content: [
+                                { type: "text", text: "Error: 'steps' array is required and must not be empty." },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    const variables = {};
+                    const results = [];
+                    async function executeStep(step, index) {
+                        const prefix = `Step ${index + 1} [${step.tool}]`;
+                        try {
+                            switch (step.tool) {
+                                case "navigate":
+                                    await cometClient.navigate(step.url, true, true);
+                                    results.push(`✓ ${prefix}: navigated to ${step.url}`);
+                                    break;
+                                case "click":
+                                    await cometClient.evaluate(`
+                    (() => {
+                      const el = document.querySelector(${safeSelector(step.selector)});
+                      if (!el) throw new Error('Element not found: ' + ${safeSelector(step.selector)});
+                      el.scrollIntoView({ block: 'center' });
+                      el.click();
+                      return el.innerText?.substring(0, 50) || el.tagName;
+                    })()
+                  `);
+                                    results.push(`✓ ${prefix}: clicked ${step.selector}`);
+                                    break;
+                                case "fill": {
+                                    const safeFillVal = JSON.stringify(step.value || "");
+                                    await cometClient.evaluate(`
+                    (() => {
+                      const el = document.querySelector(${safeSelector(step.selector)});
+                      if (!el) throw new Error('Element not found: ' + ${safeSelector(step.selector)});
+                      const val = ${safeFillVal};
+                      const nativeSet = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set
+                        || Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
+                      if (nativeSet) nativeSet.call(el, val);
+                      else el.value = val;
+                      el.dispatchEvent(new Event('input', { bubbles: true }));
+                      el.dispatchEvent(new Event('change', { bubbles: true }));
+                    })()
+                  `);
+                                    results.push(`✓ ${prefix}: filled ${step.selector}`);
+                                    break;
+                                }
+                                case "type":
+                                    for (const char of step.value || "") {
+                                        const cdpInner = cometClient.protocol;
+                                        await cdpInner.send("Input.dispatchKeyEvent", {
+                                            type: "keyDown",
+                                            text: char,
+                                        });
+                                        await cdpInner.send("Input.dispatchKeyEvent", {
+                                            type: "keyUp",
+                                            text: char,
+                                        });
+                                    }
+                                    results.push(`✓ ${prefix}: typed ${(step.value || "").length} chars`);
+                                    break;
+                                case "press": {
+                                    const cdpPress = cometClient.protocol;
+                                    await cdpPress.send("Input.dispatchKeyEvent", {
+                                        type: "keyDown",
+                                        key: step.value,
+                                        code: `Key${step.value?.toUpperCase()}`,
+                                    });
+                                    await cdpPress.send("Input.dispatchKeyEvent", {
+                                        type: "keyUp",
+                                        key: step.value,
+                                        code: `Key${step.value?.toUpperCase()}`,
+                                    });
+                                    results.push(`✓ ${prefix}: pressed ${step.value}`);
+                                    break;
+                                }
+                                case "select":
+                                    await cometClient.evaluate(`
+                    (() => {
+                      const el = document.querySelector(${safeSelector(step.selector)});
+                      if (!el) throw new Error('Element not found');
+                      el.value = ${JSON.stringify(step.value || "")};
+                      el.dispatchEvent(new Event('change', { bubbles: true }));
+                    })()
+                  `);
+                                    results.push(`✓ ${prefix}: selected ${step.value}`);
+                                    break;
+                                case "wait":
+                                    if (step.selector) {
+                                        const waitMs = Date.now();
+                                        while (Date.now() - waitMs < 10000) {
+                                            const found = await cometClient.evaluate(`!!document.querySelector(${safeSelector(step.selector)})`);
+                                            if (found.result.value)
+                                                break;
+                                            await new Promise((r) => setTimeout(r, 300));
+                                        }
+                                    }
+                                    else if (step.value) {
+                                        await new Promise((r) => setTimeout(r, parseInt(step.value)));
+                                    }
+                                    results.push(`✓ ${prefix}: waited for ${step.selector || step.value + "ms"}`);
+                                    break;
+                                case "screenshot": {
+                                    const cdpScreenshot = cometClient.protocol;
+                                    const ssResult = await cdpScreenshot.send("Page.captureScreenshot", {
+                                        format: "png",
+                                    });
+                                    const ssDir = join(homedir(), ".claude", "comet-browser", "output");
+                                    mkdirSync(ssDir, { recursive: true });
+                                    const ssPath = join(ssDir, `${step.name || "step-" + (index + 1)}-${Date.now()}.png`);
+                                    writeFileSync(ssPath, Buffer.from(ssResult.data, "base64"));
+                                    results.push(`✓ ${prefix}: screenshot → ${ssPath}`);
+                                    break;
+                                }
+                                case "extract": {
+                                    const extractResult = await cometClient.evaluate(`
+                    (() => {
+                      const el = document.querySelector(${safeSelector(step.selector)});
+                      if (!el) return null;
+                      return el.innerText?.trim() || el.value || '';
+                    })()
+                  `);
+                                    const extractedValue = extractResult.result.value;
+                                    if (step.variable && isValidIdentifier(step.variable))
+                                        variables[step.variable] = extractedValue;
+                                    results.push(`✓ ${prefix}: extracted ${String(extractedValue).substring(0, 100)}${step.variable ? ` → $${step.variable}` : ""}`);
+                                    break;
+                                }
+                                case "assert": {
+                                    const assertResult = await cometClient.evaluate(`
+                    document.querySelector(${safeSelector(step.selector)})?.innerText || ''
+                  `);
+                                    const assertText = assertResult.result.value;
+                                    if (step.contains && !assertText.includes(step.contains)) {
+                                        throw new Error(`Assertion failed: "${step.selector}" does not contain "${step.contains}". Got: "${assertText.substring(0, 200)}"`);
+                                    }
+                                    results.push(`✓ ${prefix}: assertion passed`);
+                                    break;
+                                }
+                                case "evaluate": {
+                                    const evalResult = await cometClient.evaluate(step.expression);
+                                    const evalValue = evalResult.result.value;
+                                    if (step.variable && isValidIdentifier(step.variable))
+                                        variables[step.variable] = evalValue;
+                                    results.push(`✓ ${prefix}: ${JSON.stringify(evalValue).substring(0, 200)}${step.variable ? ` → $${step.variable}` : ""}`);
+                                    break;
+                                }
+                                case "if": {
+                                    // Evaluate condition in browser context (sandboxed) with variable injection
+                                    const varInjection = Object.entries(variables)
+                                        .filter(([k]) => isValidIdentifier(k))
+                                        .map(([k, v]) => `const ${k} = ${JSON.stringify(v)};`)
+                                        .join(" ");
+                                    const condEvalResult = await cometClient.evaluate(`(() => { ${varInjection} return !!(${step.condition}); })()`);
+                                    const condResult = condEvalResult.result.value;
+                                    if (condResult && step.then) {
+                                        for (let i = 0; i < step.then.length; i++) {
+                                            const ok = await executeStep(step.then[i], i);
+                                            if (!ok)
+                                                return false;
+                                        }
+                                    }
+                                    results.push(`✓ ${prefix}: condition ${condResult ? "true" : "false"}`);
+                                    break;
+                                }
+                                case "loop": {
+                                    const loopItems = variables[step.items];
+                                    if (!Array.isArray(loopItems)) {
+                                        throw new Error(`Variable "${step.items}" is not an array`);
+                                    }
+                                    for (let li = 0; li < loopItems.length; li++) {
+                                        variables["_item"] = loopItems[li];
+                                        variables["_index"] = li;
+                                        for (let si = 0; si < (step.each || []).length; si++) {
+                                            const ok = await executeStep(step.each[si], si);
+                                            if (!ok)
+                                                return false;
+                                        }
+                                    }
+                                    results.push(`✓ ${prefix}: looped ${loopItems.length} items`);
+                                    break;
+                                }
+                                default:
+                                    throw new Error(`Unknown step tool: ${step.tool}`);
+                            }
+                            // Small pause between steps for DOM settling
+                            await new Promise((r) => setTimeout(r, 100));
+                            return true;
+                        }
+                        catch (err) {
+                            const errMsg = err instanceof Error ? err.message : String(err);
+                            results.push(`✗ ${prefix}: ${errMsg}`);
+                            if (step.optional)
+                                return true;
+                            return false;
+                        }
+                    }
+                    for (let i = 0; i < autoSteps.length; i++) {
+                        const ok = await executeStep(autoSteps[i], i);
+                        if (!ok) {
+                            results.push(`\n⚠ Workflow aborted at step ${i + 1}`);
+                            break;
+                        }
+                    }
+                    const varSummary = Object.keys(variables).length > 0
+                        ? `\n\nVariables:\n${Object.entries(variables)
+                            .filter(([k]) => !k.startsWith("_"))
+                            .map(([k, v]) => `  ${k}: ${JSON.stringify(v).substring(0, 200)}`)
+                            .join("\n")}`
+                        : "";
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `Workflow: ${autoSteps.length} steps\n\n${results.join("\n")}${varSummary}`,
+                            },
+                        ],
+                    };
+                }
+                case "comet_domain": {
+                    const domainName = args?.domain;
+                    const domainAction = args?.action || "check-auth";
+                    const domainPath = args?.path;
+                    const domainUrls = {
+                        qbo: {
+                            home: "https://app.qbo.intuit.com/app/homepage",
+                            authCheck: "app.qbo.intuit.com",
+                            name: "QuickBooks Online",
+                        },
+                        mercury: {
+                            home: "https://app.mercury.com/dashboard",
+                            authCheck: "app.mercury.com",
+                            name: "Mercury Banking",
+                        },
+                        github: {
+                            home: "https://github.com",
+                            authCheck: "github.com",
+                            name: "GitHub",
+                        },
+                        google: {
+                            home: "https://drive.google.com",
+                            authCheck: "accounts.google.com/SignOut",
+                            name: "Google Workspace",
+                        },
+                        salt: {
+                            home: "https://app.salt.dev",
+                            authCheck: "app.salt.dev",
+                            name: "SALT Tax",
+                        },
+                    };
+                    const domainConfig = domainUrls[domainName];
+                    if (!domainConfig) {
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Unknown domain: ${domainName}. Use: qbo, mercury, github, google, salt`,
+                                },
+                            ],
+                            isError: true,
+                        };
+                    }
+                    if (domainAction === "navigate" || domainAction === "status") {
+                        const targetUrl = domainPath
+                            ? new URL(domainPath, domainConfig.home).href
+                            : domainConfig.home;
+                        await cometClient.navigate(targetUrl, true, true);
+                        const finalUrlResult = await cometClient.evaluate("window.location.href");
+                        const finalUrl = finalUrlResult.result.value;
+                        const titleResult = await cometClient.evaluate("document.title");
+                        const title = titleResult.result.value;
+                        // Check if we got redirected to login
+                        const isLoginPage = finalUrl.includes("login") ||
+                            finalUrl.includes("signin") ||
+                            finalUrl.includes("auth") ||
+                            finalUrl.includes("accounts.google.com/v3/signin");
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: [
+                                        `Domain: ${domainConfig.name}`,
+                                        `URL: ${finalUrl}`,
+                                        `Title: ${title}`,
+                                        `Auth: ${isLoginPage ? "❌ NOT LOGGED IN — redirected to login page" : "✓ Authenticated"}`,
+                                        isLoginPage
+                                            ? `\nAction needed: Log in to ${domainConfig.name} in the Comet browser (profile: oe) before proceeding.`
+                                            : "",
+                                    ]
+                                        .filter(Boolean)
+                                        .join("\n"),
+                                },
+                            ],
+                            ...(isLoginPage ? { isError: true } : {}),
+                        };
+                    }
+                    // check-auth: just check current URL without navigating
+                    const currentUrlResult = await cometClient.evaluate("window.location.href");
+                    const currentUrl = currentUrlResult.result.value;
+                    const isOnDomain = currentUrl.includes(domainConfig.authCheck);
+                    if (!isOnDomain) {
+                        // Navigate to domain to check
+                        await cometClient.navigate(domainConfig.home, true, true);
+                        const checkUrlResult = await cometClient.evaluate("window.location.href");
+                        const checkUrl = checkUrlResult.result.value;
+                        const isLoginRedirect = checkUrl.includes("login") ||
+                            checkUrl.includes("signin") ||
+                            checkUrl.includes("auth");
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `${domainConfig.name}: ${isLoginRedirect ? "❌ Not authenticated" : "✓ Authenticated"}\nURL: ${checkUrl}`,
+                                },
+                            ],
+                            ...(isLoginRedirect ? { isError: true } : {}),
+                        };
+                    }
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: `${domainConfig.name}: ✓ Currently on domain\nURL: ${currentUrl}`,
+                            },
+                        ],
+                    };
+                }
+                default:
+                    throw new Error(`Unknown tool: ${name}`);
             }
-            default:
-                throw new Error(`Unknown tool: ${name}`);
         }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[comet-bridge] Tool "${name}" failed: ${errorMsg}`);
+            return {
+                content: [{ type: "text", text: `Error in ${name}: ${errorMsg}` }],
+                isError: true,
+            };
+        }
+    })();
+    // Drain queued alerts and append to response (Spec 016, FR-011, T004)
+    const queuedAlerts = drainMcpAlertQueue();
+    if (queuedAlerts.length > 0 && result?.content) {
+        const alertText = formatAlertsForResponse(queuedAlerts);
+        result.content.push({ type: "text", text: alertText });
     }
-    catch (error) {
-        return {
-            content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : error}` }],
-            isError: true,
-        };
+    // Tab group warning — once per session (Spec 016, T011)
+    if (result?.content && !result.isError) {
+        const tabGroupWarn = getTabGroupWarning(name);
+        if (tabGroupWarn) {
+            const lastContent = result.content[result.content.length - 1];
+            if (lastContent?.type === "text") {
+                lastContent.text += tabGroupWarn;
+            }
+        }
     }
+    await disconnectCdpClientsAfterTool();
+    return result;
 });
 const transport = new StdioServerTransport();
 server.connect(transport);