opendevbrowser 0.0.11 → 0.0.15

package/dist/opendevbrowser.js

@@ -1,2208 +1,211 @@
 import {
+  DaemonClient,
+  ScriptRunner,
+  buildAnnotateResult,
+  createOpenDevBrowserCore,
   extractExtension,
-  generateSecureToken,
-  getExtensionPath
-} from "./chunk-R5VUZEUU.js";
+  fetchDaemonStatusFromMetadata,
+  startDaemon
+} from "./chunk-JVBMT2O5.js";
 
-// src/config.ts
-import { z } from "zod";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { parse as parseJsonc } from "jsonc-parser";
-function isExecutable(filePath) {
+// src/cli/remote-manager.ts
+function isLegacyRelayEndpoint(wsEndpoint) {
   try {
-    fs.accessSync(filePath, fs.constants.X_OK);
-    return true;
+    const url = new URL(wsEndpoint);
+    const path = url.pathname.endsWith("/") ? url.pathname.slice(0, -1) : url.pathname;
+    return path === "/cdp";
   } catch {
     return false;
   }
 }
-var DEFAULT_RELAY_PORT = 8787;
-function buildDefaultConfigJsonc(token) {
-  return `{
-  // Set relayToken to false to disable extension pairing.
-  "relayPort": ${DEFAULT_RELAY_PORT},
-  "relayToken": "${token}"
-}
-`;
-}
-var snapshotSchema = z.object({
-  maxChars: z.number().int().min(500).max(2e5).default(16e3),
-  maxNodes: z.number().int().min(50).max(5e3).default(1e3)
-});
-var securitySchema = z.object({
-  allowRawCDP: z.boolean().default(false),
-  allowNonLocalCdp: z.boolean().default(false),
-  allowUnsafeExport: z.boolean().default(false)
-});
-var devtoolsSchema = z.object({
-  showFullUrls: z.boolean().default(false),
-  showFullConsole: z.boolean().default(false)
-});
-var exportSchema = z.object({
-  maxNodes: z.number().int().min(1).max(5e3).default(1e3),
-  inlineStyles: z.boolean().default(true)
-});
-var skillsNudgeSchema = z.object({
-  enabled: z.boolean().default(true),
-  keywords: z.array(z.string()).default([
-    "login",
-    "sign in",
-    "sign-in",
-    "auth",
-    "authentication",
-    "mfa",
-    "form",
-    "submit",
-    "validation",
-    "extract",
-    "scrape",
-    "scraping",
-    "table",
-    "pagination",
-    "crawl"
-  ]),
-  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
-});
-var skillsSchema = z.object({
-  nudge: skillsNudgeSchema.default({})
-}).default({});
-var continuityNudgeSchema = z.object({
-  enabled: z.boolean().default(true),
-  keywords: z.array(z.string()).default([
-    "plan",
-    "multi-step",
-    "multi step",
-    "long-running",
-    "long running",
-    "refactor",
-    "migration",
-    "rollout",
-    "release",
-    "upgrade",
-    "investigate",
-    "follow-up",
-    "continue"
-  ]),
-  maxAgeMs: z.number().int().min(1e3).max(6e5).default(6e4)
-});
-var continuitySchema = z.object({
-  enabled: z.boolean().default(true),
-  filePath: z.string().min(1).default("opendevbrowser_continuity.md"),
-  nudge: continuityNudgeSchema.default({})
-}).default({});
-var configSchema = z.object({
-  headless: z.boolean().default(false),
-  profile: z.string().min(1).default("default"),
-  snapshot: snapshotSchema.default({}),
-  security: securitySchema.default({}),
-  devtools: devtoolsSchema.default({}),
-  export: exportSchema.default({}),
-  skills: skillsSchema.default({}),
-  continuity: continuitySchema.default({}),
-  relayPort: z.number().int().min(0).max(65535).default(DEFAULT_RELAY_PORT),
-  relayToken: z.union([z.string(), z.literal(false)]).optional(),
-  chromePath: z.string().min(1).optional().refine(
-    (val) => val === void 0 || isExecutable(val),
-    { message: "chromePath must point to an executable file" }
-  ),
-  flags: z.array(z.string()).default([]),
-  checkForUpdates: z.boolean().default(false),
-  persistProfile: z.boolean().default(true),
-  skillPaths: z.array(z.string()).default([])
-});
-var CONFIG_FILE_NAME = "opendevbrowser.jsonc";
-function getGlobalConfigPath() {
-  const configDir = process.env.OPENCODE_CONFIG_DIR || path.join(os.homedir(), ".config", "opencode");
-  return path.join(configDir, CONFIG_FILE_NAME);
-}
-function ensureConfigFile(filePath) {
-  const token = generateSecureToken();
-  if (fs.existsSync(filePath)) {
-    return token;
-  }
-  try {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true, mode: 448 });
-    fs.writeFileSync(filePath, buildDefaultConfigJsonc(token), { encoding: "utf-8", mode: 384 });
-  } catch (error) {
-    console.warn(`[opendevbrowser] Warning: Could not create config file at ${filePath}:`, error);
-  }
-  return token;
-}
-function loadConfigFile(filePath) {
-  if (!fs.existsSync(filePath)) {
-    const token = ensureConfigFile(filePath);
-    return { raw: {}, generatedToken: token };
-  }
-  const content = fs.readFileSync(filePath, "utf-8");
-  const errors = [];
-  const parsed = parseJsonc(content, errors, { allowTrailingComma: true });
-  if (errors.length > 0) {
-    const firstError = errors[0];
-    throw new Error(`Invalid JSONC in opendevbrowser config at ${filePath}: parse error at offset ${firstError?.offset ?? 0}`);
-  }
-  return { raw: parsed ?? {}, generatedToken: null };
-}
-function loadGlobalConfig() {
-  const configPath = getGlobalConfigPath();
-  const { raw, generatedToken } = loadConfigFile(configPath);
-  const parsed = configSchema.safeParse(raw);
-  if (!parsed.success) {
-    const issues = parsed.error.issues.map((issue) => issue.message).join("; ");
-    throw new Error(`Invalid opendevbrowser config at ${configPath}: ${issues}`);
-  }
-  const data = parsed.data;
-  const relayToken = data.relayToken ?? generatedToken ?? generateSecureToken();
-  return { ...data, relayToken };
-}
-var ConfigStore = class {
-  current;
-  constructor(initial) {
-    this.current = initial;
-  }
-  get() {
-    return this.current;
-  }
-  set(next) {
-    this.current = next;
-  }
-};
-
-// src/browser/browser-manager.ts
-import { randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir2, rm } from "fs/promises";
-import { join as join4 } from "path";
-import { chromium } from "playwright-core";
-import { Mutex } from "async-mutex";
-
-// src/cache/paths.ts
-import { createHash } from "crypto";
-import { mkdir, stat } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-function safeHash(value) {
-  return createHash("sha256").update(value).digest("hex").slice(0, 16);
-}
-async function ensureDir(path2) {
-  await mkdir(path2, { recursive: true });
-}
-async function resolveCachePaths(worktree, profile) {
-  const base = process.env.OPENCODE_CACHE_DIR ?? process.env.XDG_CACHE_HOME ?? join2(homedir2(), ".cache");
-  const root = join2(base, "opendevbrowser");
-  const projectRoot = join2(root, "projects", safeHash(worktree));
-  const profileDir = join2(projectRoot, "profiles", profile);
-  const chromeDir = join2(root, "chrome");
-  await ensureDir(root);
-  await ensureDir(projectRoot);
-  await ensureDir(profileDir);
-  await ensureDir(chromeDir);
-  return { root, projectRoot, profileDir, chromeDir };
-}
-
-// src/cache/chrome-locator.ts
-import { access } from "fs/promises";
-import { delimiter, join as join3 } from "path";
-async function pathExists(path2) {
-  try {
-    await access(path2);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function pathCandidatesByPlatform() {
-  const platform = process.platform;
-  if (platform === "darwin") {
-    return [
-      "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-      "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary"
-    ];
-  }
-  if (platform === "win32") {
-    const programFiles = process.env.PROGRAMFILES || "C:\\Program Files";
-    const programFilesX86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
-    const localAppData = process.env.LOCALAPPDATA || "";
-    return [
-      join3(programFiles, "Google", "Chrome", "Application", "chrome.exe"),
-      join3(programFilesX86, "Google", "Chrome", "Application", "chrome.exe"),
-      join3(localAppData, "Google", "Chrome", "Application", "chrome.exe")
-    ];
-  }
-  return [];
-}
-function binaryCandidatesInPath() {
-  return [
-    "google-chrome",
-    "google-chrome-stable",
-    "chromium",
-    "chromium-browser"
-  ];
-}
-async function findInPath(binary) {
-  const pathValue = process.env.PATH;
-  if (!pathValue) return null;
-  const candidates = process.platform === "win32" ? [binary, `${binary}.exe`] : [binary];
-  for (const dir of pathValue.split(delimiter)) {
-    for (const name of candidates) {
-      const fullPath = join3(dir, name);
-      if (await pathExists(fullPath)) return fullPath;
-    }
-  }
-  return null;
-}
-async function findChromeExecutable(overridePath) {
-  if (overridePath && await pathExists(overridePath)) {
-    return overridePath;
-  }
-  for (const candidate of pathCandidatesByPlatform()) {
-    if (await pathExists(candidate)) return candidate;
-  }
-  for (const binary of binaryCandidatesInPath()) {
-    const found = await findInPath(binary);
-    if (found) return found;
-  }
-  return null;
-}
-
-// src/cache/downloader.ts
-import { Browser, detectBrowserPlatform, install, resolveBuildId } from "@puppeteer/browsers";
-async function downloadChromeForTesting(cacheDir) {
-  const platform = detectBrowserPlatform();
-  if (!platform) {
-    throw new Error("Unsupported platform for Chrome download");
+var RemoteManager = class {
+  client;
+  constructor(client) {
+    this.client = client;
   }
-  const buildId = await resolveBuildId(Browser.CHROME, platform, "latest");
-  const result = await install({
-    browser: Browser.CHROME,
-    buildId,
-    cacheDir,
-    downloadProgressCallback: () => void 0
-  });
-  return {
-    executablePath: result.executablePath,
-    buildId
-  };
-}
-
-// src/devtools/console-tracker.ts
-var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
-var TOKEN_LIKE_PATTERN = /\b[A-Za-z0-9_-]{16,}\b/g;
-var API_KEY_PREFIX_PATTERN = /\b(sk_|pk_|api_|key_|token_|secret_|bearer_)[A-Za-z0-9_-]+\b/gi;
-var SENSITIVE_KV_PATTERN = /\b(token|key|secret|password|auth|bearer|credential)[=:]\s*\S+/gi;
-function shouldRedactToken(token) {
-  if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(token)) {
-    return true;
-  }
-  const categories = [
-    /[a-z]/.test(token),
-    /[A-Z]/.test(token),
-    /\d/.test(token),
-    /[_-]/.test(token)
-  ].filter(Boolean).length;
-  return categories >= 2;
-}
-function redactText(text) {
-  let result = text.replace(SENSITIVE_KV_PATTERN, (match) => {
-    const sepIndex = match.search(/[=:]/);
-    return match.slice(0, sepIndex + 1) + "[REDACTED]";
-  });
-  result = result.replace(JWT_PATTERN, "[REDACTED]");
-  result = result.replace(API_KEY_PREFIX_PATTERN, "[REDACTED]");
-  result = result.replace(TOKEN_LIKE_PATTERN, (match) => shouldRedactToken(match) ? "[REDACTED]" : match);
-  return result;
-}
-var ConsoleTracker = class {
-  events = [];
-  maxEvents;
-  seq = 0;
-  page = null;
-  handler;
-  showFullConsole;
-  constructor(maxEvents = 200, options = {}) {
-    this.maxEvents = maxEvents;
-    this.showFullConsole = options.showFullConsole ?? false;
-  }
-  setOptions(options) {
-    if (typeof options.showFullConsole === "boolean") {
-      this.showFullConsole = options.showFullConsole;
-    }
+  launch(options) {
+    return this.client.call("session.launch", options);
   }
-  attach(page) {
-    if (this.page === page) return;
-    this.detach();
-    this.page = page;
-    this.handler = (msg) => {
-      const rawText = msg.text();
-      const text = this.showFullConsole ? rawText : redactText(rawText);
-      this.seq += 1;
-      this.events.push({
-        seq: this.seq,
-        level: msg.type(),
-        text,
-        ts: Date.now()
-      });
-      if (this.events.length > this.maxEvents) {
-        this.events.shift();
-      }
-    };
-    page.on("console", this.handler);
+  connect(options) {
+    return this.client.call("session.connect", options);
   }
-  detach() {
-    if (this.page && this.handler) {
-      this.page.off("console", this.handler);
-    }
-    this.page = null;
-    this.handler = void 0;
-  }
-  poll(sinceSeq = 0, max = 50) {
-    const events = this.events.filter((event) => event.seq > sinceSeq).slice(0, max);
-    const last = events[events.length - 1];
-    const nextSeq = last ? last.seq : sinceSeq;
-    return { events, nextSeq };
-  }
-};
-
-// src/devtools/network-tracker.ts
-function shouldRedactPathSegment(segment) {
-  if (segment.length < 16) return false;
-  if (/^\d+$/.test(segment)) return false;
-  if (/^[a-f0-9-]{36}$/i.test(segment)) return false;
-  if (/^(sk_|pk_|api_|key_|token_|secret_|bearer_)/i.test(segment)) return true;
-  const categories = [/[a-z]/, /[A-Z]/, /\d/, /[_-]/].filter((r) => r.test(segment)).length;
-  return categories >= 3 && segment.length >= 20;
-}
-function redactUrl(rawUrl) {
-  try {
-    const parsed = new URL(rawUrl);
-    parsed.search = "";
-    parsed.hash = "";
-    const segments = parsed.pathname.split("/");
-    const redactedSegments = segments.map(
-      (segment) => shouldRedactPathSegment(segment) ? "[REDACTED]" : segment
+  connectRelay(wsEndpoint) {
+    return this.client.call(
+      "session.connect",
+      isLegacyRelayEndpoint(wsEndpoint) ? { wsEndpoint, extensionLegacy: true } : { wsEndpoint }
     );
-    parsed.pathname = redactedSegments.join("/");
-    return parsed.toString();
-  } catch {
-    return rawUrl.split(/[?#]/)[0] ?? rawUrl;
   }
-}
-var NetworkTracker = class {
-  events = [];
-  maxEvents;
-  seq = 0;
-  page = null;
-  requestHandler;
-  responseHandler;
-  showFullUrls;
-  constructor(maxEvents = 300, options = {}) {
-    this.maxEvents = maxEvents;
-    this.showFullUrls = options.showFullUrls ?? false;
+  disconnect(sessionId, closeBrowser = false) {
+    return this.client.call("session.disconnect", { sessionId, closeBrowser });
   }
-  setOptions(options) {
-    if (typeof options.showFullUrls === "boolean") {
-      this.showFullUrls = options.showFullUrls;
-    }
+  status(sessionId) {
+    return this.client.call("session.status", { sessionId });
   }
-  attach(page) {
-    if (this.page === page) return;
-    this.detach();
-    this.page = page;
-    this.requestHandler = (req) => {
-      this.push({
-        method: req.method(),
-        url: this.showFullUrls ? req.url() : redactUrl(req.url()),
-        resourceType: req.resourceType(),
-        ts: Date.now()
-      });
-    };
-    this.responseHandler = (res) => {
-      const req = res.request();
-      this.push({
-        method: req.method(),
-        url: this.showFullUrls ? res.url() : redactUrl(res.url()),
-        status: res.status(),
-        resourceType: req.resourceType(),
-        ts: Date.now()
-      });
-    };
-    page.on("request", this.requestHandler);
-    page.on("response", this.responseHandler);
+  goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4) {
+    return this.client.call("nav.goto", { sessionId, url, waitUntil, timeoutMs });
   }
-  detach() {
-    if (this.page && this.requestHandler) {
-      this.page.off("request", this.requestHandler);
-    }
-    if (this.page && this.responseHandler) {
-      this.page.off("response", this.responseHandler);
-    }
-    this.page = null;
-    this.requestHandler = void 0;
-    this.responseHandler = void 0;
+  waitForLoad(sessionId, until, timeoutMs = 3e4) {
+    return this.client.call("nav.wait", { sessionId, until, timeoutMs });
   }
-  poll(sinceSeq = 0, max = 50) {
-    const events = this.events.filter((event) => event.seq > sinceSeq).slice(0, max);
-    const last = events[events.length - 1];
-    const nextSeq = last ? last.seq : sinceSeq;
-    return { events, nextSeq };
+  waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4) {
+    return this.client.call("nav.wait", { sessionId, ref, state, timeoutMs });
   }
-  push(event) {
-    this.seq += 1;
-    this.events.push({
-      seq: this.seq,
-      ...event
-    });
-    if (this.events.length > this.maxEvents) {
-      this.events.shift();
-    }
+  snapshot(sessionId, mode, maxChars, cursor) {
+    return this.client.call("nav.snapshot", { sessionId, mode, maxChars, cursor });
   }
-};
-
-// src/export/css-extract.ts
-var STYLE_ALLOWLIST = /* @__PURE__ */ new Set([
-  "align-content",
-  "align-items",
-  "align-self",
-  "background",
-  "background-attachment",
-  "background-clip",
-  "background-color",
-  "background-image",
-  "background-origin",
-  "background-position",
-  "background-position-x",
-  "background-position-y",
-  "background-repeat",
-  "background-size",
-  "border",
-  "border-bottom",
-  "border-bottom-color",
-  "border-bottom-left-radius",
-  "border-bottom-right-radius",
-  "border-bottom-style",
-  "border-bottom-width",
-  "border-color",
-  "border-left",
-  "border-left-color",
-  "border-left-style",
-  "border-left-width",
-  "border-radius",
-  "border-right",
-  "border-right-color",
-  "border-right-style",
-  "border-right-width",
-  "border-style",
-  "border-top",
-  "border-top-color",
-  "border-top-left-radius",
-  "border-top-right-radius",
-  "border-top-style",
-  "border-top-width",
-  "border-width",
-  "box-shadow",
-  "box-sizing",
-  "color",
-  "column-gap",
-  "contain",
-  "direction",
-  "display",
-  "filter",
-  "flex",
-  "flex-direction",
-  "flex-flow",
-  "flex-wrap",
-  "font",
-  "font-family",
-  "font-feature-settings",
-  "font-kerning",
-  "font-size",
-  "font-size-adjust",
-  "font-stretch",
-  "font-style",
-  "font-variant",
-  "font-variant-caps",
-  "font-variant-east-asian",
-  "font-variant-ligatures",
-  "font-variant-numeric",
-  "font-variation-settings",
-  "font-weight",
-  "gap",
-  "grid",
-  "grid-auto-columns",
-  "grid-auto-flow",
-  "grid-auto-rows",
-  "grid-template-areas",
-  "grid-template-columns",
-  "grid-template-rows",
-  "height",
-  "hyphens",
-  "inset",
-  "inset-block",
-  "inset-inline",
-  "isolation",
-  "justify-content",
-  "left",
-  "letter-spacing",
-  "line-height",
-  "margin",
-  "margin-bottom",
-  "margin-left",
-  "margin-right",
-  "margin-top",
-  "max-height",
-  "max-width",
-  "min-height",
-  "min-width",
-  "opacity",
-  "outline",
-  "outline-color",
-  "outline-offset",
-  "outline-style",
-  "outline-width",
-  "overflow",
-  "overflow-wrap",
-  "overflow-x",
-  "overflow-y",
-  "padding",
-  "padding-bottom",
-  "padding-left",
-  "padding-right",
-  "padding-top",
-  "position",
-  "right",
-  "row-gap",
-  "text-align",
-  "text-align-last",
-  "text-decoration",
-  "text-decoration-color",
-  "text-decoration-line",
-  "text-decoration-style",
-  "text-decoration-thickness",
-  "text-indent",
-  "text-rendering",
-  "text-shadow",
-  "text-transform",
-  "top",
-  "transform",
-  "transform-origin",
-  "visibility",
-  "white-space",
-  "width",
-  "word-break",
-  "word-spacing",
-  "writing-mode",
-  "z-index"
-]);
-var SKIP_STYLE_VALUES = /* @__PURE__ */ new Set([
-  "",
-  "initial",
-  "unset",
-  "revert",
-  "revert-layer"
-]);
-function extractCss(capture) {
-  const shouldFilter = capture.inlineStyles !== false;
-  const lines = [];
-  lines.push(".opendevbrowser-root {");
-  for (const [key, value] of Object.entries(capture.styles)) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) continue;
-    if (shouldFilter) {
-      if (!STYLE_ALLOWLIST.has(key)) continue;
-      if (SKIP_STYLE_VALUES.has(trimmed)) continue;
-    }
-    lines.push(`  ${key}: ${value};`);
+  click(sessionId, ref) {
+    return this.client.call("interact.click", { sessionId, ref });
   }
-  lines.push("}");
-  return lines.join("\n");
-}
-
-// src/export/dom-capture.ts
-var DEFAULT_MAX_NODES = 1e3;
-async function captureDom(page, selector, options = {}) {
-  const shouldSanitize = options.sanitize !== false;
-  const maxNodes = options.maxNodes ?? DEFAULT_MAX_NODES;
-  const inlineStyles = options.inlineStyles !== false;
-  const styleAllowlist = Array.from(STYLE_ALLOWLIST);
-  const skipStyleValues = Array.from(SKIP_STYLE_VALUES);
-  return page.$eval(
-    selector,
-    (el, opts) => {
-      const style = window.getComputedStyle(el);
-      const styles = {};
-      for (const prop of Array.from(style)) {
-        styles[prop] = style.getPropertyValue(prop);
-      }
-      const warnings = [];
-      const root = el;
-      const clone = root.cloneNode(true);
-      const originalElements = [root, ...Array.from(root.querySelectorAll("*"))];
-      const cloneElements = [clone, ...Array.from(clone.querySelectorAll("*"))];
-      const nodeLimit = Math.max(1, opts.maxNodes);
-      if (originalElements.length > nodeLimit) {
-        const omitted = originalElements.length - nodeLimit;
-        warnings.push(`Export truncated at ${nodeLimit} nodes; ${omitted} nodes omitted.`);
-      }
-      const limit = Math.min(originalElements.length, nodeLimit);
-      if (opts.inlineStyles) {
-        const skipSet = new Set(opts.skipStyleValues);
-        for (let index = 0; index < limit; index += 1) {
-          const source = originalElements[index];
-          const target = cloneElements[index];
-          if (!source || !target) continue;
-          const computed = window.getComputedStyle(source);
-          const parts = [];
-          for (const prop of opts.styleAllowlist) {
-            const value = computed.getPropertyValue(prop).trim();
-            if (value && !skipSet.has(value)) {
-              parts.push(`${prop}: ${value};`);
-            }
-          }
-          if (parts.length > 0) {
-            target.setAttribute("style", parts.join(" "));
-          }
-        }
-      }
-      if (originalElements.length > nodeLimit) {
-        for (let index = nodeLimit; index < cloneElements.length; index += 1) {
-          const target = cloneElements[index];
-          if (target) {
-            target.remove();
-          }
-        }
-      }
-      const container = document.createElement("template");
-      container.content.appendChild(clone);
-      if (opts.shouldSanitize) {
-        const blockedTags = /* @__PURE__ */ new Set([
-          "script",
-          "iframe",
-          "object",
-          "embed",
-          "frame",
-          "frameset",
-          "applet",
-          "base",
-          "link",
-          "meta",
-          "noscript"
-        ]);
-        const urlAttrs = /* @__PURE__ */ new Set(["href", "src", "action", "formaction", "xlink:href", "srcset"]);
-        const isDangerousUrl = (value) => {
-          const normalized = value.trim().toLowerCase();
-          return normalized.startsWith("javascript:") || normalized.startsWith("data:") || normalized.startsWith("vbscript:");
-        };
-        const isDangerousSrcset = (value) => {
-          const entries = value.split(",");
-          return entries.some((entry) => {
-            const url = entry.trim().split(/\s+/)[0] ?? "";
-            return isDangerousUrl(url);
-          });
-        };
-        const DANGEROUS_CSS_PATTERNS = [
-          /url\s*\(/i,
-          /expression\s*\(/i,
-          /-moz-binding/i,
-          /behavior\s*:/i,
-          /javascript\s*:/i
-        ];
-        const sanitizeStyle = (styleValue) => {
-          let result = styleValue;
-          let wasModified = false;
-          for (const pattern of DANGEROUS_CSS_PATTERNS) {
-            if (pattern.test(result)) {
-              result = result.replace(new RegExp(pattern.source, "gi"), "/* blocked */");
-              wasModified = true;
-            }
-          }
-          return { sanitized: result, wasModified };
-        };
-        const sanitizeSvg = (svg) => {
-          const scripts = svg.querySelectorAll("script");
-          scripts.forEach((script) => {
-            script.remove();
-            warnings.push("Removed script element from SVG");
-          });
-          const foreignObjects = svg.querySelectorAll("foreignObject");
-          foreignObjects.forEach((fo) => {
-            fo.remove();
-            warnings.push("Removed foreignObject from SVG");
-          });
-          const allElements = svg.querySelectorAll("*");
-          allElements.forEach((el2) => {
-            for (const attr of Array.from(el2.attributes)) {
-              if (attr.name.toLowerCase().startsWith("on")) {
-                el2.removeAttribute(attr.name);
-              }
-            }
-          });
-        };
-        const sanitizeElement = (element) => {
-          const tag = element.tagName.toLowerCase();
-          if (blockedTags.has(tag)) {
-            element.remove();
-            return;
-          }
-          if (tag === "svg") {
-            sanitizeSvg(element);
-          }
-          for (const attr of Array.from(element.attributes)) {
-            const name = attr.name.toLowerCase();
-            if (name.startsWith("on")) {
-              element.removeAttribute(attr.name);
-              continue;
-            }
-            if (name === "style") {
-              const { sanitized, wasModified } = sanitizeStyle(attr.value);
-              if (wasModified) {
-                element.setAttribute("style", sanitized);
-                warnings.push("Sanitized dangerous CSS in style attribute");
-              }
-              continue;
-            }
-            if (urlAttrs.has(name)) {
-              const value = attr.value || "";
-              const dangerous = name === "srcset" ? isDangerousSrcset(value) : isDangerousUrl(value);
-              if (dangerous) {
-                element.removeAttribute(attr.name);
-              }
-            }
-          }
-        };
-        for (const element of Array.from(container.content.querySelectorAll("*"))) {
-          sanitizeElement(element);
-        }
-        if (container.content.firstElementChild) {
-          sanitizeElement(container.content.firstElementChild);
-        }
-      }
-      return { html: container.innerHTML, styles, warnings, inlineStyles: opts.inlineStyles };
-    },
-    { shouldSanitize, maxNodes, inlineStyles, styleAllowlist, skipStyleValues }
-  );
-}
-
-// src/export/react-emitter.ts
-function emitReactComponent(capture, css, options = {}) {
-  const warnings = [...capture.warnings ?? []];
-  if (options.allowUnsafeExport) {
-    warnings.push("Unsafe export enabled: HTML sanitization disabled.");
+  hover(sessionId, ref) {
+    return this.client.call("interact.hover", { sessionId, ref });
   }
-  const warningComment = options.allowUnsafeExport ? "// WARNING: Unsafe export enabled. HTML sanitization disabled.\n" : "";
-  const component = `${warningComment}import "./opendevbrowser.css";
-
-export default function OpenDevBrowserComponent() {
-  return (
-    <div className="opendevbrowser-root" dangerouslySetInnerHTML={{ __html: ${JSON.stringify(capture.html)} }} />
-  );
-}`;
-  return { component, css, warnings: warnings.length > 0 ? warnings : void 0 };
-}
-
-// src/snapshot/refs.ts
-import { randomUUID } from "crypto";
-var RefStore = class {
-  refsByTarget = /* @__PURE__ */ new Map();
-  snapshotByTarget = /* @__PURE__ */ new Map();
-  setSnapshot(targetId, entries) {
-    const map = /* @__PURE__ */ new Map();
-    for (const entry of entries) {
-      map.set(entry.ref, entry);
-    }
-    const snapshotId = randomUUID();
-    this.refsByTarget.set(targetId, map);
-    this.snapshotByTarget.set(targetId, snapshotId);
-    return { snapshotId, targetId, count: entries.length };
+  press(sessionId, key, ref) {
+    return this.client.call("interact.press", { sessionId, key, ref });
   }
-  resolve(targetId, ref) {
-    const map = this.refsByTarget.get(targetId);
-    if (!map) return null;
-    return map.get(ref) ?? null;
+  check(sessionId, ref) {
+    return this.client.call("interact.check", { sessionId, ref });
   }
-  getSnapshotId(targetId) {
-    return this.snapshotByTarget.get(targetId) ?? null;
+  uncheck(sessionId, ref) {
+    return this.client.call("interact.uncheck", { sessionId, ref });
   }
-  getRefCount(targetId) {
-    const map = this.refsByTarget.get(targetId);
-    return map ? map.size : 0;
+  type(sessionId, ref, text, clear = false, submit = false) {
+    return this.client.call("interact.type", { sessionId, ref, text, clear, submit });
   }
-  clearTarget(targetId) {
-    this.refsByTarget.delete(targetId);
-    this.snapshotByTarget.delete(targetId);
+  select(sessionId, ref, values) {
+    return this.client.call("interact.select", { sessionId, ref, values });
   }
-};
-
-// src/snapshot/snapshotter.ts
-var Snapshotter = class {
-  refStore;
-  constructor(refStore) {
-    this.refStore = refStore;
+  scroll(sessionId, dy, ref) {
+    return this.client.call("interact.scroll", { sessionId, dy, ref });
   }
-  async snapshot(page, targetId, options) {
-    const startTime = Date.now();
-    const session = await page.context().newCDPSession(page);
-    let snapshotData;
-    try {
-      snapshotData = await buildSnapshot(session, options.mode, options.mainFrameOnly ?? true, options.maxNodes);
-    } finally {
-      await session.detach();
-    }
-    const snapshot = this.refStore.setSnapshot(targetId, snapshotData.entries);
-    const formatted = snapshotData.lines;
-    const startIndex = parseCursor(options.cursor);
-    const { content, truncated, nextCursor } = paginate(formatted, startIndex, options.maxChars);
-    const timingMs = Date.now() - startTime;
-    let url;
-    let title;
-    try {
-      url = page.url();
-      title = await page.title();
-    } catch (_err) {
-      void _err;
-      url = void 0;
-      title = void 0;
-    }
-    return {
-      snapshotId: snapshot.snapshotId,
-      url,
-      title,
-      content,
-      truncated,
-      nextCursor,
-      refCount: snapshot.count,
-      timingMs,
-      warnings: snapshotData.warnings
-    };
+  scrollIntoView(sessionId, ref) {
+    return this.client.call("interact.scrollIntoView", { sessionId, ref });
   }
-};
-var DEFAULT_MAX_AX_NODES = 1e3;
-var ACTIONABLE_ROLES = /* @__PURE__ */ new Set([
-  "button",
-  "link",
-  "textbox",
-  "searchbox",
-  "textarea",
-  "checkbox",
-  "radio",
-  "combobox",
-  "listbox",
-  "menuitem",
-  "menuitemcheckbox",
-  "menuitemradio",
-  "option",
-  "switch",
-  "tab",
-  "slider",
-  "spinbutton",
-  "treeitem"
-]);
-var SEMANTIC_ROLES = /* @__PURE__ */ new Set([
-  "heading",
-  "article",
-  "main",
-  "navigation",
-  "region",
-  "section",
-  "form",
-  "list",
-  "listitem",
-  "paragraph",
-  "img",
-  "table",
-  "row",
-  "cell",
-  "columnheader",
-  "rowheader",
-  "banner",
-  "contentinfo",
-  "complementary"
-]);
-var selectorFunction = function() {
-  if (!(this instanceof Element)) return null;
-  const escape = (value) => {
-    if (typeof CSS !== "undefined" && CSS.escape) {
-      return CSS.escape(value);
-    }
-    return String(value).replace(/([^\w-])/g, "\\$1");
-  };
-  const testId = this.getAttribute("data-testid");
-  if (testId) {
-    return '[data-testid="' + escape(testId) + '"]';
+  domGetHtml(sessionId, ref, maxChars = 8e3) {
+    return this.client.call("dom.getHtml", { sessionId, ref, maxChars });
   }
-  const ariaLabel = this.getAttribute("aria-label");
-  if (ariaLabel && ariaLabel.length < 50) {
-    return '[aria-label="' + escape(ariaLabel) + '"]';
+  domGetText(sessionId, ref, maxChars = 8e3) {
+    return this.client.call("dom.getText", { sessionId, ref, maxChars });
   }
-  const buildPathSelector = (start) => {
-    const parts = [];
-    let current = start;
-    while (current && current.nodeType === Node.ELEMENT_NODE) {
-      let selector = current.nodeName.toLowerCase();
-      if (current.id) {
-        selector += "#" + escape(current.id);
-        parts.unshift(selector);
-        break;
-      }
-      const parentEl = current.parentElement;
-      if (!parentEl) {
-        parts.unshift(selector);
-        break;
-      }
-      let index = 1;
-      let sibling = current;
-      while (sibling && sibling.previousElementSibling) {
-        sibling = sibling.previousElementSibling;
-        index += 1;
-      }
-      selector += ":nth-child(" + index + ")";
-      parts.unshift(selector);
-      current = parentEl;
-    }
-    return parts.join(" > ");
-  };
-  return buildPathSelector(this);
-};
-var SELECTOR_FUNCTION = selectorFunction.toString();
-async function buildSnapshot(session, mode, mainFrameOnly = true, maxNodes) {
-  await session.send("Accessibility.enable");
-  await session.send("DOM.enable");
-  const result = await session.send("Accessibility.getFullAXTree");
-  const nodes = Array.isArray(result.nodes) ? result.nodes : [];
-  const entries = [];
-  const lines = [];
-  const warnings = [];
-  const maxEntries = typeof maxNodes === "number" ? maxNodes : DEFAULT_MAX_AX_NODES;
-  let skippedFrameCount = 0;
-  for (const node of nodes) {
-    if (entries.length >= maxEntries) break;
-    if (node.ignored) continue;
-    if (typeof node.backendDOMNodeId !== "number") continue;
-    if (mainFrameOnly && node.frameId) {
-      skippedFrameCount += 1;
-      continue;
-    }
-    const role = extractValue(node.role) || extractValue(node.chromeRole);
-    if (!role) continue;
-    if (!shouldInclude(role, mode)) continue;
-    const selector = await resolveSelector(session, node.backendDOMNodeId);
-    if (!selector) continue;
-    const ref = `r${entries.length + 1}`;
-    const name = redactText2(extractValue(node.name));
-    const value = redactText2(extractValue(node.value));
-    const disabled = isTruthyProperty(node.properties, "disabled");
-    const checked = isTruthyProperty(node.properties, "checked");
-    entries.push({
-      ref,
-      selector,
-      backendNodeId: node.backendDOMNodeId,
-      frameId: node.frameId,
-      role,
-      name
-    });
-    lines.push(formatNode({
-      ref,
-      role,
-      name,
-      value,
-      disabled,
-      checked
-    }));
-  }
-  if (mainFrameOnly && skippedFrameCount > 0) {
-    warnings.push(`Skipped ${skippedFrameCount} iframe nodes; snapshot limited to main frame.`);
+  domGetAttr(sessionId, ref, name) {
+    return this.client.call("dom.getAttr", { sessionId, ref, name });
   }
-  return { entries, lines, warnings };
-}
-async function resolveSelector(session, backendNodeId) {
-  const resolved = await session.send("DOM.resolveNode", { backendNodeId });
-  const objectId = resolved.object?.objectId;
-  if (!objectId) return null;
-  const result = await session.send("Runtime.callFunctionOn", {
-    objectId,
-    functionDeclaration: SELECTOR_FUNCTION,
-    returnByValue: true
-  });
-  const selector = result.result?.value;
-  if (typeof selector !== "string" || selector.trim().length === 0) {
-    return null;
+  domGetValue(sessionId, ref) {
+    return this.client.call("dom.getValue", { sessionId, ref });
   }
-  return selector;
-}
-function shouldInclude(role, mode) {
-  const normalized = role.toLowerCase();
-  if (ACTIONABLE_ROLES.has(normalized)) return true;
-  if (mode === "actionables") return false;
-  return SEMANTIC_ROLES.has(normalized);
-}
-function parseCursor(cursor) {
-  if (!cursor) return 0;
-  const value = Number(cursor);
-  if (!Number.isFinite(value) || value < 0) return 0;
-  return Math.floor(value);
-}
-function paginate(lines, startIndex, maxChars) {
-  let total = 0;
-  const parts = [];
-  let idx = startIndex;
-  while (idx < lines.length) {
-    const line = lines[idx];
-    if (line === void 0) {
-      break;
-    }
-    if (total + line.length + 1 > maxChars && parts.length > 0) {
-      break;
-    }
-    parts.push(line);
-    total += line.length + 1;
-    idx += 1;
+  domIsVisible(sessionId, ref) {
+    return this.client.call("dom.isVisible", { sessionId, ref });
   }
-  const truncated = idx < lines.length;
-  const nextCursor = truncated ? String(idx) : void 0;
-  return {
-    content: parts.join("\n"),
-    truncated,
-    nextCursor
-  };
-}
-function formatNode(node) {
-  const name = redactText2(node.name || "");
-  const value = redactText2(node.value || "");
-  const parts = [];
-  parts.push(`[${node.ref}]`);
-  parts.push(node.role);
-  if (node.disabled) {
-    parts.push("disabled");
+  domIsEnabled(sessionId, ref) {
+    return this.client.call("dom.isEnabled", { sessionId, ref });
   }
-  if (node.checked) {
-    parts.push("checked");
+  domIsChecked(sessionId, ref) {
+    return this.client.call("dom.isChecked", { sessionId, ref });
   }
-  if (name) {
-    parts.push(`"${name}"`);
+  clonePage(sessionId) {
+    return this.client.call("export.clonePage", { sessionId });
   }
-  if (value) {
-    parts.push(`value="${value}"`);
+  cloneComponent(sessionId, ref) {
+    return this.client.call("export.cloneComponent", { sessionId, ref });
   }
-  return parts.join(" ");
-}
-function redactText2(text) {
-  const trimmed = (text ?? "").trim();
-  if (!trimmed) return "";
-  return trimmed.replace(/[A-Za-z0-9+/_-]{24,}/g, "[redacted]");
-}
-function extractValue(value) {
-  if (!value || typeof value.value === "undefined" || value.value === null) return "";
-  if (typeof value.value === "string") return value.value;
-  if (typeof value.value === "number" || typeof value.value === "boolean") {
-    return String(value.value);
+  perfMetrics(sessionId) {
+    return this.client.call("devtools.perf", { sessionId });
   }
-  return "";
-}
-function isTruthyProperty(properties, name) {
-  if (!properties) return false;
-  const found = properties.find((prop) => prop.name === name);
-  if (!found || !found.value) return false;
-  const value = found.value.value;
-  if (typeof value === "boolean") return value;
-  if (typeof value === "string") return value.toLowerCase() === "true";
-  if (typeof value === "number") return value !== 0;
-  return false;
-}
-
-// src/browser/session-store.ts
-var SessionStore = class {
-  sessions = /* @__PURE__ */ new Map();
-  add(session) {
-    this.sessions.set(session.id, session);
-  }
-  get(sessionId) {
-    const session = this.sessions.get(sessionId);
-    if (!session) {
-      throw new Error(`Unknown sessionId: ${sessionId}`);
-    }
-    return session;
-  }
-  has(sessionId) {
-    return this.sessions.has(sessionId);
-  }
-  delete(sessionId) {
-    this.sessions.delete(sessionId);
-  }
-  list() {
-    return Array.from(this.sessions.values());
-  }
-};
-
-// src/browser/target-manager.ts
-import { randomUUID as randomUUID2 } from "crypto";
-var TargetManager = class {
-  targets = /* @__PURE__ */ new Map();
-  activeTargetId = null;
-  nameToTarget = /* @__PURE__ */ new Map();
-  targetToName = /* @__PURE__ */ new Map();
-  registerPage(page, name) {
-    const targetId = randomUUID2();
-    this.targets.set(targetId, page);
-    if (!this.activeTargetId) {
-      this.activeTargetId = targetId;
-    }
-    if (name) {
-      this.setName(targetId, name);
-    }
-    return targetId;
-  }
-  registerExistingPages(pages) {
-    for (const page of pages) {
-      this.registerPage(page);
-    }
-  }
-  setName(targetId, name) {
-    const trimmed = name.trim();
-    if (!trimmed) {
-      throw new Error("Name must be non-empty");
-    }
-    if (!this.targets.has(targetId)) {
-      throw new Error(`Unknown targetId: ${targetId}`);
-    }
-    const existing = this.nameToTarget.get(trimmed);
-    if (existing && existing !== targetId) {
-      throw new Error(`Name already in use: ${trimmed}`);
-    }
-    const previousName = this.targetToName.get(targetId);
-    if (previousName && previousName !== trimmed) {
-      this.nameToTarget.delete(previousName);
-    }
-    this.nameToTarget.set(trimmed, targetId);
-    this.targetToName.set(targetId, trimmed);
-  }
-  getTargetIdByName(name) {
-    return this.nameToTarget.get(name.trim()) ?? null;
-  }
-  getName(targetId) {
-    return this.targetToName.get(targetId) ?? null;
-  }
-  listNamedTargets() {
-    return Array.from(this.nameToTarget.entries()).map(([name, targetId]) => ({
-      name,
-      targetId
-    }));
-  }
-  removeName(name) {
-    const trimmed = name.trim();
-    const targetId = this.nameToTarget.get(trimmed);
-    if (targetId) {
-      this.nameToTarget.delete(trimmed);
-      this.targetToName.delete(targetId);
-    }
-  }
-  setActiveTarget(targetId) {
-    if (!this.targets.has(targetId)) {
-      throw new Error(`Unknown targetId: ${targetId}`);
-    }
-    this.activeTargetId = targetId;
-  }
-  getActiveTargetId() {
-    return this.activeTargetId;
-  }
-  getActivePage() {
-    if (!this.activeTargetId) {
-      throw new Error("No active target");
-    }
-    const page = this.targets.get(this.activeTargetId);
-    if (!page) {
-      throw new Error(`Missing active target: ${this.activeTargetId}`);
-    }
-    return page;
-  }
-  getPage(targetId) {
-    const page = this.targets.get(targetId);
-    if (!page) {
-      throw new Error(`Unknown targetId: ${targetId}`);
-    }
-    return page;
-  }
-  async listTargets(includeUrls = false) {
-    const entries = Array.from(this.targets.entries());
-    return Promise.all(entries.map(async ([targetId, page]) => {
-      const info = {
-        targetId,
-        title: void 0,
-        url: void 0,
-        type: "page"
-      };
-      try {
-        info.title = await page.title();
-      } catch {
-        info.title = void 0;
-      }
-      if (includeUrls) {
-        try {
-          info.url = page.url();
-        } catch {
-          info.url = void 0;
-        }
-      }
-      return info;
-    }));
-  }
-  async closeTarget(targetId) {
-    const page = this.getPage(targetId);
-    let closeError;
-    try {
-      await page.close();
-    } catch (error) {
-      closeError = error;
-    } finally {
-      this.targets.delete(targetId);
-      const name = this.targetToName.get(targetId);
-      if (name) {
-        this.nameToTarget.delete(name);
-        this.targetToName.delete(targetId);
-      }
-      if (this.activeTargetId === targetId) {
-        const remaining = Array.from(this.targets.keys());
-        this.activeTargetId = remaining[0] ?? null;
-      }
-    }
-    if (closeError) {
-      throw closeError;
-    }
-  }
-  listPageEntries() {
-    return Array.from(this.targets.entries()).map(([targetId, page]) => ({
-      targetId,
-      page
-    }));
-  }
-};
-
-// src/browser/browser-manager.ts
-var BrowserManager = class {
-  store = new SessionStore();
-  sessions = /* @__PURE__ */ new Map();
-  sessionMutexes = /* @__PURE__ */ new Map();
-  worktree;
-  config;
-  pageListeners = /* @__PURE__ */ new WeakMap();
-  constructor(worktree, config) {
-    this.worktree = worktree;
-    this.config = config;
-  }
-  getMutex(sessionId) {
-    let mutex = this.sessionMutexes.get(sessionId);
-    if (!mutex) {
-      mutex = new Mutex();
-      this.sessionMutexes.set(sessionId, mutex);
-    }
-    return mutex;
-  }
-  updateConfig(config) {
-    this.config = config;
-    for (const managed of this.sessions.values()) {
-      managed.consoleTracker.setOptions({ showFullConsole: config.devtools.showFullConsole });
-      managed.networkTracker.setOptions({ showFullUrls: config.devtools.showFullUrls });
-    }
-  }
-  async launch(options) {
-    const resolvedProfile = options.profile ?? this.config.profile;
-    const resolvedHeadless = options.headless ?? this.config.headless;
-    const persistProfile = options.persistProfile ?? this.config.persistProfile;
-    const cachePaths = await resolveCachePaths(this.worktree, resolvedProfile);
-    const executable = await findChromeExecutable(options.chromePath ?? this.config.chromePath);
-    const warnings = [];
-    let executablePath = executable;
-    if (!executablePath) {
-      const download = await downloadChromeForTesting(cachePaths.chromeDir);
-      warnings.push("System Chrome not found. Downloaded Chrome for Testing.");
-      executablePath = download.executablePath;
-    }
-    const profileDir = persistProfile ? cachePaths.profileDir : join4(cachePaths.projectRoot, "temp-profiles", randomUUID3());
-    await mkdir2(profileDir, { recursive: true });
-    let context = null;
-    try {
-      context = await chromium.launchPersistentContext(profileDir, {
-        headless: resolvedHeadless,
-        executablePath: executablePath ?? void 0,
-        args: options.flags ?? this.config.flags,
-        viewport: null
-      });
-      const browser = context.browser();
-      if (!browser) {
-        throw new Error("Browser instance unavailable");
-      }
-      const sessionId = randomUUID3();
-      const targets = new TargetManager();
-      const pages = context.pages();
-      if (pages.length === 0) {
-        const page = await context.newPage();
-        targets.registerPage(page);
-      } else {
-        targets.registerExistingPages(pages);
-      }
-      const activeTargetId = targets.getActiveTargetId();
-      if (options.startUrl && activeTargetId) {
-        await this.goto(sessionId, options.startUrl, "load", 3e4, { browser, context, targets });
-      }
-      const refStore = new RefStore();
-      const snapshotter = new Snapshotter(refStore);
-      const consoleTracker = new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole });
-      const networkTracker = new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls });
-      const managed = {
-        sessionId,
-        mode: "A",
-        browser,
-        context,
-        profileDir,
-        persistProfile,
-        targets,
-        refStore,
-        snapshotter,
-        consoleTracker,
-        networkTracker
-      };
-      this.store.add({ id: sessionId, mode: "A", browser, context });
-      this.sessions.set(sessionId, managed);
-      this.attachTrackers(managed);
-      this.attachRefInvalidation(managed);
-      const wsEndpointProvider = browser;
-      const wsEndpoint = typeof wsEndpointProvider.wsEndpoint === "function" ? wsEndpointProvider.wsEndpoint() : void 0;
-      return { sessionId, mode: "A", activeTargetId, warnings, wsEndpoint: wsEndpoint || void 0 };
-    } catch (error) {
-      const launchMessage = error instanceof Error ? error.message : "Unknown error";
-      const cleanupErrors = [];
-      if (context) {
-        try {
-          await context.close();
-        } catch (closeError) {
-          cleanupErrors.push(closeError);
-        }
-      }
-      if (!persistProfile) {
-        try {
-          await rm(profileDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
-        } catch (cleanupError) {
-          cleanupErrors.push(cleanupError);
-        }
-      }
-      if (cleanupErrors.length > 0) {
-        throw new AggregateError(
-          [error, ...cleanupErrors],
-          `Failed to launch browser context: ${launchMessage}. Cleanup failed.`
-        );
-      }
-      throw new Error(`Failed to launch browser context: ${launchMessage}`, { cause: error });
-    }
-  }
-  async connect(options) {
-    const wsEndpoint = await this.resolveWsEndpoint(options);
-    return this.connectWithEndpoint(wsEndpoint, "B");
-  }
-  async connectRelay(wsEndpoint) {
-    this.ensureLocalEndpoint(wsEndpoint);
-    return this.connectWithEndpoint(wsEndpoint, "C");
-  }
-  async closeAll() {
-    const sessions = Array.from(this.sessions.keys());
-    await Promise.allSettled(sessions.map((id) => this.disconnect(id, true)));
-  }
-  async disconnect(sessionId, closeBrowser = false) {
-    const managed = this.getManaged(sessionId);
-    const cleanupErrors = [];
-    try {
-      for (const entry of managed.targets.listPageEntries()) {
-        const cleanup = this.pageListeners.get(entry.page);
-        if (cleanup) {
-          try {
-            cleanup();
-          } catch (error) {
-            cleanupErrors.push(error);
-          }
-          this.pageListeners.delete(entry.page);
-        }
-      }
-      try {
-        if (closeBrowser) {
-          await managed.browser.close();
-        } else {
-          await managed.context.close();
-        }
-      } catch (error) {
-        cleanupErrors.push(error);
-      }
-      try {
-        managed.consoleTracker.detach();
-      } catch (error) {
-        cleanupErrors.push(error);
-      }
-      try {
-        managed.networkTracker.detach();
-      } catch (error) {
-        cleanupErrors.push(error);
-      }
-      if (!managed.persistProfile && managed.profileDir) {
-        try {
-          await rm(managed.profileDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
-        } catch (error) {
-          cleanupErrors.push(error);
-        }
-      }
-    } finally {
-      this.sessions.delete(sessionId);
-      this.sessionMutexes.delete(sessionId);
-      this.store.delete(sessionId);
-    }
-    if (cleanupErrors.length === 1) {
-      throw cleanupErrors[0];
-    }
-    if (cleanupErrors.length > 1) {
-      throw new AggregateError(cleanupErrors, "Failed to disconnect browser session.");
-    }
-  }
-  async status(sessionId) {
-    const managed = this.getManaged(sessionId);
-    const activeTargetId = managed.targets.getActiveTargetId();
-    const page = activeTargetId ? managed.targets.getPage(activeTargetId) : null;
-    const title = await this.safePageTitle(page, "BrowserManager.status");
-    const url = this.safePageUrl(page, "BrowserManager.status");
-    return {
-      mode: managed.mode,
-      activeTargetId,
-      url,
-      title
-    };
-  }
-  async listTargets(sessionId, includeUrls = false) {
-    const managed = this.getManaged(sessionId);
-    const targets = await managed.targets.listTargets(includeUrls);
-    return {
-      activeTargetId: managed.targets.getActiveTargetId(),
-      targets
-    };
-  }
-  async page(sessionId, name, url) {
-    const managed = this.getManaged(sessionId);
-    const existingTargetId = managed.targets.getTargetIdByName(name);
-    let targetId = existingTargetId;
-    let created = false;
-    if (targetId) {
-      managed.targets.setActiveTarget(targetId);
-    } else {
-      const page2 = await managed.context.newPage();
-      targetId = managed.targets.registerPage(page2, name);
-      managed.targets.setActiveTarget(targetId);
-      this.attachRefInvalidationForPage(managed, targetId, page2);
-      created = true;
-    }
-    this.attachTrackers(managed);
-    if (url) {
-      await this.goto(sessionId, url, "load", 3e4);
-    }
-    const page = managed.targets.getPage(targetId);
-    const title = await this.safePageTitle(page, "BrowserManager.page");
-    const finalUrl = this.safePageUrl(page, "BrowserManager.page");
-    return { targetId, created, url: finalUrl, title };
-  }
-  async listPages(sessionId) {
-    const managed = this.getManaged(sessionId);
-    const named = managed.targets.listNamedTargets();
-    const pages = [];
-    for (const entry of named) {
-      const page = managed.targets.getPage(entry.targetId);
-      const title = await this.safePageTitle(page, "BrowserManager.listPages");
-      const url = this.safePageUrl(page, "BrowserManager.listPages");
-      pages.push({ name: entry.name, targetId: entry.targetId, url, title });
-    }
-    return { pages };
-  }
-  async closePage(sessionId, name) {
-    const managed = this.getManaged(sessionId);
-    const targetId = managed.targets.getTargetIdByName(name);
-    if (!targetId) {
-      throw new Error(`Unknown page name: ${name}`);
-    }
-    await managed.targets.closeTarget(targetId);
-    managed.refStore.clearTarget(targetId);
-    this.attachTrackers(managed);
-  }
-  async useTarget(sessionId, targetId) {
-    const managed = this.getManaged(sessionId);
-    managed.targets.setActiveTarget(targetId);
-    this.attachTrackers(managed);
-    const page = managed.targets.getPage(targetId);
-    const title = await this.safePageTitle(page, "BrowserManager.useTarget");
-    return {
-      activeTargetId: targetId,
-      url: this.safePageUrl(page, "BrowserManager.useTarget"),
-      title
-    };
-  }
-  async newTarget(sessionId, url) {
-    const managed = this.getManaged(sessionId);
-    const page = await managed.context.newPage();
-    const targetId = managed.targets.registerPage(page);
-    managed.targets.setActiveTarget(targetId);
-    this.attachRefInvalidationForPage(managed, targetId, page);
-    if (url) {
-      await page.goto(url, { waitUntil: "load" });
-    }
-    this.attachTrackers(managed);
-    return { targetId };
-  }
-  async closeTarget(sessionId, targetId) {
-    const managed = this.getManaged(sessionId);
-    await managed.targets.closeTarget(targetId);
-    managed.refStore.clearTarget(targetId);
-    this.attachTrackers(managed);
-  }
-  async goto(sessionId, url, waitUntil = "load", timeoutMs = 3e4, sessionOverride) {
-    const startTime = Date.now();
-    const managed = sessionOverride ? this.buildOverrideSession(sessionOverride) : this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    const response = await page.goto(url, { waitUntil, timeout: timeoutMs });
-    return {
-      finalUrl: page.url(),
-      status: response?.status(),
-      timingMs: Date.now() - startTime
-    };
-  }
-  async waitForLoad(sessionId, until, timeoutMs = 3e4) {
-    const startTime = Date.now();
-    const managed = this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    await page.waitForLoadState(until, { timeout: timeoutMs });
-    return { timingMs: Date.now() - startTime };
-  }
-  async waitForRef(sessionId, ref, state = "attached", timeoutMs = 3e4) {
-    const startTime = Date.now();
-    const managed = this.getManaged(sessionId);
-    const selector = this.resolveSelector(managed, ref);
-    const page = managed.targets.getActivePage();
-    await page.locator(selector).waitFor({ state, timeout: timeoutMs });
-    return { timingMs: Date.now() - startTime };
-  }
-  async snapshot(sessionId, mode, maxChars, cursor) {
-    const mutex = this.getMutex(sessionId);
-    return mutex.runExclusive(async () => {
-      const managed = this.getManaged(sessionId);
-      const targetId = managed.targets.getActiveTargetId();
-      if (!targetId) {
-        throw new Error("No active target for snapshot");
-      }
-      const page = managed.targets.getActivePage();
-      return managed.snapshotter.snapshot(page, targetId, {
-        mode,
-        maxChars,
-        cursor,
-        maxNodes: this.config.snapshot.maxNodes
-      });
-    });
-  }
-  async click(sessionId, ref) {
-    const mutex = this.getMutex(sessionId);
-    return mutex.runExclusive(async () => {
-      const startTime = Date.now();
-      const managed = this.getManaged(sessionId);
-      const selector = this.resolveSelector(managed, ref);
-      const page = managed.targets.getActivePage();
-      const previousUrl = page.url();
-      await page.locator(selector).click();
-      const navigated = page.url() !== previousUrl;
-      return { timingMs: Date.now() - startTime, navigated };
-    });
-  }
-  async type(sessionId, ref, text, clear = false, submit = false) {
-    const mutex = this.getMutex(sessionId);
-    return mutex.runExclusive(async () => {
-      const startTime = Date.now();
-      const managed = this.getManaged(sessionId);
-      const selector = this.resolveSelector(managed, ref);
-      const locator = managed.targets.getActivePage().locator(selector);
-      if (clear) {
-        await locator.fill("");
-      }
-      await locator.fill(text);
-      if (submit) {
-        await locator.press("Enter");
-      }
-      return { timingMs: Date.now() - startTime };
-    });
-  }
-  async select(sessionId, ref, values) {
-    const managed = this.getManaged(sessionId);
-    const selector = this.resolveSelector(managed, ref);
-    await managed.targets.getActivePage().locator(selector).selectOption(values);
-  }
-  async scroll(sessionId, dy, ref) {
-    const managed = this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    if (ref) {
-      const selector = this.resolveSelector(managed, ref);
-      await page.locator(selector).evaluate((el, delta) => {
-        el.scrollBy(0, delta);
-      }, dy);
-    } else {
-      await page.mouse.wheel(0, dy);
-    }
-  }
-  async domGetHtml(sessionId, ref, maxChars = 8e3) {
-    const managed = this.getManaged(sessionId);
-    const selector = this.resolveSelector(managed, ref);
-    const html = await managed.targets.getActivePage().$eval(selector, (el) => el.outerHTML);
-    return truncateHtml(html, maxChars);
-  }
-  async domGetText(sessionId, ref, maxChars = 8e3) {
-    const managed = this.getManaged(sessionId);
-    const selector = this.resolveSelector(managed, ref);
-    const text = await managed.targets.getActivePage().$eval(selector, (el) => el.innerText || el.textContent || "");
-    return truncateText(text, maxChars);
-  }
-  async clonePage(sessionId) {
-    const managed = this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    const allowUnsafeExport = this.config.security.allowUnsafeExport;
-    const exportConfig = this.config.export;
-    const capture = await captureDom(page, "body", {
-      sanitize: !allowUnsafeExport,
-      maxNodes: exportConfig.maxNodes,
-      inlineStyles: exportConfig.inlineStyles
-    });
-    const css = extractCss(capture);
-    return emitReactComponent(capture, css, { allowUnsafeExport });
-  }
-  async cloneComponent(sessionId, ref) {
-    const managed = this.getManaged(sessionId);
-    const selector = this.resolveSelector(managed, ref);
-    const allowUnsafeExport = this.config.security.allowUnsafeExport;
-    const exportConfig = this.config.export;
-    const capture = await captureDom(managed.targets.getActivePage(), selector, {
-      sanitize: !allowUnsafeExport,
-      maxNodes: exportConfig.maxNodes,
-      inlineStyles: exportConfig.inlineStyles
-    });
-    const css = extractCss(capture);
-    return emitReactComponent(capture, css, { allowUnsafeExport });
-  }
-  async perfMetrics(sessionId) {
-    const managed = this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    const session = await managed.context.newCDPSession(page);
-    const result = await session.send("Performance.getMetrics");
-    await session.detach();
-    const metrics = Array.isArray(result.metrics) ? result.metrics : [];
-    return { metrics };
-  }
-  async screenshot(sessionId, path2) {
-    const managed = this.getManaged(sessionId);
-    const page = managed.targets.getActivePage();
-    if (path2) {
-      await page.screenshot({ path: path2, type: "png" });
-      return { path: path2 };
-    }
-    const buffer = await page.screenshot({ type: "png" });
-    return { base64: buffer.toString("base64") };
+  screenshot(sessionId, path) {
+    return this.client.call("page.screenshot", { sessionId, path });
   }
   consolePoll(sessionId, sinceSeq, max = 50) {
-    const managed = this.getManaged(sessionId);
-    return managed.consoleTracker.poll(sinceSeq, max);
+    return this.client.call("devtools.consolePoll", { sessionId, sinceSeq, max });
   }
   networkPoll(sessionId, sinceSeq, max = 50) {
-    const managed = this.getManaged(sessionId);
-    return managed.networkTracker.poll(sinceSeq, max);
-  }
-  buildOverrideSession(input) {
-    const refStore = new RefStore();
-    return {
-      sessionId: "override",
-      mode: "A",
-      browser: input.browser,
-      context: input.context,
-      profileDir: "",
-      persistProfile: true,
-      targets: input.targets,
-      refStore,
-      snapshotter: new Snapshotter(refStore),
-      consoleTracker: new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole }),
-      networkTracker: new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls })
-    };
-  }
-  getManaged(sessionId) {
-    const managed = this.sessions.get(sessionId);
-    if (!managed) {
-      throw new Error(`Unknown sessionId: ${sessionId}`);
-    }
-    return managed;
-  }
-  resolveSelector(managed, ref) {
-    const targetId = managed.targets.getActiveTargetId();
-    if (!targetId) {
-      throw new Error("No active target for ref resolution");
-    }
-    const entry = managed.refStore.resolve(targetId, ref);
-    if (!entry) {
-      throw new Error(`Unknown ref: ${ref}. Take a new snapshot first.`);
-    }
-    return entry.selector;
-  }
-  async safePageTitle(page, context) {
-    if (!page) return void 0;
-    try {
-      return await page.title();
-    } catch {
-      console.warn(`${context}: failed to read page title`);
-      return void 0;
-    }
-  }
-  safePageUrl(page, context) {
-    if (!page) return void 0;
-    try {
-      return page.url();
-    } catch {
-      console.warn(`${context}: failed to read page url`);
-      return void 0;
-    }
-  }
-  attachTrackers(managed) {
-    const activeTargetId = managed.targets.getActiveTargetId();
-    if (!activeTargetId) return;
-    const page = managed.targets.getActivePage();
-    managed.consoleTracker.attach(page);
-    managed.networkTracker.attach(page);
-  }
-  attachRefInvalidation(managed) {
-    const entries = managed.targets.listPageEntries();
-    for (const entry of entries) {
-      this.attachRefInvalidationForPage(managed, entry.targetId, entry.page);
-    }
-  }
-  attachRefInvalidationForPage(managed, targetId, page) {
-    if (this.pageListeners.has(page)) return;
-    const onNavigate = (frame) => {
-      if (frame.parentFrame() === null) {
-        managed.refStore.clearTarget(targetId);
-      }
-    };
-    const onClose = () => {
-      managed.refStore.clearTarget(targetId);
-    };
-    page.on("framenavigated", onNavigate);
-    page.on("close", onClose);
-    this.pageListeners.set(page, () => {
-      page.off("framenavigated", onNavigate);
-      page.off("close", onClose);
-    });
-  }
-  async resolveWsEndpoint(options) {
-    if (options.wsEndpoint) {
-      this.ensureLocalEndpoint(options.wsEndpoint);
-      return options.wsEndpoint;
-    }
-    const host = options.host ?? "127.0.0.1";
-    const port = options.port ?? 9222;
-    const url = `http://${host}:${port}/json/version`;
-    this.ensureLocalEndpoint(url);
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch CDP endpoint from ${url}`);
-    }
-    const data = await response.json();
-    if (!data.webSocketDebuggerUrl) {
-      throw new Error("webSocketDebuggerUrl missing from /json/version response");
-    }
-    this.ensureLocalEndpoint(data.webSocketDebuggerUrl);
-    return data.webSocketDebuggerUrl;
-  }
-  ensureLocalEndpoint(endpoint) {
-    if (this.config.security.allowNonLocalCdp) return;
-    const ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["ws:", "wss:", "http:", "https:"]);
-    const LOCAL_HOSTNAMES = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
-    let parsed;
-    try {
-      parsed = new URL(endpoint);
-    } catch {
-      throw new Error("Invalid CDP endpoint URL.");
-    }
-    if (!ALLOWED_PROTOCOLS.has(parsed.protocol)) {
-      throw new Error(`Disallowed protocol "${parsed.protocol}" for CDP endpoint. Allowed: ws, wss, http, https.`);
-    }
-    const hostname = parsed.hostname.toLowerCase();
-    if (!LOCAL_HOSTNAMES.has(hostname) && !hostname.toLowerCase().startsWith("::ffff:127.")) {
-      throw new Error("Non-local CDP endpoints are disabled by default.");
-    }
-  }
-  async connectWithEndpoint(wsEndpoint, mode) {
-    const browser = await chromium.connectOverCDP(wsEndpoint);
-    const contexts = browser.contexts();
-    const context = contexts[0] ?? await browser.newContext();
-    const sessionId = randomUUID3();
-    const targets = new TargetManager();
-    const pages = context.pages();
-    if (pages.length === 0) {
-      const page = await context.newPage();
-      targets.registerPage(page);
-    } else {
-      targets.registerExistingPages(pages);
-    }
-    const refStore = new RefStore();
-    const snapshotter = new Snapshotter(refStore);
-    const consoleTracker = new ConsoleTracker(200, { showFullConsole: this.config.devtools.showFullConsole });
-    const networkTracker = new NetworkTracker(300, { showFullUrls: this.config.devtools.showFullUrls });
-    const managed = {
-      sessionId,
-      mode,
-      browser,
-      context,
-      profileDir: "",
-      persistProfile: true,
-      targets,
-      refStore,
-      snapshotter,
-      consoleTracker,
-      networkTracker
-    };
-    this.store.add({ id: sessionId, mode, browser, context });
-    this.sessions.set(sessionId, managed);
-    this.attachTrackers(managed);
-    this.attachRefInvalidation(managed);
-    return { sessionId, mode, activeTargetId: targets.getActiveTargetId(), warnings: [], wsEndpoint };
-  }
-};
-function truncateHtml(value, maxChars) {
-  if (value.length <= maxChars) {
-    return { outerHTML: value, truncated: false };
-  }
-  return { outerHTML: value.slice(0, maxChars), truncated: true };
-}
-function truncateText(value, maxChars) {
-  if (value.length <= maxChars) {
-    return { text: value, truncated: false };
-  }
-  return { text: value.slice(0, maxChars), truncated: true };
-}
-
-// src/browser/script-runner.ts
-var ScriptRunner = class {
-  manager;
-  constructor(manager) {
-    this.manager = manager;
-  }
-  async run(sessionId, steps, stopOnError = true) {
-    const startTime = Date.now();
-    const results = [];
-    for (let i = 0; i < steps.length; i += 1) {
-      const step = steps[i];
-      if (!step) {
-        continue;
-      }
-      try {
-        const data = await this.executeStep(sessionId, step);
-        results.push({ i, ok: true, data });
-      } catch (error) {
-        results.push({
-          i,
-          ok: false,
-          error: { message: error instanceof Error ? error.message : "Unknown error" }
-        });
-        if (stopOnError) {
-          break;
-        }
-      }
-    }
-    return { results, timingMs: Date.now() - startTime };
-  }
-  async executeStep(sessionId, step) {
-    const args = step.args ?? {};
-    switch (step.action) {
-      case "goto":
-        return this.manager.goto(
-          sessionId,
-          requireString(args.url, "url"),
-          requireWaitUntil(args.waitUntil),
-          requireNumber(args.timeoutMs, 3e4)
-        );
-      case "wait":
-        if (typeof args.ref === "string") {
-          const ref = args.ref;
-          const state = requireState(args.state);
-          const timeoutMs = requireNumber(args.timeoutMs, 3e4);
-          return withRetry("wait", () => this.manager.waitForRef(
-            sessionId,
-            ref,
-            state,
-            timeoutMs
-          ));
-        }
-        return withRetry("wait", () => this.manager.waitForLoad(
-          sessionId,
-          requireWaitUntil(args.until),
-          requireNumber(args.timeoutMs, 3e4)
-        ));
-      case "snapshot":
-        return this.manager.snapshot(
-          sessionId,
-          requireSnapshotMode(args.format ?? args.mode),
-          requireNumber(args.maxChars, 16e3),
-          typeof args.cursor === "string" ? args.cursor : void 0
-        );
-      case "click":
-        return withRetry("click", () => this.manager.click(sessionId, requireString(args.ref, "ref")));
-      case "type":
-        return withRetry("type", () => this.manager.type(
-          sessionId,
-          requireString(args.ref, "ref"),
-          requireString(args.text, "text"),
-          Boolean(args.clear),
-          Boolean(args.submit)
-        ));
-      case "select":
-        return withRetry("select", () => this.manager.select(
-          sessionId,
-          requireString(args.ref, "ref"),
-          requireStringArray(args.values, "values")
-        ));
-      case "scroll":
-        return withRetry("scroll", () => this.manager.scroll(
-          sessionId,
-          requireNumber(args.dy, 0),
-          typeof args.ref === "string" ? args.ref : void 0
-        ));
-      case "dom_get_html":
-        return this.manager.domGetHtml(sessionId, requireString(args.ref, "ref"), requireNumber(args.maxChars, 8e3));
-      case "dom_get_text":
-        return this.manager.domGetText(sessionId, requireString(args.ref, "ref"), requireNumber(args.maxChars, 8e3));
-      default:
-        throw new Error(`Unknown action: ${step.action}`);
-    }
-  }
-};
-function requireString(value, label) {
-  if (typeof value !== "string" || !value.trim()) {
-    throw new Error(`Missing ${label}`);
-  }
-  return value;
-}
-function requireStringArray(value, label) {
-  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
-    throw new Error(`Invalid ${label}`);
-  }
-  return value;
-}
-function requireNumber(value, fallback) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  return fallback;
-}
-function requireWaitUntil(value) {
-  if (value === "domcontentloaded" || value === "load" || value === "networkidle") {
-    return value;
-  }
-  return "load";
-}
-function requireSnapshotMode(value) {
-  if (value === "actionables") return "actionables";
-  return "outline";
-}
-function requireState(value) {
-  if (value === "visible" || value === "hidden") return value;
-  return "attached";
-}
-var RETRY_ACTIONS = /* @__PURE__ */ new Set(["click", "type", "select", "scroll", "wait"]);
-var RETRY_MAX_ATTEMPTS = 2;
-var RETRY_BASE_DELAY_MS = 150;
-var RETRY_MAX_DELAY_MS = 1e3;
-async function withRetry(action, fn) {
-  if (!RETRY_ACTIONS.has(action)) {
-    return fn();
-  }
-  let attempt = 0;
-  let delay = RETRY_BASE_DELAY_MS;
-  while (true) {
-    try {
-      return await fn();
-    } catch (error) {
-      attempt += 1;
-      if (attempt >= RETRY_MAX_ATTEMPTS || !shouldRetry(error)) {
-        throw error;
-      }
-      await sleep(delay);
-      delay = Math.min(delay * 2, RETRY_MAX_DELAY_MS);
-    }
+    return this.client.call("devtools.networkPoll", { sessionId, sinceSeq, max });
   }
-}
-function shouldRetry(error) {
-  const message = error instanceof Error ? error.message : "";
-  if (!message) return true;
-  return !/missing|invalid|unknown ref|no active target/i.test(message);
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-// src/skills/skill-loader.ts
-import { readFile, readdir } from "fs/promises";
-import { join as join5 } from "path";
-import * as os2 from "os";
-var SkillLoader = class {
-  rootDir;
-  additionalPaths;
-  skillCache = null;
-  constructor(rootDir, additionalPaths = []) {
-    this.rootDir = rootDir;
-    this.additionalPaths = additionalPaths.map((p) => this.expandPath(p));
+  listTargets(sessionId, includeUrls = false) {
+    return this.client.call("targets.list", { sessionId, includeUrls });
   }
-  expandPath(p) {
-    if (p.startsWith("~")) {
-      return join5(os2.homedir(), p.slice(1));
-    }
-    return p;
+  useTarget(sessionId, targetId) {
+    return this.client.call("targets.use", { sessionId, targetId });
   }
-  async loadBestPractices(topic) {
-    return this.loadSkill("opendevbrowser-best-practices", topic);
+  newTarget(sessionId, url) {
+    return this.client.call("targets.new", { sessionId, url });
   }
-  async loadSkill(name, topic) {
-    const skills = await this.listSkills();
-    const skill = skills.find((s) => s.name === name);
-    if (!skill) {
-      const available = skills.map((s) => s.name).join(", ") || "none";
-      throw new Error(`Skill "${name}" not found. Available: ${available}`);
-    }
-    const content = await readFile(skill.path, "utf8");
-    const trimmed = content.trim();
-    if (!topic || !topic.trim()) {
-      return trimmed;
-    }
-    const filtered = filterSections(trimmed, topic);
-    return filtered || trimmed;
+  closeTarget(sessionId, targetId) {
+    return this.client.call("targets.close", { sessionId, targetId });
   }
-  async listSkills() {
-    if (this.skillCache) {
-      return this.skillCache;
-    }
-    const skills = [];
-    const searchPaths = this.getSearchPaths();
-    for (const searchPath of searchPaths) {
-      const discovered = await this.discoverSkillsInPath(searchPath);
-      for (const skill of discovered) {
-        if (!skills.some((s) => s.name === skill.name)) {
-          skills.push(skill);
-        }
-      }
-    }
-    this.skillCache = skills;
-    return skills;
+  page(sessionId, name, url) {
+    return this.client.call("page.open", { sessionId, name, url });
   }
-  getSearchPaths() {
-    const configDir = process.env.OPENCODE_CONFIG_DIR || join5(os2.homedir(), ".config", "opencode");
-    const searchPaths = [
-      join5(this.rootDir, ".opencode", "skill"),
-      join5(configDir, "skill"),
-      join5(this.rootDir, ".claude", "skills"),
-      join5(os2.homedir(), ".claude", "skills"),
-      ...this.additionalPaths
-    ];
-    return Array.from(new Set(searchPaths));
+  listPages(sessionId) {
+    return this.client.call("page.list", { sessionId });
+  }
+  closePage(sessionId, name) {
+    return this.client.call("page.close", { sessionId, name });
+  }
+  async withPage(_sessionId, _targetId, _fn) {
+    throw new Error("Direct annotate is unavailable via daemon-managed sessions.");
+  }
+};
+
+// src/cli/remote-relay.ts
+var emptyStatus = {
+  running: false,
+  extensionConnected: false,
+  extensionHandshakeComplete: false,
+  cdpConnected: false,
+  annotationConnected: false,
+  opsConnected: false,
+  pairingRequired: false,
+  instanceId: "",
+  epoch: 0,
+  health: {
+    ok: false,
+    reason: "relay_down",
+    extensionConnected: false,
+    extensionHandshakeComplete: false,
+    cdpConnected: false,
+    annotationConnected: false,
+    opsConnected: false,
+    pairingRequired: false
   }
-  async discoverSkillsInPath(searchPath) {
-    const skills = [];
+};
+var RemoteRelay = class {
+  client;
+  lastStatus = emptyStatus;
+  lastCdpUrl = null;
+  lastAnnotationUrl = null;
+  lastOpsUrl = null;
+  constructor(client) {
+    this.client = client;
+  }
+  async refresh() {
     try {
-      const entries = await readdir(searchPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const skillPath = join5(searchPath, entry.name, "SKILL.md");
-        try {
-          const content = await readFile(skillPath, "utf8");
-          const metadata = this.parseSkillMetadata(content, entry.name);
-          skills.push({
-            name: metadata.name,
-            description: metadata.description,
-            version: metadata.version ?? "1.0.0",
-            path: skillPath
-          });
-        } catch {
-        }
-      }
+      const status = await this.client.call("relay.status");
+      this.lastStatus = status;
+      const cdpUrl = await this.client.call("relay.cdpUrl");
+      this.lastCdpUrl = typeof cdpUrl === "string" ? cdpUrl : null;
+      const annotationUrl = await this.client.call("relay.annotationUrl");
+      this.lastAnnotationUrl = typeof annotationUrl === "string" ? annotationUrl : null;
+      const opsUrl = await this.client.call("relay.opsUrl");
+      this.lastOpsUrl = typeof opsUrl === "string" ? opsUrl : null;
     } catch {
+      this.lastStatus = emptyStatus;
+      this.lastCdpUrl = null;
+      this.lastAnnotationUrl = null;
+      this.lastOpsUrl = null;
     }
-    return skills;
   }
-  parseSkillMetadata(content, dirName) {
-    const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
-    if (!frontmatterMatch) {
-      return {
-        name: dirName,
-        description: this.extractFirstParagraph(content) || `Skill: ${dirName}`
-      };
-    }
-    const frontmatter = frontmatterMatch[1] ?? "";
-    const metadata = {
-      name: dirName,
-      description: ""
-    };
-    const nameMatch = frontmatter.match(/^name:\s*["']?([^"'\n]+)["']?\s*$/m);
-    if (nameMatch?.[1]) {
-      metadata.name = nameMatch[1].trim();
-    }
-    const descMatch = frontmatter.match(/^description:\s*["']?([^"'\n]+)["']?\s*$/m);
-    if (descMatch?.[1]) {
-      metadata.description = descMatch[1].trim();
-    }
-    const versionMatch = frontmatter.match(/^version:\s*["']?([^"'\n]+)["']?\s*$/m);
-    if (versionMatch?.[1]) {
-      metadata.version = versionMatch[1].trim();
-    }
-    if (!metadata.description) {
-      const afterFrontmatter = content.slice(frontmatterMatch[0].length);
-      metadata.description = this.extractFirstParagraph(afterFrontmatter) || `Skill: ${metadata.name}`;
-    }
-    return metadata;
-  }
-  extractFirstParagraph(content) {
-    const lines = content.trim().split(/\n/);
-    const paragraphLines = [];
-    for (const line of lines) {
-      const trimmedLine = line.trim();
-      if (trimmedLine.startsWith("#")) continue;
-      if (trimmedLine === "" && paragraphLines.length > 0) break;
-      if (trimmedLine !== "") {
-        paragraphLines.push(trimmedLine);
-      }
-    }
-    const paragraph = paragraphLines.join(" ").trim();
-    return paragraph.length > 0 ? paragraph.slice(0, 200) : null;
+  status() {
+    return this.lastStatus;
   }
-  clearCache() {
-    this.skillCache = null;
+  getCdpUrl() {
+    return this.lastCdpUrl;
   }
-};
-function filterSections(content, topic) {
-  const normalized = topic.trim().toLowerCase();
-  const lines = content.split(/\r?\n/);
-  const sections = [];
-  let currentHeading = "";
-  let currentBody = [];
-  const flush = () => {
-    if (currentHeading || currentBody.length > 0) {
-      sections.push({ heading: currentHeading, body: [...currentBody] });
-    }
-    currentHeading = "";
-    currentBody = [];
-  };
-  for (const line of lines) {
-    const headingMatch = line.match(/^(#{1,3})\s+(.*)$/);
-    if (headingMatch) {
-      flush();
-      currentHeading = headingMatch[2]?.trim() ?? "";
-      currentBody.push(line);
-      continue;
-    }
-    currentBody.push(line);
+  getAnnotationUrl() {
+    return this.lastAnnotationUrl;
   }
-  flush();
-  const matches = sections.filter((section) => section.heading.toLowerCase().includes(normalized));
-  if (matches.length === 0) {
-    return null;
+  getOpsUrl() {
+    return this.lastOpsUrl;
   }
-  return matches.map((section) => section.body.join("\n")).join("\n\n");
-}
+};
 
 // src/skills/skill-nudge.ts
 var SKILL_NUDGE_MARKER = "[opendevbrowser:skill-nudge]";
@@ -2272,441 +275,6 @@ function buildContinuityNudgeMessage(filePath) {
   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.`;
 }
 
-// src/relay/relay-server.ts
-import { createServer } from "http";
-import { timingSafeEqual } from "crypto";
-import { WebSocket, WebSocketServer } from "ws";
-var DEFAULT_DISCOVERY_PORT = 8787;
-var CONFIG_PATH = "/config";
-var PAIR_PATH = "/pair";
-var RelayServer = class _RelayServer {
-  running = false;
-  baseUrl = null;
-  port = null;
-  server = null;
-  discoveryServer = null;
-  extensionWss = null;
-  cdpWss = null;
-  extensionSocket = null;
-  cdpSocket = null;
-  extensionInfo = null;
-  pairingToken = null;
-  configuredDiscoveryPort;
-  discoveryPort = null;
-  handshakeAttempts = /* @__PURE__ */ new Map();
-  cdpAllowlist = null;
-  static MAX_HANDSHAKE_ATTEMPTS = 5;
-  static RATE_LIMIT_WINDOW_MS = 6e4;
-  constructor(options = {}) {
-    this.configuredDiscoveryPort = options.discoveryPort ?? DEFAULT_DISCOVERY_PORT;
-  }
-  async start(port = 8787) {
-    if (this.running && this.baseUrl && this.port !== null) {
-      return { url: this.baseUrl, port: this.port };
-    }
-    this.server = createServer();
-    this.extensionWss = new WebSocketServer({ noServer: true });
-    this.cdpWss = new WebSocketServer({ noServer: true });
-    this.extensionWss.on("connection", (socket) => {
-      if (this.extensionSocket) {
-        this.extensionSocket.close(1e3, "Replaced by a new extension client");
-      }
-      this.extensionSocket = socket;
-      this.extensionInfo = null;
-      socket.on("message", (data) => {
-        this.handleExtensionMessage(data);
-      });
-      socket.on("close", () => {
-        if (this.extensionSocket === socket) {
-          this.extensionSocket = null;
-          this.extensionInfo = null;
-        }
-        if (this.cdpSocket) {
-          this.cdpSocket.close(1011, "Extension disconnected");
-        }
-      });
-    });
-    this.cdpWss.on("connection", (socket) => {
-      if (this.cdpSocket) {
-        socket.close(1008, "Only one CDP client supported");
-        return;
-      }
-      this.cdpSocket = socket;
-      socket.on("message", (data) => {
-        this.handleCdpMessage(data);
-      });
-      socket.on("close", () => {
-        if (this.cdpSocket === socket) {
-          this.cdpSocket = null;
-        }
-      });
-    });
-    this.server.on("request", (request, response) => {
-      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
-      const origin = request.headers.origin;
-      if (pathname === CONFIG_PATH && request.method === "OPTIONS") {
-        this.handleConfigPreflight(origin, response);
-        return;
-      }
-      if (pathname === CONFIG_PATH && request.method === "GET") {
-        this.handleConfigRequest(origin, response);
-        return;
-      }
-      if (pathname === PAIR_PATH && request.method === "OPTIONS") {
-        if (origin && origin.startsWith("chrome-extension://")) {
-          response.setHeader("Access-Control-Allow-Origin", origin);
-          response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-          response.setHeader("Access-Control-Allow-Headers", "Content-Type");
-        }
-        response.writeHead(204);
-        response.end();
-        return;
-      }
-      if (pathname === PAIR_PATH && request.method === "GET") {
-        const isLocalhost = !origin || origin.startsWith("chrome-extension://");
-        if (!isLocalhost) {
-          response.writeHead(403, { "Content-Type": "application/json" });
-          response.end(JSON.stringify({ error: "Forbidden: only localhost/extension allowed" }));
-          return;
-        }
-        if (origin && origin.startsWith("chrome-extension://")) {
-          response.setHeader("Access-Control-Allow-Origin", origin);
-        }
-        response.writeHead(200, { "Content-Type": "application/json" });
-        response.end(JSON.stringify({ token: this.pairingToken }));
-        return;
-      }
-      response.writeHead(404);
-      response.end();
-    });
-    this.server.on("upgrade", (request, socket, head) => {
-      const origin = request.headers.origin;
-      const ip = request.socket.remoteAddress ?? "unknown";
-      if (!this.isAllowedOrigin(origin)) {
-        this.logSecurityEvent("origin_blocked", { origin, ip });
-        socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
-        socket.destroy();
-        return;
-      }
-      if (this.isRateLimited(ip)) {
-        this.logSecurityEvent("rate_limited", { ip });
-        socket.write("HTTP/1.1 429 Too Many Requests\r\n\r\n");
-        socket.destroy();
-        return;
-      }
-      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
-      if (pathname === "/extension") {
-        this.extensionWss?.handleUpgrade(request, socket, head, (ws) => {
-          this.extensionWss?.emit("connection", ws, request);
-        });
-        return;
-      }
-      if (pathname === "/cdp") {
-        this.cdpWss?.handleUpgrade(request, socket, head, (ws) => {
-          this.cdpWss?.emit("connection", ws, request);
-        });
-        return;
-      }
-      socket.destroy();
-    });
-    await new Promise((resolve, reject) => {
-      this.server?.once("error", reject);
-      this.server?.listen(port, "127.0.0.1", () => {
-        resolve();
-      });
-    });
-    const address = this.server.address();
-    if (!address) {
-      throw new Error("Relay server did not expose a port");
-    }
-    this.port = address.port;
-    this.baseUrl = `ws://127.0.0.1:${address.port}`;
-    this.running = true;
-    try {
-      await this.startDiscoveryServer();
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn(`[opendevbrowser] Discovery server failed to start: ${message}`);
-      this.stopDiscoveryServer();
-    }
-    return { url: this.baseUrl, port: address.port };
-  }
-  stop() {
-    this.running = false;
-    this.baseUrl = null;
-    this.port = null;
-    this.extensionInfo = null;
-    this.stopDiscoveryServer();
-    if (this.extensionSocket) {
-      this.extensionSocket.close(1e3, "Relay stopped");
-      this.extensionSocket = null;
-    }
-    if (this.cdpSocket) {
-      this.cdpSocket.close(1e3, "Relay stopped");
-      this.cdpSocket = null;
-    }
-    this.extensionWss?.close();
-    this.cdpWss?.close();
-    this.server?.close();
-    this.extensionWss = null;
-    this.cdpWss = null;
-    this.server = null;
-  }
-  status() {
-    return {
-      running: this.running,
-      url: this.baseUrl || void 0,
-      port: this.port ?? void 0,
-      extensionConnected: Boolean(this.extensionSocket),
-      cdpConnected: Boolean(this.cdpSocket),
-      extension: this.extensionInfo ?? void 0
-    };
-  }
-  getCdpUrl() {
-    return this.baseUrl ? `${this.baseUrl}/cdp` : null;
-  }
-  getDiscoveryPort() {
-    if (this.port !== null && this.port === this.configuredDiscoveryPort) {
-      return this.port;
-    }
-    return this.discoveryPort;
-  }
-  setToken(token) {
-    const trimmed = typeof token === "string" ? token.trim() : "";
-    this.pairingToken = trimmed.length ? trimmed : null;
-  }
-  setCdpAllowlist(methods) {
-    if (!methods || methods.length === 0) {
-      this.cdpAllowlist = null;
-      return;
-    }
-    this.cdpAllowlist = new Set(methods);
-  }
-  isAllowedOrigin(origin) {
-    if (!origin) {
-      return true;
-    }
-    if (origin.startsWith("chrome-extension://")) {
-      return true;
-    }
-    return false;
-  }
-  isExtensionOrigin(origin) {
-    return Boolean(origin && origin.startsWith("chrome-extension://"));
-  }
-  handleConfigPreflight(origin, response) {
-    if (this.isExtensionOrigin(origin)) {
-      response.setHeader("Access-Control-Allow-Origin", origin);
-      response.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-      response.setHeader("Access-Control-Allow-Headers", "Content-Type");
-    }
-    response.writeHead(204);
-    response.end();
-  }
-  handleConfigRequest(origin, response) {
-    if (!this.isExtensionOrigin(origin)) {
-      response.writeHead(403, { "Content-Type": "application/json" });
-      response.end(JSON.stringify({ error: "Forbidden: extension origin required" }));
-      return;
-    }
-    if (origin) {
-      response.setHeader("Access-Control-Allow-Origin", origin);
-    }
-    if (this.port === null) {
-      response.writeHead(503, { "Content-Type": "application/json" });
-      response.end(JSON.stringify({ error: "Relay not running" }));
-      return;
-    }
-    response.writeHead(200, {
-      "Content-Type": "application/json",
-      "Cache-Control": "no-store"
-    });
-    response.end(JSON.stringify({
-      relayPort: this.port,
-      pairingRequired: Boolean(this.pairingToken)
-    }));
-  }
-  async startDiscoveryServer() {
-    if (this.port === null || this.discoveryServer) {
-      return;
-    }
-    if (this.configuredDiscoveryPort > 0 && this.configuredDiscoveryPort === this.port) {
-      return;
-    }
-    this.discoveryServer = createServer((request, response) => {
-      const pathname = new URL(request.url ?? "", "http://127.0.0.1").pathname;
-      const origin = request.headers.origin;
-      if (pathname === CONFIG_PATH && request.method === "OPTIONS") {
-        this.handleConfigPreflight(origin, response);
-        return;
-      }
-      if (pathname === CONFIG_PATH && request.method === "GET") {
-        this.handleConfigRequest(origin, response);
-        return;
-      }
-      response.writeHead(404);
-      response.end();
-    });
-    await new Promise((resolve, reject) => {
-      this.discoveryServer?.once("error", reject);
-      this.discoveryServer?.listen(this.configuredDiscoveryPort, "127.0.0.1", () => {
-        resolve();
-      });
-    });
-    const address = this.discoveryServer.address();
-    if (!address) {
-      throw new Error("Discovery server did not expose a port");
-    }
-    this.discoveryPort = address.port;
-  }
-  stopDiscoveryServer() {
-    if (this.discoveryServer) {
-      this.discoveryServer.close();
-      this.discoveryServer = null;
-    }
-    this.discoveryPort = null;
-  }
-  isRateLimited(ip) {
-    const now = Date.now();
-    const record = this.handshakeAttempts.get(ip);
-    if (!record || now > record.resetAt) {
-      this.handshakeAttempts.set(ip, { count: 1, resetAt: now + _RelayServer.RATE_LIMIT_WINDOW_MS });
-      return false;
-    }
-    record.count++;
-    return record.count > _RelayServer.MAX_HANDSHAKE_ATTEMPTS;
-  }
-  isCommandAllowed(method) {
-    if (!this.cdpAllowlist) return true;
-    return this.cdpAllowlist.has(method);
-  }
-  logSecurityEvent(event, details) {
-    const safeDetails = { ...details };
-    delete safeDetails.token;
-    delete safeDetails.pairingToken;
-    console.warn(`[security] ${event}`, JSON.stringify(safeDetails));
-  }
-  handleCdpMessage(data) {
-    const message = parseJson(data);
-    if (!isRecord(message)) {
-      return;
-    }
-    const id = message.id;
-    const method = message.method;
-    if (typeof id !== "string" && typeof id !== "number" || typeof method !== "string") {
-      return;
-    }
-    if (!this.extensionSocket) {
-      this.sendJson(this.cdpSocket, {
-        id,
-        error: { message: "Extension not connected to relay" }
-      });
-      return;
-    }
-    if (!this.isCommandAllowed(method)) {
-      this.logSecurityEvent("command_blocked", { method });
-      this.sendJson(this.cdpSocket, {
-        id,
-        error: { message: `CDP command '${method}' not in allowlist` }
-      });
-      return;
-    }
-    const relayCommand = {
-      id,
-      method: "forwardCDPCommand",
-      params: {
-        method,
-        params: message.params,
-        sessionId: typeof message.sessionId === "string" ? message.sessionId : void 0
-      }
-    };
-    this.sendJson(this.extensionSocket, relayCommand);
-  }
-  handleExtensionMessage(data) {
-    const message = parseJson(data);
-    if (!isRecord(message)) {
-      return;
-    }
-    if (isHandshake(message)) {
-      if (!this.isPairingTokenValid(message)) {
-        this.logSecurityEvent("handshake_failed", { reason: "invalid_token", tabId: message.payload.tabId });
-        this.extensionInfo = null;
-        this.extensionSocket?.close(1008, "Invalid pairing token");
-        return;
-      }
-      this.extensionInfo = {
-        tabId: message.payload.tabId,
-        url: message.payload.url,
-        title: message.payload.title,
-        groupId: message.payload.groupId
-      };
-      return;
-    }
-    if (message.method === "forwardCDPEvent" && isRecord(message.params)) {
-      const params = message.params;
-      const event = {
-        method: params.method,
-        params: params.params ?? {}
-      };
-      if (params.sessionId) {
-        event.sessionId = params.sessionId;
-      }
-      this.sendJson(this.cdpSocket, event);
-      return;
-    }
-    if (typeof message.id === "string" || typeof message.id === "number") {
-      const response = { id: message.id };
-      if (typeof message.result !== "undefined") {
-        response.result = message.result;
-      }
-      if (message.error) {
-        response.error = message.error;
-      }
-      if (typeof message.sessionId === "string") {
-        response.sessionId = message.sessionId;
-      }
-      this.sendJson(this.cdpSocket, response);
-    }
-  }
-  sendJson(socket, payload) {
-    if (!socket || socket.readyState !== WebSocket.OPEN) {
-      return;
-    }
-    socket.send(JSON.stringify(payload));
-  }
-  isPairingTokenValid(handshake) {
-    if (!this.pairingToken) {
-      return true;
-    }
-    const expected = this.pairingToken;
-    const received = handshake.payload.pairingToken ?? "";
-    const expectedBuf = Buffer.from(expected, "utf-8");
-    const receivedBuf = Buffer.from(received, "utf-8");
-    if (expectedBuf.length !== receivedBuf.length) {
-      timingSafeEqual(expectedBuf, expectedBuf);
-      return false;
-    }
-    return timingSafeEqual(expectedBuf, receivedBuf);
-  }
-};
-var parseJson = (data) => {
-  const text = typeof data === "string" ? data : data.toString();
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-};
-var isRecord = (value) => {
-  return typeof value === "object" && value !== null;
-};
-var isHandshake = (value) => {
-  if (value.type !== "handshake" || !isRecord(value.payload)) {
-    return false;
-  }
-  return typeof value.payload.tabId === "number";
-};
-
 // src/tools/launch.ts
 import { tool } from "@opencode-ai/plugin";
 
@@ -2731,85 +299,363 @@ function serializeError(error) {
 }
 
 // src/tools/launch.ts
-var z2 = tool.schema;
+var z = tool.schema;
 function createLaunchTool(deps) {
   return tool({
-    description: "Launch a managed Chrome session and return a sessionId.",
+    description: "Launch a browser session (extension relay first) and return a sessionId.",
     args: {
-      profile: z2.string().optional().describe("Profile name for persistent browsing"),
-      headless: z2.boolean().optional().describe("Run Chrome in headless mode"),
-      startUrl: z2.string().optional().describe("Optional URL to open after launch"),
-      chromePath: z2.string().optional().describe("Override Chrome executable path"),
-      flags: z2.array(z2.string()).optional().describe("Extra Chrome flags"),
-      persistProfile: z2.boolean().optional().describe("Persist profile data between sessions")
+      profile: z.string().optional().describe("Profile name for persistent browsing"),
+      headless: z.boolean().optional().describe("Run Chrome in headless mode"),
+      startUrl: z.string().optional().describe("Optional URL to open after launch"),
+      chromePath: z.string().optional().describe("Override Chrome executable path"),
+      flags: z.array(z.string()).optional().describe("Extra Chrome flags"),
+      persistProfile: z.boolean().optional().describe("Persist profile data between sessions"),
+      noExtension: z.boolean().optional().describe("Skip extension relay and launch a new browser"),
+      extensionOnly: z.boolean().optional().describe("Require extension relay or fail"),
+      extensionLegacy: z.boolean().optional().describe("Use legacy extension relay (/cdp) instead of ops"),
+      waitForExtension: z.boolean().optional().describe("Wait for extension to connect before launching"),
+      waitTimeoutMs: z.number().int().optional().describe("Timeout for waiting on extension (ms)")
     },
     async execute(args) {
-      try {
-        const relayStatus = deps.relay?.status();
-        const relayUrl = deps.relay?.getCdpUrl();
-        const useRelay = Boolean(relayStatus?.extensionConnected && relayUrl);
-        let usedRelay = false;
-        let relayWarning = null;
-        let result = null;
-        if (useRelay && relayUrl) {
-          try {
-            result = await deps.manager.connectRelay(relayUrl);
-            usedRelay = true;
-          } catch {
-            relayWarning = "Relay connection failed; falling back to managed Chrome.";
+      let attemptedRebind = false;
+      while (true) {
+        try {
+          await deps.relay?.refresh?.();
+          const config = deps.config.get();
+          const extensionLegacy = args.extensionLegacy === true;
+          let relayStatus = deps.relay?.status();
+          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"}`;
           }
-        }
-        if (!result) {
-          result = await deps.manager.launch({
-            profile: args.profile,
-            headless: args.headless,
-            startUrl: args.startUrl,
-            chromePath: args.chromePath,
-            flags: args.flags,
-            persistProfile: args.persistProfile
+          const waitTimeoutMs = clampWaitTimeout(args.waitTimeoutMs ?? 3e4);
+          const headlessExplicit = args.headless === true;
+          const managedExplicit = Boolean(args.noExtension || headlessExplicit);
+          const managedHeadless = headlessExplicit ? true : false;
+          if (args.waitForExtension && !managedExplicit) {
+            const observedPort2 = resolveObservedPort(relayStatus, config.relayPort);
+            const connected = await waitForExtensionHandshake(deps.relay, observedPort2, waitTimeoutMs);
+            if (connected) {
+              relayStatus = deps.relay?.status() ?? relayStatus;
+              relayUrl = extensionLegacy ? deps.relay?.getCdpUrl() ?? relayUrl : deps.relay?.getOpsUrl?.() ?? relayUrl;
+            }
+          }
+          const observedPort = resolveObservedPort(relayStatus, config.relayPort);
+          const shouldFetchObserved = !managedExplicit && (!relayUrl || !(relayStatus?.extensionHandshakeComplete || relayStatus?.extensionConnected));
+          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;
+          }
+          const extensionReady = Boolean(
+            relayUrl && (relayStatus?.extensionHandshakeComplete || relayStatus?.extensionConnected || observedStatus?.extensionHandshakeComplete || observedStatus?.extensionConnected)
+          );
+          let usedRelay = false;
+          let result = null;
+          if (args.extensionOnly && !extensionReady) {
+            const diagnostics = buildRelayNotReadyDiagnostics("Extension not connected.", {
+              relayUrl,
+              relayStatus,
+              observedStatus,
+              observedPort
+            });
+            if (await maybeRetryHubMismatch(diagnostics.hint, attemptedRebind, deps)) {
+              attemptedRebind = true;
+              continue;
+            }
+            return failure(buildExtensionMissingMessage(diagnostics.message), "extension_not_connected");
+          }
+          if (!managedExplicit) {
+            if (!extensionReady || !relayUrl) {
+              const diagnostics = buildRelayNotReadyDiagnostics("Extension not connected.", {
+                relayUrl,
+                relayStatus,
+                observedStatus,
+                observedPort
+              });
+              if (await maybeRetryHubMismatch(diagnostics.hint, attemptedRebind, deps)) {
+                attemptedRebind = true;
+                continue;
+              }
+              return failure(buildExtensionMissingMessage(diagnostics.message), "extension_not_connected");
+            }
+            try {
+              result = await deps.manager.connectRelay(relayUrl);
+              usedRelay = true;
+            } catch (error) {
+              const errorMessage = serializeError(error).message;
+              const unauthorized = errorMessage.toLowerCase().includes("unauthorized") || errorMessage.includes("401");
+              const relayLabel = extensionLegacy ? "/cdp" : "/ops";
+              const errorObservedStatus = observedStatus ?? await fetchRelayObservedStatus(observedPort);
+              const diagnostics = buildRelayNotReadyDiagnostics(
+                unauthorized ? `Extension relay connection failed: relay ${relayLabel} unauthorized (token mismatch).` : `Extension relay connection failed: ${errorMessage}`,
+                {
+                  relayUrl,
+                  relayStatus,
+                  observedStatus: errorObservedStatus,
+                  observedPort
+                }
+              );
+              if (await maybeRetryHubMismatch(diagnostics.hint, attemptedRebind, deps)) {
+                attemptedRebind = true;
+                continue;
+              }
+              return failure(buildExtensionMissingMessage(diagnostics.message), "extension_connect_failed");
+            }
+          }
+          if (!result) {
+            try {
+              result = await deps.manager.launch({
+                profile: args.profile,
+                headless: managedHeadless,
+                startUrl: args.startUrl,
+                chromePath: args.chromePath,
+                flags: args.flags,
+                persistProfile: args.persistProfile,
+                noExtension: args.noExtension
+              });
+            } catch (error) {
+              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,
+            mode: result.mode,
+            browserWsEndpoint: result.wsEndpoint,
+            activeTargetId: result.activeTargetId,
+            warnings: warnings.length ? warnings : void 0
           });
+        } catch (error) {
+          return failure(serializeError(error).message, "launch_failed");
         }
-        if (usedRelay && args.startUrl && result.activeTargetId) {
-          await deps.manager.goto(result.sessionId, args.startUrl, "load", 3e4);
-        }
-        const warnings = [
-          ...result.warnings ?? [],
-          ...relayWarning ? [relayWarning] : []
-        ];
-        return ok({
-          sessionId: result.sessionId,
-          mode: result.mode,
-          browserWsEndpoint: result.wsEndpoint,
-          activeTargetId: result.activeTargetId,
-          warnings: warnings.length ? warnings : void 0
-        });
-      } catch (error) {
-        return failure(serializeError(error).message, "launch_failed");
       }
     }
   });
 }
+var buildExtensionMissingMessage = (reason) => {
+  return [
+    reason,
+    "Connect the extension: open the Chrome extension popup and click Connect, then retry.",
+    "Tip: If the popup says Connected, it may be connected to a different relay instance/port than this tool expects.",
+    "Legend: ext=extension websocket, handshake=extension handshake, ops=active /ops client, cdp=active /cdp client, pairing=token required.",
+    "",
+    "Other options (explicit):",
+    "- Managed (headed): npx opendevbrowser launch --no-extension",
+    "- Managed (headless): npx opendevbrowser launch --no-extension --headless",
+    "- Legacy extension relay: npx opendevbrowser launch --extension-legacy",
+    "- CDPConnect (default port): npx opendevbrowser connect --cdp-port 9222",
+    "- CDPConnect (explicit WS): npx opendevbrowser connect --ws-endpoint ws://127.0.0.1:9222/devtools/browser/<id>",
+    "Note: CDPConnect requires Chrome started with --remote-debugging-port=9222."
+  ].join("\n");
+};
+var buildManagedFailureMessage = (error) => {
+  const detail = serializeError(error).message;
+  return [
+    `Managed session failed: ${detail}`,
+    "",
+    "Final option (explicit):",
+    "- CDPConnect (default port): npx opendevbrowser connect --cdp-port 9222",
+    "- CDPConnect (explicit WS): npx opendevbrowser connect --ws-endpoint ws://127.0.0.1:9222/devtools/browser/<id>"
+  ].join("\n");
+};
+var MIN_WAIT_TIMEOUT_MS = 3e3;
+var WAIT_MIN_DELAY_MS = 250;
+var WAIT_MAX_DELAY_MS = 2e3;
+function clampWaitTimeout(timeoutMs) {
+  if (!Number.isFinite(timeoutMs)) {
+    return MIN_WAIT_TIMEOUT_MS;
+  }
+  return Math.max(timeoutMs, MIN_WAIT_TIMEOUT_MS);
+}
+async function waitForExtensionHandshake(relay, observedPort, timeoutMs) {
+  const start = Date.now();
+  let delay = WAIT_MIN_DELAY_MS;
+  while (Date.now() - start < timeoutMs) {
+    if (relay?.status().extensionHandshakeComplete) {
+      return true;
+    }
+    const observedStatus = await fetchRelayObservedStatus(observedPort);
+    if (observedStatus?.extensionHandshakeComplete) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delay));
+    delay = Math.min(delay * 2, WAIT_MAX_DELAY_MS);
+  }
+  return false;
+}
+function resolveObservedPort(relayStatus, configPort) {
+  const relayPort = relayStatus?.port;
+  if (isValidPort(relayPort)) return relayPort;
+  if (isValidPort(configPort)) return configPort;
+  return null;
+}
+function isValidPort(port) {
+  return typeof port === "number" && Number.isInteger(port) && port > 0 && port <= 65535;
+}
+function shortInstanceId(value) {
+  if (!value) return "?";
+  return value.slice(0, 8);
+}
+function formatRelayUrl(relayUrl) {
+  return relayUrl ?? "null";
+}
+function formatLocalStatus(status) {
+  return [
+    "local(instance=",
+    shortInstanceId(status?.instanceId),
+    " port=",
+    typeof status?.port === "number" ? String(status.port) : "?",
+    " ext=",
+    String(Boolean(status?.extensionConnected)),
+    " handshake=",
+    String(Boolean(status?.extensionHandshakeComplete)),
+    " ops=",
+    String(Boolean(status?.opsConnected)),
+    " cdp=",
+    String(Boolean(status?.cdpConnected)),
+    " pairing=",
+    String(Boolean(status?.pairingRequired)),
+    ")"
+  ].join("");
+}
+function formatObservedStatus(status, port) {
+  const label = port ?? "?";
+  if (!status) {
+    return `observed@${label}=none`;
+  }
+  return [
+    "observed@",
+    label,
+    "=instance=",
+    shortInstanceId(status.instanceId),
+    " ext=",
+    String(Boolean(status.extensionConnected)),
+    " handshake=",
+    String(Boolean(status.extensionHandshakeComplete)),
+    " ops=",
+    String(Boolean(status.opsConnected)),
+    " cdp=",
+    String(Boolean(status.cdpConnected)),
+    " pairing=",
+    String(Boolean(status.pairingRequired))
+  ].join("");
+}
+function buildRelayNotReadyDiagnostics(baseReason, detail) {
+  const localExt = Boolean(detail.relayStatus?.extensionConnected);
+  const observedExt = Boolean(detail.observedStatus?.extensionConnected);
+  let hint = "none";
+  if (detail.relayUrl === null) {
+    hint = "relayUrl_null";
+  } else if (detail.observedStatus && !localExt && observedExt) {
+    hint = "possible_mismatch";
+  } else if (detail.relayStatus?.instanceId && detail.observedStatus?.instanceId && detail.relayStatus.instanceId !== detail.observedStatus.instanceId) {
+    hint = "possible_mismatch";
+  }
+  const diagnostics = [
+    "Diagnostics: relayUrl=",
+    formatRelayUrl(detail.relayUrl),
+    " ",
+    formatLocalStatus(detail.relayStatus),
+    " ",
+    formatObservedStatus(detail.observedStatus, detail.observedPort),
+    " hint=",
+    hint
+  ].join("");
+  return { message: [baseReason, diagnostics].join("\n"), hint };
+}
+async function maybeRetryHubMismatch(hint, attempted, deps) {
+  if (attempted) return false;
+  if (hint !== "possible_mismatch") return false;
+  if (!deps.ensureHub) return false;
+  await deps.ensureHub();
+  await deps.relay?.refresh?.();
+  return true;
+}
+async function fetchRelayObservedStatus(port) {
+  if (!isValidPort(port)) return null;
+  if (typeof fetch !== "function") return null;
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), 500);
+  try {
+    const response = await fetch(`http://127.0.0.1:${port}/status`, { signal: controller.signal });
+    if (!response.ok) return null;
+    const payload = await response.json();
+    if (!payload || typeof payload.instanceId !== "string") return null;
+    return {
+      instanceId: payload.instanceId,
+      running: Boolean(payload.running),
+      port: typeof payload.port === "number" ? payload.port : void 0,
+      extensionConnected: Boolean(payload.extensionConnected),
+      extensionHandshakeComplete: Boolean(payload.extensionHandshakeComplete),
+      cdpConnected: Boolean(payload.cdpConnected),
+      opsConnected: Boolean(payload.opsConnected),
+      pairingRequired: Boolean(payload.pairingRequired)
+    };
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
 
 // src/tools/connect.ts
 import { tool as tool2 } from "@opencode-ai/plugin";
-var z3 = tool2.schema;
+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.",
+    description: "Connect to an existing Chrome CDP endpoint or extension relay.",
     args: {
-      wsEndpoint: z3.string().optional().describe("Full WebSocket endpoint to connect to"),
-      host: z3.string().optional().describe("Host for /json/version lookup"),
-      port: z3.number().int().optional().describe("Port for /json/version lookup")
+      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"),
+      extensionLegacy: z2.boolean().optional().describe("Use legacy extension relay (/cdp) instead of ops")
     },
     async execute(args) {
       try {
-        const relayUrl = deps.relay?.getCdpUrl();
-        const useRelay = Boolean(relayUrl && args.wsEndpoint === relayUrl);
-        const result = useRelay && relayUrl ? await deps.manager.connectRelay(relayUrl) : await deps.manager.connect({
-          wsEndpoint: args.wsEndpoint,
-          host: args.host,
-          port: args.port
-        });
+        await deps.relay?.refresh?.();
+        const wsEndpoint = args.wsEndpoint;
+        const extensionLegacy = args.extensionLegacy === true;
+        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 relayEndpoint = relayUrl && wsEndpoint === relayUrl ? relayUrl : extensionLegacy ? normalizedLegacyEndpoint ?? normalizedOpsEndpoint : normalizedOpsEndpoint;
+        let result;
+        if (relayEndpoint || !hasExplicitCdp && relayUrl) {
+          result = 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");
+          }
+          result = await deps.manager.connect({
+            wsEndpoint,
+            host: args.host,
+            port: args.port
+          });
+        }
         return ok({
           sessionId: result.sessionId,
           mode: result.mode,
@@ -2826,13 +672,13 @@ function createConnectTool(deps) {
 
 // src/tools/disconnect.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
-var z4 = tool3.schema;
+var z3 = tool3.schema;
 function createDisconnectTool(deps) {
   return tool3({
     description: "Disconnect a browser session.",
     args: {
-      sessionId: z4.string().describe("Session id returned from launch/connect"),
-      closeBrowser: z4.boolean().optional().describe("Close the underlying browser process")
+      sessionId: z3.string().describe("Session id returned from launch/connect"),
+      closeBrowser: z3.boolean().optional().describe("Close the underlying browser process")
     },
     async execute(args) {
       try {
@@ -2846,21 +692,28 @@ function createDisconnectTool(deps) {
 }
 
 // src/tools/status.ts
-import { readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join as join6 } from "path";
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { tool as tool4 } from "@opencode-ai/plugin";
-var z5 = tool4.schema;
+
+// src/utils/hub-enabled.ts
+var isHubEnabled = (config) => {
+  return config.relayToken !== false && config.relayPort > 0;
+};
+
+// src/tools/status.ts
+var z4 = tool4.schema;
 function getPackageVersion() {
   try {
-    const baseDir = dirname2(fileURLToPath(import.meta.url));
+    const baseDir = dirname(fileURLToPath(import.meta.url));
     const candidates = [
-      join6(baseDir, "..", "..", "package.json"),
-      join6(baseDir, "..", "package.json")
+      join(baseDir, "..", "..", "package.json"),
+      join(baseDir, "..", "package.json")
     ];
     for (const pkgPath of candidates) {
       try {
-        const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
         if (typeof pkg.version === "string") {
           return pkg.version;
         }
@@ -2891,17 +744,45 @@ async function fetchLatestVersion(packageName) {
 }
 function createStatusTool(deps) {
   return tool4({
-    description: "Get status of a browser session.",
+    description: "Get daemon or session status.",
     args: {
-      sessionId: z5.string().describe("Session id")
+      sessionId: z4.string().optional().describe("Session id (required when hub is disabled)")
     },
     async execute(args) {
       try {
-        const status = await deps.manager.status(args.sessionId);
-        const extensionPath = deps.getExtensionPath?.() ?? null;
         const config = deps.config.get();
+        const hubEnabled = isHubEnabled(config);
+        const extensionPath = deps.getExtensionPath?.() ?? null;
         const version = getPackageVersion();
         let updateHint;
+        let sessionStatus = null;
+        if (hubEnabled) {
+          const daemonStatus = await fetchDaemonStatusFromMetadata();
+          if (!daemonStatus) {
+            return failure("Daemon not running. Start with `npx opendevbrowser serve`.", "status_failed");
+          }
+          if (args.sessionId) {
+            sessionStatus = await deps.manager.status(args.sessionId);
+          }
+          if (config.checkForUpdates && version) {
+            const latest = await fetchLatestVersion("opendevbrowser");
+            if (latest && latest !== version) {
+              updateHint = `Update available: ${version} -> ${latest}`;
+            }
+          }
+          return ok({
+            ...sessionStatus ?? {},
+            daemon: daemonStatus,
+            hubEnabled: true,
+            extensionPath: extensionPath ?? void 0,
+            version,
+            updateHint
+          });
+        }
+        if (!args.sessionId) {
+          return failure("Missing sessionId for status.", "status_failed");
+        }
+        sessionStatus = await deps.manager.status(args.sessionId);
         if (config.checkForUpdates && version) {
           const latest = await fetchLatestVersion("opendevbrowser");
           if (latest && latest !== version) {
@@ -2909,10 +790,10 @@ function createStatusTool(deps) {
           }
         }
         return ok({
-          mode: status.mode,
-          activeTargetId: status.activeTargetId,
-          url: status.url,
-          title: status.title,
+          mode: sessionStatus.mode,
+          activeTargetId: sessionStatus.activeTargetId,
+          url: sessionStatus.url,
+          title: sessionStatus.title,
           extensionPath: extensionPath ?? void 0,
           version,
           updateHint
@@ -2926,13 +807,13 @@ function createStatusTool(deps) {
 
 // src/tools/targets_list.ts
 import { tool as tool5 } from "@opencode-ai/plugin";
-var z6 = tool5.schema;
+var z5 = tool5.schema;
 function createTargetsListTool(deps) {
   return tool5({
     description: "List targets (tabs) in the current session.",
     args: {
-      sessionId: z6.string().describe("Session id"),
-      includeUrls: z6.boolean().optional().describe("Include target URLs")
+      sessionId: z5.string().describe("Session id"),
+      includeUrls: z5.boolean().optional().describe("Include target URLs")
     },
     async execute(args) {
       try {
@@ -2950,13 +831,13 @@ function createTargetsListTool(deps) {
 
 // src/tools/target_use.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
-var z7 = tool6.schema;
+var z6 = tool6.schema;
 function createTargetUseTool(deps) {
   return tool6({
     description: "Set the active target (tab).",
     args: {
-      sessionId: z7.string().describe("Session id"),
-      targetId: z7.string().describe("Target id")
+      sessionId: z6.string().describe("Session id"),
+      targetId: z6.string().describe("Target id")
     },
     async execute(args) {
       try {
@@ -2975,13 +856,13 @@ function createTargetUseTool(deps) {
 
 // src/tools/target_new.ts
 import { tool as tool7 } from "@opencode-ai/plugin";
-var z8 = tool7.schema;
+var z7 = tool7.schema;
 function createTargetNewTool(deps) {
   return tool7({
     description: "Open a new target (tab).",
     args: {
-      sessionId: z8.string().describe("Session id"),
-      url: z8.string().optional().describe("Optional URL to open")
+      sessionId: z7.string().describe("Session id"),
+      url: z7.string().optional().describe("Optional URL to open")
     },
     async execute(args) {
       try {
@@ -2996,13 +877,13 @@ function createTargetNewTool(deps) {
 
 // src/tools/target_close.ts
 import { tool as tool8 } from "@opencode-ai/plugin";
-var z9 = tool8.schema;
+var z8 = tool8.schema;
 function createTargetCloseTool(deps) {
   return tool8({
     description: "Close a target (tab).",
     args: {
-      sessionId: z9.string().describe("Session id"),
-      targetId: z9.string().describe("Target id")
+      sessionId: z8.string().describe("Session id"),
+      targetId: z8.string().describe("Target id")
     },
     async execute(args) {
       try {
@@ -3017,14 +898,14 @@ function createTargetCloseTool(deps) {
 
 // src/tools/page.ts
 import { tool as tool9 } from "@opencode-ai/plugin";
-var z10 = tool9.schema;
+var z9 = tool9.schema;
 function createPageTool(deps) {
   return tool9({
     description: "Open or focus a named page, optionally navigating to a URL.",
     args: {
-      sessionId: z10.string().describe("Active browser session id"),
-      name: z10.string().describe("Stable page name"),
-      url: z10.string().optional().describe("Optional URL to open")
+      sessionId: z9.string().describe("Active browser session id"),
+      name: z9.string().describe("Stable page name"),
+      url: z9.string().optional().describe("Optional URL to open")
     },
     async execute(args) {
       try {
@@ -3044,12 +925,12 @@ function createPageTool(deps) {
 
 // src/tools/list.ts
 import { tool as tool10 } from "@opencode-ai/plugin";
-var z11 = tool10.schema;
+var z10 = tool10.schema;
 function createListTool(deps) {
   return tool10({
     description: "List named pages in the current session.",
     args: {
-      sessionId: z11.string().describe("Active browser session id")
+      sessionId: z10.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -3064,13 +945,13 @@ function createListTool(deps) {
 
 // src/tools/close.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
-var z12 = tool11.schema;
+var z11 = tool11.schema;
 function createCloseTool(deps) {
   return tool11({
     description: "Close a named page within the current session.",
     args: {
-      sessionId: z12.string().describe("Active browser session id"),
-      name: z12.string().describe("Named page to close")
+      sessionId: z11.string().describe("Active browser session id"),
+      name: z11.string().describe("Named page to close")
     },
     async execute(args) {
       try {
@@ -3085,16 +966,16 @@ function createCloseTool(deps) {
 
 // src/tools/goto.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
-var z13 = tool12.schema;
-var waitUntilSchema = z13.enum(["domcontentloaded", "load", "networkidle"]);
+var z12 = tool12.schema;
+var waitUntilSchema = z12.enum(["domcontentloaded", "load", "networkidle"]);
 function createGotoTool(deps) {
   return tool12({
     description: "Navigate the active target to a URL.",
     args: {
-      sessionId: z13.string().describe("Session id"),
-      url: z13.string().describe("URL to navigate to"),
+      sessionId: z12.string().describe("Session id"),
+      url: z12.string().describe("URL to navigate to"),
       waitUntil: waitUntilSchema.optional().describe("Load state to wait for"),
-      timeoutMs: z13.number().int().optional().describe("Timeout in milliseconds")
+      timeoutMs: z12.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
@@ -3114,18 +995,18 @@ function createGotoTool(deps) {
 
 // src/tools/wait.ts
 import { tool as tool13 } from "@opencode-ai/plugin";
-var z14 = tool13.schema;
-var waitUntilSchema2 = z14.enum(["domcontentloaded", "load", "networkidle"]);
-var waitStateSchema = z14.enum(["attached", "visible", "hidden"]);
+var z13 = tool13.schema;
+var waitUntilSchema2 = z13.enum(["domcontentloaded", "load", "networkidle"]);
+var waitStateSchema = z13.enum(["attached", "visible", "hidden"]);
 function createWaitTool(deps) {
   return tool13({
     description: "Wait for a load state or a ref state.",
     args: {
-      sessionId: z14.string().describe("Session id"),
+      sessionId: z13.string().describe("Session id"),
       until: waitUntilSchema2.optional().describe("Load state to wait for"),
-      ref: z14.string().optional().describe("Ref to wait for"),
+      ref: z13.string().optional().describe("Ref to wait for"),
       state: waitStateSchema.optional().describe("Ref state to wait for"),
-      timeoutMs: z14.number().int().optional().describe("Timeout in milliseconds")
+      timeoutMs: z13.number().int().optional().describe("Timeout in milliseconds")
     },
     async execute(args) {
       try {
@@ -3156,16 +1037,16 @@ function createWaitTool(deps) {
 
 // src/tools/snapshot.ts
 import { tool as tool14 } from "@opencode-ai/plugin";
-var z15 = tool14.schema;
-var formatSchema = z15.enum(["outline", "actionables"]);
+var z14 = tool14.schema;
+var formatSchema = z14.enum(["outline", "actionables"]);
 function createSnapshotTool(deps) {
   return tool14({
     description: "Capture a snapshot of the current page and return refs.",
     args: {
-      sessionId: z15.string().describe("Session id"),
+      sessionId: z14.string().describe("Session id"),
       format: formatSchema.optional().describe("Snapshot format"),
-      maxChars: z15.number().int().optional().describe("Max characters for snapshot output"),
-      cursor: z15.string().optional().describe("Cursor for paging")
+      maxChars: z14.number().int().optional().describe("Max characters for snapshot output"),
+      cursor: z14.string().optional().describe("Cursor for paging")
     },
     async execute(args) {
       try {
@@ -3186,13 +1067,13 @@ function createSnapshotTool(deps) {
 
 // src/tools/click.ts
 import { tool as tool15 } from "@opencode-ai/plugin";
-var z16 = tool15.schema;
+var z15 = tool15.schema;
 function createClickTool(deps) {
   return tool15({
     description: "Click a referenced element.",
     args: {
-      sessionId: z16.string().describe("Session id"),
-      ref: z16.string().describe("Element ref")
+      sessionId: z15.string().describe("Session id"),
+      ref: z15.string().describe("Element ref")
     },
     async execute(args) {
       try {
@@ -3205,18 +1086,103 @@ function createClickTool(deps) {
   });
 }
 
-// src/tools/type.ts
+// src/tools/hover.ts
 import { tool as tool16 } from "@opencode-ai/plugin";
-var z17 = tool16.schema;
-function createTypeTool(deps) {
+var z16 = tool16.schema;
+function createHoverTool(deps) {
   return tool16({
+    description: "Hover over an element by ref.",
+    args: {
+      sessionId: z16.string().describe("Active browser session id"),
+      ref: z16.string().describe("Element ref from snapshot")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.hover(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "hover_failed");
+      }
+    }
+  });
+}
+
+// src/tools/press.ts
+import { tool as tool17 } from "@opencode-ai/plugin";
+var z17 = tool17.schema;
+function createPressTool(deps) {
+  return tool17({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.press(args.sessionId, args.key, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "press_failed");
+      }
+    }
+  });
+}
+
+// src/tools/check.ts
+import { tool as tool18 } from "@opencode-ai/plugin";
+var z18 = tool18.schema;
+function createCheckTool(deps) {
+  return tool18({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.check(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "check_failed");
+      }
+    }
+  });
+}
+
+// src/tools/uncheck.ts
+import { tool as tool19 } from "@opencode-ai/plugin";
+var z19 = tool19.schema;
+function createUncheckTool(deps) {
+  return tool19({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.uncheck(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "uncheck_failed");
+      }
+    }
+  });
+}
+
+// src/tools/type.ts
+import { tool as tool20 } from "@opencode-ai/plugin";
+var z20 = tool20.schema;
+function createTypeTool(deps) {
+  return tool20({
     description: "Type text into a referenced input.",
     args: {
-      sessionId: z17.string().describe("Session id"),
-      ref: z17.string().describe("Element ref"),
-      text: z17.string().describe("Text to type"),
-      clear: z17.boolean().optional().describe("Clear before typing"),
-      submit: z17.boolean().optional().describe("Press Enter after typing")
+      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")
     },
     async execute(args) {
       try {
@@ -3236,15 +1202,15 @@ function createTypeTool(deps) {
 }
 
 // src/tools/select.ts
-import { tool as tool17 } from "@opencode-ai/plugin";
-var z18 = tool17.schema;
+import { tool as tool21 } from "@opencode-ai/plugin";
+var z21 = tool21.schema;
 function createSelectTool(deps) {
-  return tool17({
+  return tool21({
     description: "Select options in a referenced select element.",
     args: {
-      sessionId: z18.string().describe("Session id"),
-      ref: z18.string().describe("Element ref"),
-      values: z18.array(z18.string()).describe("Values to select")
+      sessionId: z21.string().describe("Session id"),
+      ref: z21.string().describe("Element ref"),
+      values: z21.array(z21.string()).describe("Values to select")
     },
     async execute(args) {
       try {
@@ -3258,15 +1224,15 @@ function createSelectTool(deps) {
 }
 
 // src/tools/scroll.ts
-import { tool as tool18 } from "@opencode-ai/plugin";
-var z19 = tool18.schema;
+import { tool as tool22 } from "@opencode-ai/plugin";
+var z22 = tool22.schema;
 function createScrollTool(deps) {
-  return tool18({
+  return tool22({
     description: "Scroll the page or a referenced element.",
     args: {
-      sessionId: z19.string().describe("Session id"),
-      dy: z19.number().describe("Scroll delta in pixels"),
-      ref: z19.string().optional().describe("Optional element ref to scroll")
+      sessionId: z22.string().describe("Session id"),
+      dy: z22.number().describe("Scroll delta in pixels"),
+      ref: z22.string().optional().describe("Optional element ref to scroll")
     },
     async execute(args) {
       try {
@@ -3279,16 +1245,37 @@ function createScrollTool(deps) {
   });
 }
 
+// src/tools/scroll_into_view.ts
+import { tool as tool23 } from "@opencode-ai/plugin";
+var z23 = tool23.schema;
+function createScrollIntoViewTool(deps) {
+  return tool23({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.scrollIntoView(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "scroll_into_view_failed");
+      }
+    }
+  });
+}
+
 // src/tools/dom_get_html.ts
-import { tool as tool19 } from "@opencode-ai/plugin";
-var z20 = tool19.schema;
+import { tool as tool24 } from "@opencode-ai/plugin";
+var z24 = tool24.schema;
 function createDomGetHtmlTool(deps) {
-  return tool19({
+  return tool24({
     description: "Get outerHTML for a referenced element.",
     args: {
-      sessionId: z20.string().describe("Session id"),
-      ref: z20.string().describe("Element ref"),
-      maxChars: z20.number().int().optional().describe("Max characters")
+      sessionId: z24.string().describe("Session id"),
+      ref: z24.string().describe("Element ref"),
+      maxChars: z24.number().int().optional().describe("Max characters")
     },
     async execute(args) {
       try {
@@ -3310,15 +1297,15 @@ function createDomGetHtmlTool(deps) {
 }
 
 // src/tools/dom_get_text.ts
-import { tool as tool20 } from "@opencode-ai/plugin";
-var z21 = tool20.schema;
+import { tool as tool25 } from "@opencode-ai/plugin";
+var z25 = tool25.schema;
 function createDomGetTextTool(deps) {
-  return tool20({
+  return tool25({
     description: "Get inner text for a referenced element.",
     args: {
-      sessionId: z21.string().describe("Session id"),
-      ref: z21.string().describe("Element ref"),
-      maxChars: z21.number().int().optional().describe("Max characters")
+      sessionId: z25.string().describe("Session id"),
+      ref: z25.string().describe("Element ref"),
+      maxChars: z25.number().int().optional().describe("Max characters")
     },
     async execute(args) {
       try {
@@ -3339,21 +1326,127 @@ function createDomGetTextTool(deps) {
   });
 }
 
+// src/tools/get_attr.ts
+import { tool as tool26 } from "@opencode-ai/plugin";
+var z26 = tool26.schema;
+function createGetAttrTool(deps) {
+  return tool26({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.domGetAttr(args.sessionId, args.ref, args.name);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "get_attr_failed");
+      }
+    }
+  });
+}
+
+// src/tools/get_value.ts
+import { tool as tool27 } from "@opencode-ai/plugin";
+var z27 = tool27.schema;
+function createGetValueTool(deps) {
+  return tool27({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.domGetValue(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "get_value_failed");
+      }
+    }
+  });
+}
+
+// src/tools/is_visible.ts
+import { tool as tool28 } from "@opencode-ai/plugin";
+var z28 = tool28.schema;
+function createIsVisibleTool(deps) {
+  return tool28({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.domIsVisible(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "is_visible_failed");
+      }
+    }
+  });
+}
+
+// src/tools/is_enabled.ts
+import { tool as tool29 } from "@opencode-ai/plugin";
+var z29 = tool29.schema;
+function createIsEnabledTool(deps) {
+  return tool29({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.domIsEnabled(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "is_enabled_failed");
+      }
+    }
+  });
+}
+
+// src/tools/is_checked.ts
+import { tool as tool30 } from "@opencode-ai/plugin";
+var z30 = tool30.schema;
+function createIsCheckedTool(deps) {
+  return tool30({
+    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")
+    },
+    async execute(args) {
+      try {
+        const result = await deps.manager.domIsChecked(args.sessionId, args.ref);
+        return ok(result);
+      } catch (error) {
+        return failure(serializeError(error).message, "is_checked_failed");
+      }
+    }
+  });
+}
+
 // src/tools/run.ts
-import { tool as tool21 } from "@opencode-ai/plugin";
-var z22 = tool21.schema;
-var stepSchema = z22.object({
-  action: z22.string().describe("Action name"),
-  args: z22.record(z22.string(), z22.unknown()).optional().describe("Action arguments")
+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")
 });
 function createRunTool(deps) {
-  return tool21({
+  return tool31({
     description: "Run multiple actions in a single tool call.",
     args: {
-      sessionId: z22.string().describe("Session id"),
-      steps: z22.array(stepSchema).describe("Steps to execute"),
-      stopOnError: z22.boolean().optional().describe("Stop when a step fails"),
-      maxSnapshotChars: z22.number().int().optional().describe("Default maxChars for snapshot steps")
+      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")
     },
     async execute(args) {
       try {
@@ -3386,13 +1479,13 @@ function normalizeSteps(steps, maxSnapshotChars) {
 }
 
 // src/tools/prompting_guide.ts
-import { tool as tool22 } from "@opencode-ai/plugin";
-var z23 = tool22.schema;
+import { tool as tool32 } from "@opencode-ai/plugin";
+var z32 = tool32.schema;
 function createPromptingGuideTool(deps) {
-  return tool22({
+  return tool32({
     description: "Return best-practice prompting guidance for OpenDevBrowser.",
     args: {
-      topic: z23.string().optional().describe("Optional topic for guidance")
+      topic: z32.string().optional().describe("Optional topic for guidance")
     },
     async execute(args) {
       try {
@@ -3406,19 +1499,19 @@ function createPromptingGuideTool(deps) {
 }
 
 // src/tools/console_poll.ts
-import { tool as tool23 } from "@opencode-ai/plugin";
-var z24 = tool23.schema;
+import { tool as tool33 } from "@opencode-ai/plugin";
+var z33 = tool33.schema;
 function createConsolePollTool(deps) {
-  return tool23({
+  return tool33({
     description: "Poll console events for the active target.",
     args: {
-      sessionId: z24.string().describe("Session id"),
-      sinceSeq: z24.number().int().optional().describe("Sequence to resume from"),
-      max: z24.number().int().optional().describe("Max events to return")
+      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")
     },
     async execute(args) {
       try {
-        const result = deps.manager.consolePoll(
+        const result = await deps.manager.consolePoll(
           args.sessionId,
           args.sinceSeq,
           args.max ?? 50
@@ -3432,19 +1525,19 @@ function createConsolePollTool(deps) {
 }
 
 // src/tools/network_poll.ts
-import { tool as tool24 } from "@opencode-ai/plugin";
-var z25 = tool24.schema;
+import { tool as tool34 } from "@opencode-ai/plugin";
+var z34 = tool34.schema;
 function createNetworkPollTool(deps) {
-  return tool24({
+  return tool34({
     description: "Poll network events for the active target.",
     args: {
-      sessionId: z25.string().describe("Session id"),
-      sinceSeq: z25.number().int().optional().describe("Sequence to resume from"),
-      max: z25.number().int().optional().describe("Max events to return")
+      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")
     },
     async execute(args) {
       try {
-        const result = deps.manager.networkPoll(
+        const result = await deps.manager.networkPoll(
           args.sessionId,
           args.sinceSeq,
           args.max ?? 50
@@ -3458,13 +1551,13 @@ function createNetworkPollTool(deps) {
 }
 
 // src/tools/clone_page.ts
-import { tool as tool25 } from "@opencode-ai/plugin";
-var z26 = tool25.schema;
+import { tool as tool35 } from "@opencode-ai/plugin";
+var z35 = tool35.schema;
 function createClonePageTool(deps) {
-  return tool25({
+  return tool35({
     description: "Export the active page as a React component and CSS bundle.",
     args: {
-      sessionId: z26.string().describe("Active browser session id")
+      sessionId: z35.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -3478,14 +1571,14 @@ function createClonePageTool(deps) {
 }
 
 // src/tools/clone_component.ts
-import { tool as tool26 } from "@opencode-ai/plugin";
-var z27 = tool26.schema;
+import { tool as tool36 } from "@opencode-ai/plugin";
+var z36 = tool36.schema;
 function createCloneComponentTool(deps) {
-  return tool26({
+  return tool36({
     description: "Export a selected element subtree as a React component and CSS bundle.",
     args: {
-      sessionId: z27.string().describe("Active browser session id"),
-      ref: z27.string().describe("Element ref from snapshot")
+      sessionId: z36.string().describe("Active browser session id"),
+      ref: z36.string().describe("Element ref from snapshot")
     },
     async execute(args) {
       try {
@@ -3499,13 +1592,13 @@ function createCloneComponentTool(deps) {
 }
 
 // src/tools/perf.ts
-import { tool as tool27 } from "@opencode-ai/plugin";
-var z28 = tool27.schema;
+import { tool as tool37 } from "@opencode-ai/plugin";
+var z37 = tool37.schema;
 function createPerfTool(deps) {
-  return tool27({
+  return tool37({
     description: "Fetch lightweight performance metrics from the active page.",
     args: {
-      sessionId: z28.string().describe("Active browser session id")
+      sessionId: z37.string().describe("Active browser session id")
     },
     async execute(args) {
       try {
@@ -3519,14 +1612,14 @@ function createPerfTool(deps) {
 }
 
 // src/tools/screenshot.ts
-import { tool as tool28 } from "@opencode-ai/plugin";
-var z29 = tool28.schema;
+import { tool as tool38 } from "@opencode-ai/plugin";
+var z38 = tool38.schema;
 function createScreenshotTool(deps) {
-  return tool28({
+  return tool38({
     description: "Capture a screenshot of the active page.",
     args: {
-      sessionId: z29.string().describe("Active browser session id"),
-      path: z29.string().optional().describe("Optional output file path")
+      sessionId: z38.string().describe("Active browser session id"),
+      path: z38.string().optional().describe("Optional output file path")
     },
     async execute(args) {
       try {
@@ -3539,10 +1632,67 @@ 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"]);
+function createAnnotateTool(deps) {
+  return tool39({
+    description: "Request interactive annotations via direct (CDP) or relay transport.",
+    args: {
+      sessionId: z39.string().describe("Session id"),
+      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"),
+      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")
+    },
+    async execute(args) {
+      try {
+        const transport = args.transport ?? "auto";
+        if (transport === "relay") {
+          const status = await deps.manager.status(args.sessionId);
+          if (status.mode !== "extension") {
+            return failure("Annotations require extension mode (relay).", "annotate_requires_extension");
+          }
+        }
+        const response = await deps.annotationManager.requestAnnotation({
+          sessionId: args.sessionId,
+          transport,
+          targetId: args.targetId,
+          tabId: args.tabId,
+          url: args.url,
+          screenshotMode: args.screenshotMode ?? "visible",
+          debug: args.debug ?? false,
+          context: args.context,
+          timeoutMs: args.timeoutMs
+        });
+        if (response.status !== "ok" || !response.payload) {
+          const message2 = response.error?.message ?? "Annotation failed.";
+          const code = response.error?.code ?? "annotate_failed";
+          return failure(message2, code);
+        }
+        const { message, details, screenshots } = await buildAnnotateResult(response.payload);
+        return ok({
+          message,
+          details,
+          screenshots
+        });
+      } catch (error) {
+        return failure(serializeError(error).message, "annotate_failed");
+      }
+    }
+  });
+}
+
 // src/tools/skill_list.ts
-import { tool as tool29 } from "@opencode-ai/plugin";
+import { tool as tool40 } from "@opencode-ai/plugin";
 function createSkillListTool(deps) {
-  return tool29({
+  return tool40({
     description: "List available skills from OpenCode skill directories (compatibility wrapper)",
     args: {},
     async execute() {
@@ -3558,14 +1708,14 @@ function createSkillListTool(deps) {
 }
 
 // src/tools/skill_load.ts
-import { tool as tool30 } from "@opencode-ai/plugin";
-var z30 = tool30.schema;
+import { tool as tool41 } from "@opencode-ai/plugin";
+var z40 = tool41.schema;
 function createSkillLoadTool(deps) {
-  return tool30({
+  return tool41({
     description: "Load a specific skill by name from OpenCode skill directories (compatibility wrapper)",
     args: {
-      name: z30.string().describe("Name of the skill to load (e.g., 'login-automation', 'form-testing')"),
-      topic: z30.string().optional().describe("Optional topic to filter the skill content")
+      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")
     },
     async execute(args) {
       try {
@@ -3581,129 +1731,203 @@ function createSkillLoadTool(deps) {
 
 // src/tools/index.ts
 function createTools(deps) {
+  const wrap = (definition) => {
+    if (!deps.ensureHub) return definition;
+    return {
+      ...definition,
+      execute: async (args, context) => {
+        try {
+          await deps.ensureHub?.();
+        } catch {
+        }
+        return definition.execute(args, context);
+      }
+    };
+  };
   return {
-    opendevbrowser_launch: createLaunchTool(deps),
-    opendevbrowser_connect: createConnectTool(deps),
-    opendevbrowser_disconnect: createDisconnectTool(deps),
-    opendevbrowser_status: createStatusTool(deps),
-    opendevbrowser_targets_list: createTargetsListTool(deps),
-    opendevbrowser_target_use: createTargetUseTool(deps),
-    opendevbrowser_target_new: createTargetNewTool(deps),
-    opendevbrowser_target_close: createTargetCloseTool(deps),
-    opendevbrowser_page: createPageTool(deps),
-    opendevbrowser_list: createListTool(deps),
-    opendevbrowser_close: createCloseTool(deps),
-    opendevbrowser_goto: createGotoTool(deps),
-    opendevbrowser_wait: createWaitTool(deps),
-    opendevbrowser_snapshot: createSnapshotTool(deps),
-    opendevbrowser_click: createClickTool(deps),
-    opendevbrowser_type: createTypeTool(deps),
-    opendevbrowser_select: createSelectTool(deps),
-    opendevbrowser_scroll: createScrollTool(deps),
-    opendevbrowser_dom_get_html: createDomGetHtmlTool(deps),
-    opendevbrowser_dom_get_text: createDomGetTextTool(deps),
-    opendevbrowser_run: createRunTool(deps),
-    opendevbrowser_prompting_guide: createPromptingGuideTool(deps),
-    opendevbrowser_console_poll: createConsolePollTool(deps),
-    opendevbrowser_network_poll: createNetworkPollTool(deps),
-    opendevbrowser_clone_page: createClonePageTool(deps),
-    opendevbrowser_clone_component: createCloneComponentTool(deps),
-    opendevbrowser_perf: createPerfTool(deps),
-    opendevbrowser_screenshot: createScreenshotTool(deps),
-    opendevbrowser_skill_list: createSkillListTool(deps),
-    opendevbrowser_skill_load: createSkillLoadTool(deps)
+    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_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))
   };
 }
 
 // src/index.ts
 var OpenDevBrowserPlugin = async ({ directory, worktree }) => {
-  const initialConfig = loadGlobalConfig();
-  const configStore = new ConfigStore(initialConfig);
-  const cacheRoot = worktree || directory;
-  const manager = new BrowserManager(cacheRoot, initialConfig);
-  const runner = new ScriptRunner(manager);
-  const skills = new SkillLoader(cacheRoot, initialConfig.skillPaths);
-  const relay = new RelayServer();
+  const core = createOpenDevBrowserCore({ directory, worktree });
+  const { config, configStore, skills, ensureRelay, cleanup, getExtensionPath } = core;
+  let relay = core.relay;
+  let manager = core.manager;
+  let runner = core.runner;
+  let annotationManager = core.annotationManager;
+  let hubStop = null;
+  let daemonClient = null;
   const skillNudgeState = createSkillNudgeState();
   const continuityNudgeState = createContinuityNudgeState();
-  relay.setToken(initialConfig.relayToken);
   console.info(
-    `[opendevbrowser] loaded (cacheRoot=${cacheRoot}, relay=${initialConfig.relayToken === false ? "disabled" : "enabled"})`
+    `[opendevbrowser] loaded (cacheRoot=${core.cacheRoot}, relay=${config.relayToken === false ? "disabled" : "enabled"})`
   );
   try {
     extractExtension();
   } catch (error) {
     console.warn("Extension extraction failed:", error instanceof Error ? error.message : error);
   }
-  const ensureRelay = async (port) => {
-    if (port <= 0 || initialConfig.relayToken === false) {
-      relay.stop();
+  const toolDeps = {
+    manager,
+    annotationManager,
+    runner,
+    config: configStore,
+    skills,
+    relay,
+    getExtensionPath
+  };
+  const bindRemote = () => {
+    if (!daemonClient) {
+      daemonClient = new DaemonClient({ autoRenew: true });
+    }
+    manager = new RemoteManager(daemonClient);
+    relay = new RemoteRelay(daemonClient);
+    annotationManager.setRelay(relay);
+    annotationManager.setBrowserManager(manager);
+    runner = new ScriptRunner(manager);
+    toolDeps.manager = manager;
+    toolDeps.relay = relay;
+    toolDeps.runner = runner;
+  };
+  const ensureHub = async () => {
+    const currentConfig = configStore.get();
+    if (!isHubEnabled(currentConfig)) {
       return;
     }
-    const status = relay.status();
-    if (status.running && status.port === port) {
-      return;
+    if (!daemonClient) {
+      daemonClient = new DaemonClient({ autoRenew: true });
+    }
+    const deadline = Date.now() + 2e3;
+    let attempt = 0;
+    let lastError = null;
+    while (attempt < 2 && Date.now() < deadline) {
+      attempt += 1;
+      const status = await fetchDaemonStatusFromMetadata(currentConfig);
+      if (status?.ok) {
+        bindRemote();
+        await relay?.refresh?.();
+        return;
+      }
+      try {
+        const { stop } = await startDaemon({ config: currentConfig, directory, worktree });
+        hubStop = stop;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+      }
+      if (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      }
+    }
+    if (lastError) {
+      throw lastError;
     }
-    relay.stop();
+    throw new Error("Hub daemon unavailable.");
+  };
+  toolDeps.ensureHub = ensureHub;
+  const hubEnabled = isHubEnabled(config);
+  if (hubEnabled) {
+    bindRemote();
     try {
-      await relay.start(port);
+      await ensureHub();
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("EADDRINUSE") || message.includes("in use")) {
-        console.warn(`[opendevbrowser] Relay server port ${port} is already in use. Extension pairing will be unavailable.`);
-        console.warn(`[opendevbrowser] To fix: kill the process using port ${port} or change relayPort in config.`);
-      } else {
-        console.warn(`[opendevbrowser] Failed to start relay server: ${message}`);
-      }
+      console.warn(`[opendevbrowser] Hub daemon unavailable: ${message}`);
     }
-  };
-  const cleanup = () => {
-    relay.stop();
-    manager.closeAll().catch(() => {
+  } else {
+    await ensureRelay(config.relayPort);
+  }
+  const cleanupAll = () => {
+    if (hubStop) {
+      hubStop().catch(() => {
+      });
+    }
+    daemonClient?.releaseBinding().catch(() => {
     });
+    cleanup();
   };
-  process.on("SIGINT", cleanup);
-  process.on("SIGTERM", cleanup);
-  process.on("beforeExit", cleanup);
-  await ensureRelay(initialConfig.relayPort);
+  process.on("SIGINT", cleanupAll);
+  process.on("SIGTERM", cleanupAll);
+  process.on("beforeExit", cleanupAll);
   return {
-    tool: createTools({ manager, runner, config: configStore, skills, relay, getExtensionPath }),
+    tool: createTools(toolDeps),
     "chat.message": async (_input, output) => {
-      const config = configStore.get();
+      const config2 = configStore.get();
       if (output.message.role !== "user") return;
       const text = extractTextFromParts(output.parts);
       if (!text) return;
-      if (config.skills.nudge.enabled && shouldTriggerSkillNudge(text, config.skills.nudge.keywords)) {
+      if (config2.skills.nudge.enabled && shouldTriggerSkillNudge(text, config2.skills.nudge.keywords)) {
         markSkillNudge(skillNudgeState, Date.now());
       }
-      if (config.continuity.enabled && config.continuity.nudge.enabled) {
-        if (shouldTriggerContinuityNudge(text, config.continuity.nudge.keywords)) {
+      if (config2.continuity.enabled && config2.continuity.nudge.enabled) {
+        if (shouldTriggerContinuityNudge(text, config2.continuity.nudge.keywords)) {
           markContinuityNudge(continuityNudgeState, Date.now());
         }
       }
     },
     "experimental.chat.system.transform": async (_input, output) => {
-      const config = configStore.get();
+      const config2 = configStore.get();
       const systemEntries = output.system ?? [];
       let nextEntries = systemEntries;
       let changed = false;
-      if (config.skills.nudge.enabled) {
+      if (config2.skills.nudge.enabled) {
         if (systemEntries.some((entry) => entry.includes(SKILL_NUDGE_MARKER))) {
           clearSkillNudge(skillNudgeState);
-        } else if (consumeSkillNudge(skillNudgeState, Date.now(), config.skills.nudge.maxAgeMs)) {
+        } else if (consumeSkillNudge(skillNudgeState, Date.now(), config2.skills.nudge.maxAgeMs)) {
           nextEntries = [...nextEntries, buildSkillNudgeMessage()];
           changed = true;
         }
       }
-      if (config.continuity.enabled && config.continuity.nudge.enabled) {
+      if (config2.continuity.enabled && config2.continuity.nudge.enabled) {
         if (systemEntries.some((entry) => entry.includes(CONTINUITY_NUDGE_MARKER))) {
           clearContinuityNudge(continuityNudgeState);
         } else if (consumeContinuityNudge(
           continuityNudgeState,
           Date.now(),
-          config.continuity.nudge.maxAgeMs
+          config2.continuity.nudge.maxAgeMs
         )) {
-          nextEntries = [...nextEntries, buildContinuityNudgeMessage(config.continuity.filePath)];
+          nextEntries = [...nextEntries, buildContinuityNudgeMessage(config2.continuity.filePath)];
           changed = true;
         }
       }
@@ -3717,5 +1941,4 @@ var index_default = OpenDevBrowserPlugin;
 export {
   index_default as default
 };
-/* v8 ignore next -- @preserve */
 //# sourceMappingURL=index.js.map