opendevbrowser 0.0.15 → 0.0.17

package/dist/index.js

@@ -3,10 +3,24 @@ import {
   ScriptRunner,
   buildAnnotateResult,
   createOpenDevBrowserCore,
+  executeMacroResolution,
   extractExtension,
   fetchDaemonStatusFromMetadata,
+  shapeExecutionPayload,
   startDaemon
-} from "./chunk-JVBMT2O5.js";
+} from "./chunk-5J3IFL3X.js";
+import "./chunk-Y2KL55OG.js";
+import "./chunk-TBUCZX4A.js";
+import {
+  createBrowserFallbackPort,
+  createConfiguredProviderRuntime
+} from "./chunk-V7KUDHDG.js";
+import {
+  buildBlockerArtifacts,
+  classifyBlockerSignal,
+  createRequestId
+} from "./chunk-D633UO34.js";
+import "./chunk-FUSXMW3G.js";
 
 // src/cli/remote-manager.ts
 function isLegacyRelayEndpoint(wsEndpoint) {
@@ -29,10 +43,18 @@ 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;
     return this.client.call(
       "session.connect",
-      isLegacyRelayEndpoint(wsEndpoint) ? { wsEndpoint, extensionLegacy: true } : { wsEndpoint }
+      isLegacyRelayEndpoint(wsEndpoint) ? {
+        wsEndpoint,
+        extensionLegacy: true,
+        ...startUrl ? { startUrl } : {}
+      } : {
+        wsEndpoint,
+        ...startUrl ? { startUrl } : {}
+      }
     );
   }
   disconnect(sessionId, closeBrowser = false) {
@@ -41,77 +63,202 @@ var RemoteManager = class {
   status(sessionId) {
     return this.client.call("session.status", { sessionId });
   }
-  goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4) {
-    return this.client.call("nav.goto", { sessionId, url, waitUntil, timeoutMs });
+  cookieImport(sessionId, cookies, strict = true, requestId) {
+    return this.client.call("session.cookieImport", {
+      sessionId,
+      cookies,
+      strict,
+      requestId
+    });
   }
-  waitForLoad(sessionId, until, timeoutMs = 3e4) {
-    return this.client.call("nav.wait", { sessionId, until, timeoutMs });
+  cookieList(sessionId, urls, requestId) {
+    return this.client.call("session.cookieList", {
+      sessionId,
+      ...urls && urls.length > 0 ? { urls } : {},
+      requestId
+    });
   }
-  waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4) {
-    return this.client.call("nav.wait", { sessionId, ref, state, timeoutMs });
+  goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4, _sessionOverride, targetId) {
+    return this.client.call("nav.goto", {
+      sessionId,
+      url,
+      waitUntil,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  snapshot(sessionId, mode, maxChars, cursor) {
-    return this.client.call("nav.snapshot", { sessionId, mode, maxChars, cursor });
+  waitForLoad(sessionId, until, timeoutMs = 3e4, targetId) {
+    return this.client.call("nav.wait", {
+      sessionId,
+      until,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  click(sessionId, ref) {
-    return this.client.call("interact.click", { sessionId, ref });
+  waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4, targetId) {
+    return this.client.call("nav.wait", {
+      sessionId,
+      ref,
+      state,
+      timeoutMs,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  hover(sessionId, ref) {
-    return this.client.call("interact.hover", { sessionId, ref });
+  snapshot(sessionId, mode, maxChars, cursor, targetId) {
+    return this.client.call("nav.snapshot", {
+      sessionId,
+      mode,
+      maxChars,
+      cursor,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  press(sessionId, key, ref) {
-    return this.client.call("interact.press", { sessionId, key, ref });
+  click(sessionId, ref, targetId) {
+    return this.client.call("interact.click", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  check(sessionId, ref) {
-    return this.client.call("interact.check", { sessionId, ref });
+  hover(sessionId, ref, targetId) {
+    return this.client.call("interact.hover", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  uncheck(sessionId, ref) {
-    return this.client.call("interact.uncheck", { sessionId, ref });
+  press(sessionId, key, ref, targetId) {
+    return this.client.call("interact.press", {
+      sessionId,
+      key,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  type(sessionId, ref, text, clear = false, submit = false) {
-    return this.client.call("interact.type", { sessionId, ref, text, clear, submit });
+  check(sessionId, ref, targetId) {
+    return this.client.call("interact.check", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  select(sessionId, ref, values) {
-    return this.client.call("interact.select", { sessionId, ref, values });
+  uncheck(sessionId, ref, targetId) {
+    return this.client.call("interact.uncheck", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  scroll(sessionId, dy, ref) {
-    return this.client.call("interact.scroll", { sessionId, dy, ref });
+  type(sessionId, ref, text, clear = false, submit = false, targetId) {
+    return this.client.call("interact.type", {
+      sessionId,
+      ref,
+      text,
+      clear,
+      submit,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  scrollIntoView(sessionId, ref) {
-    return this.client.call("interact.scrollIntoView", { sessionId, ref });
+  select(sessionId, ref, values, targetId) {
+    return this.client.call("interact.select", {
+      sessionId,
+      ref,
+      values,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetHtml(sessionId, ref, maxChars = 8e3) {
-    return this.client.call("dom.getHtml", { sessionId, ref, maxChars });
+  scroll(sessionId, dy, ref, targetId) {
+    return this.client.call("interact.scroll", {
+      sessionId,
+      dy,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetText(sessionId, ref, maxChars = 8e3) {
-    return this.client.call("dom.getText", { sessionId, ref, maxChars });
+  scrollIntoView(sessionId, ref, targetId) {
+    return this.client.call("interact.scrollIntoView", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetAttr(sessionId, ref, name) {
-    return this.client.call("dom.getAttr", { sessionId, ref, name });
+  domGetHtml(sessionId, ref, maxChars = 8e3, targetId) {
+    return this.client.call("dom.getHtml", {
+      sessionId,
+      ref,
+      maxChars,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domGetValue(sessionId, ref) {
-    return this.client.call("dom.getValue", { sessionId, ref });
+  domGetText(sessionId, ref, maxChars = 8e3, targetId) {
+    return this.client.call("dom.getText", {
+      sessionId,
+      ref,
+      maxChars,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsVisible(sessionId, ref) {
-    return this.client.call("dom.isVisible", { sessionId, ref });
+  domGetAttr(sessionId, ref, name, targetId) {
+    return this.client.call("dom.getAttr", {
+      sessionId,
+      ref,
+      name,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsEnabled(sessionId, ref) {
-    return this.client.call("dom.isEnabled", { sessionId, ref });
+  domGetValue(sessionId, ref, targetId) {
+    return this.client.call("dom.getValue", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  domIsChecked(sessionId, ref) {
-    return this.client.call("dom.isChecked", { sessionId, ref });
+  domIsVisible(sessionId, ref, targetId) {
+    return this.client.call("dom.isVisible", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  clonePage(sessionId) {
-    return this.client.call("export.clonePage", { sessionId });
+  domIsEnabled(sessionId, ref, targetId) {
+    return this.client.call("dom.isEnabled", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  cloneComponent(sessionId, ref) {
-    return this.client.call("export.cloneComponent", { sessionId, ref });
+  domIsChecked(sessionId, ref, targetId) {
+    return this.client.call("dom.isChecked", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  perfMetrics(sessionId) {
-    return this.client.call("devtools.perf", { sessionId });
+  clonePage(sessionId, targetId) {
+    return this.client.call("export.clonePage", {
+      sessionId,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
-  screenshot(sessionId, path) {
-    return this.client.call("page.screenshot", { sessionId, path });
+  cloneComponent(sessionId, ref, targetId) {
+    return this.client.call("export.cloneComponent", {
+      sessionId,
+      ref,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  perfMetrics(sessionId, targetId) {
+    return this.client.call("devtools.perf", {
+      sessionId,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
+  }
+  screenshot(sessionId, path, targetId) {
+    return this.client.call("page.screenshot", {
+      sessionId,
+      path,
+      ...typeof targetId === "string" ? { targetId } : {}
+    });
   }
   consolePoll(sessionId, sinceSeq, max = 50) {
     return this.client.call("devtools.consolePoll", { sessionId, sinceSeq, max });
@@ -145,6 +292,17 @@ 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-relay.ts
 var emptyStatus = {
   running: false,
@@ -153,6 +311,7 @@ var emptyStatus = {
   cdpConnected: false,
   annotationConnected: false,
   opsConnected: false,
+  canvasConnected: false,
   pairingRequired: false,
   instanceId: "",
   epoch: 0,
@@ -164,6 +323,7 @@ var emptyStatus = {
     cdpConnected: false,
     annotationConnected: false,
     opsConnected: false,
+    canvasConnected: false,
     pairingRequired: false
   }
 };
@@ -173,6 +333,7 @@ var RemoteRelay = class {
   lastCdpUrl = null;
   lastAnnotationUrl = null;
   lastOpsUrl = null;
+  lastCanvasUrl = null;
   constructor(client) {
     this.client = client;
   }
@@ -186,11 +347,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() {
@@ -205,11 +369,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, call the OpenCode skill tool early (skill("<skill-name>", topic?)) and load only the most relevant skill before using browser tools. If unsure which skill applies, check the available skills first.`;
+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.`;
 function createSkillNudgeState() {
   return { pending: false, requestedAtMs: null };
 }
@@ -272,7 +439,7 @@ function consumeContinuityNudge(state, nowMs, maxAgeMs) {
 }
 function buildContinuityNudgeMessage(filePath) {
   const target = filePath?.trim() || DEFAULT_FILE_PATH;
-  return `${CONTINUITY_NUDGE_MARKER} For long-running tasks, create or update ${target} at the repo root with Goal, Constraints/Assumptions, Key decisions, State (Done/Now/Next), Open questions, and Working set. Keep it brief.`;
+  return `${CONTINUITY_NUDGE_MARKER} For long-running tasks, load skill("opendevbrowser-continuity-ledger") and create or update ${target} at the repo root with Goal, Constraints/Assumptions, Key decisions, State (Done/Now/Next), Open questions, and Working set. Keep it brief.`;
 }
 
 // src/tools/launch.ts
@@ -282,18 +449,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" };
 }
@@ -333,6 +507,12 @@ function createLaunchTool(deps) {
           const headlessExplicit = args.headless === true;
           const managedExplicit = Boolean(args.noExtension || headlessExplicit);
           const managedHeadless = headlessExplicit ? true : false;
+          if (headlessExplicit && !args.noExtension) {
+            return failure(
+              "Extension mode does not support headless launches. Use noExtension=true with headless=true for managed mode.",
+              "unsupported_mode"
+            );
+          }
           if (args.waitForExtension && !managedExplicit) {
             const observedPort2 = resolveObservedPort(relayStatus, config.relayPort);
             const connected = await waitForExtensionHandshake(deps.relay, observedPort2, waitTimeoutMs);
@@ -381,7 +561,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;
@@ -419,9 +599,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,
@@ -628,6 +805,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) {
@@ -635,6 +813,7 @@ 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);
@@ -645,7 +824,7 @@ function createConnectTool(deps) {
         const relayEndpoint = relayUrl && wsEndpoint === relayUrl ? relayUrl : extensionLegacy ? normalizedLegacyEndpoint ?? normalizedOpsEndpoint : normalizedOpsEndpoint;
         let result;
         if (relayEndpoint || !hasExplicitCdp && relayUrl) {
-          result = await deps.manager.connectRelay(relayEndpoint ?? relayUrl ?? "");
+          result = startUrl ? await deps.manager.connectRelay(relayEndpoint ?? relayUrl ?? "", { startUrl }) : await deps.manager.connectRelay(relayEndpoint ?? relayUrl ?? "");
         } else {
           if (!hasExplicitCdp) {
             return failure("Extension relay not available. Connect the extension or pass wsEndpoint/host/port.", "extension_not_connected");
@@ -653,7 +832,8 @@ function createConnectTool(deps) {
           result = await deps.manager.connect({
             wsEndpoint,
             host: args.host,
-            port: args.port
+            port: args.port,
+            startUrl
           });
         }
         return ok({
@@ -974,6 +1154,7 @@ function createGotoTool(deps) {
     args: {
       sessionId: z12.string().describe("Session id"),
       url: z12.string().describe("URL to navigate to"),
+      targetId: z12.string().optional().describe("Optional target id"),
       waitUntil: waitUntilSchema.optional().describe("Load state to wait for"),
       timeoutMs: z12.number().int().optional().describe("Timeout in milliseconds")
     },
@@ -983,7 +1164,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) {
@@ -1003,6 +1186,7 @@ function createWaitTool(deps) {
     description: "Wait for a load state or a ref state.",
     args: {
       sessionId: z13.string().describe("Session id"),
+      targetId: z13.string().optional().describe("Optional target id"),
       until: waitUntilSchema2.optional().describe("Load state to wait for"),
       ref: z13.string().optional().describe("Ref to wait for"),
       state: waitStateSchema.optional().describe("Ref state to wait for"),
@@ -1015,7 +1199,8 @@ function createWaitTool(deps) {
             args.sessionId,
             args.ref,
             args.state ?? "attached",
-            args.timeoutMs ?? 3e4
+            args.timeoutMs ?? 3e4,
+            args.targetId
           );
           return ok(result2);
         }
@@ -1025,7 +1210,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) {
@@ -1044,6 +1230,7 @@ function createSnapshotTool(deps) {
     description: "Capture a snapshot of the current page and return refs.",
     args: {
       sessionId: z14.string().describe("Session id"),
+      targetId: z14.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")
@@ -1055,7 +1242,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) {
@@ -1073,11 +1261,12 @@ function createClickTool(deps) {
     description: "Click a referenced element.",
     args: {
       sessionId: z15.string().describe("Session id"),
+      targetId: z15.string().optional().describe("Optional target id"),
       ref: z15.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");
@@ -1094,11 +1283,12 @@ function createHoverTool(deps) {
     description: "Hover over an element by ref.",
     args: {
       sessionId: z16.string().describe("Active browser session id"),
+      targetId: z16.string().optional().describe("Optional target id"),
       ref: z16.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");
@@ -1115,12 +1305,13 @@ function createPressTool(deps) {
     description: "Press a keyboard key, optionally focusing a ref first.",
     args: {
       sessionId: z17.string().describe("Active browser session id"),
+      targetId: z17.string().optional().describe("Optional target 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")
     },
     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");
@@ -1137,11 +1328,12 @@ function createCheckTool(deps) {
     description: "Check a checkbox or toggle by ref.",
     args: {
       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.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");
@@ -1158,11 +1350,12 @@ function createUncheckTool(deps) {
     description: "Uncheck a checkbox or toggle by ref.",
     args: {
       sessionId: z19.string().describe("Active browser session id"),
+      targetId: z19.string().optional().describe("Optional target id"),
       ref: z19.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");
@@ -1179,6 +1372,7 @@ function createTypeTool(deps) {
     description: "Type text into a referenced input.",
     args: {
       sessionId: z20.string().describe("Session id"),
+      targetId: z20.string().optional().describe("Optional target id"),
       ref: z20.string().describe("Element ref"),
       text: z20.string().describe("Text to type"),
       clear: z20.boolean().optional().describe("Clear before typing"),
@@ -1191,7 +1385,8 @@ function createTypeTool(deps) {
           args.ref,
           args.text,
           Boolean(args.clear),
-          Boolean(args.submit)
+          Boolean(args.submit),
+          args.targetId
         );
         return ok(result);
       } catch (error) {
@@ -1209,12 +1404,13 @@ function createSelectTool(deps) {
     description: "Select options in a referenced select element.",
     args: {
       sessionId: z21.string().describe("Session id"),
+      targetId: z21.string().optional().describe("Optional target id"),
       ref: z21.string().describe("Element ref"),
       values: z21.array(z21.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");
@@ -1231,12 +1427,13 @@ function createScrollTool(deps) {
     description: "Scroll the page or a referenced element.",
     args: {
       sessionId: z22.string().describe("Session id"),
+      targetId: z22.string().optional().describe("Optional target id"),
       dy: z22.number().describe("Scroll delta in pixels"),
       ref: z22.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");
@@ -1253,11 +1450,12 @@ function createScrollIntoViewTool(deps) {
     description: "Scroll an element into view by ref.",
     args: {
       sessionId: z23.string().describe("Active browser session id"),
+      targetId: z23.string().optional().describe("Optional target id"),
       ref: z23.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");
@@ -1274,6 +1472,7 @@ function createDomGetHtmlTool(deps) {
     description: "Get outerHTML for a referenced element.",
     args: {
       sessionId: z24.string().describe("Session id"),
+      targetId: z24.string().optional().describe("Optional target id"),
       ref: z24.string().describe("Element ref"),
       maxChars: z24.number().int().optional().describe("Max characters")
     },
@@ -1282,7 +1481,8 @@ function createDomGetHtmlTool(deps) {
         const result = await deps.manager.domGetHtml(
           args.sessionId,
           args.ref,
-          args.maxChars ?? 8e3
+          args.maxChars ?? 8e3,
+          args.targetId
         );
         return ok({
           ref: args.ref,
@@ -1304,6 +1504,7 @@ function createDomGetTextTool(deps) {
     description: "Get inner text for a referenced element.",
     args: {
       sessionId: z25.string().describe("Session id"),
+      targetId: z25.string().optional().describe("Optional target id"),
       ref: z25.string().describe("Element ref"),
       maxChars: z25.number().int().optional().describe("Max characters")
     },
@@ -1312,7 +1513,8 @@ function createDomGetTextTool(deps) {
         const result = await deps.manager.domGetText(
           args.sessionId,
           args.ref,
-          args.maxChars ?? 8e3
+          args.maxChars ?? 8e3,
+          args.targetId
         );
         return ok({
           ref: args.ref,
@@ -1334,12 +1536,13 @@ function createGetAttrTool(deps) {
     description: "Get a DOM attribute value 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 from snapshot"),
       name: z26.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");
@@ -1356,11 +1559,12 @@ function createGetValueTool(deps) {
     description: "Get the input value for an element by ref.",
     args: {
       sessionId: z27.string().describe("Active browser session id"),
+      targetId: z27.string().optional().describe("Optional target id"),
       ref: z27.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");
@@ -1377,11 +1581,12 @@ function createIsVisibleTool(deps) {
     description: "Check if an element is visible by ref.",
     args: {
       sessionId: z28.string().describe("Active browser session id"),
+      targetId: z28.string().optional().describe("Optional target id"),
       ref: z28.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");
@@ -1398,11 +1603,12 @@ function createIsEnabledTool(deps) {
     description: "Check if an element is enabled by ref.",
     args: {
       sessionId: z29.string().describe("Active browser session id"),
+      targetId: z29.string().optional().describe("Optional target id"),
       ref: z29.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");
@@ -1419,11 +1625,12 @@ function createIsCheckedTool(deps) {
     description: "Check if an element is checked by ref.",
     args: {
       sessionId: z30.string().describe("Active browser session id"),
+      targetId: z30.string().optional().describe("Optional target id"),
       ref: z30.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");
@@ -1550,18 +1757,468 @@ function createNetworkPollTool(deps) {
   });
 }
 
-// src/tools/clone_page.ts
+// src/tools/debug_trace_snapshot.ts
 import { tool as tool35 } from "@opencode-ai/plugin";
 var z35 = tool35.schema;
-function createClonePageTool(deps) {
+function createDebugTraceSnapshotTool(deps) {
   return tool35({
+    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")
+    },
+    async execute(args) {
+      try {
+        const manager = deps.manager;
+        const options = {
+          sinceConsoleSeq: args.sinceConsoleSeq,
+          sinceNetworkSeq: args.sinceNetworkSeq,
+          sinceExceptionSeq: args.sinceExceptionSeq,
+          max: args.max,
+          requestId: args.requestId
+        };
+        if (typeof manager.debugTraceSnapshot === "function") {
+          const result = await manager.debugTraceSnapshot(args.sessionId, options);
+          return ok(result);
+        }
+        const max = args.max ?? 500;
+        const requestId = args.requestId ?? createRequestId();
+        const [page, consoleChannel, networkChannel] = await Promise.all([
+          deps.manager.status(args.sessionId),
+          deps.manager.consolePoll(args.sessionId, args.sinceConsoleSeq, max),
+          deps.manager.networkPoll(args.sessionId, args.sinceNetworkSeq, max)
+        ]);
+        const exceptionChannel = typeof manager.exceptionPoll === "function" ? await manager.exceptionPoll(args.sessionId, args.sinceExceptionSeq, max) : {
+          events: [],
+          nextSeq: args.sinceExceptionSeq ?? 0,
+          truncated: false
+        };
+        const annotateTraceContext = (events) => events.map((event) => ({
+          ...event,
+          requestId,
+          sessionId: args.sessionId
+        }));
+        const blocker = classifyBlockerSignal({
+          source: "network",
+          url: typeof page.url === "string" ? page.url : void 0,
+          finalUrl: typeof page.url === "string" ? page.url : void 0,
+          title: typeof page.title === "string" ? page.title : void 0,
+          status: findLatestStatus(networkChannel.events),
+          traceRequestId: requestId,
+          networkHosts: extractHosts(networkChannel.events),
+          threshold: deps.config.get().blockerDetectionThreshold,
+          promptGuardEnabled: deps.config.get().security.promptInjectionGuard?.enabled ?? true
+        });
+        const blockerArtifacts = blocker ? buildBlockerArtifacts({
+          networkEvents: networkChannel.events,
+          consoleEvents: consoleChannel.events,
+          exceptionEvents: exceptionChannel.events,
+          promptGuardEnabled: deps.config.get().security.promptInjectionGuard?.enabled ?? true,
+          caps: deps.config.get().blockerArtifactCaps
+        }) : void 0;
+        return ok({
+          requestId,
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          page,
+          channels: {
+            console: {
+              nextSeq: consoleChannel.nextSeq,
+              truncated: consoleChannel.truncated,
+              events: annotateTraceContext(consoleChannel.events)
+            },
+            network: {
+              nextSeq: networkChannel.nextSeq,
+              truncated: networkChannel.truncated,
+              events: annotateTraceContext(networkChannel.events)
+            },
+            exception: {
+              nextSeq: exceptionChannel.nextSeq,
+              truncated: exceptionChannel.truncated,
+              events: annotateTraceContext(exceptionChannel.events)
+            }
+          },
+          meta: {
+            blockerState: blocker ? "active" : "clear",
+            ...blocker ? { blocker } : {},
+            ...blockerArtifacts ? { blockerArtifacts } : {}
+          }
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "debug_trace_snapshot_failed");
+      }
+    }
+  });
+}
+function findLatestStatus(events) {
+  for (let index = events.length - 1; index >= 0; index -= 1) {
+    const status = events[index]?.status;
+    if (typeof status === "number") {
+      return status;
+    }
+  }
+  return void 0;
+}
+function extractHosts(events) {
+  const hosts = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    if (typeof event.url !== "string") continue;
+    try {
+      const host = new URL(event.url).hostname.toLowerCase();
+      if (!host || seen.has(host)) continue;
+      seen.add(host);
+      hosts.push(host);
+    } catch {
+    }
+  }
+  return hosts;
+}
+
+// src/tools/cookie_import.ts
+import { tool as tool36 } from "@opencode-ai/plugin";
+var z36 = tool36.schema;
+function validateCookieRecord(cookie) {
+  const name = cookie.name?.trim();
+  if (!name) {
+    return { valid: false, reason: "Cookie name is required.", cookie };
+  }
+  if (!/^[^\s;=]+$/.test(name)) {
+    return { valid: false, reason: `Invalid cookie name: ${cookie.name}.`, cookie };
+  }
+  if (typeof cookie.value !== "string") {
+    return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+  }
+  const value = cookie.value;
+  if (/\r|\n|;/.test(value)) {
+    return { valid: false, reason: `Invalid cookie value for ${name}.`, cookie };
+  }
+  const hasUrl = typeof cookie.url === "string" && cookie.url.trim().length > 0;
+  const hasDomain = typeof cookie.domain === "string" && cookie.domain.trim().length > 0;
+  if (!hasUrl && !hasDomain) {
+    return { valid: false, reason: `Cookie ${name} requires url or domain.`, cookie };
+  }
+  let normalizedUrl;
+  if (hasUrl) {
+    try {
+      const parsedUrl = new URL(cookie.url);
+      if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+        return { valid: false, reason: `Cookie ${name} url must be http(s).`, cookie };
+      }
+      normalizedUrl = parsedUrl.toString();
+    } catch {
+      return { valid: false, reason: `Cookie ${name} has invalid url.`, cookie };
+    }
+  }
+  let normalizedDomain;
+  if (hasDomain) {
+    normalizedDomain = String(cookie.domain).trim().toLowerCase();
+    if (!/^\.?[a-z0-9.-]+$/.test(normalizedDomain)) {
+      return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+    }
+    if (normalizedDomain.includes("..")) {
+      return { valid: false, reason: `Cookie ${name} has invalid domain.`, cookie };
+    }
+  }
+  const normalizedPath = typeof cookie.path === "string" ? cookie.path.trim() : void 0;
+  if (typeof normalizedPath === "string" && !normalizedPath.startsWith("/")) {
+    return { valid: false, reason: `Cookie ${name} path must start with '/'.`, cookie };
+  }
+  if (typeof cookie.expires !== "undefined") {
+    if (!Number.isFinite(cookie.expires)) {
+      return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+    }
+    if (cookie.expires < -1) {
+      return { valid: false, reason: `Cookie ${name} has invalid expires.`, cookie };
+    }
+  }
+  if (cookie.sameSite === "None" && cookie.secure !== true) {
+    return { valid: false, reason: `Cookie ${name} with SameSite=None must set secure=true.`, cookie };
+  }
+  const normalizedCookie = {
+    name,
+    value,
+    ...typeof cookie.expires === "number" ? { expires: cookie.expires } : {},
+    ...typeof cookie.httpOnly === "boolean" ? { httpOnly: cookie.httpOnly } : {},
+    ...typeof cookie.secure === "boolean" ? { secure: cookie.secure } : {},
+    ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+  };
+  if (normalizedDomain) {
+    normalizedCookie.domain = normalizedDomain;
+    normalizedCookie.path = normalizedPath ?? "/";
+  } else if (normalizedUrl) {
+    normalizedCookie.url = normalizedUrl;
+  }
+  return {
+    valid: true,
+    reason: "",
+    cookie: normalizedCookie
+  };
+}
+function createCookieImportTool(deps) {
+  return tool36({
+    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()
+      })).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")
+    },
+    async execute(args) {
+      try {
+        const strict = args.strict ?? true;
+        const requestId = args.requestId ?? createRequestId();
+        const manager = deps.manager;
+        const normalized = [];
+        const rejected = [];
+        args.cookies.forEach((cookie, index) => {
+          const validation = validateCookieRecord(cookie);
+          if (!validation.valid) {
+            rejected.push({ index, reason: validation.reason });
+            return;
+          }
+          normalized.push(validation.cookie);
+        });
+        if (typeof manager.cookieImport === "function") {
+          return ok(await manager.cookieImport(args.sessionId, normalized, strict, requestId));
+        }
+        if (strict && rejected.length > 0) {
+          return failure(`Cookie import rejected ${rejected.length} entries.`, "cookie_import_failed");
+        }
+        if (normalized.length > 0) {
+          await deps.manager.withPage(args.sessionId, null, async (page) => {
+            await page.context().addCookies(normalized);
+            return void 0;
+          });
+        }
+        return ok({
+          requestId,
+          imported: normalized.length,
+          rejected
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "cookie_import_failed");
+      }
+    }
+  });
+}
+
+// src/tools/cookie_list.ts
+import { tool as tool37 } from "@opencode-ai/plugin";
+var z37 = tool37.schema;
+function normalizeCookieUrls(urls) {
+  if (!urls || urls.length === 0) {
+    return void 0;
+  }
+  const normalized = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of urls) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error("Cookie list urls must be non-empty strings.");
+    }
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(trimmed);
+    } catch {
+      throw new Error(`Cookie list url is invalid: ${trimmed}`);
+    }
+    if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+      throw new Error(`Cookie list url must be http(s): ${trimmed}`);
+    }
+    const normalizedUrl = parsedUrl.toString();
+    if (seen.has(normalizedUrl)) {
+      continue;
+    }
+    seen.add(normalizedUrl);
+    normalized.push(normalizedUrl);
+  }
+  return normalized;
+}
+function createCookieListTool(deps) {
+  return tool37({
+    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")
+    },
+    async execute(args) {
+      try {
+        const manager = deps.manager;
+        const normalizedUrls = normalizeCookieUrls(args.urls);
+        const requestId = args.requestId ?? createRequestId();
+        if (typeof manager.cookieList === "function") {
+          return ok(await manager.cookieList(args.sessionId, normalizedUrls, requestId));
+        }
+        const cookies = await deps.manager.withPage(
+          args.sessionId,
+          null,
+          async (page) => {
+            const listed = normalizedUrls ? await page.context().cookies(normalizedUrls) : await page.context().cookies();
+            return listed.map((cookie) => ({
+              name: cookie.name,
+              value: cookie.value,
+              domain: cookie.domain,
+              path: cookie.path,
+              expires: cookie.expires,
+              httpOnly: cookie.httpOnly,
+              secure: cookie.secure,
+              ...cookie.sameSite ? { sameSite: cookie.sameSite } : {}
+            }));
+          }
+        );
+        return ok({
+          requestId,
+          cookies,
+          count: cookies.length
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "cookie_list_failed");
+      }
+    }
+  });
+}
+
+// src/tools/macro_resolve.ts
+import { tool as tool38 } from "@opencode-ai/plugin";
+var z38 = tool38.schema;
+async function loadMacroRuntime() {
+  try {
+    const module = await import("./macros-ND2M7LWU.js");
+    return module;
+  } catch {
+    return null;
+  }
+}
+async function resolveMacroProviderRuntime(deps) {
+  if (deps.providerRuntime) {
+    return deps.providerRuntime;
+  }
+  const { createConfiguredProviderRuntime: createConfiguredProviderRuntime2 } = await import("./runtime-factory-BICHDPE7.js");
+  return createConfiguredProviderRuntime2({
+    config: deps.config?.get?.(),
+    manager: deps.manager,
+    browserFallbackPort: deps.browserFallbackPort
+  });
+}
+function parseFallbackMacro(expression, defaultProvider) {
+  const raw = expression.trim();
+  if (!raw.startsWith("@")) {
+    throw new Error("Macro expressions must start with '@'");
+  }
+  const body = raw.slice(1).trim();
+  if (!body) {
+    throw new Error("Macro name is required");
+  }
+  const openParen = body.indexOf("(");
+  const closeParen = body.endsWith(")") ? body.length - 1 : -1;
+  const macroName = openParen >= 0 ? body.slice(0, openParen).trim() : body;
+  const argsBody = openParen >= 0 && closeParen > openParen ? body.slice(openParen + 1, closeParen).trim() : "";
+  const positional = argsBody ? argsBody.split(",").map((part) => part.trim().replace(/^['\"]|['\"]$/g, "")).filter(Boolean) : [];
+  const query = positional[0] ?? macroName;
+  const provider = defaultProvider ?? "web/default";
+  return {
+    action: {
+      source: "web",
+      operation: "search",
+      input: {
+        query,
+        limit: 10,
+        providerId: provider
+      }
+    },
+    provenance: {
+      macro: macroName,
+      provider,
+      resolvedQuery: query,
+      pack: "fallback",
+      args: {
+        positional,
+        named: {}
+      }
+    }
+  };
+}
+function createMacroResolveTool(deps) {
+  return tool38({
+    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")
+    },
+    async execute(args) {
+      try {
+        const runtime = await loadMacroRuntime();
+        const registry = runtime?.createDefaultMacroRegistry?.();
+        let resolvedRuntime = "fallback";
+        let resolution;
+        let catalog;
+        if (registry) {
+          resolvedRuntime = "macros";
+          resolution = await registry.resolve(args.expression, {
+            defaultProvider: args.defaultProvider
+          });
+          catalog = args.includeCatalog ? registry.list().map((entry) => ({
+            name: entry.name,
+            pack: entry.pack,
+            description: entry.description
+          })) : void 0;
+        } else {
+          resolution = parseFallbackMacro(args.expression, args.defaultProvider);
+        }
+        if (!args.execute) {
+          return ok({
+            runtime: resolvedRuntime,
+            resolution,
+            ...catalog ? { catalog } : {}
+          });
+        }
+        const providerRuntime = await resolveMacroProviderRuntime(deps);
+        const execution = shapeExecutionPayload(
+          await executeMacroResolution(resolution, providerRuntime)
+        );
+        return ok({
+          runtime: resolvedRuntime,
+          resolution,
+          ...catalog ? { catalog } : {},
+          execution
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "macro_resolve_failed");
+      }
+    }
+  });
+}
+
+// src/tools/clone_page.ts
+import { tool as tool39 } from "@opencode-ai/plugin";
+var z39 = tool39.schema;
+function createClonePageTool(deps) {
+  return tool39({
     description: "Export the active page as a React component and CSS bundle.",
     args: {
-      sessionId: z35.string().describe("Active browser session id")
+      sessionId: z39.string().describe("Active browser session id"),
+      targetId: z39.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");
@@ -1571,18 +2228,19 @@ function createClonePageTool(deps) {
 }
 
 // src/tools/clone_component.ts
-import { tool as tool36 } from "@opencode-ai/plugin";
-var z36 = tool36.schema;
+import { tool as tool40 } from "@opencode-ai/plugin";
+var z40 = tool40.schema;
 function createCloneComponentTool(deps) {
-  return tool36({
+  return tool40({
     description: "Export a selected element subtree as a React component and CSS bundle.",
     args: {
-      sessionId: z36.string().describe("Active browser session id"),
-      ref: z36.string().describe("Element ref from snapshot")
+      sessionId: z40.string().describe("Active browser session id"),
+      targetId: z40.string().optional().describe("Optional target id"),
+      ref: z40.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");
@@ -1592,17 +2250,18 @@ function createCloneComponentTool(deps) {
 }
 
 // src/tools/perf.ts
-import { tool as tool37 } from "@opencode-ai/plugin";
-var z37 = tool37.schema;
+import { tool as tool41 } from "@opencode-ai/plugin";
+var z41 = tool41.schema;
 function createPerfTool(deps) {
-  return tool37({
+  return tool41({
     description: "Fetch lightweight performance metrics from the active page.",
     args: {
-      sessionId: z37.string().describe("Active browser session id")
+      sessionId: z41.string().describe("Active browser session id"),
+      targetId: z41.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");
@@ -1612,18 +2271,19 @@ function createPerfTool(deps) {
 }
 
 // src/tools/screenshot.ts
-import { tool as tool38 } from "@opencode-ai/plugin";
-var z38 = tool38.schema;
+import { tool as tool42 } from "@opencode-ai/plugin";
+var z42 = tool42.schema;
 function createScreenshotTool(deps) {
-  return tool38({
+  return tool42({
     description: "Capture a screenshot of the active page.",
     args: {
-      sessionId: z38.string().describe("Active browser session id"),
-      path: z38.string().optional().describe("Optional output file path")
+      sessionId: z42.string().describe("Active browser session id"),
+      targetId: z42.string().optional().describe("Optional target id"),
+      path: z42.string().optional().describe("Optional output file path")
     },
     async execute(args) {
       try {
-        const result = await deps.manager.screenshot(args.sessionId, args.path);
+        const result = await deps.manager.screenshot(args.sessionId, args.path, args.targetId);
         return ok(result);
       } catch (error) {
         return failure(serializeError(error).message, "screenshot_failed");
@@ -1633,27 +2293,29 @@ function createScreenshotTool(deps) {
 }
 
 // src/tools/annotate.ts
-import { tool as tool39 } from "@opencode-ai/plugin";
-var z39 = tool39.schema;
-var screenshotModeSchema = z39.enum(["visible", "full", "none"]);
-var transportSchema = z39.enum(["auto", "direct", "relay"]);
+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"]);
 function createAnnotateTool(deps) {
-  return tool39({
+  return tool43({
     description: "Request interactive annotations via direct (CDP) or relay transport.",
     args: {
-      sessionId: z39.string().describe("Session id"),
+      sessionId: z43.string().describe("Session id"),
+      stored: z43.boolean().optional().describe("Fetch the latest payload explicitly sent from popup/canvas surfaces"),
+      includeScreenshots: z43.boolean().optional().describe("When fetching stored payloads, prefer screenshots if still available in memory"),
       transport: transportSchema.optional().describe("auto | direct | relay (default: auto)"),
-      targetId: z39.string().optional().describe("Optional target id for direct mode"),
-      tabId: z39.number().int().optional().describe("Optional Chrome tab id for relay mode"),
-      url: z39.string().optional().describe("Optional URL to open before annotating"),
+      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"),
       screenshotMode: screenshotModeSchema.optional().describe("visible | full | none (default: visible)"),
-      debug: z39.boolean().optional().describe("Include debug metadata"),
-      context: z39.string().optional().describe("Optional context for the annotator"),
-      timeoutMs: z39.number().int().optional().describe("Timeout in milliseconds")
+      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")
     },
     async execute(args) {
       try {
-        const transport = args.transport ?? "auto";
+        const transport = args.stored ? "relay" : args.transport ?? "auto";
         if (transport === "relay") {
           const status = await deps.manager.status(args.sessionId);
           if (status.mode !== "extension") {
@@ -1663,6 +2325,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,
@@ -1671,6 +2335,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";
@@ -1689,10 +2359,221 @@ function createAnnotateTool(deps) {
   });
 }
 
+// src/tools/research_run.ts
+import { tool as tool44 } from "@opencode-ai/plugin";
+
+// src/tools/workflow-runtime.ts
+var resolveProviderRuntime = async (deps) => {
+  if (deps.providerRuntime) {
+    return deps.providerRuntime;
+  }
+  const { createConfiguredProviderRuntime: createConfiguredProviderRuntime2 } = await import("./runtime-factory-BICHDPE7.js");
+  return createConfiguredProviderRuntime2({
+    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"]);
+function createResearchRunTool(deps) {
+  return tool44({
+    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"),
+      sourceSelection: sourceSelectionSchema.optional().describe("auto|web|community|social|shopping|all"),
+      sources: z44.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"),
+      cookiePolicyOverride: cookiePolicySchema.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = await resolveProviderRuntime(deps);
+        const { runResearchWorkflow } = await import("./providers-G3LRHQXX.js");
+        const result = await runResearchWorkflow(runtime, {
+          topic: args.topic,
+          days: args.days,
+          from: args.from,
+          to: args.to,
+          sourceSelection: args.sourceSelection,
+          sources: args.sources,
+          mode: args.mode ?? "compact",
+          includeEngagement: args.includeEngagement,
+          limitPerSource: args.limitPerSource,
+          outputDir: args.outputDir,
+          ttlHours: args.ttlHours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "research_run_failed");
+      }
+    }
+  });
+}
+
+// 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"]);
+function createShoppingRunTool(deps) {
+  return tool45({
+    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"),
+      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"),
+      cookiePolicyOverride: cookiePolicySchema2.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = await resolveProviderRuntime(deps);
+        const { runShoppingWorkflow } = await import("./providers-G3LRHQXX.js");
+        const result = await runShoppingWorkflow(runtime, {
+          query: args.query,
+          providers: args.providers,
+          budget: args.budget,
+          region: args.region,
+          sort: args.sort,
+          mode: args.mode ?? "compact",
+          outputDir: args.outputDir,
+          ttlHours: args.ttlHours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "shopping_run_failed");
+      }
+    }
+  });
+}
+
+// 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"]);
+async function captureScreenshotBuffer(deps, url) {
+  let sessionId = null;
+  try {
+    const launched = await deps.manager.launch({
+      headless: true,
+      startUrl: url
+    });
+    sessionId = launched.sessionId;
+    const screenshot = await deps.manager.screenshot(sessionId);
+    if (typeof screenshot.base64 === "string" && screenshot.base64.length > 0) {
+      return Buffer.from(screenshot.base64, "base64");
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (sessionId) {
+      await deps.manager.disconnect(sessionId, true).catch(() => {
+      });
+    }
+  }
+}
+function createProductVideoRunTool(deps) {
+  return tool46({
+    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"),
+      cookiePolicyOverride: cookiePolicySchema3.optional().describe("Override cookie policy: off|auto|required")
+    },
+    async execute(args) {
+      try {
+        const runtime = await resolveProviderRuntime(deps);
+        const { runProductVideoWorkflow } = await import("./providers-G3LRHQXX.js");
+        const includeScreenshots = args.include_screenshots ?? true;
+        const result = await runProductVideoWorkflow(runtime, {
+          product_url: args.product_url,
+          product_name: args.product_name,
+          provider_hint: args.provider_hint,
+          include_screenshots: includeScreenshots,
+          include_all_images: args.include_all_images,
+          include_copy: args.include_copy,
+          output_dir: args.output_dir,
+          ttl_hours: args.ttl_hours,
+          useCookies: args.useCookies,
+          cookiePolicyOverride: args.cookiePolicyOverride
+        }, {
+          captureScreenshot: includeScreenshots ? async (url) => captureScreenshotBuffer(deps, url) : void 0
+        });
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "product_video_run_failed");
+      }
+    }
+  });
+}
+
+// src/tools/canvas.ts
+import { tool as tool47 } from "@opencode-ai/plugin";
+var z47 = tool47.schema;
+function createCanvasTool(deps) {
+  return tool47({
+    description: "Execute a typed design-canvas command such as canvas.session.open or canvas.document.patch.",
+    args: {
+      command: z47.string().min(1).describe("Canvas command name"),
+      params: z47.record(z47.string(), z47.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 tool40 } from "@opencode-ai/plugin";
+import { tool as tool48 } from "@opencode-ai/plugin";
 function createSkillListTool(deps) {
-  return tool40({
+  return tool48({
     description: "List available skills from OpenCode skill directories (compatibility wrapper)",
     args: {},
     async execute() {
@@ -1708,14 +2589,14 @@ function createSkillListTool(deps) {
 }
 
 // src/tools/skill_load.ts
-import { tool as tool41 } from "@opencode-ai/plugin";
-var z40 = tool41.schema;
+import { tool as tool49 } from "@opencode-ai/plugin";
+var z48 = tool49.schema;
 function createSkillLoadTool(deps) {
-  return tool41({
+  return tool49({
     description: "Load a specific skill by name from OpenCode skill directories (compatibility wrapper)",
     args: {
-      name: z40.string().describe("Name of the skill to load (e.g., 'login-automation', 'form-testing')"),
-      topic: z40.string().optional().describe("Optional topic to filter the skill content")
+      name: z48.string().describe("Name of the skill to load (e.g., 'opendevbrowser-login-automation', 'opendevbrowser-form-testing')"),
+      topic: z48.string().optional().describe("Optional topic to filter the skill content")
     },
     async execute(args) {
       try {
@@ -1779,6 +2660,14 @@ function createTools(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_canvas: wrap(createCanvasTool(deps)),
     opendevbrowser_clone_page: wrap(createClonePageTool(deps)),
     opendevbrowser_clone_component: wrap(createCloneComponentTool(deps)),
     opendevbrowser_perf: wrap(createPerfTool(deps)),
@@ -1795,8 +2684,11 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   const { config, configStore, skills, ensureRelay, cleanup, getExtensionPath } = core;
   let relay = core.relay;
   let manager = core.manager;
+  let canvasManager = core.canvasManager;
   let runner = core.runner;
   let annotationManager = core.annotationManager;
+  let providerRuntime = core.providerRuntime;
+  let browserFallbackPort = core.browserFallbackPort;
   let hubStop = null;
   let daemonClient = null;
   const skillNudgeState = createSkillNudgeState();
@@ -1811,10 +2703,13 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
   }
   const toolDeps = {
     manager,
+    canvasManager,
     annotationManager,
     runner,
     config: configStore,
     skills,
+    providerRuntime,
+    browserFallbackPort,
     relay,
     getExtensionPath
   };
@@ -1823,13 +2718,23 @@ var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
       daemonClient = new DaemonClient({ autoRenew: true });
     }
     manager = new RemoteManager(daemonClient);
+    canvasManager = new RemoteCanvasManager(daemonClient);
     relay = new RemoteRelay(daemonClient);
     annotationManager.setRelay(relay);
     annotationManager.setBrowserManager(manager);
     runner = new ScriptRunner(manager);
+    browserFallbackPort = createBrowserFallbackPort(manager);
+    providerRuntime = createConfiguredProviderRuntime({
+      config: configStore.get(),
+      manager,
+      browserFallbackPort
+    });
     toolDeps.manager = manager;
+    toolDeps.canvasManager = canvasManager;
     toolDeps.relay = relay;
     toolDeps.runner = runner;
+    toolDeps.providerRuntime = providerRuntime;
+    toolDeps.browserFallbackPort = browserFallbackPort;
   };
   const ensureHub = async () => {
     const currentConfig = configStore.get();