openmd-cli 0.1.0__py3-none-any.whl

openmd/browser_extension/vendor/opencli-bridge/background.js

@@ -0,0 +1,2742 @@
+// OpenCLI Browser Bridge 1.0.27 (Apache-2.0, https://github.com/jackwener/opencli),
+// vendored by scripts/vendor_opencli_bridge.py. Modified by Openmd: see VENDOR.md.
+const OPENMD_BRIDGE_VERSION = "1.0.27";
+const CHROME_METHODS = {
+  "tabs.query": "(queryInfo: object) => Tab[]",
+  "tabs.get": "(tabId: number) => Tab",
+  "tabs.create": "(createProperties: object) => Tab",
+  "tabs.duplicate": "(tabId: number) => Tab",
+  "tabs.update": "(tabId: number, updateProperties: object) => Tab",
+  "tabs.move": "(tabIds: number | number[], moveProperties: object) => Tab | Tab[]",
+  "tabs.remove": "(tabIds: number | number[]) => void",
+  "tabs.group": "(options: {tabIds: number[], groupId?: number, createProperties?: {windowId?: number}}) => number",
+  "tabs.ungroup": "(tabIds: number | number[]) => void",
+  "tabGroups.query": "(queryInfo: object) => TabGroup[]",
+  "tabGroups.get": "(groupId: number) => TabGroup",
+  "tabGroups.update": "(groupId: number, updateProperties: {title?: string, color?: string, collapsed?: boolean}) => TabGroup",
+  "tabGroups.move": "(groupId: number, moveProperties: {index: number, windowId?: number}) => TabGroup",
+  "windows.get": "(windowId: number, queryOptions?: object) => Window",
+  "windows.getAll": "(queryOptions?: object) => Window[]",
+  "windows.create": "(createData: object) => Window",
+  "windows.update": "(windowId: number, updateInfo: object) => Window",
+  "windows.remove": "(windowId: number) => void"
+};
+class ChromeApiError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+  hint;
+}
+const nativeError = (code, message) => new ChromeApiError(code, message);
+const READ = /* @__PURE__ */ new Set(["tabs.query", "tabs.get", "tabGroups.query", "tabGroups.get", "windows.get", "windows.getAll"]);
+function resolve(method) {
+  if (!Object.hasOwn(CHROME_METHODS, method)) throw nativeError("unsupported_chrome_method", `Unsupported Chrome method ${method}. Use chrome describe to list browser-management methods.`);
+  const [namespace, name] = method.split(".");
+  const receiver = chrome[namespace];
+  return { receiver, fn: receiver?.[name], namespace, name };
+}
+async function describeChrome(method) {
+  if (!method) return { methods: Object.keys(CHROME_METHODS), ids: "Use numeric Chrome IDs from tabs.query/tabGroups.query/windows.getAll, not page targetIds.", lifecycle: "Native-created tabs and windows are user-managed and persist after the CLI exits." };
+  const { fn, namespace, name } = resolve(method);
+  return {
+    method,
+    signature: CHROME_METHODS[method],
+    available: typeof fn === "function",
+    access: READ.has(method) ? "read" : "write",
+    declaredPermissions: chrome.runtime.getManifest().permissions ?? [],
+    grantedPermissions: await chrome.permissions.getAll(),
+    documentation: `https://developer.chrome.com/docs/extensions/reference/api/${namespace}#method-${name}`,
+    ...namespace === "tabGroups" ? { colors: ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"] } : {}
+  };
+}
+async function callChrome(method, args, protectedTabs, protectedGroups) {
+  const { receiver, fn } = resolve(method);
+  if (!Array.isArray(args)) throw nativeError("invalid_args", "Chrome args must be an array of positional arguments.");
+  if (typeof fn !== "function") throw nativeError("chrome_api_unavailable", `chrome.${method} is unavailable.`);
+  try {
+    if (!READ.has(method)) {
+      let tabs = [];
+      const first = args[0];
+      if (method.startsWith("tabGroups.") || ["windows.update", "windows.remove"].includes(method)) {
+        if (!Number.isInteger(first)) throw nativeError("invalid_args", "Use an explicit numeric group or window ID.");
+      }
+      if (method.startsWith("tabGroups.")) {
+        if (protectedGroups.has(first)) throw nativeError("managed_resource_conflict", "This group is managed by OpenCLI browser sessions. Use an ordinary Chrome group.");
+        tabs = await chrome.tabs.query({ groupId: first });
+      } else if (method === "tabs.group") {
+        if (!Array.isArray(first?.tabIds) || !first.tabIds.length || first.tabIds.some((id) => !Number.isInteger(id))) throw nativeError("invalid_args", "tabs.group requires a non-empty tabIds array.");
+        if (first.groupId !== void 0) {
+          if (protectedGroups.has(first.groupId)) throw nativeError("managed_resource_conflict", "Cannot add tabs to an OpenCLI-managed group.");
+          tabs.push(...await chrome.tabs.query({ groupId: first.groupId }));
+        }
+        tabs.push(...await Promise.all(first.tabIds.map((id) => chrome.tabs.get(id))));
+      } else if (["tabs.update", "tabs.move", "tabs.remove", "tabs.ungroup", "tabs.duplicate"].includes(method)) {
+        const ids = Array.isArray(first) ? first : [first];
+        if (!ids.length || ids.some((id) => !Number.isInteger(id))) throw nativeError("invalid_args", "Use explicit numeric tab IDs from tabs.query.");
+        tabs = await Promise.all(ids.map((id) => chrome.tabs.get(id)));
+      } else if (["windows.update", "windows.remove"].includes(method)) tabs = await chrome.tabs.query({ windowId: first });
+      else if (method === "windows.create" && first?.tabId !== void 0) tabs = [await chrome.tabs.get(first.tabId)];
+      if (tabs.some((t) => protectedTabs.has(t.id) || protectedGroups.has(t.groupId))) {
+        throw nativeError("managed_resource_conflict", "The operation touches an active OpenCLI session. Finish that session before reorganizing its tabs.");
+      }
+    }
+    return await Reflect.apply(fn, receiver, args) ?? null;
+  } catch (error) {
+    if (error instanceof ChromeApiError) throw error;
+    throw nativeError("chrome_api_error", `chrome.${method}: ${error.message}`);
+  }
+}
+
+const DAEMON_PORT = 19825;
+const DAEMON_HOST = "127.0.0.1";
+const DAEMON_WS_URL = `ws://${DAEMON_HOST}:${DAEMON_PORT}/ext`;
+const DAEMON_PING_URL = `http://${DAEMON_HOST}:${DAEMON_PORT}/ping`;
+
+const KEY = "opencli_idle_interactive_v1";
+const PAGE = "idle.html";
+async function idlePlaceholderUrl() {
+  const data = await chrome.storage.local.get(KEY);
+  const token = data[KEY];
+  return typeof token === "string" && /^[a-f0-9-]{36}$/.test(token) ? `${chrome.runtime.getURL(PAGE)}#${token}` : null;
+}
+async function parkIdleInteractiveTab(tabId, windowId) {
+  const tabs = await chrome.tabs.query({ windowId });
+  if (tabs.length !== 1 || tabs[0].id !== tabId) return null;
+  const token = crypto.randomUUID();
+  await chrome.storage.local.set({ [KEY]: token });
+  return `${chrome.runtime.getURL(PAGE)}#${token}`;
+}
+async function consumeIdlePlaceholder(tab) {
+  const url = await idlePlaceholderUrl();
+  if (url && tab.url === url) {
+    if (tab.pendingUrl && tab.pendingUrl !== url) throw new Error("Idle OpenCLI tab is being navigated; retry the command.");
+    await chrome.storage.local.remove(KEY);
+  }
+}
+async function findIdleInteractiveGroup(reservedTabs) {
+  const url = await idlePlaceholderUrl();
+  if (!url) return null;
+  const tabs = (await chrome.tabs.query({})).filter((tab2) => tab2.url === url && !tab2.pendingUrl);
+  if (tabs.length !== 1) return null;
+  const tab = tabs[0];
+  if (tab.id === void 0 || reservedTabs.has(tab.id) || tab.incognito || tab.groupId === void 0 || tab.groupId === chrome.tabGroups.TAB_GROUP_ID_NONE) return null;
+  const window = await chrome.windows.get(tab.windowId);
+  if (window.incognito || window.type !== "normal") return null;
+  const windowTabs = await chrome.tabs.query({ windowId: tab.windowId });
+  if (windowTabs.length !== 1 || windowTabs[0].id !== tab.id || windowTabs[0].url !== url || windowTabs[0].pendingUrl) return null;
+  const group = await chrome.tabGroups.get(tab.groupId);
+  return group.windowId === tab.windowId ? group : null;
+}
+
+const attached = /* @__PURE__ */ new Set();
+const tabFrameContexts = /* @__PURE__ */ new Map();
+const frameTargets = /* @__PURE__ */ new Map();
+const frameTargetKeys = /* @__PURE__ */ new Map();
+let frameTargetCleanupRegistered = false;
+const CDP_RESPONSE_BODY_CAPTURE_LIMIT = 8 * 1024 * 1024;
+const CDP_REQUEST_BODY_CAPTURE_LIMIT = 1 * 1024 * 1024;
+const networkCaptures = /* @__PURE__ */ new Map();
+const CDP_COMMAND_TIMEOUT_MS = 6e4;
+const CDP_PROBE_TIMEOUT_MS = 2e3;
+async function sendDebuggerCommand(target, method, params, timeoutMs = CDP_COMMAND_TIMEOUT_MS) {
+  let timer;
+  const commandPromise = params === void 0 ? chrome.debugger.sendCommand(target, method) : chrome.debugger.sendCommand(target, method, params);
+  commandPromise.catch(() => {
+  });
+  try {
+    return await Promise.race([
+      commandPromise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(
+          `CDP command ${method} timed out after ${Math.round(timeoutMs / 1e3)}s — the page may be blocked by a native dialog (alert/confirm/print)`
+        )), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function isDebuggableUrl$1(url) {
+  if (!url) return true;
+  return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
+}
+async function ensureAttached(tabId, aggressiveRetry = false) {
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (!isDebuggableUrl$1(tab.url)) {
+      attached.delete(tabId);
+      throw new Error(`Cannot debug tab ${tabId}: URL is ${tab.url ?? "unknown"}`);
+    }
+  } catch (e) {
+    if (e instanceof Error && e.message.startsWith("Cannot debug tab")) throw e;
+    attached.delete(tabId);
+    throw new Error(`Tab ${tabId} no longer exists`);
+  }
+  if (attached.has(tabId)) {
+    try {
+      await sendDebuggerCommand({ tabId }, "Runtime.evaluate", {
+        expression: "1",
+        returnByValue: true
+      }, CDP_PROBE_TIMEOUT_MS);
+      return;
+    } catch {
+      attached.delete(tabId);
+    }
+  }
+  const MAX_ATTACH_RETRIES = aggressiveRetry ? 5 : 2;
+  const RETRY_DELAY_MS = aggressiveRetry ? 1500 : 500;
+  let lastError = "";
+  const preservedNetworkCapture = networkCaptures.get(tabId);
+  for (let attempt = 1; attempt <= MAX_ATTACH_RETRIES; attempt++) {
+    try {
+      try {
+        await chrome.debugger.detach({ tabId });
+      } catch {
+      }
+      await chrome.debugger.attach({ tabId }, "1.3");
+      lastError = "";
+      break;
+    } catch (e) {
+      lastError = e instanceof Error ? e.message : String(e);
+      if (attempt < MAX_ATTACH_RETRIES) {
+        console.warn(`[opencli] attach attempt ${attempt}/${MAX_ATTACH_RETRIES} failed: ${lastError}, retrying in ${RETRY_DELAY_MS}ms...`);
+        await new Promise((resolve) => setTimeout(resolve, RETRY_DELAY_MS));
+        try {
+          const tab = await chrome.tabs.get(tabId);
+          if (!isDebuggableUrl$1(tab.url)) {
+            lastError = `Tab URL changed to ${tab.url} during retry`;
+            break;
+          }
+        } catch {
+          lastError = `Tab ${tabId} no longer exists`;
+        }
+      }
+    }
+  }
+  if (lastError) {
+    let finalUrl = "unknown";
+    let finalWindowId = "unknown";
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      finalUrl = tab.url ?? "undefined";
+      finalWindowId = String(tab.windowId);
+    } catch {
+    }
+    console.warn(`[opencli] attach failed for tab ${tabId}: url=${finalUrl}, windowId=${finalWindowId}, error=${lastError}`);
+    const hint = lastError.includes("chrome-extension://") ? ". Tip: another Chrome extension may be interfering — try disabling other extensions" : "";
+    throw new Error(`attach failed: ${lastError}${hint}`);
+  }
+  attached.add(tabId);
+  try {
+    await sendDebuggerCommand({ tabId }, "Runtime.enable");
+  } catch {
+  }
+  if (preservedNetworkCapture) {
+    try {
+      await sendDebuggerCommand({ tabId }, "Network.enable");
+      networkCaptures.set(tabId, preservedNetworkCapture);
+    } catch {
+    }
+  }
+}
+async function evaluate(tabId, expression, aggressiveRetry = false, timeoutMs = CDP_COMMAND_TIMEOUT_MS) {
+  try {
+    await ensureAttached(tabId, aggressiveRetry);
+    const result = await sendDebuggerCommand({ tabId }, "Runtime.evaluate", {
+      expression,
+      returnByValue: true,
+      awaitPromise: true
+    }, timeoutMs);
+    if (result.exceptionDetails) {
+      const errMsg = result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Eval error";
+      throw new Error(errMsg);
+    }
+    return result.result?.value;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("Detached") || msg.includes("Debugger is not attached") || msg.includes("Target closed")) {
+      attached.delete(tabId);
+    }
+    throw e;
+  }
+}
+const evaluateAsync = evaluate;
+async function screenshot(tabId, options = {}) {
+  await ensureAttached(tabId);
+  const format = options.format ?? "png";
+  const fullPage = options.fullPage === true;
+  const overrideWidth = options.width && options.width > 0 ? Math.ceil(options.width) : void 0;
+  const overrideHeight = !fullPage && options.height && options.height > 0 ? Math.ceil(options.height) : void 0;
+  const needsOverride = fullPage || overrideWidth !== void 0 || overrideHeight !== void 0;
+  if (needsOverride) {
+    if (overrideWidth !== void 0 && fullPage) {
+      await sendDebuggerCommand({ tabId }, "Emulation.setDeviceMetricsOverride", {
+        mobile: false,
+        width: overrideWidth,
+        height: 0,
+        deviceScaleFactor: 1
+      });
+    }
+    let finalWidth = overrideWidth ?? 0;
+    let finalHeight = overrideHeight ?? 0;
+    if (fullPage) {
+      const metrics = await sendDebuggerCommand({ tabId }, "Page.getLayoutMetrics");
+      const size = metrics.cssContentSize || metrics.contentSize;
+      if (size) {
+        if (finalWidth === 0) finalWidth = Math.ceil(size.width);
+        finalHeight = Math.ceil(size.height);
+      }
+    }
+    await sendDebuggerCommand({ tabId }, "Emulation.setDeviceMetricsOverride", {
+      mobile: false,
+      width: finalWidth,
+      height: finalHeight,
+      deviceScaleFactor: 1
+    });
+  }
+  try {
+    const params = { format };
+    if (format === "jpeg" && options.quality !== void 0) {
+      params.quality = Math.max(0, Math.min(100, options.quality));
+    }
+    const result = await sendDebuggerCommand({ tabId }, "Page.captureScreenshot", params);
+    return result.data;
+  } finally {
+    if (needsOverride) {
+      await sendDebuggerCommand({ tabId }, "Emulation.clearDeviceMetricsOverride").catch(() => {
+      });
+    }
+  }
+}
+async function setFileInputFiles(tabId, files, selector) {
+  await ensureAttached(tabId);
+  await sendDebuggerCommand({ tabId }, "DOM.enable");
+  await sendDebuggerCommand({ tabId }, "Page.enable");
+  const query = selector || 'input[type="file"]';
+  const found = await sendDebuggerCommand({ tabId }, "Runtime.evaluate", {
+    expression: `!!document.querySelector(${JSON.stringify(query)})`,
+    returnByValue: true
+  });
+  if (!found.result?.value) {
+    throw new Error(`No element found matching selector: ${query}`);
+  }
+  await sendDebuggerCommand({ tabId }, "Page.setInterceptFileChooserDialog", { enabled: true });
+  try {
+    const backendNodeId = await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Page.fileChooserOpened not received within 5s — the input may not have opened a file chooser"));
+      }, 5e3);
+      const listener = (source, method, params) => {
+        if (source.tabId !== tabId || method !== "Page.fileChooserOpened") return;
+        cleanup();
+        const backend = params?.backendNodeId;
+        if (typeof backend === "number") resolve(backend);
+        else reject(new Error("Page.fileChooserOpened carried no backendNodeId"));
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        chrome.debugger.onEvent.removeListener(listener);
+      };
+      chrome.debugger.onEvent.addListener(listener);
+      void sendDebuggerCommand({ tabId }, "Runtime.evaluate", {
+        expression: `document.querySelector(${JSON.stringify(query)}).click()`,
+        userGesture: true
+      }).catch((err) => {
+        cleanup();
+        reject(err instanceof Error ? err : new Error(String(err)));
+      });
+    });
+    await sendDebuggerCommand({ tabId }, "DOM.setFileInputFiles", {
+      files,
+      backendNodeId
+    });
+  } finally {
+    await sendDebuggerCommand({ tabId }, "Page.setInterceptFileChooserDialog", { enabled: false }).catch(() => {
+    });
+  }
+}
+function matchesDownloadPattern(item, pattern) {
+  if (!pattern) return true;
+  const haystack = [
+    item.filename,
+    item.url,
+    item.finalUrl,
+    item.mime
+  ].filter(Boolean).join("\n").toLowerCase();
+  return haystack.includes(pattern.toLowerCase());
+}
+function downloadResult(item, startedAt) {
+  return {
+    downloaded: item.state === "complete",
+    id: item.id,
+    filename: item.filename,
+    url: item.url,
+    finalUrl: item.finalUrl,
+    mime: item.mime,
+    totalBytes: item.totalBytes,
+    state: item.state,
+    danger: item.danger,
+    error: item.error,
+    elapsedMs: Date.now() - startedAt
+  };
+}
+async function waitForDownload(pattern = "", timeoutMs = 3e4) {
+  const startedAt = Date.now();
+  const timeout = Math.max(1, timeoutMs);
+  return await new Promise((resolve) => {
+    let done = false;
+    const inProgressIds = /* @__PURE__ */ new Set();
+    const finish = (result) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      chrome.downloads.onCreated.removeListener(onCreated);
+      chrome.downloads.onChanged.removeListener(onChanged);
+      resolve(result);
+    };
+    const inspectById = async (id) => {
+      const items = await chrome.downloads.search({ id });
+      const item = items[0];
+      if (!item || !matchesDownloadPattern(item, pattern)) return;
+      inProgressIds.add(id);
+      if (item.state === "complete" || item.state === "interrupted") finish(downloadResult(item, startedAt));
+    };
+    const onCreated = (item) => {
+      if (!matchesDownloadPattern(item, pattern)) return;
+      inProgressIds.add(item.id);
+      if (item.state === "complete" || item.state === "interrupted") finish(downloadResult(item, startedAt));
+    };
+    const onChanged = (delta) => {
+      if (!delta.id) return;
+      if (!inProgressIds.has(delta.id) && !delta.filename && !delta.url) return;
+      if (delta.filename?.current || delta.url?.current) {
+        void inspectById(delta.id);
+        return;
+      }
+      if (delta.state?.current === "complete" || delta.state?.current === "interrupted") {
+        void inspectById(delta.id);
+      }
+    };
+    const timer = setTimeout(() => {
+      finish({
+        downloaded: false,
+        state: "interrupted",
+        error: `No download matched "${pattern || "*"}" within ${timeout}ms`,
+        elapsedMs: Date.now() - startedAt
+      });
+    }, timeout);
+    chrome.downloads.onCreated.addListener(onCreated);
+    chrome.downloads.onChanged.addListener(onChanged);
+    void chrome.downloads.search({
+      limit: 50,
+      orderBy: ["-startTime"],
+      startedAfter: new Date(startedAt - Math.max(timeout, 1e3)).toISOString()
+    }).then((recent) => {
+      if (done) return;
+      const completed = recent.find((item) => item.state === "complete" && matchesDownloadPattern(item, pattern));
+      if (completed) {
+        finish(downloadResult(completed, startedAt));
+        return;
+      }
+      for (const item of recent) {
+        if (item.state === "in_progress" && matchesDownloadPattern(item, pattern)) inProgressIds.add(item.id);
+      }
+    }).catch((err) => {
+      finish({
+        downloaded: false,
+        state: "interrupted",
+        error: err instanceof Error ? err.message : String(err),
+        elapsedMs: Date.now() - startedAt
+      });
+    });
+  });
+}
+function frameTargetKey(tabId, frameId) {
+  return `${tabId}:${frameId}`;
+}
+function registerFrameTargetCleanup() {
+  if (frameTargetCleanupRegistered) return;
+  frameTargetCleanupRegistered = true;
+  chrome.debugger.onEvent.addListener((_source, method, params) => {
+    if (method === "Target.detachedFromTarget") {
+      const targetId = String(params?.targetId || "");
+      clearFrameTarget(targetId);
+    }
+  });
+}
+function clearFrameTarget(targetId) {
+  if (!targetId) return;
+  const key = frameTargetKeys.get(targetId);
+  if (key) frameTargets.delete(key);
+  frameTargetKeys.delete(targetId);
+}
+async function ensureFrameTarget(tabId, frameId, aggressiveRetry = false, targetUrl) {
+  registerFrameTargetCleanup();
+  await ensureAttached(tabId, aggressiveRetry);
+  const key = frameTargetKey(tabId, frameId);
+  const existing = frameTargets.get(key);
+  if (existing) return existing;
+  await sendDebuggerCommand({ tabId }, "Target.setDiscoverTargets", { discover: true }).catch(() => {
+  });
+  await sendDebuggerCommand({ tabId }, "Target.setAutoAttach", {
+    autoAttach: true,
+    waitForDebuggerOnStart: false,
+    flatten: true,
+    filter: [{ type: "iframe", exclude: false }]
+  }).catch(() => {
+  });
+  const targetId = await resolveFrameTargetId(tabId, frameId, targetUrl);
+  try {
+    await chrome.debugger.attach({ targetId }, "1.3");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    if (!message.includes("Another debugger is already attached")) throw err;
+  }
+  frameTargets.set(key, targetId);
+  frameTargetKeys.set(targetId, key);
+  return targetId;
+}
+async function resolveFrameTargetId(tabId, frameId, targetUrl) {
+  const result = await sendDebuggerCommand({ tabId }, "Target.getTargets").catch(() => null);
+  const targets = result?.targetInfos ?? [];
+  const frameTarget = targets.find((candidate) => {
+    const candidateId = candidate.targetId || candidate.id;
+    return candidate.type === "iframe" && (candidateId === frameId || !!targetUrl && candidate.url === targetUrl);
+  });
+  const targetId = frameTarget?.targetId || frameTarget?.id;
+  if (targetId) return targetId;
+  const candidates = targets.filter((target) => target.type === "iframe").map((target) => `${target.targetId || target.id || "?"} ${target.url || ""}`).join("; ");
+  throw new Error(`No iframe target found for frame ${frameId}${targetUrl ? ` (${targetUrl})` : ""}. Candidates: ${candidates || "none"}`);
+}
+async function sendCommandInFrameTarget(tabId, frameId, method, params = {}, aggressiveRetry = false, timeoutMs = CDP_COMMAND_TIMEOUT_MS, targetUrl) {
+  const targetId = await ensureFrameTarget(tabId, frameId, aggressiveRetry, targetUrl);
+  const target = { targetId };
+  return sendDebuggerCommand(target, method, params, timeoutMs);
+}
+async function insertText(tabId, text) {
+  await ensureAttached(tabId);
+  await sendDebuggerCommand({ tabId }, "Input.insertText", { text });
+}
+function registerFrameTracking() {
+  registerFrameTargetCleanup();
+  chrome.debugger.onEvent.addListener((source, method, params) => {
+    const tabId = source.tabId;
+    if (!tabId) return;
+    if (method === "Runtime.executionContextCreated") {
+      const context = params.context;
+      if (!context?.auxData?.frameId || context.auxData.isDefault !== true) return;
+      const frameId = context.auxData.frameId;
+      if (!tabFrameContexts.has(tabId)) {
+        tabFrameContexts.set(tabId, /* @__PURE__ */ new Map());
+      }
+      tabFrameContexts.get(tabId).set(frameId, context.id);
+    }
+    if (method === "Runtime.executionContextDestroyed") {
+      const ctxId = params.executionContextId;
+      const contexts = tabFrameContexts.get(tabId);
+      if (contexts) {
+        for (const [fid, cid] of contexts) {
+          if (cid === ctxId) {
+            contexts.delete(fid);
+            break;
+          }
+        }
+      }
+    }
+    if (method === "Runtime.executionContextsCleared") {
+      tabFrameContexts.delete(tabId);
+    }
+  });
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    tabFrameContexts.delete(tabId);
+  });
+}
+async function getFrameTree(tabId) {
+  await ensureAttached(tabId);
+  return sendDebuggerCommand({ tabId }, "Page.getFrameTree");
+}
+async function evaluateInFrame(tabId, expression, frameId, aggressiveRetry = false, timeoutMs = CDP_COMMAND_TIMEOUT_MS) {
+  await ensureAttached(tabId, aggressiveRetry);
+  await sendDebuggerCommand({ tabId }, "Runtime.enable").catch(() => {
+  });
+  const contexts = tabFrameContexts.get(tabId);
+  const contextId = contexts?.get(frameId);
+  if (contextId !== void 0) {
+    try {
+      const result2 = await sendDebuggerCommand({ tabId }, "Runtime.evaluate", {
+        expression,
+        contextId,
+        returnByValue: true,
+        awaitPromise: true
+      }, timeoutMs);
+      if (result2.exceptionDetails) {
+        const errMsg = result2.exceptionDetails.exception?.description || result2.exceptionDetails.text || "Eval error";
+        throw new Error(errMsg);
+      }
+      return result2.result?.value;
+    } catch (err) {
+      const msg = String(err?.message || err);
+      if (!/Cannot find context|context with specified id|Execution context was destroyed/i.test(msg)) {
+        throw err;
+      }
+      contexts?.delete(frameId);
+    }
+  }
+  await sendCommandInFrameTarget(tabId, frameId, "Runtime.enable", {}, aggressiveRetry, timeoutMs).catch(() => void 0);
+  const result = await sendCommandInFrameTarget(tabId, frameId, "Runtime.evaluate", {
+    expression,
+    returnByValue: true,
+    awaitPromise: true
+  }, aggressiveRetry, timeoutMs);
+  if (result.exceptionDetails) {
+    const errMsg = result.exceptionDetails.exception?.description || result.exceptionDetails.text || "Eval error";
+    throw new Error(errMsg);
+  }
+  return result.result?.value;
+}
+function normalizeCapturePatterns(pattern) {
+  return String(pattern || "").split("|").map((part) => part.trim()).filter(Boolean);
+}
+function shouldCaptureUrl(url, patterns) {
+  if (!url) return false;
+  if (!patterns.length) return true;
+  return patterns.some((pattern) => url.includes(pattern));
+}
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return {};
+  const out = {};
+  for (const [key, value] of Object.entries(headers)) {
+    out[String(key)] = String(value);
+  }
+  return out;
+}
+function getOrCreateNetworkCaptureEntry(tabId, requestId, fallback) {
+  const state = networkCaptures.get(tabId);
+  if (!state) return null;
+  const existingIndex = state.requestToIndex.get(requestId);
+  if (existingIndex !== void 0) {
+    return state.entries[existingIndex] || null;
+  }
+  const url = fallback?.url || "";
+  if (!shouldCaptureUrl(url, state.patterns)) return null;
+  const entry = {
+    kind: "cdp",
+    requestId,
+    url,
+    method: fallback?.method || "GET",
+    requestHeaders: fallback?.requestHeaders || {},
+    timestamp: Date.now()
+  };
+  state.entries.push(entry);
+  state.requestToIndex.set(requestId, state.entries.length - 1);
+  return entry;
+}
+async function startNetworkCapture(tabId, pattern) {
+  await ensureAttached(tabId);
+  await sendDebuggerCommand({ tabId }, "Network.enable");
+  networkCaptures.set(tabId, {
+    patterns: normalizeCapturePatterns(pattern),
+    entries: [],
+    requestToIndex: /* @__PURE__ */ new Map()
+  });
+}
+async function readNetworkCapture(tabId, retainIncomplete = false) {
+  const state = networkCaptures.get(tabId);
+  if (!state) return [];
+  const entries = state.entries.map((entry) => ({ ...entry }));
+  if (!retainIncomplete) {
+    state.entries = [];
+    state.requestToIndex.clear();
+    return entries;
+  }
+  const pendingEntries = [];
+  const pendingMap = /* @__PURE__ */ new Map();
+  for (const [requestId, index] of state.requestToIndex) {
+    const entry = state.entries[index];
+    if (entry && !entry.captureComplete) {
+      pendingMap.set(requestId, pendingEntries.length);
+      pendingEntries.push(entry);
+    }
+  }
+  state.entries = pendingEntries;
+  state.requestToIndex = pendingMap;
+  return entries;
+}
+function hasActiveNetworkCapture(tabId) {
+  return networkCaptures.has(tabId);
+}
+function clearFrameTargetsForTab(tabId) {
+  for (const [key, targetId] of [...frameTargets.entries()]) {
+    if (!key.startsWith(`${tabId}:`)) continue;
+    frameTargets.delete(key);
+    frameTargetKeys.delete(targetId);
+    chrome.debugger.detach({ targetId }).catch(() => {
+    });
+  }
+}
+async function detach(tabId) {
+  clearFrameTargetsForTab(tabId);
+  if (!attached.has(tabId)) return;
+  attached.delete(tabId);
+  networkCaptures.delete(tabId);
+  tabFrameContexts.delete(tabId);
+  try {
+    await chrome.debugger.detach({ tabId });
+  } catch {
+  }
+}
+function registerListeners() {
+  chrome.tabs.onRemoved.addListener((tabId) => {
+    attached.delete(tabId);
+    networkCaptures.delete(tabId);
+    tabFrameContexts.delete(tabId);
+    clearFrameTargetsForTab(tabId);
+  });
+  chrome.debugger.onDetach.addListener((source) => {
+    if (source.tabId) {
+      attached.delete(source.tabId);
+      networkCaptures.delete(source.tabId);
+      tabFrameContexts.delete(source.tabId);
+      clearFrameTargetsForTab(source.tabId);
+      return;
+    }
+    if (source.targetId) clearFrameTarget(source.targetId);
+  });
+  chrome.tabs.onUpdated.addListener(async (tabId, info) => {
+    if (info.url && !isDebuggableUrl$1(info.url)) {
+      await detach(tabId);
+    }
+  });
+  chrome.debugger.onEvent.addListener(async (source, method, params) => {
+    const tabId = source.tabId;
+    if (!tabId) return;
+    const state = networkCaptures.get(tabId);
+    if (!state) return;
+    const eventParams = params;
+    if (method === "Network.requestWillBeSent") {
+      const requestId = String(eventParams?.requestId || "");
+      const request = eventParams?.request;
+      const entry = getOrCreateNetworkCaptureEntry(tabId, requestId, {
+        url: request?.url,
+        method: request?.method,
+        requestHeaders: normalizeHeaders(request?.headers)
+      });
+      if (!entry) return;
+      if (!eventParams?.redirectResponse) {
+        entry.requestBodyKind = request?.hasPostData ? "string" : "empty";
+        {
+          const raw = String(request?.postData || "");
+          const fullSize = raw.length;
+          const truncated = fullSize > CDP_REQUEST_BODY_CAPTURE_LIMIT;
+          entry.requestBodyPreview = truncated ? raw.slice(0, CDP_REQUEST_BODY_CAPTURE_LIMIT) : raw;
+          entry.requestBodyFullSize = fullSize;
+          entry.requestBodyTruncated = truncated;
+        }
+        entry.requestBodyPending = true;
+        try {
+          const postData = await sendDebuggerCommand({ tabId }, "Network.getRequestPostData", { requestId });
+          if (postData?.postData) {
+            const raw = postData.postData;
+            const fullSize = raw.length;
+            const truncated = fullSize > CDP_REQUEST_BODY_CAPTURE_LIMIT;
+            entry.requestBodyKind = "string";
+            entry.requestBodyPreview = truncated ? raw.slice(0, CDP_REQUEST_BODY_CAPTURE_LIMIT) : raw;
+            entry.requestBodyFullSize = fullSize;
+            entry.requestBodyTruncated = truncated;
+          }
+        } catch {
+        } finally {
+          entry.requestBodyPending = false;
+          if (entry.responseFinished) entry.captureComplete = true;
+        }
+      }
+      return;
+    }
+    if (method === "Network.responseReceived") {
+      const requestId = String(eventParams?.requestId || "");
+      const response = eventParams?.response;
+      const stateEntryIndex = state.requestToIndex.get(requestId);
+      if (stateEntryIndex === void 0) return;
+      const entry = state.entries[stateEntryIndex];
+      if (!entry) return;
+      entry.responseStatus = response?.status;
+      entry.responseContentType = response?.mimeType || "";
+      entry.responseHeaders = normalizeHeaders(response?.headers);
+      return;
+    }
+    if (method === "Network.loadingFinished") {
+      const requestId = String(eventParams?.requestId || "");
+      const stateEntryIndex = state.requestToIndex.get(requestId);
+      if (stateEntryIndex === void 0) return;
+      const entry = state.entries[stateEntryIndex];
+      if (!entry) return;
+      try {
+        const body = await sendDebuggerCommand({ tabId }, "Network.getResponseBody", { requestId });
+        if (typeof body?.body === "string") {
+          const fullSize = body.body.length;
+          const truncated = fullSize > CDP_RESPONSE_BODY_CAPTURE_LIMIT;
+          const stored = truncated ? body.body.slice(0, CDP_RESPONSE_BODY_CAPTURE_LIMIT) : body.body;
+          entry.responsePreview = body.base64Encoded ? `base64:${stored}` : stored;
+          entry.responseBodyFullSize = fullSize;
+          entry.responseBodyTruncated = truncated;
+        }
+      } catch {
+      } finally {
+        entry.responseFinished = true;
+        if (!entry.requestBodyPending) entry.captureComplete = true;
+      }
+      return;
+    }
+    if (method === "Network.loadingFailed") {
+      const requestId = String(eventParams?.requestId || "");
+      const stateEntryIndex = state.requestToIndex.get(requestId);
+      if (stateEntryIndex === void 0) return;
+      const entry = state.entries[stateEntryIndex];
+      if (entry) {
+        entry.responseFinished = true;
+        if (!entry.requestBodyPending) entry.captureComplete = true;
+      }
+    }
+  });
+}
+
+const targetToTab = /* @__PURE__ */ new Map();
+const tabToTarget = /* @__PURE__ */ new Map();
+async function resolveTargetId(tabId) {
+  const cached = tabToTarget.get(tabId);
+  if (cached) return cached;
+  await refreshMappings();
+  const result = tabToTarget.get(tabId);
+  if (!result) throw new Error(`No targetId for tab ${tabId} — page may have been closed`);
+  return result;
+}
+async function resolveTabId$1(targetId) {
+  const cached = targetToTab.get(targetId);
+  if (cached !== void 0) return cached;
+  await refreshMappings();
+  const result = targetToTab.get(targetId);
+  if (result === void 0) throw new Error(`Page not found: ${targetId} — stale page identity`);
+  return result;
+}
+function evictTab(tabId) {
+  const targetId = tabToTarget.get(tabId);
+  if (targetId) targetToTab.delete(targetId);
+  tabToTarget.delete(tabId);
+}
+async function refreshMappings() {
+  const targets = await chrome.debugger.getTargets();
+  targetToTab.clear();
+  tabToTarget.clear();
+  for (const t of targets) {
+    if (t.type === "page" && t.tabId !== void 0) {
+      targetToTab.set(t.id, t.tabId);
+      tabToTarget.set(t.tabId, t.id);
+    }
+  }
+}
+
+const JOURNAL_KEY = "opencli_command_journal_v1";
+const JOURNAL_MAX_ENTRIES = 64;
+const JOURNAL_RESULT_MAX_BYTES = 64 * 1024;
+let cache = null;
+let writeQueue = Promise.resolve();
+const inFlight = /* @__PURE__ */ new Map();
+async function load() {
+  if (cache) return cache;
+  try {
+    const stored = await chrome.storage.session.get(JOURNAL_KEY);
+    cache = stored?.[JOURNAL_KEY] ?? {};
+  } catch {
+    cache = {};
+  }
+  return cache;
+}
+function persist() {
+  const snapshot = cache;
+  if (!snapshot) return;
+  writeQueue = writeQueue.then(async () => {
+    try {
+      await chrome.storage.session.set({ [JOURNAL_KEY]: snapshot });
+    } catch {
+    }
+  });
+}
+function trim(journal) {
+  const ids = Object.keys(journal);
+  if (ids.length <= JOURNAL_MAX_ENTRIES) return;
+  ids.sort((a, b) => journal[a].ts - journal[b].ts);
+  for (const id of ids.slice(0, ids.length - JOURNAL_MAX_ENTRIES)) delete journal[id];
+}
+function resultByteLength(result) {
+  try {
+    return JSON.stringify(result).length;
+  } catch {
+    return Number.POSITIVE_INFINITY;
+  }
+}
+const UNKNOWN_OUTCOME_HINT = "Inspect the browser/session state before retrying. Do not blindly re-run write commands such as navigate, click, type, or eval.";
+async function executeWithJournal(cmd, execute) {
+  const id = cmd.id;
+  if (!id) return execute(cmd);
+  const running = inFlight.get(id);
+  if (running) return running;
+  const run = (async () => {
+    const journal = await load();
+    const entry = journal[id];
+    if (entry?.status === "done") {
+      if (entry.result) return entry.result;
+      return {
+        id,
+        ok: false,
+        errorCode: "result_evicted",
+        error: "Command already executed, but its result was too large to record for replay.",
+        errorHint: UNKNOWN_OUTCOME_HINT
+      };
+    }
+    if (entry?.status === "started") {
+      return {
+        id,
+        ok: false,
+        errorCode: "command_lost",
+        error: "Command was interrupted mid-execution (extension or browser restarted); it may or may not have applied.",
+        errorHint: UNKNOWN_OUTCOME_HINT
+      };
+    }
+    journal[id] = { status: "started", ts: Date.now() };
+    trim(journal);
+    persist();
+    let result;
+    try {
+      result = await execute(cmd);
+    } catch (err) {
+      result = { id, ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
+    journal[id] = resultByteLength(result) <= JOURNAL_RESULT_MAX_BYTES ? { status: "done", ts: Date.now(), result } : { status: "done", ts: Date.now() };
+    persist();
+    return result;
+  })();
+  inFlight.set(id, run);
+  try {
+    return await run;
+  } finally {
+    inFlight.delete(id);
+  }
+}
+
+let ws = null;
+let reconnectTimer = null;
+let reconnectAttempts = 0;
+const CONTEXT_ID_KEY = "opencli_context_id_v1";
+let currentContextId = "default";
+let contextIdPromise = null;
+let connectInFlight = null;
+let workerReady = Promise.resolve();
+let workerRecovered = true;
+async function getCurrentContextId() {
+  if (contextIdPromise) return contextIdPromise;
+  contextIdPromise = (async () => {
+    try {
+      const local = chrome.storage?.local;
+      if (!local) return currentContextId;
+      const raw = await local.get(CONTEXT_ID_KEY);
+      const existing = raw[CONTEXT_ID_KEY];
+      if (typeof existing === "string" && existing.trim()) {
+        currentContextId = existing.trim();
+        return currentContextId;
+      }
+      const generated = "openmd"; // Openmd patch: fixed Browser Bridge profile id
+      await local.set({ [CONTEXT_ID_KEY]: generated });
+      currentContextId = generated;
+      return currentContextId;
+    } catch {
+      return currentContextId;
+    }
+  })();
+  return contextIdPromise;
+}
+function generateContextId() {
+  const alphabet = "23456789abcdefghjkmnpqrstuvwxyz";
+  const maxUnbiasedByte = Math.floor(256 / alphabet.length) * alphabet.length;
+  let id = "";
+  while (id.length < 8) {
+    const bytes = new Uint8Array(8);
+    try {
+      crypto.getRandomValues(bytes);
+    } catch {
+      for (let i = 0; i < bytes.length; i++) bytes[i] = Math.floor(Math.random() * 256);
+    }
+    for (const byte of bytes) {
+      if (byte >= maxUnbiasedByte) continue;
+      id += alphabet[byte % alphabet.length];
+      if (id.length === 8) break;
+    }
+  }
+  return id;
+}
+const _origLog = console.log.bind(console);
+const _origWarn = console.warn.bind(console);
+const _origError = console.error.bind(console);
+function forwardLog(level, args) {
+  try {
+    const msg = args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+    safeSend(ws, { type: "log", level, msg, ts: Date.now() });
+  } catch {
+  }
+}
+function safeSend(socket, payload) {
+  if (!socket || socket.readyState !== WebSocket.OPEN) return false;
+  try {
+    socket.send(JSON.stringify(payload));
+    return true;
+  } catch {
+    return false;
+  }
+}
+console.log = (...args) => {
+  _origLog(...args);
+  forwardLog("info", args);
+};
+console.warn = (...args) => {
+  _origWarn(...args);
+  forwardLog("warn", args);
+};
+console.error = (...args) => {
+  _origError(...args);
+  forwardLog("error", args);
+};
+function isDaemonSocketActive(socket = ws) {
+  return socket?.readyState === WebSocket.OPEN || socket?.readyState === WebSocket.CONNECTING;
+}
+function connect() {
+  if (isDaemonSocketActive()) return Promise.resolve();
+  if (connectInFlight) return connectInFlight;
+  const attempt = workerRecovered ? connectAttempt() : workerReady.then(() => connectAttempt());
+  connectInFlight = attempt.finally(() => {
+    connectInFlight = null;
+  });
+  return connectInFlight;
+}
+async function connectAttempt() {
+  if (isDaemonSocketActive()) return;
+  try {
+    const res = await fetch(DAEMON_PING_URL, {
+      signal: AbortSignal.timeout(1e3),
+      credentials: "omit"
+    });
+    if (!res.ok) {
+      console.warn(`[opencli] daemon ping failed: HTTP ${res.status}`);
+      scheduleReconnect();
+      return;
+    }
+    reconnectAttempts = 0;
+  } catch {
+    scheduleReconnect();
+    return;
+  }
+  if (isDaemonSocketActive()) return;
+  let thisWs;
+  try {
+    const contextId = await getCurrentContextId();
+    if (isDaemonSocketActive()) return;
+    thisWs = new WebSocket(DAEMON_WS_URL);
+    ws = thisWs;
+    currentContextId = contextId;
+  } catch {
+    scheduleReconnect();
+    return;
+  }
+  thisWs.onopen = () => {
+    if (ws !== thisWs) return;
+    console.log("[opencli] Connected to daemon");
+    reconnectAttempts = 0;
+    if (reconnectTimer) {
+      clearTimeout(reconnectTimer);
+      reconnectTimer = null;
+    }
+    safeSend(thisWs, {
+      type: "hello",
+      contextId: currentContextId,
+      version: OPENMD_BRIDGE_VERSION,
+      compatRange: ">=1.7.0"
+    });
+    startWsKeepalive(thisWs);
+  };
+  thisWs.onmessage = async (event) => {
+    if (ws !== thisWs) return;
+    try {
+      const command = JSON.parse(event.data);
+      const result = await executeWithJournal(command, handleCommand);
+      const target = ws && ws.readyState === WebSocket.OPEN ? ws : thisWs;
+      safeSend(target, result);
+    } catch (err) {
+      console.error("[opencli] Message handling error:", err);
+    }
+  };
+  thisWs.onclose = () => {
+    stopWsKeepalive(thisWs);
+    if (ws !== thisWs) return;
+    console.log("[opencli] Disconnected from daemon");
+    ws = null;
+    scheduleReconnect();
+  };
+  thisWs.onerror = () => {
+    thisWs.close();
+  };
+}
+const WS_KEEPALIVE_INTERVAL_MS = 2e4;
+let wsKeepaliveTimer = null;
+let wsKeepaliveSocket = null;
+function startWsKeepalive(socket) {
+  if (wsKeepaliveTimer) clearInterval(wsKeepaliveTimer);
+  wsKeepaliveSocket = socket;
+  wsKeepaliveTimer = setInterval(() => {
+    if (socket !== ws || socket.readyState !== WebSocket.OPEN) {
+      stopWsKeepalive(socket);
+      return;
+    }
+    safeSend(socket, { type: "ping", ts: Date.now() });
+  }, WS_KEEPALIVE_INTERVAL_MS);
+}
+function stopWsKeepalive(socket) {
+  if (wsKeepaliveSocket !== socket) return;
+  if (wsKeepaliveTimer) clearInterval(wsKeepaliveTimer);
+  wsKeepaliveTimer = null;
+  wsKeepaliveSocket = null;
+}
+const RECONNECT_BASE_DELAY_MS = 1e3;
+const RECONNECT_MAX_DELAY_MS = 15e3;
+function nextReconnectDelayMs() {
+  const exp = Math.min(RECONNECT_MAX_DELAY_MS, RECONNECT_BASE_DELAY_MS * 2 ** Math.min(reconnectAttempts, 6));
+  return exp + Math.floor(Math.random() * 500);
+}
+function scheduleReconnect() {
+  if (reconnectTimer) return;
+  const delay = nextReconnectDelayMs();
+  reconnectAttempts++;
+  reconnectTimer = setTimeout(() => {
+    reconnectTimer = null;
+    void connect();
+  }, delay);
+}
+const automationSessions = /* @__PURE__ */ new Map();
+const IDLE_TIMEOUT_DEFAULT = 3e4;
+const IDLE_TIMEOUT_INTERACTIVE = 6e5;
+const IDLE_TIMEOUT_NONE = -1;
+const REGISTRY_KEY = "opencli_target_lease_registry_v2";
+const LEASE_IDLE_ALARM_PREFIX = "opencli:lease-idle:";
+const CONTAINER_TAB_GROUP_TITLE = {
+  interactive: "Openmd",
+  // Retained for registry/type compatibility. Adapter automation no longer
+  // creates or discovers a visible tab group.
+  automation: "Openmd"
+};
+const OWNED_TAB_GROUP_COLOR = "orange";
+let leaseMutationQueue = Promise.resolve();
+const ownedContainers = {
+  interactive: { windowId: null, groupId: null, promise: null, groupPromise: null },
+  automation: { windowId: null, groupId: null, promise: null, groupPromise: null }
+};
+const interactiveGroupLedger = /* @__PURE__ */ new Set();
+class CommandFailure extends Error {
+  constructor(code, message, hint) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.name = "CommandFailure";
+  }
+}
+const sessionOverrides = /* @__PURE__ */ new Map();
+function setSessionOverride(key, patch) {
+  sessionOverrides.set(key, { ...sessionOverrides.get(key), ...patch });
+}
+const activeCommandCounts = /* @__PURE__ */ new Map();
+const closingLeases = /* @__PURE__ */ new Set();
+const closingTabs = /* @__PURE__ */ new Set();
+const LEASE_KEY_SEPARATOR = "\0";
+function getLeaseKey(session, surface) {
+  return `${surface}${LEASE_KEY_SEPARATOR}${encodeURIComponent(session)}`;
+}
+function getSessionName(session) {
+  const raw = session?.trim();
+  if (!raw) throw new CommandFailure(
+    "session_required",
+    "Browser session is required.",
+    "Pass a browser session name, e.g. opencli browser <session> <command>."
+  );
+  return raw;
+}
+function getCommandSurface(cmd) {
+  return cmd.surface === "adapter" ? "adapter" : "browser";
+}
+function getSurfaceFromKey(key) {
+  return key.split(LEASE_KEY_SEPARATOR, 1)[0] === "adapter" ? "adapter" : "browser";
+}
+function getSessionFromKey(key) {
+  const idx = key.indexOf(LEASE_KEY_SEPARATOR);
+  if (idx === -1) return key;
+  try {
+    return decodeURIComponent(key.slice(idx + 1));
+  } catch {
+    return key.slice(idx + 1);
+  }
+}
+function getIdleTimeout(key) {
+  const session = automationSessions.get(key);
+  if (session?.kind === "bound") return IDLE_TIMEOUT_NONE;
+  const overrides = sessionOverrides.get(key);
+  const adapterPersistent = getSurfaceFromKey(key) === "adapter" && (session?.lifecycle === "persistent" || overrides?.lifecycle === "persistent");
+  if (adapterPersistent) return IDLE_TIMEOUT_NONE;
+  if (overrides?.idleTimeoutMs !== void 0) return overrides.idleTimeoutMs;
+  return getSurfaceFromKey(key) === "browser" ? IDLE_TIMEOUT_INTERACTIVE : IDLE_TIMEOUT_DEFAULT;
+}
+function getLeaseLifecycle(key, kind) {
+  if (kind === "bound") return "pinned";
+  const override = sessionOverrides.get(key)?.lifecycle;
+  if (override) return override;
+  return getSurfaceFromKey(key) === "browser" ? "persistent" : "ephemeral";
+}
+function getOwnedWindowRole(key) {
+  return getSurfaceFromKey(key) === "browser" ? "interactive" : "automation";
+}
+function getWindowRole(key, ownership) {
+  return ownership === "borrowed" ? "borrowed-user" : getOwnedWindowRole(key);
+}
+function getWindowMode(key) {
+  return sessionOverrides.get(key)?.windowMode ?? (getOwnedWindowRole(key) === "interactive" ? "foreground" : "background");
+}
+function makeAlarmName(leaseKey) {
+  return `${LEASE_IDLE_ALARM_PREFIX}${encodeURIComponent(leaseKey)}`;
+}
+function leaseKeyFromAlarmName(name) {
+  if (!name.startsWith(LEASE_IDLE_ALARM_PREFIX)) return null;
+  try {
+    return decodeURIComponent(name.slice(LEASE_IDLE_ALARM_PREFIX.length));
+  } catch {
+    return null;
+  }
+}
+function withLeaseMutation(fn) {
+  const run = leaseMutationQueue.then(fn, fn);
+  leaseMutationQueue = run.then(() => void 0, () => void 0);
+  return run;
+}
+function makeSession(key, session) {
+  const ownership = session.owned ? "owned" : "borrowed";
+  return {
+    ...session,
+    contextId: currentContextId,
+    ownership,
+    lifecycle: getLeaseLifecycle(key, session.kind),
+    windowRole: getWindowRole(key, ownership)
+  };
+}
+function emptyRegistry() {
+  return {
+    version: 2,
+    contextId: currentContextId,
+    ownedContainers: {
+      interactive: {
+        windowId: ownedContainers.interactive.windowId,
+        groupIds: [...interactiveGroupLedger]
+      },
+      automation: { windowId: ownedContainers.automation.windowId }
+    },
+    leases: {}
+  };
+}
+async function readRegistry() {
+  try {
+    const session = chrome.storage?.session;
+    if (!session) return emptyRegistry();
+    const raw = await session.get(REGISTRY_KEY);
+    const stored = raw[REGISTRY_KEY];
+    if (!stored || stored.version !== 2 || typeof stored.leases !== "object") return emptyRegistry();
+    const storedContainers = stored.ownedContainers && typeof stored.ownedContainers === "object" ? stored.ownedContainers : emptyRegistry().ownedContainers;
+    return {
+      version: 2,
+      contextId: currentContextId,
+      ownedContainers: {
+        interactive: {
+          windowId: typeof storedContainers.interactive?.windowId === "number" ? storedContainers.interactive.windowId : null,
+          groupIds: Array.isArray(storedContainers.interactive?.groupIds) ? storedContainers.interactive.groupIds.filter((id) => typeof id === "number") : []
+        },
+        automation: {
+          windowId: typeof storedContainers.automation?.windowId === "number" ? storedContainers.automation.windowId : null
+        }
+      },
+      leases: stored.leases
+    };
+  } catch {
+    return emptyRegistry();
+  }
+}
+async function writeRegistry(registry) {
+  try {
+    await chrome.storage?.session?.set({ [REGISTRY_KEY]: registry });
+  } catch {
+  }
+}
+async function persistRuntimeState() {
+  const leases = {};
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    leases[leaseKey] = {
+      session: session.session,
+      surface: session.surface,
+      kind: session.kind,
+      windowId: session.windowId,
+      owned: session.owned,
+      preferredTabId: session.preferredTabId,
+      contextId: session.contextId,
+      ownership: session.ownership,
+      lifecycle: session.lifecycle,
+      windowRole: session.windowRole,
+      idleDeadlineAt: session.idleDeadlineAt,
+      updatedAt: Date.now()
+    };
+  }
+  await writeRegistry({
+    version: 2,
+    contextId: currentContextId,
+    ownedContainers: {
+      interactive: {
+        windowId: ownedContainers.interactive.windowId,
+        groupIds: [...interactiveGroupLedger]
+      },
+      automation: { windowId: ownedContainers.automation.windowId }
+    },
+    leases
+  });
+}
+function scheduleIdleAlarm(leaseKey, timeout) {
+  const alarmName = makeAlarmName(leaseKey);
+  try {
+    if (timeout > 0) {
+      chrome.alarms?.create?.(alarmName, { when: Date.now() + timeout });
+    } else {
+      chrome.alarms?.clear?.(alarmName);
+    }
+  } catch {
+  }
+}
+async function safeDetach(tabId) {
+  try {
+    const detach$1 = detach;
+    if (typeof detach$1 === "function") await detach$1(tabId);
+  } catch {
+  }
+}
+async function removeLeaseSession(leaseKey) {
+  const existing = automationSessions.get(leaseKey);
+  if (existing?.idleTimer) clearTimeout(existing.idleTimer);
+  automationSessions.delete(leaseKey);
+  sessionOverrides.delete(leaseKey);
+  scheduleIdleAlarm(leaseKey, IDLE_TIMEOUT_NONE);
+  await persistRuntimeState();
+}
+function resetWindowIdleTimer(leaseKey, remainingMs) {
+  const session = automationSessions.get(leaseKey);
+  if (!session) return;
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  const timeout = getIdleTimeout(leaseKey);
+  if (timeout <= 0) {
+    scheduleIdleAlarm(leaseKey, timeout);
+    session.idleTimer = null;
+    session.idleDeadlineAt = 0;
+    void persistRuntimeState();
+    return;
+  }
+  const interval = remainingMs === void 0 ? timeout : Math.max(0, Math.min(remainingMs, timeout));
+  scheduleIdleAlarm(leaseKey, interval);
+  session.idleDeadlineAt = Date.now() + interval;
+  void persistRuntimeState();
+  session.idleTimer = setTimeout(async () => {
+    if ((activeCommandCounts.get(leaseKey) ?? 0) > 0) {
+      return;
+    }
+    await releaseLease(leaseKey, "idle timeout");
+  }, interval);
+}
+async function focusOwnedWindowIfRequested(windowId, mode) {
+  if (mode !== "foreground") return;
+  const updateWindow = chrome.windows.update;
+  if (typeof updateWindow === "function") await updateWindow(windowId, { focused: true }).catch(() => {
+  });
+}
+async function toOwnedContainerGroupCandidate(group) {
+  let chromeWindow;
+  try {
+    chromeWindow = await chrome.windows.get(group.windowId);
+  } catch (err) {
+    if (err instanceof Error && classifyExtensionError(err.message) === "tab_gone") return null;
+    throw err;
+  }
+  const reusableTabId = await findReusableOwnedContainerTab(group.windowId, group.id);
+  return {
+    id: group.id,
+    windowId: group.windowId,
+    title: group.title,
+    focused: !!chromeWindow.focused,
+    hasReusableTab: reusableTabId !== void 0
+  };
+}
+function selectOwnedContainerGroupCandidate(candidates) {
+  if (candidates.length === 0) return null;
+  return [...candidates].sort((a, b) => {
+    if (a.focused !== b.focused) return a.focused ? -1 : 1;
+    if (a.hasReusableTab !== b.hasReusableTab) return a.hasReusableTab ? -1 : 1;
+    if (a.windowId !== b.windowId) return a.windowId - b.windowId;
+    return a.id - b.id;
+  })[0];
+}
+function isMissingTabGroupError(err) {
+  return err instanceof Error && /No group with id|group no longer exists/i.test(err.message);
+}
+async function collectOwnedGroupCandidates(role) {
+  if (role === "automation") return [];
+  const container = ownedContainers[role];
+  const groupsById = /* @__PURE__ */ new Map();
+  if (container.groupId !== null) {
+    try {
+      const group = await chrome.tabGroups.get(container.groupId);
+      groupsById.set(group.id, group);
+    } catch (err) {
+      if (!isMissingTabGroupError(err)) throw err;
+      container.groupId = null;
+    }
+  }
+  let ledgerPruned = false;
+  for (const groupId of [...interactiveGroupLedger]) {
+    if (groupsById.has(groupId)) continue;
+    try {
+      const group = await chrome.tabGroups.get(groupId);
+      groupsById.set(group.id, group);
+    } catch (err) {
+      if (!isMissingTabGroupError(err)) throw err;
+      interactiveGroupLedger.delete(groupId);
+      ledgerPruned = true;
+    }
+  }
+  if (ledgerPruned) await persistRuntimeState();
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    if (!session.owned || getOwnedWindowRole(leaseKey) !== role || session.preferredTabId === null) continue;
+    let tab;
+    try {
+      tab = await chrome.tabs.get(session.preferredTabId);
+    } catch (err) {
+      if (err instanceof Error && classifyExtensionError(err.message) === "tab_gone") continue;
+      throw err;
+    }
+    const groupId = tab.groupId;
+    if (typeof groupId !== "number" || groupId === chrome.tabGroups.TAB_GROUP_ID_NONE) continue;
+    try {
+      const group = await chrome.tabGroups.get(groupId);
+      groupsById.set(group.id, group);
+    } catch (err) {
+      if (!isMissingTabGroupError(err)) throw err;
+    }
+  }
+  const ownedPreferredTabIds = /* @__PURE__ */ new Set();
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    if (!session.owned || getOwnedWindowRole(leaseKey) !== role || session.preferredTabId === null) continue;
+    ownedPreferredTabIds.add(session.preferredTabId);
+  }
+  if (ownedPreferredTabIds.size > 0) {
+    const allGroups = await chrome.tabGroups.query({});
+    for (const group of allGroups) {
+      if (group.title) continue;
+      if (groupsById.has(group.id)) continue;
+      const tabsInGroup = await chrome.tabs.query({ groupId: group.id });
+      if (tabsInGroup.some((tab) => tab.id !== void 0 && ownedPreferredTabIds.has(tab.id))) {
+        groupsById.set(group.id, group);
+      }
+    }
+  }
+  if (groupsById.size === 0) {
+    const reservedTabs = new Set([...automationSessions.values()].flatMap((session) => session.preferredTabId === null ? [] : [session.preferredTabId]));
+    const idleGroup = await findIdleInteractiveGroup(reservedTabs);
+    if (idleGroup) groupsById.set(idleGroup.id, idleGroup);
+  }
+  const candidates = await Promise.all([...groupsById.values()].map(toOwnedContainerGroupCandidate));
+  return candidates.filter((candidate) => candidate !== null);
+}
+function updateOwnedSessionWindowForTabs(role, tabIds, windowId) {
+  const moved = new Set(tabIds);
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    if (!session.owned || getOwnedWindowRole(leaseKey) !== role) continue;
+    if (session.preferredTabId !== null && moved.has(session.preferredTabId)) {
+      session.windowId = windowId;
+    }
+  }
+}
+async function ensureTabsInWindow(tabIds, windowId) {
+  const movedIds = [];
+  for (const tabId of tabIds) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (tab.windowId !== windowId) {
+        await chrome.tabs.move(tabId, { windowId, index: -1 });
+        movedIds.push(tabId);
+      }
+    } catch (err) {
+      if (!(err instanceof Error) || classifyExtensionError(err.message) !== "tab_gone") throw err;
+    }
+  }
+  return movedIds;
+}
+async function ensureCanonicalGroupTitle(role, group) {
+  const canonicalTitle = CONTAINER_TAB_GROUP_TITLE[role];
+  if (group.title === canonicalTitle) return group;
+  const updated = await chrome.tabGroups.update(group.id, {
+    title: canonicalTitle,
+    color: OWNED_TAB_GROUP_COLOR
+  });
+  return { id: updated.id, windowId: updated.windowId, title: updated.title };
+}
+async function convergeOwnedGroupDuplicates(role, canonical, candidates) {
+  for (const duplicate of candidates) {
+    if (duplicate.id === canonical.id) continue;
+    const tabs = await chrome.tabs.query({ groupId: duplicate.id });
+    const tabIds = tabs.map((tab) => tab.id).filter((id) => id !== void 0);
+    if (tabIds.length === 0) continue;
+    await ensureTabsInWindow(tabIds, canonical.windowId);
+    await chrome.tabs.group({ groupId: canonical.id, tabIds });
+    updateOwnedSessionWindowForTabs(role, tabIds, canonical.windowId);
+  }
+  return canonical;
+}
+async function attachTabsToOwnedGroup(role, group, ids) {
+  if (ids.length === 0) return group;
+  await ensureTabsInWindow(ids, group.windowId);
+  const tabs = await Promise.all(ids.map(async (id) => {
+    try {
+      return await chrome.tabs.get(id);
+    } catch (err) {
+      if (err instanceof Error && classifyExtensionError(err.message) === "tab_gone") return null;
+      throw err;
+    }
+  }));
+  const missing = tabs.filter((tab) => tab !== null && tab.id !== void 0 && tab.groupId !== group.id).map((tab) => tab.id);
+  if (missing.length > 0) await chrome.tabs.group({ groupId: group.id, tabIds: missing });
+  updateOwnedSessionWindowForTabs(role, ids, group.windowId);
+  return group;
+}
+async function createOwnedGroup(role, windowId, ids) {
+  if (ids.length === 0) throw new Error(`Cannot create ${role} tab group without tabs`);
+  await ensureTabsInWindow(ids, windowId);
+  const groupId = await chrome.tabs.group({ tabIds: ids, createProperties: { windowId } });
+  ownedContainers[role].groupId = groupId;
+  ownedContainers[role].windowId = windowId;
+  if (role === "interactive") interactiveGroupLedger.add(groupId);
+  await persistRuntimeState();
+  const group = await chrome.tabGroups.update(groupId, {
+    color: OWNED_TAB_GROUP_COLOR,
+    title: CONTAINER_TAB_GROUP_TITLE[role],
+    collapsed: false
+  });
+  updateOwnedSessionWindowForTabs(role, ids, group.windowId);
+  return { id: group.id, windowId: group.windowId, title: group.title };
+}
+async function ensureOwnedContainerGroup(role, fallbackWindowId, tabIds) {
+  if (role === "automation") return null;
+  const ids = [...new Set(tabIds.filter((id) => id !== void 0))];
+  const container = ownedContainers[role];
+  const previousGroupPromise = container.groupPromise ?? Promise.resolve(null);
+  const nextGroupPromise = previousGroupPromise.catch(() => null).then(() => ensureOwnedContainerGroupUnlocked(role, fallbackWindowId, ids));
+  const trackedGroupPromise = nextGroupPromise.finally(() => {
+    if (container.groupPromise === trackedGroupPromise) container.groupPromise = null;
+  });
+  container.groupPromise = trackedGroupPromise;
+  return trackedGroupPromise;
+}
+async function ensureOwnedContainerGroupUnlocked(role, fallbackWindowId, ids) {
+  try {
+    const candidates = await collectOwnedGroupCandidates(role);
+    const selected = selectOwnedContainerGroupCandidate(candidates);
+    let canonical = selected ? { id: selected.id, windowId: selected.windowId, title: selected.title } : null;
+    if (canonical) {
+      canonical = await convergeOwnedGroupDuplicates(role, canonical, candidates);
+      canonical = await ensureCanonicalGroupTitle(role, canonical);
+      canonical = await attachTabsToOwnedGroup(role, canonical, ids);
+    } else if (fallbackWindowId !== null && ids.length > 0) {
+      canonical = await createOwnedGroup(role, fallbackWindowId, ids);
+    }
+    if (canonical) {
+      ownedContainers[role].windowId = canonical.windowId;
+      ownedContainers[role].groupId = canonical.id;
+      if (!interactiveGroupLedger.has(canonical.id)) {
+        interactiveGroupLedger.add(canonical.id);
+        await persistRuntimeState();
+      }
+    } else {
+      ownedContainers[role].groupId = null;
+      if (fallbackWindowId === null) ownedContainers[role].windowId = null;
+    }
+    return canonical;
+  } catch (err) {
+    console.warn(`[opencli] Failed to ensure ${role} tab group: ${err instanceof Error ? err.message : String(err)}`);
+    throw err;
+  }
+}
+async function ensureOwnedContainerWindow(role, initialUrl, mode = "background") {
+  const container = ownedContainers[role];
+  if (container.promise) return container.promise;
+  container.promise = ensureOwnedContainerWindowUnlocked(role, initialUrl, mode).finally(() => {
+    container.promise = null;
+  });
+  return container.promise;
+}
+async function ensureOwnedContainerWindowUnlocked(role, initialUrl, mode = "background") {
+  const container = ownedContainers[role];
+  if (container.windowId !== null) {
+    const windowId = container.windowId;
+    try {
+      await chrome.windows.get(windowId);
+    } catch (err) {
+      if (!(err instanceof Error) || classifyExtensionError(err.message) !== "tab_gone") throw err;
+      console.warn(`[opencli] Owned ${role} window ${windowId} is unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      container.windowId = null;
+      container.groupId = null;
+    }
+    if (container.windowId === windowId) {
+      const group2 = await ensureOwnedContainerGroup(role, windowId, []);
+      if (group2) {
+        await focusOwnedWindowIfRequested(group2.windowId, mode);
+        const initialTabId2 = await findReusableOwnedContainerTab(group2.windowId, group2.id);
+        return {
+          windowId: group2.windowId,
+          initialTabId: initialTabId2
+        };
+      }
+      if (role === "interactive") {
+        container.windowId = null;
+        container.groupId = null;
+      } else {
+        await focusOwnedWindowIfRequested(windowId, mode);
+        const initialTabId2 = await findReusableOwnedContainerTab(windowId, null);
+        return {
+          windowId,
+          initialTabId: initialTabId2
+        };
+      }
+    }
+  }
+  const existingGroup = await ensureOwnedContainerGroup(role, null, []);
+  if (existingGroup) {
+    await focusOwnedWindowIfRequested(existingGroup.windowId, mode);
+    const initialTabId2 = await findReusableOwnedContainerTab(existingGroup.windowId, existingGroup.id);
+    await persistRuntimeState();
+    return {
+      windowId: existingGroup.windowId,
+      initialTabId: initialTabId2
+    };
+  }
+  const startUrl = initialUrl && isSafeNavigationUrl(initialUrl) ? initialUrl : BLANK_PAGE;
+  const win = await chrome.windows.create({
+    url: startUrl,
+    focused: mode === "foreground",
+    width: 1280,
+    height: 900,
+    type: "normal"
+  });
+  // Openmd patch: background reads never stay on screen. windows.create ignores
+  // state:"minimized" on Windows (Edge/Chrome 157), so minimize right after.
+  if (mode !== "foreground") await chrome.windows.update(win.id, { state: "minimized" }).catch(() => {});
+  container.windowId = win.id;
+  await persistRuntimeState();
+  console.log(`[opencli] Created owned ${role} window ${container.windowId} (start=${startUrl})`);
+  const tabs = await chrome.tabs.query({ windowId: win.id });
+  const initialTabId = tabs[0]?.id;
+  if (initialTabId) {
+    await new Promise((resolve) => {
+      const timeout = setTimeout(resolve, 500);
+      const listener = (tabId, info) => {
+        if (tabId === initialTabId && info.status === "complete") {
+          chrome.tabs.onUpdated.removeListener(listener);
+          clearTimeout(timeout);
+          resolve();
+        }
+      };
+      if (tabs[0].status === "complete") {
+        clearTimeout(timeout);
+        resolve();
+      } else {
+        chrome.tabs.onUpdated.addListener(listener);
+      }
+    });
+  }
+  const group = await ensureOwnedContainerGroup(role, container.windowId, [initialTabId]);
+  await persistRuntimeState();
+  return { windowId: group?.windowId ?? container.windowId, initialTabId };
+}
+async function findReusableOwnedContainerTab(windowId, ownedGroupId) {
+  const idleUrl = await idlePlaceholderUrl();
+  const tabs = await chrome.tabs.query({ windowId });
+  const reusable = tabs.find(
+    (tab) => tab.id !== void 0 && initialTabIsAvailable(tab.id) && (isDebuggableUrl(tab.url) || idleUrl !== null && tab.url === idleUrl && !tab.pendingUrl) && (ownedGroupId === void 0 || ownedGroupId !== null && tab.groupId === ownedGroupId || !isSafeNavigationUrl(tab.url ?? ""))
+  );
+  return reusable?.id;
+}
+function initialTabIsAvailable(tabId) {
+  if (tabId === void 0) return false;
+  for (const session of automationSessions.values()) {
+    if (session.owned && session.preferredTabId === tabId) return false;
+  }
+  return true;
+}
+async function createOwnedTabLease(leaseKey, initialUrl) {
+  return withLeaseMutation(() => createOwnedTabLeaseUnlocked(leaseKey, initialUrl));
+}
+async function createOwnedTabLeaseUnlocked(leaseKey, initialUrl) {
+  const targetUrl = initialUrl && isSafeNavigationUrl(initialUrl) ? initialUrl : BLANK_PAGE;
+  const role = getOwnedWindowRole(leaseKey);
+  const { windowId, initialTabId } = await ensureOwnedContainerWindow(role, BLANK_PAGE, getWindowMode(leaseKey));
+  let tab;
+  if (initialTabIsAvailable(initialTabId)) {
+    tab = await chrome.tabs.get(initialTabId);
+    await consumeIdlePlaceholder(tab);
+    if (!isTargetUrl(tab.url, targetUrl)) {
+      tab = await chrome.tabs.update(initialTabId, { url: targetUrl });
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      tab = await chrome.tabs.get(initialTabId);
+    }
+  } else {
+    tab = await chrome.tabs.create({ windowId, url: targetUrl, active: true });
+  }
+  const tabId = tab.id;
+  if (!tabId) throw new Error("Failed to create tab lease in automation container");
+  const group = await ensureOwnedContainerGroup(role, windowId, [tabId]);
+  const sessionWindowId = group?.windowId ?? tab.windowId;
+  if (tab.windowId !== sessionWindowId) tab = await chrome.tabs.get(tabId);
+  setLeaseSession(leaseKey, {
+    session: getSessionFromKey(leaseKey),
+    surface: getSurfaceFromKey(leaseKey),
+    kind: "owned",
+    windowId: sessionWindowId,
+    owned: true,
+    preferredTabId: tabId
+  });
+  resetWindowIdleTimer(leaseKey);
+  return { tabId, tab };
+}
+async function getAutomationWindow(leaseKey, initialUrl) {
+  const existing = automationSessions.get(leaseKey);
+  if (existing) {
+    if (!existing.owned) {
+      throw new CommandFailure(
+        "bound_window_operation_blocked",
+        `Session "${existing.session}" is bound to a user tab and does not own an OpenCLI tab lease.`,
+        "Use page commands on the bound tab, or unbind the session first."
+      );
+    }
+    try {
+      const tabId = existing.preferredTabId;
+      if (tabId !== null) {
+        const tab = await chrome.tabs.get(tabId);
+        if (isDebuggableUrl(tab.url)) return tab.windowId;
+      }
+      await chrome.windows.get(existing.windowId);
+      return existing.windowId;
+    } catch {
+      await removeLeaseSession(leaseKey);
+    }
+  }
+  const role = getOwnedWindowRole(leaseKey);
+  return (await ensureOwnedContainerWindow(role, initialUrl, getWindowMode(leaseKey))).windowId;
+}
+chrome.windows.onRemoved.addListener(async (windowId) => {
+  await workerReady;
+  for (const container of Object.values(ownedContainers)) {
+    if (container.windowId === windowId) {
+      container.windowId = null;
+      container.groupId = null;
+    }
+  }
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    if (session.windowId === windowId) {
+      console.log(`[opencli] ${session.surface} container closed (session=${session.session})`);
+      if (session.idleTimer) clearTimeout(session.idleTimer);
+      automationSessions.delete(leaseKey);
+      sessionOverrides.delete(leaseKey);
+      scheduleIdleAlarm(leaseKey, IDLE_TIMEOUT_NONE);
+    }
+  }
+  await persistRuntimeState();
+});
+chrome.tabs.onRemoved.addListener(async (tabId) => {
+  await workerReady;
+  evictTab(tabId);
+  for (const [leaseKey, session] of automationSessions.entries()) {
+    if (session.preferredTabId === tabId) {
+      if (session.idleTimer) clearTimeout(session.idleTimer);
+      automationSessions.delete(leaseKey);
+      sessionOverrides.delete(leaseKey);
+      scheduleIdleAlarm(leaseKey, IDLE_TIMEOUT_NONE);
+      console.log(`[opencli] Session ${session.session} detached from tab ${tabId} (tab closed)`);
+    }
+  }
+  await persistRuntimeState();
+});
+let initialized = false;
+function initialize() {
+  if (initialized) return;
+  initialized = true;
+  chrome.alarms.create("keepalive", { periodInMinutes: 0.5 });
+  registerListeners();
+  try {
+    const registerFrameTracking$1 = registerFrameTracking;
+    registerFrameTracking$1?.();
+  } catch {
+  }
+  try {
+    void chrome.storage?.local?.remove?.(REGISTRY_KEY)?.catch?.(() => {
+    });
+  } catch {
+  }
+  workerRecovered = false;
+  workerReady = (async () => {
+    await getCurrentContextId();
+    await reconcileTargetLeaseRegistry();
+  })().catch((err) => {
+    console.warn(`[opencli] Startup recovery failed: ${err instanceof Error ? err.message : String(err)}`);
+  }).finally(() => {
+    workerRecovered = true;
+  });
+  void workerReady.then(() => connect());
+  console.log("[opencli] OpenCLI extension initialized");
+}
+chrome.runtime.onInstalled.addListener(() => {
+  initialize();
+});
+chrome.runtime.onStartup.addListener(() => {
+  initialize();
+});
+initialize();
+chrome.alarms.onAlarm.addListener(async (alarm) => {
+  await workerReady;
+  if (alarm.name === "keepalive") void connect();
+  const leaseKey = leaseKeyFromAlarmName(alarm.name);
+  if (!leaseKey) return;
+  if ((activeCommandCounts.get(leaseKey) ?? 0) > 0) {
+    resetWindowIdleTimer(leaseKey);
+    return;
+  }
+  await releaseLease(leaseKey, "idle alarm");
+});
+chrome.runtime.onMessage.addListener((msg, _sender, sendResponse) => {
+  if (msg?.type === "getStatus") {
+    void (async () => {
+      const contextId = await getCurrentContextId();
+      const connected = ws?.readyState === WebSocket.OPEN;
+      const extensionVersion = OPENMD_BRIDGE_VERSION;
+      const daemonVersion = connected ? await fetchDaemonVersion() : null;
+      sendResponse({
+        connected,
+        reconnecting: reconnectTimer !== null,
+        contextId,
+        extensionVersion,
+        daemonVersion
+      });
+    })();
+    return true;
+  }
+  return false;
+});
+async function fetchDaemonVersion() {
+  try {
+    const res = await fetch(`http://${DAEMON_HOST}:${DAEMON_PORT}/status`, {
+      method: "GET",
+      headers: { "X-OpenCLI": "1" },
+      signal: AbortSignal.timeout(1500)
+    });
+    if (!res.ok) return null;
+    const body = await res.json();
+    return typeof body.daemonVersion === "string" ? body.daemonVersion : null;
+  } catch {
+    return null;
+  }
+}
+async function handleCommand(cmd) {
+  if (cmd.action === "chrome-describe" || cmd.action === "chrome-call") {
+    try {
+      if (cmd.action === "chrome-describe") return { id: cmd.id, ok: true, data: await describeChrome(cmd.chromeMethod) };
+      return await withLeaseMutation(async () => ({ id: cmd.id, ok: true, data: await callChrome(
+        cmd.chromeMethod ?? "",
+        cmd.chromeArgs ?? [],
+        new Set([...automationSessions.values()].map((s) => s.preferredTabId).filter((id) => id !== null)),
+        /* @__PURE__ */ new Set([...interactiveGroupLedger, ...Object.values(ownedContainers).map((c) => c.groupId).filter((id) => id !== null)])
+      ) }));
+    } catch (error) {
+      return errorResult(cmd.id, error);
+    }
+  }
+  const session = getSessionName(cmd.session);
+  const surface = getCommandSurface(cmd);
+  const leaseKey = getLeaseKey(session, surface);
+  if (closingLeases.has(leaseKey)) {
+    return errorResult(cmd.id, new CommandFailure("session_busy", "This session is closing; retry after cleanup finishes."));
+  }
+  if (cmd.windowMode === "foreground" || cmd.windowMode === "background") {
+    setSessionOverride(leaseKey, { windowMode: cmd.windowMode });
+  }
+  if (surface === "adapter" && (cmd.siteSession === "persistent" || cmd.siteSession === "ephemeral")) {
+    setSessionOverride(leaseKey, { lifecycle: cmd.siteSession });
+  }
+  if (cmd.idleTimeout != null && cmd.idleTimeout > 0) {
+    setSessionOverride(leaseKey, { idleTimeoutMs: cmd.idleTimeout * 1e3 });
+  }
+  resetWindowIdleTimer(leaseKey);
+  activeCommandCounts.set(leaseKey, (activeCommandCounts.get(leaseKey) ?? 0) + 1);
+  try {
+    switch (cmd.action) {
+      case "exec":
+        return await handleExec(cmd, leaseKey);
+      case "navigate":
+        return await handleNavigate(cmd, leaseKey);
+      case "tabs":
+        return await handleTabs(cmd, leaseKey);
+      case "cookies":
+        return await handleCookies(cmd);
+      case "screenshot":
+        return await handleScreenshot(cmd, leaseKey);
+      case "close-owned-tab":
+      case "close-window":
+        return await handleCloseWindow(cmd, leaseKey);
+      case "cdp":
+        return await handleCdp(cmd, leaseKey);
+      case "set-file-input":
+        return await handleSetFileInput(cmd, leaseKey);
+      case "insert-text":
+        return await handleInsertText(cmd, leaseKey);
+      case "bind":
+        return await handleBind(cmd, leaseKey);
+      case "network-capture-start":
+        return await handleNetworkCaptureStart(cmd, leaseKey);
+      case "network-capture-read":
+        return await handleNetworkCaptureRead(cmd, leaseKey);
+      case "wait-download":
+        return await handleWaitDownload(cmd);
+      case "frames":
+        return await handleFrames(cmd, leaseKey);
+      default:
+        return { id: cmd.id, ok: false, error: `Unknown action: ${cmd.action}` };
+    }
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  } finally {
+    const remaining = (activeCommandCounts.get(leaseKey) ?? 1) - 1;
+    if (remaining <= 0) activeCommandCounts.delete(leaseKey);
+    else activeCommandCounts.set(leaseKey, remaining);
+    resetWindowIdleTimer(leaseKey);
+  }
+}
+const BLANK_PAGE = "about:blank";
+function isDebuggableUrl(url) {
+  if (!url) return true;
+  return url.startsWith("http://") || url.startsWith("https://") || url === "about:blank" || url.startsWith("data:");
+}
+function isSafeNavigationUrl(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+function normalizeUrlForComparison(url) {
+  if (!url) return "";
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol === "https:" && parsed.port === "443" || parsed.protocol === "http:" && parsed.port === "80") {
+      parsed.port = "";
+    }
+    const pathname = parsed.pathname === "/" ? "" : parsed.pathname;
+    return `${parsed.protocol}//${parsed.host}${pathname}${parsed.search}${parsed.hash}`;
+  } catch {
+    return url;
+  }
+}
+function isTargetUrl(currentUrl, targetUrl) {
+  return normalizeUrlForComparison(currentUrl) === normalizeUrlForComparison(targetUrl);
+}
+function getUrlOrigin(url) {
+  if (!url) return null;
+  try {
+    return new URL(url).origin;
+  } catch {
+    return null;
+  }
+}
+function enumerateCrossOriginFrames(tree) {
+  const frames = [];
+  function collect(node, accessibleOrigin) {
+    for (const child of node.childFrames || []) {
+      const frame = child.frame;
+      const frameUrl = frame.url || frame.unreachableUrl || "";
+      const frameOrigin = getUrlOrigin(frameUrl);
+      if (accessibleOrigin && frameOrigin && frameOrigin === accessibleOrigin) {
+        collect(child, frameOrigin);
+        continue;
+      }
+      frames.push({
+        index: frames.length,
+        frameId: frame.id,
+        url: frameUrl,
+        name: frame.name || ""
+      });
+    }
+  }
+  const rootFrame = tree?.frameTree?.frame;
+  const rootUrl = rootFrame?.url || rootFrame?.unreachableUrl || "";
+  collect(tree.frameTree, getUrlOrigin(rootUrl));
+  return frames;
+}
+function setLeaseSession(leaseKey, session) {
+  if (session.preferredTabId !== null && closingTabs.has(session.preferredTabId)) {
+    throw new CommandFailure("session_busy", "This tab is closing; wait for cleanup to finish.");
+  }
+  const existing = automationSessions.get(leaseKey);
+  if (existing?.idleTimer) clearTimeout(existing.idleTimer);
+  const timeout = getIdleTimeout(leaseKey);
+  automationSessions.set(leaseKey, {
+    ...makeSession(leaseKey, session),
+    idleTimer: null,
+    idleDeadlineAt: timeout <= 0 ? 0 : Date.now() + timeout
+  });
+  void persistRuntimeState();
+}
+async function resolveCommandTabId(cmd) {
+  if (cmd.page) return resolveTabId$1(cmd.page);
+  return void 0;
+}
+async function resolveTab(tabId, leaseKey, initialUrl) {
+  const existingSession = automationSessions.get(leaseKey);
+  if (tabId !== void 0) {
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      const session = existingSession;
+      const matchesSession = session ? session.preferredTabId !== null ? session.preferredTabId === tabId : tab.windowId === session.windowId : false;
+      if (isDebuggableUrl(tab.url) && matchesSession) return { tabId, tab };
+      if (session && !session.owned) {
+        throw new CommandFailure(
+          matchesSession ? "bound_tab_not_debuggable" : "bound_tab_mismatch",
+          matchesSession ? `Bound tab for session "${session.session}" is not debuggable (${tab.url ?? "unknown URL"}).` : `Target tab is not the tab bound to session "${session.session}".`,
+          'Run "opencli browser bind" again on a debuggable http(s) tab.'
+        );
+      }
+      if (session && !matchesSession && session.preferredTabId === null && isDebuggableUrl(tab.url)) {
+        console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId}, moving back to ${session.windowId}`);
+        try {
+          await chrome.tabs.move(tabId, { windowId: session.windowId, index: -1 });
+          const moved = await chrome.tabs.get(tabId);
+          if (moved.windowId === session.windowId && isDebuggableUrl(moved.url)) {
+            return { tabId, tab: moved };
+          }
+        } catch (moveErr) {
+          console.warn(`[opencli] Failed to move tab back: ${moveErr}`);
+        }
+      } else if (!isDebuggableUrl(tab.url)) {
+        console.warn(`[opencli] Tab ${tabId} URL is not debuggable (${tab.url}), re-resolving`);
+      }
+    } catch (err) {
+      if (err instanceof CommandFailure) throw err;
+      if (existingSession && !existingSession.owned) {
+        automationSessions.delete(leaseKey);
+        throw new CommandFailure(
+          "bound_tab_gone",
+          `Bound tab for session "${existingSession.session}" no longer exists.`,
+          'Run "opencli browser bind" again, then retry the command.'
+        );
+      }
+      console.warn(`[opencli] Tab ${tabId} no longer exists, re-resolving`);
+    }
+  }
+  const existingPreferredTabId = existingSession?.preferredTabId ?? null;
+  if (existingSession && existingPreferredTabId !== null) {
+    const session = existingSession;
+    try {
+      const preferredTab = await chrome.tabs.get(existingPreferredTabId);
+      if (isDebuggableUrl(preferredTab.url)) return { tabId: preferredTab.id, tab: preferredTab };
+      if (!session.owned) {
+        throw new CommandFailure(
+          "bound_tab_not_debuggable",
+          `Bound tab for session "${session.session}" is not debuggable (${preferredTab.url ?? "unknown URL"}).`,
+          'Switch the tab to an http(s) page or run "opencli browser bind" on another tab.'
+        );
+      }
+    } catch (err) {
+      if (err instanceof CommandFailure) throw err;
+      await removeLeaseSession(leaseKey);
+      if (!session.owned) {
+        throw new CommandFailure(
+          "bound_tab_gone",
+          `Bound tab for session "${session.session}" no longer exists.`,
+          'Run "opencli browser bind" again, then retry the command.'
+        );
+      }
+      return createOwnedTabLease(leaseKey, initialUrl);
+    }
+  }
+  if (!existingSession || existingSession.owned && existingSession.preferredTabId === null) {
+    return createOwnedTabLease(leaseKey, initialUrl);
+  }
+  const windowId = await getAutomationWindow(leaseKey, initialUrl);
+  const role = getOwnedWindowRole(leaseKey);
+  const group = existingSession?.owned ? await ensureOwnedContainerGroup(role, windowId, []) : null;
+  const scopedWindowId = group?.windowId ?? windowId;
+  const reusableTabId = await findReusableOwnedContainerTab(scopedWindowId, existingSession?.owned ? group?.id ?? null : void 0);
+  if (reusableTabId !== void 0) return { tabId: reusableTabId, tab: await chrome.tabs.get(reusableTabId) };
+  const tabs = await chrome.tabs.query({ windowId: scopedWindowId });
+  const reuseTab = existingSession?.owned ? void 0 : tabs.find((t) => t.id);
+  if (reuseTab?.id) {
+    await chrome.tabs.update(reuseTab.id, { url: BLANK_PAGE });
+    await new Promise((resolve) => setTimeout(resolve, 300));
+    try {
+      const updated = await chrome.tabs.get(reuseTab.id);
+      if (isDebuggableUrl(updated.url)) return { tabId: reuseTab.id, tab: updated };
+      console.warn(`[opencli] data: URI was intercepted (${updated.url}), creating fresh tab`);
+    } catch {
+    }
+  }
+  const newTab = await chrome.tabs.create({ windowId: scopedWindowId, url: BLANK_PAGE, active: true });
+  if (!newTab.id) throw new Error("Failed to create tab in automation container");
+  await ensureOwnedContainerGroup(role, scopedWindowId, [newTab.id]);
+  return { tabId: newTab.id, tab: await chrome.tabs.get(newTab.id) };
+}
+async function pageScopedResult(id, tabId, data) {
+  const page = await resolveTargetId(tabId);
+  return { id, ok: true, data, page };
+}
+async function resolveTabId(tabId, leaseKey, initialUrl) {
+  const resolved = await resolveTab(tabId, leaseKey, initialUrl);
+  return resolved.tabId;
+}
+async function listAutomationTabs(leaseKey) {
+  const session = automationSessions.get(leaseKey);
+  if (!session) return [];
+  if (session.preferredTabId !== null) {
+    try {
+      return [await chrome.tabs.get(session.preferredTabId)];
+    } catch {
+      automationSessions.delete(leaseKey);
+      return [];
+    }
+  }
+  try {
+    return await chrome.tabs.query({ windowId: session.windowId });
+  } catch {
+    automationSessions.delete(leaseKey);
+    return [];
+  }
+}
+async function listAutomationWebTabs(leaseKey) {
+  const tabs = await listAutomationTabs(leaseKey);
+  return tabs.filter((tab) => isDebuggableUrl(tab.url));
+}
+function commandCdpTimeoutMs(cmd) {
+  if (typeof cmd.deadlineAt === "number" && cmd.deadlineAt > 0) {
+    return Math.max(1e4, cmd.deadlineAt - Date.now() - 5e3);
+  }
+  if (typeof cmd.timeout === "number" && cmd.timeout > 0) {
+    return Math.max(1e4, cmd.timeout * 1e3 - 5e3);
+  }
+  return void 0;
+}
+function classifyExtensionError(message) {
+  if (/Inspected target navigated|Target closed/.test(message)) return "target_navigated";
+  if (/Detached while handling command/.test(message)) return "detached_mid_command";
+  if (/CDP command .* timed out/.test(message)) return "cdp_timeout";
+  if (/attach failed|Debugger is not attached/.test(message)) return "attach_failed";
+  if (/No tab with id|no longer exists|No window with id/.test(message)) return "tab_gone";
+  return void 0;
+}
+function errorResult(id, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  if (err instanceof CommandFailure || err instanceof ChromeApiError) {
+    return { id, ok: false, error: message, errorCode: err.code, ...err.hint ? { errorHint: err.hint } : {} };
+  }
+  const errorCode = classifyExtensionError(message);
+  return { id, ok: false, error: message, ...errorCode ? { errorCode } : {} };
+}
+async function handleExec(cmd, leaseKey) {
+  if (!cmd.code) return { id: cmd.id, ok: false, error: "Missing code" };
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    const aggressive = getSurfaceFromKey(leaseKey) === "browser";
+    if (cmd.frameIndex != null) {
+      const tree = await getFrameTree(tabId);
+      const frames = enumerateCrossOriginFrames(tree);
+      if (cmd.frameIndex < 0 || cmd.frameIndex >= frames.length) {
+        return { id: cmd.id, ok: false, error: `Frame index ${cmd.frameIndex} out of range (${frames.length} cross-origin frames available)` };
+      }
+      const data2 = await evaluateInFrame(tabId, cmd.code, frames[cmd.frameIndex].frameId, aggressive, commandCdpTimeoutMs(cmd));
+      return pageScopedResult(cmd.id, tabId, data2);
+    }
+    const data = await evaluateAsync(tabId, cmd.code, aggressive, commandCdpTimeoutMs(cmd));
+    return pageScopedResult(cmd.id, tabId, data);
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function handleFrames(cmd, leaseKey) {
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    const tree = await getFrameTree(tabId);
+    return { id: cmd.id, ok: true, data: enumerateCrossOriginFrames(tree) };
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+function preferOwnedTab(leaseKey, tabId) {
+  const session = automationSessions.get(leaseKey);
+  if (!session?.owned) return;
+  setLeaseSession(leaseKey, {
+    session: session.session,
+    surface: session.surface,
+    kind: session.kind,
+    windowId: session.windowId,
+    owned: true,
+    preferredTabId: tabId
+  });
+}
+async function handleNavigate(cmd, leaseKey) {
+  if (!cmd.url) return { id: cmd.id, ok: false, error: "Missing url" };
+  if (!isSafeNavigationUrl(cmd.url)) {
+    return { id: cmd.id, ok: false, error: "Blocked URL scheme -- only http:// and https:// are allowed" };
+  }
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const resolved = await resolveTab(cmdTabId, leaseKey);
+  const tabId = resolved.tabId;
+  const beforeTab = resolved.tab ?? await chrome.tabs.get(tabId);
+  const beforeNormalized = normalizeUrlForComparison(beforeTab.url);
+  const targetUrl = cmd.url;
+  if (beforeTab.status === "complete" && isTargetUrl(beforeTab.url, targetUrl)) {
+    return pageScopedResult(cmd.id, tabId, { title: beforeTab.title, url: beforeTab.url, timedOut: false });
+  }
+  if (!hasActiveNetworkCapture(tabId)) {
+    await detach(tabId);
+  }
+  await chrome.tabs.update(tabId, { url: targetUrl });
+  let timedOut = false;
+  await new Promise((resolve) => {
+    let settled = false;
+    let checkTimer = null;
+    let timeoutTimer = null;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      chrome.tabs.onUpdated.removeListener(listener);
+      if (checkTimer) clearTimeout(checkTimer);
+      if (timeoutTimer) clearTimeout(timeoutTimer);
+      resolve();
+    };
+    const isNavigationDone = (url) => {
+      return isTargetUrl(url, targetUrl) || normalizeUrlForComparison(url) !== beforeNormalized;
+    };
+    const listener = (id, info, tab2) => {
+      if (id !== tabId) return;
+      if (info.status === "complete" && isNavigationDone(tab2.url ?? info.url)) {
+        finish();
+      }
+    };
+    chrome.tabs.onUpdated.addListener(listener);
+    checkTimer = setTimeout(async () => {
+      try {
+        const currentTab = await chrome.tabs.get(tabId);
+        if (currentTab.status === "complete" && isNavigationDone(currentTab.url)) {
+          finish();
+        }
+      } catch {
+      }
+    }, 100);
+    timeoutTimer = setTimeout(() => {
+      timedOut = true;
+      console.warn(`[opencli] Navigate to ${targetUrl} timed out after 15s`);
+      finish();
+    }, 15e3);
+  });
+  let tab = await chrome.tabs.get(tabId);
+  const postNavigationSession = automationSessions.get(leaseKey);
+  if (postNavigationSession && tab.windowId !== postNavigationSession.windowId) {
+    console.warn(`[opencli] Tab ${tabId} drifted to window ${tab.windowId} during navigation, moving back to ${postNavigationSession.windowId}`);
+    try {
+      await chrome.tabs.move(tabId, { windowId: postNavigationSession.windowId, index: -1 });
+      tab = await chrome.tabs.get(tabId);
+    } catch (moveErr) {
+      console.warn(`[opencli] Failed to recover drifted tab: ${moveErr}`);
+    }
+  }
+  return pageScopedResult(cmd.id, tabId, { title: tab.title, url: tab.url, timedOut });
+}
+async function handleTabs(cmd, leaseKey) {
+  const session = automationSessions.get(leaseKey);
+  if (session && !session.owned && cmd.op !== "list") {
+    return {
+      id: cmd.id,
+      ok: false,
+      errorCode: "bound_tab_mutation_blocked",
+      error: `Session "${session.session}" is bound to a user tab; tab new/select/close requires an owned OpenCLI session.`,
+      errorHint: "Unbind the session first, or use a different session for owned OpenCLI tabs."
+    };
+  }
+  switch (cmd.op) {
+    case "list": {
+      const tabs = await listAutomationWebTabs(leaseKey);
+      const data = await Promise.all(tabs.map(async (t, i) => {
+        let page;
+        try {
+          page = t.id ? await resolveTargetId(t.id) : void 0;
+        } catch {
+        }
+        return { index: i, page, url: t.url, title: t.title, active: t.active };
+      }));
+      return { id: cmd.id, ok: true, data };
+    }
+    case "new": {
+      if (cmd.url && !isSafeNavigationUrl(cmd.url)) {
+        return { id: cmd.id, ok: false, error: "Blocked URL scheme -- only http:// and https:// are allowed" };
+      }
+      if (!automationSessions.has(leaseKey)) {
+        const created = await createOwnedTabLease(leaseKey, cmd.url);
+        return pageScopedResult(cmd.id, created.tabId, { url: created.tab?.url });
+      }
+      const windowId = await getAutomationWindow(leaseKey);
+      let tab = await chrome.tabs.create({ windowId, url: cmd.url ?? BLANK_PAGE, active: true });
+      const tabId = tab.id;
+      if (!tabId) return { id: cmd.id, ok: false, error: "Failed to create tab" };
+      const group = await ensureOwnedContainerGroup(getOwnedWindowRole(leaseKey), windowId, [tabId]);
+      const sessionWindowId = group?.windowId ?? tab.windowId;
+      if (tab.windowId !== sessionWindowId) tab = await chrome.tabs.get(tabId);
+      setLeaseSession(leaseKey, {
+        session: getSessionFromKey(leaseKey),
+        surface: getSurfaceFromKey(leaseKey),
+        kind: "owned",
+        windowId: sessionWindowId,
+        owned: true,
+        preferredTabId: tabId
+      });
+      resetWindowIdleTimer(leaseKey);
+      return pageScopedResult(cmd.id, tabId, { url: tab.url });
+    }
+    case "close": {
+      if (cmd.index !== void 0) {
+        const tabs = await listAutomationWebTabs(leaseKey);
+        const target = tabs[cmd.index];
+        if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
+        const closedPage2 = await resolveTargetId(target.id).catch(() => void 0);
+        const currentSession2 = automationSessions.get(leaseKey);
+        if (currentSession2?.preferredTabId === target.id) {
+          await releaseLease(leaseKey, "tab close");
+        } else {
+          await safeDetach(target.id);
+          await chrome.tabs.remove(target.id);
+        }
+        return { id: cmd.id, ok: true, data: { closed: closedPage2 } };
+      }
+      if (cmd.page !== void 0 && session?.owned) {
+        let tabId2;
+        try {
+          tabId2 = await resolveCommandTabId(cmd);
+        } catch {
+          return { id: cmd.id, ok: false, error: `Page no longer exists` };
+        }
+        if (tabId2 === void 0) {
+          return { id: cmd.id, ok: false, error: `Page no longer exists` };
+        }
+        let tab;
+        try {
+          tab = await chrome.tabs.get(tabId2);
+        } catch {
+          return { id: cmd.id, ok: false, error: `Page no longer exists` };
+        }
+        if (tab.windowId !== session.windowId) {
+          return { id: cmd.id, ok: false, error: `Page is not in the automation container` };
+        }
+        const closedPage2 = await resolveTargetId(tabId2).catch(() => void 0);
+        if (session.preferredTabId === tabId2) {
+          await releaseLease(leaseKey, "tab close");
+        } else {
+          await safeDetach(tabId2);
+          await chrome.tabs.remove(tabId2);
+        }
+        return { id: cmd.id, ok: true, data: { closed: closedPage2 } };
+      }
+      const cmdTabId = await resolveCommandTabId(cmd);
+      const tabId = await resolveTabId(cmdTabId, leaseKey);
+      const closedPage = await resolveTargetId(tabId).catch(() => void 0);
+      const currentSession = automationSessions.get(leaseKey);
+      if (currentSession?.preferredTabId === tabId) {
+        await releaseLease(leaseKey, "tab close");
+      } else {
+        await safeDetach(tabId);
+        await chrome.tabs.remove(tabId);
+      }
+      return { id: cmd.id, ok: true, data: { closed: closedPage } };
+    }
+    case "select": {
+      if (cmd.index === void 0 && cmd.page === void 0)
+        return { id: cmd.id, ok: false, error: "Missing index or page" };
+      const cmdTabId = await resolveCommandTabId(cmd);
+      if (cmdTabId !== void 0) {
+        const session2 = automationSessions.get(leaseKey);
+        let tab;
+        try {
+          tab = await chrome.tabs.get(cmdTabId);
+        } catch {
+          return { id: cmd.id, ok: false, error: `Page no longer exists` };
+        }
+        if (!session2 || tab.windowId !== session2.windowId) {
+          return { id: cmd.id, ok: false, error: `Page is not in the automation container` };
+        }
+        await chrome.tabs.update(cmdTabId, { active: true });
+        preferOwnedTab(leaseKey, cmdTabId);
+        return pageScopedResult(cmd.id, cmdTabId, { selected: true });
+      }
+      const tabs = await listAutomationWebTabs(leaseKey);
+      const target = tabs[cmd.index];
+      if (!target?.id) return { id: cmd.id, ok: false, error: `Tab index ${cmd.index} not found` };
+      await chrome.tabs.update(target.id, { active: true });
+      preferOwnedTab(leaseKey, target.id);
+      return pageScopedResult(cmd.id, target.id, { selected: true });
+    }
+    default:
+      return { id: cmd.id, ok: false, error: `Unknown tabs op: ${cmd.op}` };
+  }
+}
+async function handleCookies(cmd) {
+  if (!cmd.domain && !cmd.url) {
+    return { id: cmd.id, ok: false, error: "Cookie scope required: provide domain or url to avoid dumping all cookies" };
+  }
+  const details = {};
+  if (cmd.domain) details.domain = cmd.domain;
+  if (cmd.url) details.url = cmd.url;
+  const cookies = await chrome.cookies.getAll(details);
+  const data = cookies.map((c) => ({
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    secure: c.secure,
+    httpOnly: c.httpOnly,
+    expirationDate: c.expirationDate
+  }));
+  return { id: cmd.id, ok: true, data };
+}
+async function handleScreenshot(cmd, leaseKey) {
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    const data = await screenshot(tabId, {
+      format: cmd.format,
+      quality: cmd.quality,
+      fullPage: cmd.fullPage,
+      width: cmd.width,
+      height: cmd.height
+    });
+    return pageScopedResult(cmd.id, tabId, data);
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+const CDP_ALLOWLIST = /* @__PURE__ */ new Set([
+  // Agent DOM context
+  "Accessibility.enable",
+  "Accessibility.getFullAXTree",
+  "DOM.enable",
+  "DOM.getDocument",
+  "DOM.getBoxModel",
+  "DOM.getContentQuads",
+  "DOM.focus",
+  "DOM.querySelector",
+  "DOM.querySelectorAll",
+  "DOM.scrollIntoViewIfNeeded",
+  "DOMSnapshot.captureSnapshot",
+  // Native input events
+  "Input.dispatchMouseEvent",
+  "Input.dispatchKeyEvent",
+  "Input.insertText",
+  // Page metrics & screenshots
+  "Page.getLayoutMetrics",
+  "Page.captureScreenshot",
+  "Page.getFrameTree",
+  "Page.handleJavaScriptDialog",
+  // Runtime.enable needed for CDP attach setup (Runtime.evaluate goes through 'exec' action)
+  "Runtime.enable",
+  // Emulation (used by screenshot full-page)
+  "Emulation.setDeviceMetricsOverride",
+  "Emulation.clearDeviceMetricsOverride"
+]);
+async function handleCdp(cmd, leaseKey) {
+  if (!cmd.cdpMethod) return { id: cmd.id, ok: false, error: "Missing cdpMethod" };
+  if (!CDP_ALLOWLIST.has(cmd.cdpMethod)) {
+    return { id: cmd.id, ok: false, error: `CDP method not permitted: ${cmd.cdpMethod}` };
+  }
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    const aggressive = getSurfaceFromKey(leaseKey) === "browser";
+    await ensureAttached(tabId, aggressive);
+    const params = cmd.cdpParams ?? {};
+    const routeFrameId = typeof params.frameId === "string" && params.sessionId === "target" ? params.frameId : void 0;
+    const routeTargetUrl = typeof params.targetUrl === "string" ? params.targetUrl : void 0;
+    const data = routeFrameId ? await sendCommandInFrameTarget(tabId, routeFrameId, cmd.cdpMethod, stripOpenCliFrameRoutingParams(params, true), aggressive, commandCdpTimeoutMs(cmd) ?? 3e4, routeTargetUrl) : await sendDebuggerCommand(
+      { tabId },
+      cmd.cdpMethod,
+      stripOpenCliFrameRoutingParams(params, false),
+      commandCdpTimeoutMs(cmd)
+    );
+    return pageScopedResult(cmd.id, tabId, data);
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+function stripOpenCliFrameRoutingParams(params, stripFrameId) {
+  const { sessionId, frameId, targetUrl, ...rest } = params;
+  if (!stripFrameId && frameId !== void 0) return { ...rest, frameId };
+  return rest;
+}
+async function handleCloseWindow(cmd, leaseKey) {
+  if (cmd.action === "close-owned-tab") {
+    return withLeaseMutation(async () => {
+      if ((activeCommandCounts.get(leaseKey) ?? 0) > 1) {
+        throw new CommandFailure("session_busy", "Cannot close a tab while another command is using this session.");
+      }
+      closingLeases.add(leaseKey);
+      let closingTabId;
+      try {
+        const session = automationSessions.get(leaseKey);
+        if (!session?.owned) {
+          await releaseLease(leaseKey, "explicit close");
+          return { id: cmd.id, ok: true, data: { closed: true, session: getSessionFromKey(leaseKey), tabCleanup: "no-owned-tab" } };
+        }
+        const tabId = session.preferredTabId;
+        if (tabId === null) {
+          throw new CommandFailure("owned_tab_identity_missing", "Cannot close an owned lease without a tab identity.");
+        }
+        if ([...automationSessions.entries()].some(([key, lease]) => key !== leaseKey && lease.preferredTabId === tabId)) {
+          throw new CommandFailure("session_busy", "Another session also uses this tab; release that session before closing it.");
+        }
+        closingTabId = tabId;
+        closingTabs.add(tabId);
+        const tab = await chrome.tabs.get(tabId);
+        if (tab.groupId !== void 0 && tab.groupId !== chrome.tabGroups.TAB_GROUP_ID_NONE) {
+          await chrome.tabs.ungroup(tabId);
+        }
+        await safeDetach(tabId);
+        await chrome.tabs.remove(tabId);
+        evictTab(tabId);
+        await removeLeaseSession(leaseKey);
+        return { id: cmd.id, ok: true, data: { closed: true, session: session.session, tabCleanup: "closed-owned-tab" } };
+      } finally {
+        closingLeases.delete(leaseKey);
+        if (closingTabId !== void 0) closingTabs.delete(closingTabId);
+      }
+    });
+  }
+  const sessionName = automationSessions.get(leaseKey)?.session ?? getSessionFromKey(leaseKey);
+  await releaseLease(leaseKey, "explicit close");
+  return { id: cmd.id, ok: true, data: { closed: true, session: sessionName } };
+}
+async function handleSetFileInput(cmd, leaseKey) {
+  if (!cmd.files || !Array.isArray(cmd.files) || cmd.files.length === 0) {
+    return { id: cmd.id, ok: false, error: "Missing or empty files array" };
+  }
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    await setFileInputFiles(tabId, cmd.files, cmd.selector);
+    return pageScopedResult(cmd.id, tabId, { count: cmd.files.length });
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function handleInsertText(cmd, leaseKey) {
+  if (typeof cmd.text !== "string") {
+    return { id: cmd.id, ok: false, error: "Missing text payload" };
+  }
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    await insertText(tabId, cmd.text);
+    return pageScopedResult(cmd.id, tabId, { inserted: true });
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function handleNetworkCaptureStart(cmd, leaseKey) {
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    await startNetworkCapture(tabId, cmd.pattern);
+    return pageScopedResult(cmd.id, tabId, { started: true });
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function handleNetworkCaptureRead(cmd, leaseKey) {
+  const cmdTabId = await resolveCommandTabId(cmd);
+  const tabId = await resolveTabId(cmdTabId, leaseKey);
+  try {
+    const data = await readNetworkCapture(tabId, cmd.retainIncomplete === true);
+    return pageScopedResult(cmd.id, tabId, data);
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function handleWaitDownload(cmd) {
+  try {
+    const data = await waitForDownload(cmd.pattern ?? "", cmd.timeoutMs ?? 3e4);
+    return { id: cmd.id, ok: true, data };
+  } catch (err) {
+    return errorResult(cmd.id, err);
+  }
+}
+async function releaseLease(leaseKey, reason = "released") {
+  const session = automationSessions.get(leaseKey);
+  if (!session) {
+    sessionOverrides.delete(leaseKey);
+    scheduleIdleAlarm(leaseKey, IDLE_TIMEOUT_NONE);
+    await persistRuntimeState();
+    return;
+  }
+  if (session.idleTimer) clearTimeout(session.idleTimer);
+  scheduleIdleAlarm(leaseKey, IDLE_TIMEOUT_NONE);
+  if (session.owned) {
+    const tabId = session.preferredTabId;
+    if (tabId !== null) {
+      const hasOtherOwnedLease = [...automationSessions.entries()].some(
+        ([otherLease, otherSession]) => otherLease !== leaseKey && otherSession.owned && otherSession.windowId === session.windowId && otherSession.preferredTabId !== null
+      );
+      await safeDetach(tabId);
+      evictTab(tabId);
+      if (hasOtherOwnedLease) {
+        await chrome.tabs.remove(tabId).catch(() => {
+        });
+        console.log(`[opencli] Released owned tab lease ${tabId} (session=${session.session}, surface=${session.surface}, ${reason})`);
+      } else {
+        try {
+          const role = getOwnedWindowRole(leaseKey);
+          const idleUrl = role === "interactive" ? await parkIdleInteractiveTab(tabId, session.windowId) : null;
+          const tab = await chrome.tabs.update(tabId, { url: idleUrl ?? BLANK_PAGE, active: true });
+          const group = await ensureOwnedContainerGroup(getOwnedWindowRole(leaseKey), session.windowId, [tab.id ?? tabId]);
+          if (group) session.windowId = group.windowId;
+          console.log(`[opencli] Released owned tab lease ${tabId} as reusable placeholder (session=${session.session}, surface=${session.surface}, ${reason})`);
+        } catch {
+          await chrome.tabs.remove(tabId).catch(() => {
+          });
+          console.log(`[opencli] Released owned tab lease ${tabId} (session=${session.session}, surface=${session.surface}, ${reason})`);
+        }
+      }
+    } else {
+      console.log(`[opencli] Released legacy owned window lease ${session.windowId} without closing container (session=${session.session}, surface=${session.surface}, ${reason})`);
+    }
+  } else if (session.preferredTabId !== null) {
+    await safeDetach(session.preferredTabId);
+    console.log(`[opencli] Detached borrowed tab lease ${session.preferredTabId} (session=${session.session}, surface=${session.surface}, ${reason})`);
+  }
+  automationSessions.delete(leaseKey);
+  sessionOverrides.delete(leaseKey);
+  await persistRuntimeState();
+}
+async function reconcileTargetLeaseRegistry() {
+  const registry = await readRegistry();
+  interactiveGroupLedger.clear();
+  for (const id of registry.ownedContainers.interactive.groupIds) interactiveGroupLedger.add(id);
+  for (const role of Object.keys(ownedContainers)) {
+    ownedContainers[role].windowId = registry.ownedContainers[role]?.windowId ?? null;
+    const windowId = ownedContainers[role].windowId;
+    if (windowId !== null) {
+      try {
+        await chrome.windows.get(windowId);
+      } catch {
+        ownedContainers[role].windowId = null;
+      }
+    }
+  }
+  automationSessions.clear();
+  for (const [leaseKey, stored] of Object.entries(registry.leases)) {
+    const tabId = stored.preferredTabId;
+    if (tabId === null) continue;
+    try {
+      const tab = await chrome.tabs.get(tabId);
+      if (!isDebuggableUrl(tab.url)) continue;
+      if (stored.lifecycle === "ephemeral" || stored.lifecycle === "persistent" || stored.lifecycle === "pinned") {
+        setSessionOverride(leaseKey, { lifecycle: stored.lifecycle });
+      }
+      const session = makeSession(leaseKey, {
+        session: typeof stored.session === "string" ? stored.session : getSessionFromKey(leaseKey),
+        surface: stored.surface === "adapter" ? "adapter" : getSurfaceFromKey(leaseKey),
+        kind: stored.kind === "bound" || stored.owned === false ? "bound" : "owned",
+        windowId: tab.windowId,
+        owned: stored.owned,
+        preferredTabId: tabId
+      });
+      const timeout = getIdleTimeout(leaseKey);
+      automationSessions.set(leaseKey, {
+        ...session,
+        idleTimer: null,
+        idleDeadlineAt: stored.idleDeadlineAt
+      });
+      if (session.owned) {
+        const role = getOwnedWindowRole(leaseKey);
+        if (ownedContainers[role].windowId === null) ownedContainers[role].windowId = tab.windowId;
+        const group = await ensureOwnedContainerGroup(role, tab.windowId, [tabId]);
+        if (group) {
+          const current = automationSessions.get(leaseKey);
+          if (current) current.windowId = group.windowId;
+        }
+      }
+      const remaining = stored.idleDeadlineAt > 0 ? stored.idleDeadlineAt - Date.now() : timeout;
+      if (timeout > 0) {
+        if (remaining <= 0) {
+          await releaseLease(leaseKey, "reconciled idle expiry");
+        } else {
+          resetWindowIdleTimer(leaseKey, remaining);
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    await ensureOwnedContainerGroup("interactive", null, []);
+  } catch (err) {
+    console.warn(`[opencli] Startup interactive group convergence failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  await persistRuntimeState();
+}
+async function handleBind(cmd, leaseKey) {
+  const existing = automationSessions.get(leaseKey);
+  if (existing?.owned) {
+    await releaseLease(leaseKey, "rebind");
+  }
+  const activeTabs = await chrome.tabs.query({ active: true, lastFocusedWindow: true });
+  const fallbackTabs = await chrome.tabs.query({ lastFocusedWindow: true });
+  const boundTab = activeTabs.find((tab) => isDebuggableUrl(tab.url)) ?? fallbackTabs.find((tab) => isDebuggableUrl(tab.url));
+  if (!boundTab?.id) {
+    return {
+      id: cmd.id,
+      ok: false,
+      errorCode: "bound_tab_not_found",
+      error: "No debuggable tab found in the current window",
+      errorHint: "Focus the target Chrome tab/window, then retry bind."
+    };
+  }
+  const current = automationSessions.get(leaseKey);
+  if (current && !current.owned && current.preferredTabId !== null && current.preferredTabId !== boundTab.id) {
+    await detach(current.preferredTabId).catch(() => {
+    });
+  }
+  setLeaseSession(leaseKey, {
+    session: getSessionFromKey(leaseKey),
+    surface: getSurfaceFromKey(leaseKey),
+    kind: "bound",
+    windowId: boundTab.windowId,
+    owned: false,
+    preferredTabId: boundTab.id
+  });
+  resetWindowIdleTimer(leaseKey);
+  console.log(`[opencli] Session ${getSessionFromKey(leaseKey)} explicitly bound to tab ${boundTab.id} (${boundTab.url})`);
+  return pageScopedResult(cmd.id, boundTab.id, {
+    url: boundTab.url,
+    title: boundTab.title,
+    session: getSessionFromKey(leaseKey)
+  });
+}