opendevbrowser 0.0.16 → 0.0.18

package/dist/opendevbrowser.js

@@ -1,34 +1,35 @@
 import {
+  AGENT_INBOX_SYSTEM_MARKER,
   DaemonClient,
   ScriptRunner,
   buildAnnotateResult,
-  buildBlockerArtifacts,
-  classifyBlockerSignal,
-  createBrowserFallbackPort,
-  createConfiguredProviderRuntime,
+  buildBrowserReviewResult,
+  buildLoopbackSessionRelayEndpoint,
+  classifySessionRelayEndpoint,
+  createAutomationCoordinator,
+  createCoreRuntimeAssemblies,
   createOpenDevBrowserCore,
-  createRequestId,
-  executeMacroResolution,
+  executeMacroWithRuntime,
   extractExtension,
   fetchDaemonStatusFromMetadata,
-  runProductVideoWorkflow,
-  runResearchWorkflow,
-  runShoppingWorkflow,
-  shapeExecutionPayload,
+  inspectSession,
+  onboarding_metadata_default,
+  resolveBundledProviderRuntime,
+  resolveSessionRelayRoute,
   startDaemon
-} from "./chunk-ST7CO5FA.js";
-import "./chunk-7W3SPXIB.js";
+} from "./chunk-L57D35TB.js";
+import "./chunk-YBQECXZX.js";
+import "./chunk-Y2KL55OG.js";
+import "./chunk-TBUCZX4A.js";
+import {
+  CHALLENGE_AUTOMATION_MODES,
+  buildBlockerArtifacts,
+  classifyBlockerSignal,
+  createRequestId
+} from "./chunk-5FZQJRBQ.js";
+import "./chunk-FUSXMW3G.js";
 
 // src/cli/remote-manager.ts
-function isLegacyRelayEndpoint(wsEndpoint) {
-  try {
-    const url = new URL(wsEndpoint);
-    const path = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-    return path === "/cdp";
-  } catch {
-    return false;
-  }
-}
 var RemoteManager = class {
   client;
   constructor(client) {
@@ -40,10 +41,16 @@ var RemoteManager = class {
   connect(options) {
     return this.client.call("session.connect", options);
   }
-  connectRelay(wsEndpoint) {
+  connectRelay(wsEndpoint, options) {
+    const startUrl = typeof options?.startUrl === "string" && options.startUrl.trim().length > 0 ? options.startUrl.trim() : void 0;
+    const parsedRelayEndpoint = classifySessionRelayEndpoint(wsEndpoint);
     return this.client.call(
       "session.connect",
-      isLegacyRelayEndpoint(wsEndpoint) ? { wsEndpoint, extensionLegacy: true } : { wsEndpoint }
+      {
+        wsEndpoint,
+        ...parsedRelayEndpoint?.inputPath === "/cdp" ? { extensionLegacy: true } : {},
+        ...startUrl ? { startUrl } : {}
+      }
     );
   }
   disconnect(sessionId, closeBrowser = false) {
@@ -242,11 +249,44 @@ var RemoteManager = class {
       ...typeof targetId === "string" ? { targetId } : {}
     });
   }
-  screenshot(sessionId, path, targetId) {
+  screenshot(sessionId, options = {}) {
     return this.client.call("page.screenshot", {
       sessionId,
-      path,
-      ...typeof targetId === "string" ? { targetId } : {}
+      ...typeof options.path === "string" ? { path: options.path } : {},
+      ...typeof options.targetId === "string" ? { targetId: options.targetId } : {},
+      ...typeof options.ref === "string" ? { ref: options.ref } : {},
+      ...options.fullPage === true ? { fullPage: true } : {}
+    });
+  }
+  startScreencast(sessionId, options = {}) {
+    return this.client.call("page.screencast.start", {
+      sessionId,
+      ...typeof options.targetId === "string" ? { targetId: options.targetId } : {},
+      ...typeof options.outputDir === "string" ? { outputDir: options.outputDir } : {},
+      ...typeof options.intervalMs === "number" ? { intervalMs: options.intervalMs } : {},
+      ...typeof options.maxFrames === "number" ? { maxFrames: options.maxFrames } : {}
+    });
+  }
+  stopScreencast(sessionId, screencastId) {
+    return this.client.call("page.screencast.stop", {
+      sessionId,
+      screencastId
+    });
+  }
+  upload(sessionId, input) {
+    return this.client.call("interact.upload", {
+      sessionId,
+      ref: input.ref,
+      files: input.files,
+      ...typeof input.targetId === "string" ? { targetId: input.targetId } : {}
+    });
+  }
+  dialog(sessionId, input = {}) {
+    return this.client.call("page.dialog", {
+      sessionId,
+      action: input.action ?? "status",
+      ...typeof input.promptText === "string" ? { promptText: input.promptText } : {},
+      ...typeof input.targetId === "string" ? { targetId: input.targetId } : {}
     });
   }
   consolePoll(sessionId, sinceSeq, max = 50) {
@@ -255,6 +295,59 @@ var RemoteManager = class {
   networkPoll(sessionId, sinceSeq, max = 50) {
     return this.client.call("devtools.networkPoll", { sessionId, sinceSeq, max });
   }
+  debugTraceSnapshot(sessionId, options = {}) {
+    return this.client.call("devtools.debugTraceSnapshot", {
+      sessionId,
+      ...options
+    });
+  }
+  createSessionInspector() {
+    return {
+      status: (sessionId) => this.status(sessionId),
+      listTargets: (sessionId, includeUrls) => this.listTargets(sessionId, includeUrls),
+      consolePoll: (sessionId, sinceSeq, max) => this.consolePoll(sessionId, sinceSeq, max),
+      networkPoll: (sessionId, sinceSeq, max) => this.networkPoll(sessionId, sinceSeq, max),
+      debugTraceSnapshot: (sessionId, options) => this.debugTraceSnapshot(sessionId, options)
+    };
+  }
+  pointerMove(sessionId, x, y, targetId, steps) {
+    return this.client.call("pointer.move", {
+      sessionId,
+      x,
+      y,
+      ...typeof steps === "number" ? { steps } : {},
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  pointerDown(sessionId, x, y, targetId, button = "left", clickCount = 1) {
+    return this.client.call("pointer.down", {
+      sessionId,
+      x,
+      y,
+      button,
+      clickCount,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  pointerUp(sessionId, x, y, targetId, button = "left", clickCount = 1) {
+    return this.client.call("pointer.up", {
+      sessionId,
+      x,
+      y,
+      button,
+      clickCount,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  drag(sessionId, from, to, targetId, steps) {
+    return this.client.call("pointer.drag", {
+      sessionId,
+      from,
+      to,
+      ...typeof steps === "number" ? { steps } : {},
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
   listTargets(sessionId, includeUrls = false) {
     return this.client.call("targets.list", { sessionId, includeUrls });
   }
@@ -281,6 +374,53 @@ var RemoteManager = class {
   }
 };
 
+// src/cli/remote-canvas-manager.ts
+var RemoteCanvasManager = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  execute(command, params = {}) {
+    return this.client.call("canvas.execute", { command, params });
+  }
+};
+
+// src/cli/remote-desktop-runtime.ts
+var RemoteDesktopRuntime = class {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  status() {
+    return this.client.call("desktop.status");
+  }
+  listWindows(reason) {
+    return this.client.call("desktop.windows.list", {
+      ...reason ? { reason } : {}
+    });
+  }
+  activeWindow(reason) {
+    return this.client.call("desktop.window.active", {
+      ...reason ? { reason } : {}
+    });
+  }
+  captureDesktop(input) {
+    return this.client.call("desktop.capture.desktop", { reason: input.reason });
+  }
+  captureWindow(windowId, input) {
+    return this.client.call("desktop.capture.window", {
+      windowId,
+      reason: input.reason
+    });
+  }
+  accessibilitySnapshot(reason, windowId) {
+    return this.client.call("desktop.accessibility.snapshot", {
+      reason,
+      ...windowId ? { windowId } : {}
+    });
+  }
+};
+
 // src/cli/remote-relay.ts
 var emptyStatus = {
   running: false,
@@ -289,6 +429,7 @@ var emptyStatus = {
   cdpConnected: false,
   annotationConnected: false,
   opsConnected: false,
+  canvasConnected: false,
   pairingRequired: false,
   instanceId: "",
   epoch: 0,
@@ -300,6 +441,7 @@ var emptyStatus = {
     cdpConnected: false,
     annotationConnected: false,
     opsConnected: false,
+    canvasConnected: false,
     pairingRequired: false
   }
 };
@@ -309,6 +451,7 @@ var RemoteRelay = class {
   lastCdpUrl = null;
   lastAnnotationUrl = null;
   lastOpsUrl = null;
+  lastCanvasUrl = null;
   constructor(client) {
     this.client = client;
   }
@@ -322,11 +465,14 @@ var RemoteRelay = class {
       this.lastAnnotationUrl = typeof annotationUrl === "string" ? annotationUrl : null;
       const opsUrl = await this.client.call("relay.opsUrl");
       this.lastOpsUrl = typeof opsUrl === "string" ? opsUrl : null;
+      const canvasUrl = await this.client.call("relay.canvasUrl");
+      this.lastCanvasUrl = typeof canvasUrl === "string" ? canvasUrl : null;
     } catch {
       this.lastStatus = emptyStatus;
       this.lastCdpUrl = null;
       this.lastAnnotationUrl = null;
       this.lastOpsUrl = null;
+      this.lastCanvasUrl = null;
     }
   }
   status() {
@@ -341,11 +487,14 @@ var RemoteRelay = class {
   getOpsUrl() {
     return this.lastOpsUrl;
   }
+  getCanvasUrl() {
+    return this.lastCanvasUrl;
+  }
 };
 
 // src/skills/skill-nudge.ts
 var SKILL_NUDGE_MARKER = "[opendevbrowser:skill-nudge]";
-var SKILL_NUDGE_MESSAGE = `${SKILL_NUDGE_MARKER} If this task likely matches a skill, start with skill("opendevbrowser-best-practices", "quick start"). Use another skill only when it is more relevant.`;
+var SKILL_NUDGE_MESSAGE = `${SKILL_NUDGE_MARKER} If this task likely matches a skill, start with skill("${onboarding_metadata_default.skillName}", "${onboarding_metadata_default.skillTopic}"). For frontend, UI, screenshot-to-code, or /canvas design work, then load skill("${onboarding_metadata_default.designSkillName}"). Use the canonical opendevbrowser-* packs and start with the bundled quick-start lane before low-level browser commands.`;
 function createSkillNudgeState() {
   return { pending: false, requestedAtMs: null };
 }
@@ -418,18 +567,25 @@ import { tool } from "@opencode-ai/plugin";
 function ok(data) {
   return JSON.stringify({ ok: true, ...data });
 }
-function failure(message, code) {
+function failure(message, code, details) {
   return JSON.stringify({
     ok: false,
     error: {
       message,
-      code
+      code,
+      ...details ? { details } : {}
     }
   });
 }
 function serializeError(error) {
   if (error instanceof Error) {
-    return { message: error.message };
+    const detailCarrier = error;
+    const details = detailCarrier.details && typeof detailCarrier.details === "object" && !Array.isArray(detailCarrier.details) ? detailCarrier.details : detailCarrier.blocker && typeof detailCarrier.blocker === "object" && !Array.isArray(detailCarrier.blocker) ? { blocker: detailCarrier.blocker } : void 0;
+    return {
+      message: error.message,
+      code: detailCarrier.code,
+      details
+    };
   }
   return { message: "Unknown error" };
 }
@@ -463,7 +619,7 @@ function createLaunchTool(deps) {
           let relayUrl = extensionLegacy ? deps.relay?.getCdpUrl() ?? null : deps.relay?.getOpsUrl?.() ?? null;
           const relayPort = relayStatus?.port;
           if (!relayUrl && isValidPort(relayPort)) {
-            relayUrl = `ws://127.0.0.1:${relayPort}/${extensionLegacy ? "cdp" : "ops"}`;
+            relayUrl = buildLoopbackSessionRelayEndpoint(relayPort, { extensionLegacy });
           }
           const waitTimeoutMs = clampWaitTimeout(args.waitTimeoutMs ?? 3e4);
           const headlessExplicit = args.headless === true;
@@ -488,7 +644,7 @@ function createLaunchTool(deps) {
           const observedStatus = shouldFetchObserved ? await fetchRelayObservedStatus(observedPort) : null;
           if (!relayUrl) {
             const fallbackPort = isValidPort(observedStatus?.port) ? observedStatus?.port : observedPort;
-            relayUrl = fallbackPort ? `ws://127.0.0.1:${fallbackPort}/${extensionLegacy ? "cdp" : "ops"}` : null;
+            relayUrl = fallbackPort ? buildLoopbackSessionRelayEndpoint(fallbackPort, { extensionLegacy }) : null;
           }
           const extensionReady = Boolean(
             relayUrl && (relayStatus?.extensionHandshakeComplete || relayStatus?.extensionConnected || observedStatus?.extensionHandshakeComplete || observedStatus?.extensionConnected)
@@ -523,7 +679,7 @@ function createLaunchTool(deps) {
               return failure(buildExtensionMissingMessage(diagnostics.message), "extension_not_connected");
             }
             try {
-              result = await deps.manager.connectRelay(relayUrl);
+              result = args.startUrl ? await deps.manager.connectRelay(relayUrl, { startUrl: args.startUrl }) : await deps.manager.connectRelay(relayUrl);
               usedRelay = true;
             } catch (error) {
               const errorMessage = serializeError(error).message;
@@ -561,9 +717,6 @@ function createLaunchTool(deps) {
               return failure(buildManagedFailureMessage(error), "launch_failed");
             }
           }
-          if (usedRelay && args.startUrl && result.activeTargetId) {
-            await deps.manager.goto(result.sessionId, args.startUrl, "load", 3e4);
-          }
           const warnings = result.warnings ?? [];
           return ok({
             sessionId: result.sessionId,
@@ -748,21 +901,6 @@ async function fetchRelayObservedStatus(port) {
 // src/tools/connect.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
 var z2 = tool2.schema;
-function normalizeRelayEndpoint(wsEndpoint, path, allowBase) {
-  if (!wsEndpoint) return null;
-  try {
-    const url = new URL(wsEndpoint);
-    if (url.protocol !== "ws:" && url.protocol !== "wss:") return null;
-    if (url.hostname !== "127.0.0.1" && url.hostname !== "localhost") return null;
-    if (!url.port || !/^\d+$/.test(url.port)) return null;
-    const normalizedPath = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
-    if (!allowBase && normalizedPath === "") return null;
-    if (normalizedPath && normalizedPath !== `/${path}`) return null;
-    return `${url.protocol}//${url.hostname}:${url.port}/${path}`;
-  } catch {
-    return null;
-  }
-}
 function createConnectTool(deps) {
   return tool2({
     description: "Connect to an existing Chrome CDP endpoint or extension relay.",
@@ -770,6 +908,7 @@ function createConnectTool(deps) {
       wsEndpoint: z2.string().optional().describe("Full WebSocket endpoint to connect to"),
       host: z2.string().optional().describe("Host for /json/version lookup"),
       port: z2.number().int().optional().describe("Port for /json/version lookup"),
+      startUrl: z2.string().optional().describe("Open this URL immediately after connect"),
       extensionLegacy: z2.boolean().optional().describe("Use legacy extension relay (/cdp) instead of ops")
     },
     async execute(args) {
@@ -777,17 +916,19 @@ function createConnectTool(deps) {
         await deps.relay?.refresh?.();
         const wsEndpoint = args.wsEndpoint;
         const extensionLegacy = args.extensionLegacy === true;
+        const startUrl = typeof args.startUrl === "string" && args.startUrl.trim().length > 0 ? args.startUrl.trim() : void 0;
         const hasExplicitCdp = Boolean(wsEndpoint || args.host || args.port);
         const relayUrl = extensionLegacy ? deps.relay?.getCdpUrl() ?? null : deps.relay?.getOpsUrl?.() ?? null;
-        const normalizedOpsEndpoint = normalizeRelayEndpoint(wsEndpoint, "ops", true);
-        const normalizedLegacyEndpoint = normalizeRelayEndpoint(wsEndpoint, "cdp", extensionLegacy);
-        if (normalizedLegacyEndpoint && !extensionLegacy) {
-          return failure("Legacy extension relay (/cdp) requires extensionLegacy=true.", "extension_legacy_required");
+        const parsedRelayEndpoint = classifySessionRelayEndpoint(wsEndpoint);
+        const resolvedRelayEndpoint = parsedRelayEndpoint ? resolveSessionRelayRoute(parsedRelayEndpoint, { extensionLegacy }) : null;
+        if (resolvedRelayEndpoint && "code" in resolvedRelayEndpoint) {
+          return failure(resolvedRelayEndpoint.message, resolvedRelayEndpoint.code);
         }
-        const relayEndpoint = relayUrl && wsEndpoint === relayUrl ? relayUrl : extensionLegacy ? normalizedLegacyEndpoint ?? normalizedOpsEndpoint : normalizedOpsEndpoint;
+        const relayEndpoint = relayUrl && wsEndpoint === relayUrl ? relayUrl : resolvedRelayEndpoint?.normalizedEndpoint ?? null;
+        const preferredRelayEndpoint = relayEndpoint ?? (!hasExplicitCdp ? relayUrl : null);
         let result;
-        if (relayEndpoint || !hasExplicitCdp && relayUrl) {
-          result = await deps.manager.connectRelay(relayEndpoint ?? relayUrl ?? "");
+        if (preferredRelayEndpoint) {
+          result = startUrl ? await deps.manager.connectRelay(preferredRelayEndpoint, { startUrl }) : await deps.manager.connectRelay(preferredRelayEndpoint);
         } else {
           if (!hasExplicitCdp) {
             return failure("Extension relay not available. Connect the extension or pass wsEndpoint/host/port.", "extension_not_connected");
@@ -795,7 +936,8 @@ function createConnectTool(deps) {
           result = await deps.manager.connect({
             wsEndpoint,
             host: args.host,
-            port: args.port
+            port: args.port,
+            startUrl
           });
         }
         return ok({
@@ -947,15 +1089,56 @@ function createStatusTool(deps) {
   });
 }
 
-// src/tools/targets_list.ts
+// src/tools/session_inspector.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
 var z5 = tool5.schema;
-function createTargetsListTool(deps) {
+function createSessionInspectorTool(deps) {
   return tool5({
-    description: "List targets (tabs) in the current session.",
+    description: "Capture a session-first diagnostic bundle with relay health, trace proof, and a suggested next action.",
     args: {
       sessionId: z5.string().describe("Session id"),
-      includeUrls: z5.boolean().optional().describe("Include target URLs")
+      includeUrls: z5.boolean().optional().describe("Include target URLs in the targets summary"),
+      sinceConsoleSeq: z5.number().int().optional().describe("Resume cursor for console events"),
+      sinceNetworkSeq: z5.number().int().optional().describe("Resume cursor for network events"),
+      sinceExceptionSeq: z5.number().int().optional().describe("Resume cursor for exception events"),
+      max: z5.number().int().optional().describe("Max events per diagnostics channel"),
+      requestId: z5.string().optional().describe("Optional trace request id")
+    },
+    async execute(args) {
+      try {
+        const inspector = deps.manager.createSessionInspector?.();
+        if (!inspector) {
+          return failure("Session inspector is unavailable for the current runtime.", "session_inspector_unavailable");
+        }
+        await deps.relay?.refresh?.().catch(() => void 0);
+        const relayStatus = deps.relay?.status?.() ?? null;
+        const result = await inspectSession(inspector, {
+          sessionId: args.sessionId,
+          includeUrls: args.includeUrls,
+          sinceConsoleSeq: args.sinceConsoleSeq,
+          sinceNetworkSeq: args.sinceNetworkSeq,
+          sinceExceptionSeq: args.sinceExceptionSeq,
+          max: args.max,
+          requestId: args.requestId,
+          relayStatus
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "session_inspector_failed");
+      }
+    }
+  });
+}
+
+// src/tools/targets_list.ts
+import { tool as tool6 } from "@opencode-ai/plugin";
+var z6 = tool6.schema;
+function createTargetsListTool(deps) {
+  return tool6({
+    description: "List targets (tabs) in the current session.",
+    args: {
+      sessionId: z6.string().describe("Session id"),
+      includeUrls: z6.boolean().optional().describe("Include target URLs")
     },
     async execute(args) {
       try {
@@ -972,14 +1155,14 @@ function createTargetsListTool(deps) {
 }
 
 // src/tools/target_use.ts
-import { tool as tool6 } from "@opencode-ai/plugin";
-var z6 = tool6.schema;
+import { tool as tool7 } from "@opencode-ai/plugin";
+var z7 = tool7.schema;
 function createTargetUseTool(deps) {
-  return tool6({
+  return tool7({
     description: "Set the active target (tab).",
     args: {
-      sessionId: z6.string().describe("Session id"),
-      targetId: z6.string().describe("Target id")
+      sessionId: z7.string().describe("Session id"),
+      targetId: z7.string().describe("Target id")
     },
     async execute(args) {
       try {
@@ -997,14 +1180,14 @@ function createTargetUseTool(deps) {
 }
 
 // src/tools/target_new.ts
-import { tool as tool7 } from "@opencode-ai/plugin";
-var z7 = tool7.schema;
+import { tool as tool8 } from "@opencode-ai/plugin";
+var z8 = tool8.schema;
 function createTargetNewTool(deps) {
-  return tool7({
+  return tool8({
     description: "Open a new target (tab).",
     args: {
-      sessionId: z7.string().describe("Session id"),
-      url: z7.string().optional().describe("Optional URL to open")
+      sessionId: z8.string().describe("Session id"),
+      url: z8.string().optional().describe("Optional URL to open")
     },
     async execute(args) {
       try {
@@ -1018,14 +1201,14 @@ function createTargetNewTool(deps) {
 }
 
 // src/tools/target_close.ts
-import { tool as tool8 } from "@opencode-ai/plugin";
-var z8 = tool8.schema;
+import { tool as tool9 } from "@opencode-ai/plugin";
+var z9 = tool9.schema;
 function createTargetCloseTool(deps) {
-  return tool8({
+  return tool9({
     description: "Close a target (tab).",
     args: {
-      sessionId: z8.string().describe("Session id"),
-      targetId: z8.string().describe("Target id")
+      sessionId: z9.string().describe("Session id"),
+      targetId: z9.string().describe("Target id")
     },
     async execute(args) {
       try {
@@ -1039,15 +1222,15 @@ function createTargetCloseTool(deps) {
 }
 
 // src/tools/page.ts
-import { tool as tool9 } from "@opencode-ai/plugin";
-var z9 = tool9.schema;
+import { tool as tool10 } from "@opencode-ai/plugin";
+var z10 = tool10.schema;
 function createPageTool(deps) {
-  return tool9({
+  return tool10({
     description: "Open or focus a named page, optionally navigating to a URL.",
     args: {
-      sessionId: z9.string().describe("Active browser session id"),
-      name: z9.string().describe("Stable page name"),
-      url: z9.string().optional().describe("Optional URL to open")
+      sessionId: z10.string().describe("Active browser session id"),
+      name: z10.string().describe("Stable page name"),
+      url: z10.string().optional().describe("Optional URL to open")
     },
     async execute(args) {
       try {
@@ -1066,13 +1249,13 @@ function createPageTool(deps) {
 }
 
 // src/tools/list.ts
-import { tool as tool10 } from "@opencode-ai/plugin";
-var z10 = tool10.schema;
+import { tool as tool11 } from "@opencode-ai/plugin";
+var z11 = tool11.schema;
 function createListTool(deps) {
-  return tool10({
+  return tool11({
     description: "List named pages in the current session.",
     args: {
-      sessionId: z10.string().describe("Active browser session id")
+      sessionId: z11.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -1086,14 +1269,14 @@ function createListTool(deps) {
 }
 
 // src/tools/close.ts
-import { tool as tool11 } from "@opencode-ai/plugin";
-var z11 = tool11.schema;
+import { tool as tool12 } from "@opencode-ai/plugin";
+var z12 = tool12.schema;
 function createCloseTool(deps) {
-  return tool11({
+  return tool12({
     description: "Close a named page within the current session.",
     args: {
-      sessionId: z11.string().describe("Active browser session id"),
-      name: z11.string().describe("Named page to close")
+      sessionId: z12.string().describe("Active browser session id"),
+      name: z12.string().describe("Named page to close")
     },
     async execute(args) {
       try {
@@ -1107,17 +1290,18 @@ function createCloseTool(deps) {
 }
 
 // src/tools/goto.ts
-import { tool as tool12 } from "@opencode-ai/plugin";
-var z12 = tool12.schema;
-var waitUntilSchema = z12.enum(["domcontentloaded", "load", "networkidle"]);
+import { tool as tool13 } from "@opencode-ai/plugin";
+var z13 = tool13.schema;
+var waitUntilSchema = z13.enum(["domcontentloaded", "load", "networkidle"]);
 function createGotoTool(deps) {
-  return tool12({
+  return tool13({
     description: "Navigate the active target to a URL.",
     args: {
-      sessionId: z12.string().describe("Session id"),
-      url: z12.string().describe("URL to navigate to"),
+      sessionId: z13.string().describe("Session id"),
+      url: z13.string().describe("URL to navigate to"),
+      targetId: z13.string().optional().describe("Optional target id"),
       waitUntil: waitUntilSchema.optional().describe("Load state to wait for"),
-      timeoutMs: z12.number().int().optional().describe("Timeout in milliseconds")
+      timeoutMs: z13.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
@@ -1125,7 +1309,9 @@ function createGotoTool(deps) {
           args.sessionId,
           args.url,
           args.waitUntil ?? "load",
-          args.timeoutMs ?? 3e4
+          args.timeoutMs ?? 3e4,
+          void 0,
+          args.targetId
         );
         return ok(result);
       } catch (error) {
@@ -1136,19 +1322,20 @@ function createGotoTool(deps) {
 }
 
 // src/tools/wait.ts
-import { tool as tool13 } from "@opencode-ai/plugin";
-var z13 = tool13.schema;
-var waitUntilSchema2 = z13.enum(["domcontentloaded", "load", "networkidle"]);
-var waitStateSchema = z13.enum(["attached", "visible", "hidden"]);
+import { tool as tool14 } from "@opencode-ai/plugin";
+var z14 = tool14.schema;
+var waitUntilSchema2 = z14.enum(["domcontentloaded", "load", "networkidle"]);
+var waitStateSchema = z14.enum(["attached", "visible", "hidden"]);
 function createWaitTool(deps) {
-  return tool13({
+  return tool14({
     description: "Wait for a load state or a ref state.",
     args: {
-      sessionId: z13.string().describe("Session id"),
+      sessionId: z14.string().describe("Session id"),
+      targetId: z14.string().optional().describe("Optional target id"),
       until: waitUntilSchema2.optional().describe("Load state to wait for"),
-      ref: z13.string().optional().describe("Ref to wait for"),
+      ref: z14.string().optional().describe("Ref to wait for"),
       state: waitStateSchema.optional().describe("Ref state to wait for"),
-      timeoutMs: z13.number().int().optional().describe("Timeout in milliseconds")
+      timeoutMs: z14.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
@@ -1157,7 +1344,8 @@ function createWaitTool(deps) {
             args.sessionId,
             args.ref,
             args.state ?? "attached",
-            args.timeoutMs ?? 3e4
+            args.timeoutMs ?? 3e4,
+            args.targetId
           );
           return ok(result2);
         }
@@ -1167,7 +1355,8 @@ function createWaitTool(deps) {
         const result = await deps.manager.waitForLoad(
           args.sessionId,
           args.until,
-          args.timeoutMs ?? 3e4
+          args.timeoutMs ?? 3e4,
+          args.targetId
         );
         return ok(result);
       } catch (error) {
@@ -1178,17 +1367,18 @@ function createWaitTool(deps) {
 }
 
 // src/tools/snapshot.ts
-import { tool as tool14 } from "@opencode-ai/plugin";
-var z14 = tool14.schema;
-var formatSchema = z14.enum(["outline", "actionables"]);
+import { tool as tool15 } from "@opencode-ai/plugin";
+var z15 = tool15.schema;
+var formatSchema = z15.enum(["outline", "actionables"]);
 function createSnapshotTool(deps) {
-  return tool14({
+  return tool15({
     description: "Capture a snapshot of the current page and return refs.",
     args: {
-      sessionId: z14.string().describe("Session id"),
+      sessionId: z15.string().describe("Session id"),
+      targetId: z15.string().optional().describe("Optional target id"),
       format: formatSchema.optional().describe("Snapshot format"),
-      maxChars: z14.number().int().optional().describe("Max characters for snapshot output"),
-      cursor: z14.string().optional().describe("Cursor for paging")
+      maxChars: z15.number().int().optional().describe("Max characters for snapshot output"),
+      cursor: z15.string().optional().describe("Cursor for paging")
     },
     async execute(args) {
       try {
@@ -1197,7 +1387,8 @@ function createSnapshotTool(deps) {
           args.sessionId,
           args.format ?? "outline",
           args.maxChars ?? config.snapshot.maxChars,
-          args.cursor
+          args.cursor,
+          args.targetId
         );
         return ok(result);
       } catch (error) {
@@ -1207,19 +1398,50 @@ function createSnapshotTool(deps) {
   });
 }
 
+// src/tools/review.ts
+import { tool as tool16 } from "@opencode-ai/plugin";
+var z16 = tool16.schema;
+function createReviewTool(deps) {
+  return tool16({
+    description: "Capture a first-class review payload with status and actionables.",
+    args: {
+      sessionId: z16.string().describe("Session id"),
+      targetId: z16.string().optional().describe("Optional target id"),
+      maxChars: z16.number().int().optional().describe("Max characters for review output"),
+      cursor: z16.string().optional().describe("Cursor for paging")
+    },
+    async execute(args) {
+      try {
+        const config = deps.config.get();
+        const result = await buildBrowserReviewResult({
+          manager: deps.manager,
+          sessionId: args.sessionId,
+          targetId: args.targetId,
+          maxChars: args.maxChars ?? config.snapshot.maxChars,
+          cursor: args.cursor
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "review_failed");
+      }
+    }
+  });
+}
+
 // src/tools/click.ts
-import { tool as tool15 } from "@opencode-ai/plugin";
-var z15 = tool15.schema;
+import { tool as tool17 } from "@opencode-ai/plugin";
+var z17 = tool17.schema;
 function createClickTool(deps) {
-  return tool15({
+  return tool17({
     description: "Click a referenced element.",
     args: {
-      sessionId: z15.string().describe("Session id"),
-      ref: z15.string().describe("Element ref")
+      sessionId: z17.string().describe("Session id"),
+      targetId: z17.string().optional().describe("Optional target id"),
+      ref: z17.string().describe("Element ref")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.click(args.sessionId, args.ref);
+        const result = await deps.manager.click(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "click_failed");
@@ -1229,18 +1451,19 @@ function createClickTool(deps) {
 }
 
 // src/tools/hover.ts
-import { tool as tool16 } from "@opencode-ai/plugin";
-var z16 = tool16.schema;
+import { tool as tool18 } from "@opencode-ai/plugin";
+var z18 = tool18.schema;
 function createHoverTool(deps) {
-  return tool16({
+  return tool18({
     description: "Hover over an element by ref.",
     args: {
-      sessionId: z16.string().describe("Active browser session id"),
-      ref: z16.string().describe("Element ref from snapshot")
+      sessionId: z18.string().describe("Active browser session id"),
+      targetId: z18.string().optional().describe("Optional target id"),
+      ref: z18.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.hover(args.sessionId, args.ref);
+        const result = await deps.manager.hover(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "hover_failed");
@@ -1250,19 +1473,20 @@ function createHoverTool(deps) {
 }
 
 // src/tools/press.ts
-import { tool as tool17 } from "@opencode-ai/plugin";
-var z17 = tool17.schema;
+import { tool as tool19 } from "@opencode-ai/plugin";
+var z19 = tool19.schema;
 function createPressTool(deps) {
-  return tool17({
+  return tool19({
     description: "Press a keyboard key, optionally focusing a ref first.",
     args: {
-      sessionId: z17.string().describe("Active browser session id"),
-      key: z17.string().describe("Keyboard key to press, e.g. Enter or ArrowDown"),
-      ref: z17.string().optional().describe("Optional element ref to focus first")
+      sessionId: z19.string().describe("Active browser session id"),
+      targetId: z19.string().optional().describe("Optional target id"),
+      key: z19.string().describe("Keyboard key to press, e.g. Enter or ArrowDown"),
+      ref: z19.string().optional().describe("Optional element ref to focus first")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.press(args.sessionId, args.key, args.ref);
+        const result = await deps.manager.press(args.sessionId, args.key, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "press_failed");
@@ -1272,18 +1496,19 @@ function createPressTool(deps) {
 }
 
 // src/tools/check.ts
-import { tool as tool18 } from "@opencode-ai/plugin";
-var z18 = tool18.schema;
+import { tool as tool20 } from "@opencode-ai/plugin";
+var z20 = tool20.schema;
 function createCheckTool(deps) {
-  return tool18({
+  return tool20({
     description: "Check a checkbox or toggle by ref.",
     args: {
-      sessionId: z18.string().describe("Active browser session id"),
-      ref: z18.string().describe("Element ref from snapshot")
+      sessionId: z20.string().describe("Active browser session id"),
+      targetId: z20.string().optional().describe("Optional target id"),
+      ref: z20.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.check(args.sessionId, args.ref);
+        const result = await deps.manager.check(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "check_failed");
@@ -1293,18 +1518,19 @@ function createCheckTool(deps) {
 }
 
 // src/tools/uncheck.ts
-import { tool as tool19 } from "@opencode-ai/plugin";
-var z19 = tool19.schema;
+import { tool as tool21 } from "@opencode-ai/plugin";
+var z21 = tool21.schema;
 function createUncheckTool(deps) {
-  return tool19({
+  return tool21({
     description: "Uncheck a checkbox or toggle by ref.",
     args: {
-      sessionId: z19.string().describe("Active browser session id"),
-      ref: z19.string().describe("Element ref from snapshot")
+      sessionId: z21.string().describe("Active browser session id"),
+      targetId: z21.string().optional().describe("Optional target id"),
+      ref: z21.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.uncheck(args.sessionId, args.ref);
+        const result = await deps.manager.uncheck(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "uncheck_failed");
@@ -1314,17 +1540,18 @@ function createUncheckTool(deps) {
 }
 
 // src/tools/type.ts
-import { tool as tool20 } from "@opencode-ai/plugin";
-var z20 = tool20.schema;
+import { tool as tool22 } from "@opencode-ai/plugin";
+var z22 = tool22.schema;
 function createTypeTool(deps) {
-  return tool20({
+  return tool22({
     description: "Type text into a referenced input.",
     args: {
-      sessionId: z20.string().describe("Session id"),
-      ref: z20.string().describe("Element ref"),
-      text: z20.string().describe("Text to type"),
-      clear: z20.boolean().optional().describe("Clear before typing"),
-      submit: z20.boolean().optional().describe("Press Enter after typing")
+      sessionId: z22.string().describe("Session id"),
+      targetId: z22.string().optional().describe("Optional target id"),
+      ref: z22.string().describe("Element ref"),
+      text: z22.string().describe("Text to type"),
+      clear: z22.boolean().optional().describe("Clear before typing"),
+      submit: z22.boolean().optional().describe("Press Enter after typing")
     },
     async execute(args) {
       try {
@@ -1333,7 +1560,8 @@ function createTypeTool(deps) {
           args.ref,
           args.text,
           Boolean(args.clear),
-          Boolean(args.submit)
+          Boolean(args.submit),
+          args.targetId
         );
         return ok(result);
       } catch (error) {
@@ -1344,19 +1572,20 @@ function createTypeTool(deps) {
 }
 
 // src/tools/select.ts
-import { tool as tool21 } from "@opencode-ai/plugin";
-var z21 = tool21.schema;
+import { tool as tool23 } from "@opencode-ai/plugin";
+var z23 = tool23.schema;
 function createSelectTool(deps) {
-  return tool21({
+  return tool23({
     description: "Select options in a referenced select element.",
     args: {
-      sessionId: z21.string().describe("Session id"),
-      ref: z21.string().describe("Element ref"),
-      values: z21.array(z21.string()).describe("Values to select")
+      sessionId: z23.string().describe("Session id"),
+      targetId: z23.string().optional().describe("Optional target id"),
+      ref: z23.string().describe("Element ref"),
+      values: z23.array(z23.string()).describe("Values to select")
     },
     async execute(args) {
       try {
-        await deps.manager.select(args.sessionId, args.ref, args.values);
+        await deps.manager.select(args.sessionId, args.ref, args.values, args.targetId);
         return ok({});
       } catch (error) {
         return failure(serializeError(error).message, "select_failed");
@@ -1366,19 +1595,20 @@ function createSelectTool(deps) {
 }
 
 // src/tools/scroll.ts
-import { tool as tool22 } from "@opencode-ai/plugin";
-var z22 = tool22.schema;
+import { tool as tool24 } from "@opencode-ai/plugin";
+var z24 = tool24.schema;
 function createScrollTool(deps) {
-  return tool22({
+  return tool24({
     description: "Scroll the page or a referenced element.",
     args: {
-      sessionId: z22.string().describe("Session id"),
-      dy: z22.number().describe("Scroll delta in pixels"),
-      ref: z22.string().optional().describe("Optional element ref to scroll")
+      sessionId: z24.string().describe("Session id"),
+      targetId: z24.string().optional().describe("Optional target id"),
+      dy: z24.number().describe("Scroll delta in pixels"),
+      ref: z24.string().optional().describe("Optional element ref to scroll")
     },
     async execute(args) {
       try {
-        await deps.manager.scroll(args.sessionId, args.dy, args.ref);
+        await deps.manager.scroll(args.sessionId, args.dy, args.ref, args.targetId);
         return ok({});
       } catch (error) {
         return failure(serializeError(error).message, "scroll_failed");
@@ -1388,18 +1618,19 @@ function createScrollTool(deps) {
 }
 
 // src/tools/scroll_into_view.ts
-import { tool as tool23 } from "@opencode-ai/plugin";
-var z23 = tool23.schema;
+import { tool as tool25 } from "@opencode-ai/plugin";
+var z25 = tool25.schema;
 function createScrollIntoViewTool(deps) {
-  return tool23({
+  return tool25({
     description: "Scroll an element into view by ref.",
     args: {
-      sessionId: z23.string().describe("Active browser session id"),
-      ref: z23.string().describe("Element ref from snapshot")
+      sessionId: z25.string().describe("Active browser session id"),
+      targetId: z25.string().optional().describe("Optional target id"),
+      ref: z25.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.scrollIntoView(args.sessionId, args.ref);
+        const result = await deps.manager.scrollIntoView(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "scroll_into_view_failed");
@@ -1408,23 +1639,172 @@ function createScrollIntoViewTool(deps) {
   });
 }
 
+// src/tools/upload.ts
+import { tool as tool26 } from "@opencode-ai/plugin";
+var z26 = tool26.schema;
+function createUploadTool(deps) {
+  return tool26({
+    description: "Upload files to an input or chooser by ref.",
+    args: {
+      sessionId: z26.string().describe("Active browser session id"),
+      targetId: z26.string().optional().describe("Optional target id"),
+      ref: z26.string().describe("Element ref"),
+      files: z26.array(z26.string()).min(1).describe("Local host file paths")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.upload(args.sessionId, {
+          targetId: args.targetId,
+          ref: args.ref,
+          files: args.files
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "upload_failed");
+      }
+    }
+  });
+}
+
+// src/tools/pointer_move.ts
+import { tool as tool27 } from "@opencode-ai/plugin";
+var z27 = tool27.schema;
+function createPointerMoveTool(deps) {
+  return tool27({
+    description: "Move the pointer to viewport coordinates.",
+    args: {
+      sessionId: z27.string().describe("Active browser session id"),
+      targetId: z27.string().optional().describe("Optional target id"),
+      x: z27.number().describe("Viewport x coordinate"),
+      y: z27.number().describe("Viewport y coordinate"),
+      steps: z27.number().int().positive().optional().describe("Optional move interpolation step count")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.pointerMove(args.sessionId, args.x, args.y, args.targetId, args.steps);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "pointer_move_failed");
+      }
+    }
+  });
+}
+
+// src/tools/pointer_down.ts
+import { tool as tool28 } from "@opencode-ai/plugin";
+var z28 = tool28.schema;
+function createPointerDownTool(deps) {
+  return tool28({
+    description: "Move to viewport coordinates and press a mouse button.",
+    args: {
+      sessionId: z28.string().describe("Active browser session id"),
+      targetId: z28.string().optional().describe("Optional target id"),
+      x: z28.number().describe("Viewport x coordinate"),
+      y: z28.number().describe("Viewport y coordinate"),
+      button: z28.enum(["left", "middle", "right"]).optional().describe("Mouse button to press"),
+      clickCount: z28.number().int().positive().optional().describe("Associated click count")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.pointerDown(
+          args.sessionId,
+          args.x,
+          args.y,
+          args.targetId,
+          args.button,
+          args.clickCount
+        );
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "pointer_down_failed");
+      }
+    }
+  });
+}
+
+// src/tools/pointer_up.ts
+import { tool as tool29 } from "@opencode-ai/plugin";
+var z29 = tool29.schema;
+function createPointerUpTool(deps) {
+  return tool29({
+    description: "Move to viewport coordinates and release a mouse button.",
+    args: {
+      sessionId: z29.string().describe("Active browser session id"),
+      targetId: z29.string().optional().describe("Optional target id"),
+      x: z29.number().describe("Viewport x coordinate"),
+      y: z29.number().describe("Viewport y coordinate"),
+      button: z29.enum(["left", "middle", "right"]).optional().describe("Mouse button to release"),
+      clickCount: z29.number().int().positive().optional().describe("Associated click count")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.pointerUp(
+          args.sessionId,
+          args.x,
+          args.y,
+          args.targetId,
+          args.button,
+          args.clickCount
+        );
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "pointer_up_failed");
+      }
+    }
+  });
+}
+
+// src/tools/pointer_drag.ts
+import { tool as tool30 } from "@opencode-ai/plugin";
+var z30 = tool30.schema;
+function createPointerDragTool(deps) {
+  return tool30({
+    description: "Drag the pointer between two viewport coordinates.",
+    args: {
+      sessionId: z30.string().describe("Active browser session id"),
+      targetId: z30.string().optional().describe("Optional target id"),
+      fromX: z30.number().describe("Start x coordinate"),
+      fromY: z30.number().describe("Start y coordinate"),
+      toX: z30.number().describe("End x coordinate"),
+      toY: z30.number().describe("End y coordinate"),
+      steps: z30.number().int().positive().optional().describe("Optional drag interpolation step count")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.drag(
+          args.sessionId,
+          { x: args.fromX, y: args.fromY },
+          { x: args.toX, y: args.toY },
+          args.targetId,
+          args.steps
+        );
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "pointer_drag_failed");
+      }
+    }
+  });
+}
+
 // src/tools/dom_get_html.ts
-import { tool as tool24 } from "@opencode-ai/plugin";
-var z24 = tool24.schema;
+import { tool as tool31 } from "@opencode-ai/plugin";
+var z31 = tool31.schema;
 function createDomGetHtmlTool(deps) {
-  return tool24({
+  return tool31({
     description: "Get outerHTML for a referenced element.",
     args: {
-      sessionId: z24.string().describe("Session id"),
-      ref: z24.string().describe("Element ref"),
-      maxChars: z24.number().int().optional().describe("Max characters")
+      sessionId: z31.string().describe("Session id"),
+      targetId: z31.string().optional().describe("Optional target id"),
+      ref: z31.string().describe("Element ref"),
+      maxChars: z31.number().int().optional().describe("Max characters")
     },
     async execute(args) {
       try {
         const result = await deps.manager.domGetHtml(
           args.sessionId,
           args.ref,
-          args.maxChars ?? 8e3
+          args.maxChars ?? 8e3,
+          args.targetId
         );
         return ok({
           ref: args.ref,
@@ -1439,22 +1819,24 @@ function createDomGetHtmlTool(deps) {
 }
 
 // src/tools/dom_get_text.ts
-import { tool as tool25 } from "@opencode-ai/plugin";
-var z25 = tool25.schema;
+import { tool as tool32 } from "@opencode-ai/plugin";
+var z32 = tool32.schema;
 function createDomGetTextTool(deps) {
-  return tool25({
+  return tool32({
     description: "Get inner text for a referenced element.",
     args: {
-      sessionId: z25.string().describe("Session id"),
-      ref: z25.string().describe("Element ref"),
-      maxChars: z25.number().int().optional().describe("Max characters")
+      sessionId: z32.string().describe("Session id"),
+      targetId: z32.string().optional().describe("Optional target id"),
+      ref: z32.string().describe("Element ref"),
+      maxChars: z32.number().int().optional().describe("Max characters")
     },
     async execute(args) {
       try {
         const result = await deps.manager.domGetText(
           args.sessionId,
           args.ref,
-          args.maxChars ?? 8e3
+          args.maxChars ?? 8e3,
+          args.targetId
         );
         return ok({
           ref: args.ref,
@@ -1469,19 +1851,20 @@ function createDomGetTextTool(deps) {
 }
 
 // src/tools/get_attr.ts
-import { tool as tool26 } from "@opencode-ai/plugin";
-var z26 = tool26.schema;
+import { tool as tool33 } from "@opencode-ai/plugin";
+var z33 = tool33.schema;
 function createGetAttrTool(deps) {
-  return tool26({
+  return tool33({
     description: "Get a DOM attribute value by ref.",
     args: {
-      sessionId: z26.string().describe("Active browser session id"),
-      ref: z26.string().describe("Element ref from snapshot"),
-      name: z26.string().describe("Attribute name, e.g. href or aria-label")
+      sessionId: z33.string().describe("Active browser session id"),
+      targetId: z33.string().optional().describe("Optional target id"),
+      ref: z33.string().describe("Element ref from snapshot"),
+      name: z33.string().describe("Attribute name, e.g. href or aria-label")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.domGetAttr(args.sessionId, args.ref, args.name);
+        const result = await deps.manager.domGetAttr(args.sessionId, args.ref, args.name, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "get_attr_failed");
@@ -1491,18 +1874,19 @@ function createGetAttrTool(deps) {
 }
 
 // src/tools/get_value.ts
-import { tool as tool27 } from "@opencode-ai/plugin";
-var z27 = tool27.schema;
+import { tool as tool34 } from "@opencode-ai/plugin";
+var z34 = tool34.schema;
 function createGetValueTool(deps) {
-  return tool27({
+  return tool34({
     description: "Get the input value for an element by ref.",
     args: {
-      sessionId: z27.string().describe("Active browser session id"),
-      ref: z27.string().describe("Element ref from snapshot")
+      sessionId: z34.string().describe("Active browser session id"),
+      targetId: z34.string().optional().describe("Optional target id"),
+      ref: z34.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.domGetValue(args.sessionId, args.ref);
+        const result = await deps.manager.domGetValue(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "get_value_failed");
@@ -1512,18 +1896,19 @@ function createGetValueTool(deps) {
 }
 
 // src/tools/is_visible.ts
-import { tool as tool28 } from "@opencode-ai/plugin";
-var z28 = tool28.schema;
+import { tool as tool35 } from "@opencode-ai/plugin";
+var z35 = tool35.schema;
 function createIsVisibleTool(deps) {
-  return tool28({
+  return tool35({
     description: "Check if an element is visible by ref.",
     args: {
-      sessionId: z28.string().describe("Active browser session id"),
-      ref: z28.string().describe("Element ref from snapshot")
+      sessionId: z35.string().describe("Active browser session id"),
+      targetId: z35.string().optional().describe("Optional target id"),
+      ref: z35.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.domIsVisible(args.sessionId, args.ref);
+        const result = await deps.manager.domIsVisible(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "is_visible_failed");
@@ -1533,18 +1918,19 @@ function createIsVisibleTool(deps) {
 }
 
 // src/tools/is_enabled.ts
-import { tool as tool29 } from "@opencode-ai/plugin";
-var z29 = tool29.schema;
+import { tool as tool36 } from "@opencode-ai/plugin";
+var z36 = tool36.schema;
 function createIsEnabledTool(deps) {
-  return tool29({
+  return tool36({
     description: "Check if an element is enabled by ref.",
     args: {
-      sessionId: z29.string().describe("Active browser session id"),
-      ref: z29.string().describe("Element ref from snapshot")
+      sessionId: z36.string().describe("Active browser session id"),
+      targetId: z36.string().optional().describe("Optional target id"),
+      ref: z36.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.domIsEnabled(args.sessionId, args.ref);
+        const result = await deps.manager.domIsEnabled(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "is_enabled_failed");
@@ -1554,18 +1940,19 @@ function createIsEnabledTool(deps) {
 }
 
 // src/tools/is_checked.ts
-import { tool as tool30 } from "@opencode-ai/plugin";
-var z30 = tool30.schema;
+import { tool as tool37 } from "@opencode-ai/plugin";
+var z37 = tool37.schema;
 function createIsCheckedTool(deps) {
-  return tool30({
+  return tool37({
     description: "Check if an element is checked by ref.",
     args: {
-      sessionId: z30.string().describe("Active browser session id"),
-      ref: z30.string().describe("Element ref from snapshot")
+      sessionId: z37.string().describe("Active browser session id"),
+      targetId: z37.string().optional().describe("Optional target id"),
+      ref: z37.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.domIsChecked(args.sessionId, args.ref);
+        const result = await deps.manager.domIsChecked(args.sessionId, args.ref, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "is_checked_failed");
@@ -1575,20 +1962,20 @@ function createIsCheckedTool(deps) {
 }
 
 // src/tools/run.ts
-import { tool as tool31 } from "@opencode-ai/plugin";
-var z31 = tool31.schema;
-var stepSchema = z31.object({
-  action: z31.string().describe("Action name"),
-  args: z31.record(z31.string(), z31.unknown()).optional().describe("Action arguments")
+import { tool as tool38 } from "@opencode-ai/plugin";
+var z38 = tool38.schema;
+var stepSchema = z38.object({
+  action: z38.string().describe("Action name"),
+  args: z38.record(z38.string(), z38.unknown()).optional().describe("Action arguments")
 });
 function createRunTool(deps) {
-  return tool31({
+  return tool38({
     description: "Run multiple actions in a single tool call.",
     args: {
-      sessionId: z31.string().describe("Session id"),
-      steps: z31.array(stepSchema).describe("Steps to execute"),
-      stopOnError: z31.boolean().optional().describe("Stop when a step fails"),
-      maxSnapshotChars: z31.number().int().optional().describe("Default maxChars for snapshot steps")
+      sessionId: z38.string().describe("Session id"),
+      steps: z38.array(stepSchema).describe("Steps to execute"),
+      stopOnError: z38.boolean().optional().describe("Stop when a step fails"),
+      maxSnapshotChars: z38.number().int().optional().describe("Default maxChars for snapshot steps")
     },
     async execute(args) {
       try {
@@ -1621,13 +2008,13 @@ function normalizeSteps(steps, maxSnapshotChars) {
 }
 
 // src/tools/prompting_guide.ts
-import { tool as tool32 } from "@opencode-ai/plugin";
-var z32 = tool32.schema;
+import { tool as tool39 } from "@opencode-ai/plugin";
+var z39 = tool39.schema;
 function createPromptingGuideTool(deps) {
-  return tool32({
-    description: "Return best-practice prompting guidance for OpenDevBrowser.",
+  return tool39({
+    description: `Start here for first-contact OpenDevBrowser guidance, including ${onboarding_metadata_default.skillName} ${onboarding_metadata_default.skillTopic}.`,
     args: {
-      topic: z32.string().optional().describe("Optional topic for guidance")
+      topic: z39.string().optional().describe("Optional topic for guidance")
     },
     async execute(args) {
       try {
@@ -1641,15 +2028,15 @@ function createPromptingGuideTool(deps) {
 }
 
 // src/tools/console_poll.ts
-import { tool as tool33 } from "@opencode-ai/plugin";
-var z33 = tool33.schema;
+import { tool as tool40 } from "@opencode-ai/plugin";
+var z40 = tool40.schema;
 function createConsolePollTool(deps) {
-  return tool33({
+  return tool40({
     description: "Poll console events for the active target.",
     args: {
-      sessionId: z33.string().describe("Session id"),
-      sinceSeq: z33.number().int().optional().describe("Sequence to resume from"),
-      max: z33.number().int().optional().describe("Max events to return")
+      sessionId: z40.string().describe("Session id"),
+      sinceSeq: z40.number().int().optional().describe("Sequence to resume from"),
+      max: z40.number().int().optional().describe("Max events to return")
     },
     async execute(args) {
       try {
@@ -1667,15 +2054,15 @@ function createConsolePollTool(deps) {
 }
 
 // src/tools/network_poll.ts
-import { tool as tool34 } from "@opencode-ai/plugin";
-var z34 = tool34.schema;
+import { tool as tool41 } from "@opencode-ai/plugin";
+var z41 = tool41.schema;
 function createNetworkPollTool(deps) {
-  return tool34({
+  return tool41({
     description: "Poll network events for the active target.",
     args: {
-      sessionId: z34.string().describe("Session id"),
-      sinceSeq: z34.number().int().optional().describe("Sequence to resume from"),
-      max: z34.number().int().optional().describe("Max events to return")
+      sessionId: z41.string().describe("Session id"),
+      sinceSeq: z41.number().int().optional().describe("Sequence to resume from"),
+      max: z41.number().int().optional().describe("Max events to return")
     },
     async execute(args) {
       try {
@@ -1693,18 +2080,18 @@ function createNetworkPollTool(deps) {
 }
 
 // src/tools/debug_trace_snapshot.ts
-import { tool as tool35 } from "@opencode-ai/plugin";
-var z35 = tool35.schema;
+import { tool as tool42 } from "@opencode-ai/plugin";
+var z42 = tool42.schema;
 function createDebugTraceSnapshotTool(deps) {
-  return tool35({
+  return tool42({
     description: "Capture a combined debug trace snapshot (page + console + network + exceptions).",
     args: {
-      sessionId: z35.string().describe("Session id"),
-      sinceConsoleSeq: z35.number().int().optional().describe("Resume cursor for console events"),
-      sinceNetworkSeq: z35.number().int().optional().describe("Resume cursor for network events"),
-      sinceExceptionSeq: z35.number().int().optional().describe("Resume cursor for exception events"),
-      max: z35.number().int().optional().describe("Max events per channel"),
-      requestId: z35.string().optional().describe("Optional trace request id")
+      sessionId: z42.string().describe("Session id"),
+      sinceConsoleSeq: z42.number().int().optional().describe("Resume cursor for console events"),
+      sinceNetworkSeq: z42.number().int().optional().describe("Resume cursor for network events"),
+      sinceExceptionSeq: z42.number().int().optional().describe("Resume cursor for exception events"),
+      max: z42.number().int().optional().describe("Max events per channel"),
+      requestId: z42.string().optional().describe("Optional trace request id")
     },
     async execute(args) {
       try {
@@ -1814,8 +2201,8 @@ function extractHosts(events) {
 }
 
 // src/tools/cookie_import.ts
-import { tool as tool36 } from "@opencode-ai/plugin";
-var z36 = tool36.schema;
+import { tool as tool43 } from "@opencode-ai/plugin";
+var z43 = tool43.schema;
 function validateCookieRecord(cookie) {
   const name = cookie.name?.trim();
   if (!name) {
@@ -1894,23 +2281,23 @@ function validateCookieRecord(cookie) {
   };
 }
 function createCookieImportTool(deps) {
-  return tool36({
+  return tool43({
     description: "Import validated cookies into the current session context.",
     args: {
-      sessionId: z36.string().describe("Session id"),
-      cookies: z36.array(z36.object({
-        name: z36.string().min(1),
-        value: z36.string(),
-        url: z36.string().optional(),
-        domain: z36.string().optional(),
-        path: z36.string().optional(),
-        expires: z36.number().optional(),
-        httpOnly: z36.boolean().optional(),
-        secure: z36.boolean().optional(),
-        sameSite: z36.enum(["Strict", "Lax", "None"]).optional()
+      sessionId: z43.string().describe("Session id"),
+      cookies: z43.array(z43.object({
+        name: z43.string().min(1),
+        value: z43.string(),
+        url: z43.string().optional(),
+        domain: z43.string().optional(),
+        path: z43.string().optional(),
+        expires: z43.number().optional(),
+        httpOnly: z43.boolean().optional(),
+        secure: z43.boolean().optional(),
+        sameSite: z43.enum(["Strict", "Lax", "None"]).optional()
       })).min(1).describe("Cookies to import"),
-      strict: z36.boolean().optional().describe("Reject on first invalid cookie (default true)"),
-      requestId: z36.string().optional().describe("Optional trace request id")
+      strict: z43.boolean().optional().describe("Reject on first invalid cookie (default true)"),
+      requestId: z43.string().optional().describe("Optional trace request id")
     },
     async execute(args) {
       try {
@@ -1952,8 +2339,8 @@ function createCookieImportTool(deps) {
 }
 
 // src/tools/cookie_list.ts
-import { tool as tool37 } from "@opencode-ai/plugin";
-var z37 = tool37.schema;
+import { tool as tool44 } from "@opencode-ai/plugin";
+var z44 = tool44.schema;
 function normalizeCookieUrls(urls) {
   if (!urls || urls.length === 0) {
     return void 0;
@@ -1984,12 +2371,12 @@ function normalizeCookieUrls(urls) {
   return normalized;
 }
 function createCookieListTool(deps) {
-  return tool37({
+  return tool44({
     description: "List cookies in the current session context with optional URL filtering.",
     args: {
-      sessionId: z37.string().describe("Session id"),
-      urls: z37.array(z37.string().min(1)).optional().describe("Optional URL filters for cookie scoping"),
-      requestId: z37.string().optional().describe("Optional trace request id")
+      sessionId: z44.string().describe("Session id"),
+      urls: z44.array(z44.string().min(1)).optional().describe("Optional URL filters for cookie scoping"),
+      requestId: z44.string().optional().describe("Optional trace request id")
     },
     async execute(args) {
       try {
@@ -2029,11 +2416,24 @@ function createCookieListTool(deps) {
 }
 
 // src/tools/macro_resolve.ts
-import { tool as tool38 } from "@opencode-ai/plugin";
-var z38 = tool38.schema;
+import { tool as tool45 } from "@opencode-ai/plugin";
+
+// src/tools/workflow-runtime.ts
+var resolveProviderRuntime = async (deps, options) => {
+  return resolveBundledProviderRuntime({
+    existingRuntime: deps.providerRuntime,
+    config: deps.config?.get?.(),
+    manager: deps.manager,
+    browserFallbackPort: deps.browserFallbackPort,
+    init: options?.init
+  });
+};
+
+// src/tools/macro_resolve.ts
+var z45 = tool45.schema;
 async function loadMacroRuntime() {
   try {
-    const module = await import("./macros-NUBRM44Y.js");
+    const module = await import("./macros-ND2M7LWU.js");
     return module;
   } catch {
     return null;
@@ -2078,13 +2478,13 @@ function parseFallbackMacro(expression, defaultProvider) {
   };
 }
 function createMacroResolveTool(deps) {
-  return tool38({
+  return tool45({
     description: "Resolve a macro expression to a provider action with provenance metadata.",
     args: {
-      expression: z38.string().min(2).describe('Macro expression, e.g. @web.search("query")'),
-      defaultProvider: z38.string().optional().describe("Default provider fallback"),
-      includeCatalog: z38.boolean().optional().describe("Include available runtime macro names"),
-      execute: z38.boolean().optional().describe("Execute the resolved provider action and include execution payload")
+      expression: z45.string().min(2).describe('Macro expression, e.g. @web.search("query")'),
+      defaultProvider: z45.string().optional().describe("Default provider fallback"),
+      includeCatalog: z45.boolean().optional().describe("Include available runtime macro names"),
+      execute: z45.boolean().optional().describe("Execute the resolved provider action and include execution payload")
     },
     async execute(args) {
       try {
@@ -2113,15 +2513,11 @@ function createMacroResolveTool(deps) {
             ...catalog ? { catalog } : {}
           });
         }
-        const runtimeConfig = deps.config?.get?.();
-        const providerRuntime = deps.providerRuntime ?? createConfiguredProviderRuntime({
-          config: runtimeConfig,
-          manager: deps.manager,
-          browserFallbackPort: deps.browserFallbackPort
+        const providerRuntime = await resolveProviderRuntime(deps);
+        const execution = await executeMacroWithRuntime({
+          resolution,
+          runtime: providerRuntime
         });
-        const execution = shapeExecutionPayload(
-          await executeMacroResolution(resolution, providerRuntime)
-        );
         return ok({
           runtime: resolvedRuntime,
           resolution,
@@ -2136,17 +2532,18 @@ function createMacroResolveTool(deps) {
 }
 
 // src/tools/clone_page.ts
-import { tool as tool39 } from "@opencode-ai/plugin";
-var z39 = tool39.schema;
+import { tool as tool46 } from "@opencode-ai/plugin";
+var z46 = tool46.schema;
 function createClonePageTool(deps) {
-  return tool39({
+  return tool46({
     description: "Export the active page as a React component and CSS bundle.",
     args: {
-      sessionId: z39.string().describe("Active browser session id")
+      sessionId: z46.string().describe("Active browser session id"),
+      targetId: z46.string().optional().describe("Optional target id")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.clonePage(args.sessionId);
+        const result = await deps.manager.clonePage(args.sessionId, args.targetId);
         return ok({ component: result.component, css: result.css, warnings: result.warnings });
       } catch (error) {
         return failure(serializeError(error).message, "clone_page_failed");
@@ -2156,18 +2553,19 @@ function createClonePageTool(deps) {
 }
 
 // src/tools/clone_component.ts
-import { tool as tool40 } from "@opencode-ai/plugin";
-var z40 = tool40.schema;
+import { tool as tool47 } from "@opencode-ai/plugin";
+var z47 = tool47.schema;
 function createCloneComponentTool(deps) {
-  return tool40({
+  return tool47({
     description: "Export a selected element subtree as a React component and CSS bundle.",
     args: {
-      sessionId: z40.string().describe("Active browser session id"),
-      ref: z40.string().describe("Element ref from snapshot")
+      sessionId: z47.string().describe("Active browser session id"),
+      targetId: z47.string().optional().describe("Optional target id"),
+      ref: z47.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.cloneComponent(args.sessionId, args.ref);
+        const result = await deps.manager.cloneComponent(args.sessionId, args.ref, args.targetId);
         return ok({ component: result.component, css: result.css, warnings: result.warnings });
       } catch (error) {
         return failure(serializeError(error).message, "clone_component_failed");
@@ -2177,17 +2575,18 @@ function createCloneComponentTool(deps) {
 }
 
 // src/tools/perf.ts
-import { tool as tool41 } from "@opencode-ai/plugin";
-var z41 = tool41.schema;
+import { tool as tool48 } from "@opencode-ai/plugin";
+var z48 = tool48.schema;
 function createPerfTool(deps) {
-  return tool41({
+  return tool48({
     description: "Fetch lightweight performance metrics from the active page.",
     args: {
-      sessionId: z41.string().describe("Active browser session id")
+      sessionId: z48.string().describe("Active browser session id"),
+      targetId: z48.string().optional().describe("Optional target id")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.perfMetrics(args.sessionId);
+        const result = await deps.manager.perfMetrics(args.sessionId, args.targetId);
         return ok({ metrics: result.metrics });
       } catch (error) {
         return failure(serializeError(error).message, "perf_failed");
@@ -2197,18 +2596,26 @@ function createPerfTool(deps) {
 }
 
 // src/tools/screenshot.ts
-import { tool as tool42 } from "@opencode-ai/plugin";
-var z42 = tool42.schema;
+import { tool as tool49 } from "@opencode-ai/plugin";
+var z49 = tool49.schema;
 function createScreenshotTool(deps) {
-  return tool42({
+  return tool49({
     description: "Capture a screenshot of the active page.",
     args: {
-      sessionId: z42.string().describe("Active browser session id"),
-      path: z42.string().optional().describe("Optional output file path")
+      sessionId: z49.string().describe("Active browser session id"),
+      targetId: z49.string().optional().describe("Optional target id"),
+      path: z49.string().optional().describe("Optional output file path"),
+      ref: z49.string().optional().describe("Optional snapshot ref for an element capture"),
+      fullPage: z49.boolean().optional().describe("Capture the full scrollable page")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.screenshot(args.sessionId, args.path);
+        const result = await deps.manager.screenshot(args.sessionId, {
+          targetId: args.targetId,
+          path: args.path,
+          ref: args.ref,
+          fullPage: args.fullPage
+        });
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "screenshot_failed");
@@ -2217,29 +2624,273 @@ function createScreenshotTool(deps) {
   });
 }
 
+// src/tools/screencast_start.ts
+import { tool as tool50 } from "@opencode-ai/plugin";
+var z50 = tool50.schema;
+function createScreencastStartTool(deps) {
+  return tool50({
+    description: "Start a browser screencast replay capture.",
+    args: {
+      sessionId: z50.string().describe("Active browser session id"),
+      targetId: z50.string().optional().describe("Optional target id"),
+      outputDir: z50.string().optional().describe("Optional screencast output directory"),
+      intervalMs: z50.number().int().min(250).optional().describe("Frame capture interval in milliseconds"),
+      maxFrames: z50.number().int().min(1).optional().describe("Maximum frame count before auto-stop")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.startScreencast(args.sessionId, {
+          targetId: args.targetId,
+          outputDir: args.outputDir,
+          intervalMs: args.intervalMs,
+          maxFrames: args.maxFrames
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "screencast_start_failed");
+      }
+    }
+  });
+}
+
+// src/tools/screencast_stop.ts
+import { tool as tool51 } from "@opencode-ai/plugin";
+var z51 = tool51.schema;
+function createScreencastStopTool(deps) {
+  return tool51({
+    description: "Stop a browser screencast replay capture.",
+    args: {
+      sessionId: z51.string().describe("Browser session id that owns the screencast"),
+      screencastId: z51.string().describe("Active screencast id")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.stopScreencast(args.sessionId, args.screencastId);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "screencast_stop_failed");
+      }
+    }
+  });
+}
+
+// src/tools/dialog.ts
+import { tool as tool52 } from "@opencode-ai/plugin";
+var z52 = tool52.schema;
+function createDialogTool(deps) {
+  return tool52({
+    description: "Inspect or handle a JavaScript dialog.",
+    args: {
+      sessionId: z52.string().describe("Active browser session id"),
+      targetId: z52.string().optional().describe("Optional target id"),
+      action: z52.enum(["status", "accept", "dismiss"]).optional().describe("Dialog action"),
+      promptText: z52.string().optional().describe("Prompt text to submit when accepting a prompt dialog")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.dialog(args.sessionId, {
+          targetId: args.targetId,
+          action: args.action,
+          promptText: args.promptText
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "dialog_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_status.ts
+import { tool as tool53 } from "@opencode-ai/plugin";
+
+// src/tools/desktop-shared.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireDesktopRuntime(deps) {
+  if (deps.desktopRuntime) {
+    return deps.desktopRuntime;
+  }
+  return failure("Desktop runtime unavailable.", "desktop_runtime_unavailable");
+}
+function desktopResult(result) {
+  if (result.ok) {
+    const payload = isRecord(result.value) ? { ok: true, ...result.value, audit: result.audit } : { ok: true, value: result.value, audit: result.audit };
+    return JSON.stringify(payload);
+  }
+  return JSON.stringify({
+    ok: false,
+    code: result.code,
+    message: result.message,
+    audit: result.audit
+  });
+}
+function desktopToolFailure(error, code) {
+  return failure(serializeError(error).message, code);
+}
+
+// src/tools/desktop_status.ts
+function createDesktopStatusTool(deps) {
+  return tool53({
+    description: "Inspect sibling desktop observation availability.",
+    args: {},
+    async execute() {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return ok(await runtime.status());
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_status_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_windows.ts
+import { tool as tool54 } from "@opencode-ai/plugin";
+var z53 = tool54.schema;
+function createDesktopWindowsTool(deps) {
+  return tool54({
+    description: "List observable desktop windows.",
+    args: {
+      reason: z53.string().optional().describe("Optional audit reason")
+    },
+    async execute(args) {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return desktopResult(await runtime.listWindows(args.reason));
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_windows_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_active_window.ts
+import { tool as tool55 } from "@opencode-ai/plugin";
+var z54 = tool55.schema;
+function createDesktopActiveWindowTool(deps) {
+  return tool55({
+    description: "Inspect the active desktop window.",
+    args: {
+      reason: z54.string().optional().describe("Optional audit reason")
+    },
+    async execute(args) {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return desktopResult(await runtime.activeWindow(args.reason));
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_active_window_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_capture_desktop.ts
+import { tool as tool56 } from "@opencode-ai/plugin";
+var z55 = tool56.schema;
+function createDesktopCaptureDesktopTool(deps) {
+  return tool56({
+    description: "Capture the current desktop surface.",
+    args: {
+      reason: z55.string().describe("Audit reason for the capture")
+    },
+    async execute(args) {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return desktopResult(await runtime.captureDesktop({ reason: args.reason }));
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_capture_desktop_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_capture_window.ts
+import { tool as tool57 } from "@opencode-ai/plugin";
+var z56 = tool57.schema;
+function createDesktopCaptureWindowTool(deps) {
+  return tool57({
+    description: "Capture a specific desktop window.",
+    args: {
+      windowId: z56.string().describe("Desktop window id"),
+      reason: z56.string().describe("Audit reason for the capture")
+    },
+    async execute(args) {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return desktopResult(await runtime.captureWindow(args.windowId, { reason: args.reason }));
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_capture_window_failed");
+      }
+    }
+  });
+}
+
+// src/tools/desktop_accessibility_snapshot.ts
+import { tool as tool58 } from "@opencode-ai/plugin";
+var z57 = tool58.schema;
+function createDesktopAccessibilitySnapshotTool(deps) {
+  return tool58({
+    description: "Capture desktop accessibility state.",
+    args: {
+      reason: z57.string().describe("Audit reason for the accessibility snapshot"),
+      windowId: z57.string().optional().describe("Optional desktop window id")
+    },
+    async execute(args) {
+      const runtime = requireDesktopRuntime(deps);
+      if (typeof runtime === "string") {
+        return runtime;
+      }
+      try {
+        return desktopResult(await runtime.accessibilitySnapshot(args.reason, args.windowId));
+      } catch (error) {
+        return desktopToolFailure(error, "desktop_accessibility_snapshot_failed");
+      }
+    }
+  });
+}
+
 // src/tools/annotate.ts
-import { tool as tool43 } from "@opencode-ai/plugin";
-var z43 = tool43.schema;
-var screenshotModeSchema = z43.enum(["visible", "full", "none"]);
-var transportSchema = z43.enum(["auto", "direct", "relay"]);
+import { tool as tool59 } from "@opencode-ai/plugin";
+var z58 = tool59.schema;
+var screenshotModeSchema = z58.enum(["visible", "full", "none"]);
+var transportSchema = z58.enum(["auto", "direct", "relay"]);
 function createAnnotateTool(deps) {
-  return tool43({
+  return tool59({
     description: "Request interactive annotations via direct (CDP) or relay transport.",
     args: {
-      sessionId: z43.string().describe("Session id"),
+      sessionId: z58.string().describe("Session id"),
+      stored: z58.boolean().optional().describe("Fetch the latest payload explicitly sent from popup/canvas surfaces"),
+      includeScreenshots: z58.boolean().optional().describe("When fetching stored payloads, prefer screenshots if still available in memory"),
       transport: transportSchema.optional().describe("auto | direct | relay (default: auto)"),
-      targetId: z43.string().optional().describe("Optional target id for direct mode"),
-      tabId: z43.number().int().optional().describe("Optional Chrome tab id for relay mode"),
-      url: z43.string().optional().describe("Optional URL to open before annotating"),
+      targetId: z58.string().optional().describe("Optional target id for direct mode"),
+      tabId: z58.number().int().optional().describe("Optional Chrome tab id for relay mode"),
+      url: z58.string().optional().describe("Optional URL to open before annotating"),
       screenshotMode: screenshotModeSchema.optional().describe("visible | full | none (default: visible)"),
-      debug: z43.boolean().optional().describe("Include debug metadata"),
-      context: z43.string().optional().describe("Optional context for the annotator"),
-      timeoutMs: z43.number().int().optional().describe("Timeout in milliseconds")
+      debug: z58.boolean().optional().describe("Include debug metadata"),
+      context: z58.string().optional().describe("Optional context for the annotator"),
+      timeoutMs: z58.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
-        const transport = args.transport ?? "auto";
-        if (transport === "relay") {
+        const transport = args.stored ? "relay" : args.transport ?? "auto";
+        if (transport === "relay" && !args.stored) {
           const status = await deps.manager.status(args.sessionId);
           if (status.mode !== "extension") {
             return failure("Annotations require extension mode (relay).", "annotate_requires_extension");
@@ -2248,6 +2899,8 @@ function createAnnotateTool(deps) {
         const response = await deps.annotationManager.requestAnnotation({
           sessionId: args.sessionId,
           transport,
+          stored: args.stored ?? false,
+          includeScreenshots: args.includeScreenshots ?? true,
           targetId: args.targetId,
           tabId: args.tabId,
           url: args.url,
@@ -2256,6 +2909,12 @@ function createAnnotateTool(deps) {
           context: args.context,
           timeoutMs: args.timeoutMs
         });
+        if (response.status === "cancelled") {
+          return ok({
+            cancelled: true,
+            message: response.error?.message ?? "Annotation cancelled."
+          });
+        }
         if (response.status !== "ok" || !response.payload) {
           const message2 = response.error?.message ?? "Annotation failed.";
           const code = response.error?.code ?? "annotate_failed";
@@ -2275,47 +2934,36 @@ function createAnnotateTool(deps) {
 }
 
 // src/tools/research_run.ts
-import { tool as tool44 } from "@opencode-ai/plugin";
-
-// src/tools/workflow-runtime.ts
-var resolveProviderRuntime = (deps) => {
-  if (deps.providerRuntime) {
-    return deps.providerRuntime;
-  }
-  return createConfiguredProviderRuntime({
-    config: deps.config?.get?.(),
-    manager: deps.manager,
-    browserFallbackPort: deps.browserFallbackPort
-  });
-};
-
-// src/tools/research_run.ts
-var z44 = tool44.schema;
-var sourceSelectionSchema = z44.enum(["auto", "web", "community", "social", "shopping", "all"]);
-var sourceSchema = z44.enum(["web", "community", "social", "shopping"]);
-var modeSchema = z44.enum(["compact", "json", "md", "context", "path"]);
-var cookiePolicySchema = z44.enum(["off", "auto", "required"]);
+import { tool as tool60 } from "@opencode-ai/plugin";
+var z59 = tool60.schema;
+var sourceSelectionSchema = z59.enum(["auto", "web", "community", "social", "shopping", "all"]);
+var sourceSchema = z59.enum(["web", "community", "social", "shopping"]);
+var modeSchema = z59.enum(["compact", "json", "md", "context", "path"]);
+var cookiePolicySchema = z59.enum(["off", "auto", "required"]);
+var challengeAutomationModeSchema = z59.enum(CHALLENGE_AUTOMATION_MODES);
 function createResearchRunTool(deps) {
-  return tool44({
+  return tool60({
     description: "Run cross-source research with strict timebox and artifact outputs.",
     args: {
-      topic: z44.string().min(1).describe("Research topic"),
-      days: z44.number().int().positive().optional().describe("Timebox in days"),
-      from: z44.string().optional().describe("ISO start date"),
-      to: z44.string().optional().describe("ISO end date"),
+      topic: z59.string().min(1).describe("Research topic"),
+      days: z59.number().int().positive().optional().describe("Timebox in days"),
+      from: z59.string().optional().describe("ISO start date"),
+      to: z59.string().optional().describe("ISO end date"),
       sourceSelection: sourceSelectionSchema.optional().describe("auto|web|community|social|shopping|all"),
-      sources: z44.array(sourceSchema).optional().describe("Explicit source list"),
+      sources: z59.array(sourceSchema).optional().describe("Explicit source list"),
       mode: modeSchema.optional().describe("compact|json|md|context|path"),
-      includeEngagement: z44.boolean().optional().describe("Include engagement enrichment"),
-      limitPerSource: z44.number().int().positive().optional().describe("Result limit per source"),
-      outputDir: z44.string().optional().describe("Optional artifact output directory"),
-      ttlHours: z44.number().int().positive().optional().describe("Artifact retention TTL in hours"),
-      useCookies: z44.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      includeEngagement: z59.boolean().optional().describe("Include engagement enrichment"),
+      limitPerSource: z59.number().int().positive().optional().describe("Result limit per source"),
+      outputDir: z59.string().optional().describe("Optional artifact output directory"),
+      ttlHours: z59.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      useCookies: z59.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      challengeAutomationMode: challengeAutomationModeSchema.optional().describe("Challenge automation mode: off|browser|browser_with_helper"),
       cookiePolicyOverride: cookiePolicySchema.optional().describe("Override cookie policy: off|auto|required")
     },
     async execute(args) {
       try {
-        const runtime = resolveProviderRuntime(deps);
+        const runtime = await resolveProviderRuntime(deps);
+        const { runResearchWorkflow } = await import("./providers-G36AM3Z2.js");
         const result = await runResearchWorkflow(runtime, {
           topic: args.topic,
           days: args.days,
@@ -2329,6 +2977,7 @@ function createResearchRunTool(deps) {
           outputDir: args.outputDir,
           ttlHours: args.ttlHours,
           useCookies: args.useCookies,
+          challengeAutomationMode: args.challengeAutomationMode,
           cookiePolicyOverride: args.cookiePolicyOverride
         });
         return ok(result);
@@ -2340,29 +2989,32 @@ function createResearchRunTool(deps) {
 }
 
 // src/tools/shopping_run.ts
-import { tool as tool45 } from "@opencode-ai/plugin";
-var z45 = tool45.schema;
-var sortSchema = z45.enum(["best_deal", "lowest_price", "highest_rating", "fastest_shipping"]);
-var modeSchema2 = z45.enum(["compact", "json", "md", "context", "path"]);
-var cookiePolicySchema2 = z45.enum(["off", "auto", "required"]);
+import { tool as tool61 } from "@opencode-ai/plugin";
+var z60 = tool61.schema;
+var sortSchema = z60.enum(["best_deal", "lowest_price", "highest_rating", "fastest_shipping"]);
+var modeSchema2 = z60.enum(["compact", "json", "md", "context", "path"]);
+var cookiePolicySchema2 = z60.enum(["off", "auto", "required"]);
+var challengeAutomationModeSchema2 = z60.enum(CHALLENGE_AUTOMATION_MODES);
 function createShoppingRunTool(deps) {
-  return tool45({
+  return tool61({
     description: "Run shopping/deal intelligence across shopping providers.",
     args: {
-      query: z45.string().min(1).describe("Shopping query"),
-      providers: z45.array(z45.string()).optional().describe("Optional provider allow-list"),
-      budget: z45.number().positive().optional().describe("Optional budget amount"),
-      region: z45.string().optional().describe("Region hint"),
+      query: z60.string().min(1).describe("Shopping query"),
+      providers: z60.array(z60.string()).optional().describe("Optional provider allow-list"),
+      budget: z60.number().positive().optional().describe("Optional budget amount"),
+      region: z60.string().optional().describe("Region hint"),
       sort: sortSchema.optional().describe("best_deal|lowest_price|highest_rating|fastest_shipping"),
       mode: modeSchema2.optional().describe("compact|json|md|context|path"),
-      outputDir: z45.string().optional().describe("Optional artifact output directory"),
-      ttlHours: z45.number().int().positive().optional().describe("Artifact retention TTL in hours"),
-      useCookies: z45.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      outputDir: z60.string().optional().describe("Optional artifact output directory"),
+      ttlHours: z60.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      useCookies: z60.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      challengeAutomationMode: challengeAutomationModeSchema2.optional().describe("Challenge automation mode: off|browser|browser_with_helper"),
       cookiePolicyOverride: cookiePolicySchema2.optional().describe("Override cookie policy: off|auto|required")
     },
     async execute(args) {
       try {
-        const runtime = resolveProviderRuntime(deps);
+        const runtime = await resolveProviderRuntime(deps);
+        const { runShoppingWorkflow } = await import("./providers-G36AM3Z2.js");
         const result = await runShoppingWorkflow(runtime, {
           query: args.query,
           providers: args.providers,
@@ -2373,6 +3025,7 @@ function createShoppingRunTool(deps) {
           outputDir: args.outputDir,
           ttlHours: args.ttlHours,
           useCookies: args.useCookies,
+          challengeAutomationMode: args.challengeAutomationMode,
           cookiePolicyOverride: args.cookiePolicyOverride
         });
         return ok(result);
@@ -2384,9 +3037,10 @@ function createShoppingRunTool(deps) {
 }
 
 // src/tools/product_video_run.ts
-import { tool as tool46 } from "@opencode-ai/plugin";
-var z46 = tool46.schema;
-var cookiePolicySchema3 = z46.enum(["off", "auto", "required"]);
+import { tool as tool62 } from "@opencode-ai/plugin";
+var z61 = tool62.schema;
+var cookiePolicySchema3 = z61.enum(["off", "auto", "required"]);
+var challengeAutomationModeSchema3 = z61.enum(CHALLENGE_AUTOMATION_MODES);
 async function captureScreenshotBuffer(deps, url) {
   let sessionId = null;
   try {
@@ -2410,23 +3064,26 @@ async function captureScreenshotBuffer(deps, url) {
   }
 }
 function createProductVideoRunTool(deps) {
-  return tool46({
+  return tool62({
     description: "Collect a product presentation asset pack for video/UGC workflows.",
     args: {
-      product_url: z46.string().optional().describe("Product URL"),
-      product_name: z46.string().optional().describe("Product name"),
-      provider_hint: z46.string().optional().describe("Optional provider hint"),
-      include_screenshots: z46.boolean().optional().describe("Include screenshots (default true)"),
-      include_all_images: z46.boolean().optional().describe("Include all discovered images (default true)"),
-      include_copy: z46.boolean().optional().describe("Include product copy extraction (default true)"),
-      output_dir: z46.string().optional().describe("Optional output directory"),
-      ttl_hours: z46.number().int().positive().optional().describe("Artifact retention TTL in hours"),
-      useCookies: z46.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      product_url: z61.string().optional().describe("Product URL"),
+      product_name: z61.string().optional().describe("Product name"),
+      provider_hint: z61.string().optional().describe("Optional provider hint"),
+      include_screenshots: z61.boolean().optional().describe("Include screenshots (default true)"),
+      include_all_images: z61.boolean().optional().describe("Include all discovered images (default true)"),
+      include_copy: z61.boolean().optional().describe("Include product copy extraction (default true)"),
+      output_dir: z61.string().optional().describe("Optional output directory"),
+      ttl_hours: z61.number().int().positive().optional().describe("Artifact retention TTL in hours"),
+      timeoutMs: z61.number().int().positive().optional().describe("Workflow timeout in milliseconds"),
+      useCookies: z61.boolean().optional().describe("Enable/disable provider cookie injection for this run"),
+      challengeAutomationMode: challengeAutomationModeSchema3.optional().describe("Challenge automation mode: off|browser|browser_with_helper"),
       cookiePolicyOverride: cookiePolicySchema3.optional().describe("Override cookie policy: off|auto|required")
     },
     async execute(args) {
       try {
-        const runtime = resolveProviderRuntime(deps);
+        const runtime = await resolveProviderRuntime(deps);
+        const { runProductVideoWorkflow } = await import("./providers-G36AM3Z2.js");
         const includeScreenshots = args.include_screenshots ?? true;
         const result = await runProductVideoWorkflow(runtime, {
           product_url: args.product_url,
@@ -2437,7 +3094,9 @@ function createProductVideoRunTool(deps) {
           include_copy: args.include_copy,
           output_dir: args.output_dir,
           ttl_hours: args.ttl_hours,
+          timeoutMs: args.timeoutMs,
           useCookies: args.useCookies,
+          challengeAutomationMode: args.challengeAutomationMode,
           cookiePolicyOverride: args.cookiePolicyOverride
         }, {
           captureScreenshot: includeScreenshots ? async (url) => captureScreenshotBuffer(deps, url) : void 0
@@ -2450,11 +3109,42 @@ function createProductVideoRunTool(deps) {
   });
 }
 
+// src/tools/canvas.ts
+import { tool as tool63 } from "@opencode-ai/plugin";
+var z62 = tool63.schema;
+function createCanvasTool(deps) {
+  return tool63({
+    description: "Execute a typed design-canvas command such as canvas.session.open, canvas.feedback.next, or canvas.document.patch.",
+    args: {
+      command: z62.string().min(1).describe("Canvas command name"),
+      params: z62.record(z62.string(), z62.unknown()).optional().describe("Canvas command payload")
+    },
+    async execute(args) {
+      if (!deps.canvasManager) {
+        return failure("Canvas manager unavailable.", "canvas_unavailable");
+      }
+      try {
+        if (!args.command.startsWith("canvas.")) {
+          return failure("Canvas commands must start with 'canvas.'.", "canvas_invalid_command");
+        }
+        const result = await deps.canvasManager.execute(args.command, args.params ?? {});
+        if (result && typeof result === "object" && !Array.isArray(result)) {
+          return ok(result);
+        }
+        return ok({ result });
+      } catch (error) {
+        const serialized = serializeError(error);
+        return failure(serialized.message, serialized.code ?? "canvas_failed", serialized.details);
+      }
+    }
+  });
+}
+
 // src/tools/skill_list.ts
-import { tool as tool47 } from "@opencode-ai/plugin";
+import { tool as tool64 } from "@opencode-ai/plugin";
 function createSkillListTool(deps) {
-  return tool47({
-    description: "List available skills from OpenCode skill directories (compatibility wrapper)",
+  return tool64({
+    description: "List bundled and discovered skill packs before choosing a local onboarding or workflow lane.",
     args: {},
     async execute() {
       const skills = await deps.skills.listSkills();
@@ -2463,20 +3153,23 @@ function createSkillListTool(deps) {
         description: s.description,
         version: s.version
       }));
-      return ok({ skills: skillList, count: skillList.length });
+      return ok({
+        skills: skillList,
+        count: skillList.length
+      });
     }
   });
 }
 
 // src/tools/skill_load.ts
-import { tool as tool48 } from "@opencode-ai/plugin";
-var z47 = tool48.schema;
+import { tool as tool65 } from "@opencode-ai/plugin";
+var z63 = tool65.schema;
 function createSkillLoadTool(deps) {
-  return tool48({
-    description: "Load a specific skill by name from OpenCode skill directories (compatibility wrapper)",
+  return tool65({
+    description: `Load a local skill directly; start with ${onboarding_metadata_default.skillName} ${onboarding_metadata_default.skillTopic} before low-level browser commands.`,
     args: {
-      name: z47.string().describe("Name of the skill to load (e.g., 'opendevbrowser-login-automation', 'opendevbrowser-form-testing')"),
-      topic: z47.string().optional().describe("Optional topic to filter the skill content")
+      name: z63.string().describe("Name of the skill to load (e.g., 'opendevbrowser-login-automation', 'opendevbrowser-form-testing')"),
+      topic: z63.string().optional().describe("Optional topic to filter the skill content")
     },
     async execute(args) {
       try {
@@ -2491,9 +3184,10 @@ function createSkillLoadTool(deps) {
 }
 
 // src/tools/index.ts
+var LOCAL_ONLY_TOOL_NAMES = new Set(onboarding_metadata_default.localOnlyToolNames);
 function createTools(deps) {
-  const wrap = (definition) => {
-    if (!deps.ensureHub) return definition;
+  const wrap = (name, definition) => {
+    if (!deps.ensureHub || LOCAL_ONLY_TOOL_NAMES.has(name)) return definition;
     return {
       ...definition,
       execute: async (args, context) => {
@@ -2506,65 +3200,88 @@ function createTools(deps) {
     };
   };
   return {
-    opendevbrowser_launch: wrap(createLaunchTool(deps)),
-    opendevbrowser_connect: wrap(createConnectTool(deps)),
-    opendevbrowser_disconnect: wrap(createDisconnectTool(deps)),
-    opendevbrowser_status: wrap(createStatusTool(deps)),
-    opendevbrowser_targets_list: wrap(createTargetsListTool(deps)),
-    opendevbrowser_target_use: wrap(createTargetUseTool(deps)),
-    opendevbrowser_target_new: wrap(createTargetNewTool(deps)),
-    opendevbrowser_target_close: wrap(createTargetCloseTool(deps)),
-    opendevbrowser_page: wrap(createPageTool(deps)),
-    opendevbrowser_list: wrap(createListTool(deps)),
-    opendevbrowser_close: wrap(createCloseTool(deps)),
-    opendevbrowser_goto: wrap(createGotoTool(deps)),
-    opendevbrowser_wait: wrap(createWaitTool(deps)),
-    opendevbrowser_snapshot: wrap(createSnapshotTool(deps)),
-    opendevbrowser_click: wrap(createClickTool(deps)),
-    opendevbrowser_hover: wrap(createHoverTool(deps)),
-    opendevbrowser_press: wrap(createPressTool(deps)),
-    opendevbrowser_check: wrap(createCheckTool(deps)),
-    opendevbrowser_uncheck: wrap(createUncheckTool(deps)),
-    opendevbrowser_type: wrap(createTypeTool(deps)),
-    opendevbrowser_select: wrap(createSelectTool(deps)),
-    opendevbrowser_scroll: wrap(createScrollTool(deps)),
-    opendevbrowser_scroll_into_view: wrap(createScrollIntoViewTool(deps)),
-    opendevbrowser_dom_get_html: wrap(createDomGetHtmlTool(deps)),
-    opendevbrowser_dom_get_text: wrap(createDomGetTextTool(deps)),
-    opendevbrowser_get_attr: wrap(createGetAttrTool(deps)),
-    opendevbrowser_get_value: wrap(createGetValueTool(deps)),
-    opendevbrowser_is_visible: wrap(createIsVisibleTool(deps)),
-    opendevbrowser_is_enabled: wrap(createIsEnabledTool(deps)),
-    opendevbrowser_is_checked: wrap(createIsCheckedTool(deps)),
-    opendevbrowser_run: wrap(createRunTool(deps)),
-    opendevbrowser_prompting_guide: wrap(createPromptingGuideTool(deps)),
-    opendevbrowser_console_poll: wrap(createConsolePollTool(deps)),
-    opendevbrowser_network_poll: wrap(createNetworkPollTool(deps)),
-    opendevbrowser_debug_trace_snapshot: wrap(createDebugTraceSnapshotTool(deps)),
-    opendevbrowser_cookie_import: wrap(createCookieImportTool(deps)),
-    opendevbrowser_cookie_list: wrap(createCookieListTool(deps)),
-    opendevbrowser_macro_resolve: wrap(createMacroResolveTool(deps)),
-    opendevbrowser_research_run: wrap(createResearchRunTool(deps)),
-    opendevbrowser_shopping_run: wrap(createShoppingRunTool(deps)),
-    opendevbrowser_product_video_run: wrap(createProductVideoRunTool(deps)),
-    opendevbrowser_clone_page: wrap(createClonePageTool(deps)),
-    opendevbrowser_clone_component: wrap(createCloneComponentTool(deps)),
-    opendevbrowser_perf: wrap(createPerfTool(deps)),
-    opendevbrowser_screenshot: wrap(createScreenshotTool(deps)),
-    opendevbrowser_annotate: wrap(createAnnotateTool(deps)),
-    opendevbrowser_skill_list: wrap(createSkillListTool(deps)),
-    opendevbrowser_skill_load: wrap(createSkillLoadTool(deps))
+    opendevbrowser_launch: wrap("opendevbrowser_launch", createLaunchTool(deps)),
+    opendevbrowser_connect: wrap("opendevbrowser_connect", createConnectTool(deps)),
+    opendevbrowser_disconnect: wrap("opendevbrowser_disconnect", createDisconnectTool(deps)),
+    opendevbrowser_status: wrap("opendevbrowser_status", createStatusTool(deps)),
+    opendevbrowser_session_inspector: wrap("opendevbrowser_session_inspector", createSessionInspectorTool(deps)),
+    opendevbrowser_targets_list: wrap("opendevbrowser_targets_list", createTargetsListTool(deps)),
+    opendevbrowser_target_use: wrap("opendevbrowser_target_use", createTargetUseTool(deps)),
+    opendevbrowser_target_new: wrap("opendevbrowser_target_new", createTargetNewTool(deps)),
+    opendevbrowser_target_close: wrap("opendevbrowser_target_close", createTargetCloseTool(deps)),
+    opendevbrowser_page: wrap("opendevbrowser_page", createPageTool(deps)),
+    opendevbrowser_list: wrap("opendevbrowser_list", createListTool(deps)),
+    opendevbrowser_close: wrap("opendevbrowser_close", createCloseTool(deps)),
+    opendevbrowser_goto: wrap("opendevbrowser_goto", createGotoTool(deps)),
+    opendevbrowser_wait: wrap("opendevbrowser_wait", createWaitTool(deps)),
+    opendevbrowser_snapshot: wrap("opendevbrowser_snapshot", createSnapshotTool(deps)),
+    opendevbrowser_review: wrap("opendevbrowser_review", createReviewTool(deps)),
+    opendevbrowser_click: wrap("opendevbrowser_click", createClickTool(deps)),
+    opendevbrowser_hover: wrap("opendevbrowser_hover", createHoverTool(deps)),
+    opendevbrowser_press: wrap("opendevbrowser_press", createPressTool(deps)),
+    opendevbrowser_check: wrap("opendevbrowser_check", createCheckTool(deps)),
+    opendevbrowser_uncheck: wrap("opendevbrowser_uncheck", createUncheckTool(deps)),
+    opendevbrowser_type: wrap("opendevbrowser_type", createTypeTool(deps)),
+    opendevbrowser_select: wrap("opendevbrowser_select", createSelectTool(deps)),
+    opendevbrowser_scroll: wrap("opendevbrowser_scroll", createScrollTool(deps)),
+    opendevbrowser_scroll_into_view: wrap("opendevbrowser_scroll_into_view", createScrollIntoViewTool(deps)),
+    opendevbrowser_upload: wrap("opendevbrowser_upload", createUploadTool(deps)),
+    opendevbrowser_pointer_move: wrap("opendevbrowser_pointer_move", createPointerMoveTool(deps)),
+    opendevbrowser_pointer_down: wrap("opendevbrowser_pointer_down", createPointerDownTool(deps)),
+    opendevbrowser_pointer_up: wrap("opendevbrowser_pointer_up", createPointerUpTool(deps)),
+    opendevbrowser_pointer_drag: wrap("opendevbrowser_pointer_drag", createPointerDragTool(deps)),
+    opendevbrowser_dom_get_html: wrap("opendevbrowser_dom_get_html", createDomGetHtmlTool(deps)),
+    opendevbrowser_dom_get_text: wrap("opendevbrowser_dom_get_text", createDomGetTextTool(deps)),
+    opendevbrowser_get_attr: wrap("opendevbrowser_get_attr", createGetAttrTool(deps)),
+    opendevbrowser_get_value: wrap("opendevbrowser_get_value", createGetValueTool(deps)),
+    opendevbrowser_is_visible: wrap("opendevbrowser_is_visible", createIsVisibleTool(deps)),
+    opendevbrowser_is_enabled: wrap("opendevbrowser_is_enabled", createIsEnabledTool(deps)),
+    opendevbrowser_is_checked: wrap("opendevbrowser_is_checked", createIsCheckedTool(deps)),
+    opendevbrowser_run: wrap("opendevbrowser_run", createRunTool(deps)),
+    opendevbrowser_prompting_guide: wrap("opendevbrowser_prompting_guide", createPromptingGuideTool(deps)),
+    opendevbrowser_console_poll: wrap("opendevbrowser_console_poll", createConsolePollTool(deps)),
+    opendevbrowser_network_poll: wrap("opendevbrowser_network_poll", createNetworkPollTool(deps)),
+    opendevbrowser_debug_trace_snapshot: wrap("opendevbrowser_debug_trace_snapshot", createDebugTraceSnapshotTool(deps)),
+    opendevbrowser_cookie_import: wrap("opendevbrowser_cookie_import", createCookieImportTool(deps)),
+    opendevbrowser_cookie_list: wrap("opendevbrowser_cookie_list", createCookieListTool(deps)),
+    opendevbrowser_macro_resolve: wrap("opendevbrowser_macro_resolve", createMacroResolveTool(deps)),
+    opendevbrowser_research_run: wrap("opendevbrowser_research_run", createResearchRunTool(deps)),
+    opendevbrowser_shopping_run: wrap("opendevbrowser_shopping_run", createShoppingRunTool(deps)),
+    opendevbrowser_product_video_run: wrap("opendevbrowser_product_video_run", createProductVideoRunTool(deps)),
+    opendevbrowser_canvas: wrap("opendevbrowser_canvas", createCanvasTool(deps)),
+    opendevbrowser_clone_page: wrap("opendevbrowser_clone_page", createClonePageTool(deps)),
+    opendevbrowser_clone_component: wrap("opendevbrowser_clone_component", createCloneComponentTool(deps)),
+    opendevbrowser_perf: wrap("opendevbrowser_perf", createPerfTool(deps)),
+    opendevbrowser_screenshot: wrap("opendevbrowser_screenshot", createScreenshotTool(deps)),
+    opendevbrowser_screencast_start: wrap("opendevbrowser_screencast_start", createScreencastStartTool(deps)),
+    opendevbrowser_screencast_stop: wrap("opendevbrowser_screencast_stop", createScreencastStopTool(deps)),
+    opendevbrowser_dialog: wrap("opendevbrowser_dialog", createDialogTool(deps)),
+    opendevbrowser_desktop_status: wrap("opendevbrowser_desktop_status", createDesktopStatusTool(deps)),
+    opendevbrowser_desktop_windows: wrap("opendevbrowser_desktop_windows", createDesktopWindowsTool(deps)),
+    opendevbrowser_desktop_active_window: wrap("opendevbrowser_desktop_active_window", createDesktopActiveWindowTool(deps)),
+    opendevbrowser_desktop_capture_desktop: wrap("opendevbrowser_desktop_capture_desktop", createDesktopCaptureDesktopTool(deps)),
+    opendevbrowser_desktop_capture_window: wrap("opendevbrowser_desktop_capture_window", createDesktopCaptureWindowTool(deps)),
+    opendevbrowser_desktop_accessibility_snapshot: wrap(
+      "opendevbrowser_desktop_accessibility_snapshot",
+      createDesktopAccessibilitySnapshotTool(deps)
+    ),
+    opendevbrowser_annotate: wrap("opendevbrowser_annotate", createAnnotateTool(deps)),
+    opendevbrowser_skill_list: wrap("opendevbrowser_skill_list", createSkillListTool(deps)),
+    opendevbrowser_skill_load: wrap("opendevbrowser_skill_load", createSkillLoadTool(deps))
   };
 }
 
 // src/index.ts
 var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   const core = createOpenDevBrowserCore({ directory, worktree });
-  const { config, configStore, skills, ensureRelay, cleanup, getExtensionPath } = core;
+  const { config, configStore, skills, ensureRelay, cleanup, getExtensionPath, agentInbox } = core;
   let relay = core.relay;
   let manager = core.manager;
+  let canvasManager = core.canvasManager;
   let runner = core.runner;
   let annotationManager = core.annotationManager;
+  let desktopRuntime = core.desktopRuntime;
+  let automationCoordinator = core.automationCoordinator;
   let providerRuntime = core.providerRuntime;
   let browserFallbackPort = core.browserFallbackPort;
   let hubStop = null;
@@ -2581,10 +3298,13 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   }
   const toolDeps = {
     manager,
+    canvasManager,
     annotationManager,
     runner,
     config: configStore,
     skills,
+    desktopRuntime,
+    automationCoordinator,
     providerRuntime,
     browserFallbackPort,
     relay,
@@ -2595,19 +3315,30 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
       daemonClient = new DaemonClient({ autoRenew: true });
     }
     manager = new RemoteManager(daemonClient);
+    canvasManager = new RemoteCanvasManager(daemonClient);
+    desktopRuntime = new RemoteDesktopRuntime(daemonClient);
     relay = new RemoteRelay(daemonClient);
     annotationManager.setRelay(relay);
     annotationManager.setBrowserManager(manager);
     runner = new ScriptRunner(manager);
-    browserFallbackPort = createBrowserFallbackPort(manager);
-    providerRuntime = createConfiguredProviderRuntime({
+    ({
+      providerRuntime,
+      browserFallbackPort
+    } = createCoreRuntimeAssemblies({
+      cacheRoot: core.cacheRoot,
       config: configStore.get(),
+      manager
+    }));
+    automationCoordinator = createAutomationCoordinator({
       manager,
-      browserFallbackPort
+      desktopRuntime
     });
     toolDeps.manager = manager;
+    toolDeps.canvasManager = canvasManager;
     toolDeps.relay = relay;
     toolDeps.runner = runner;
+    toolDeps.desktopRuntime = desktopRuntime;
+    toolDeps.automationCoordinator = automationCoordinator;
     toolDeps.providerRuntime = providerRuntime;
     toolDeps.browserFallbackPort = browserFallbackPort;
   };
@@ -2670,11 +3401,30 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   process.on("SIGINT", cleanupAll);
   process.on("SIGTERM", cleanupAll);
   process.on("beforeExit", cleanupAll);
+  const registerAgentInboxScope = (sessionID, registration) => {
+    if (!sessionID) {
+      return;
+    }
+    try {
+      agentInbox.registerScope(sessionID, registration);
+    } catch (error) {
+      console.warn(
+        "[opendevbrowser] Failed to register agent inbox scope:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  };
   return {
     tool: createTools(toolDeps),
-    "chat.message": async (_input, output) => {
+    "chat.message": async (input, output) => {
       const config2 = configStore.get();
       if (output.message.role !== "user") return;
+      registerAgentInboxScope(input.sessionID, {
+        messageId: input.messageID ?? null,
+        agent: input.agent ?? null,
+        model: input.model ?? null,
+        variant: input.variant ?? null
+      });
       const text = extractTextFromParts(output.parts);
       if (!text) return;
       if (config2.skills.nudge.enabled && shouldTriggerSkillNudge(text, config2.skills.nudge.keywords)) {
@@ -2686,11 +3436,22 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
         }
       }
     },
-    "experimental.chat.system.transform": async (_input, output) => {
+    "experimental.chat.system.transform": async (input, output) => {
       const config2 = configStore.get();
       const systemEntries = output.system ?? [];
       let nextEntries = systemEntries;
       let changed = false;
+      registerAgentInboxScope(input.sessionID, {
+        model: null
+      });
+      if (input.sessionID && !systemEntries.some((entry) => entry.includes(AGENT_INBOX_SYSTEM_MARKER))) {
+        const injection = agentInbox.buildSystemInjection(input.sessionID);
+        if (injection) {
+          nextEntries = [...nextEntries, injection.systemBlock];
+          agentInbox.acknowledge(injection.receiptIds);
+          changed = true;
+        }
+      }
       if (config2.skills.nudge.enabled) {
         if (systemEntries.some((entry) => entry.includes(SKILL_NUDGE_MARKER))) {
           clearSkillNudge(skillNudgeState);