@quanta-intellect/vessel-browser 0.1.145 → 0.1.147

package/out/main/index.js

@@ -175,12 +175,32 @@ function sanitizeSidebarDetachedBounds(value) {
     height: Math.max(DETACHED_SIDEBAR_MIN_HEIGHT, Math.round(height))
   };
 }
+const DETACHED_DEVTOOLS_DEFAULT_WIDTH = 920;
+const DETACHED_DEVTOOLS_DEFAULT_HEIGHT = 560;
+const DETACHED_DEVTOOLS_MIN_WIDTH = 520;
+const DETACHED_DEVTOOLS_MIN_HEIGHT = 320;
+function sanitizeDevToolsDetachedBounds(value) {
+  if (!value || typeof value !== "object") return null;
+  const bounds = value;
+  const width = Number(bounds.width);
+  const height = Number(bounds.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  const x = Number(bounds.x);
+  const y = Number(bounds.y);
+  return {
+    ...Number.isFinite(x) ? { x: Math.round(x) } : {},
+    ...Number.isFinite(y) ? { y: Math.round(y) } : {},
+    width: Math.max(DETACHED_DEVTOOLS_MIN_WIDTH, Math.round(width)),
+    height: Math.max(DETACHED_DEVTOOLS_MIN_HEIGHT, Math.round(height))
+  };
+}
 const defaults = {
   defaultUrl: "https://start.duckduckgo.com",
   theme: "dark",
   sidebarPanelMode: "docked",
   sidebarWidth: 400,
   sidebarDetachedBounds: null,
+  devtoolsPanelDetachedBounds: null,
   mcpPort: 3100,
   autoRestoreSession: true,
   clearBookmarksOnLaunch: false,
@@ -222,6 +242,15 @@ const SettingsValueSchemas = {
       height: zod.z.number().int().min(DETACHED_SIDEBAR_MIN_HEIGHT)
     })
   ]),
+  devtoolsPanelDetachedBounds: zod.z.union([
+    zod.z.null(),
+    zod.z.object({
+      x: zod.z.number().optional(),
+      y: zod.z.number().optional(),
+      width: zod.z.number().int().min(DETACHED_DEVTOOLS_MIN_WIDTH),
+      height: zod.z.number().int().min(DETACHED_DEVTOOLS_MIN_HEIGHT)
+    })
+  ]),
   mcpPort: zod.z.number().int().min(1).max(65535),
   autoRestoreSession: zod.z.boolean(),
   clearBookmarksOnLaunch: zod.z.boolean(),
@@ -477,6 +506,9 @@ function loadSettings() {
       sidebarDetachedBounds: sanitizeSidebarDetachedBounds(
         parsed.sidebarDetachedBounds
       ),
+      devtoolsPanelDetachedBounds: sanitizeDevToolsDetachedBounds(
+        parsed.devtoolsPanelDetachedBounds
+      ),
       sourceDoNotAllowList: sanitizeStringList(
         parsed.sourceDoNotAllowList ?? defaults.sourceDoNotAllowList
       ),
@@ -530,6 +562,8 @@ function setSetting(key2, value) {
     settings.sidebarPanelMode = sanitizeSidebarPanelMode(value);
   } else if (key2 === "sidebarDetachedBounds") {
     settings.sidebarDetachedBounds = sanitizeSidebarDetachedBounds(value);
+  } else if (key2 === "devtoolsPanelDetachedBounds") {
+    settings.devtoolsPanelDetachedBounds = sanitizeDevToolsDetachedBounds(value);
   } else if (key2 === "sourceDoNotAllowList") {
     settings.sourceDoNotAllowList = sanitizeStringList(value);
   } else if (key2 === "chatProvider") {
@@ -682,15 +716,6 @@ function loadTrustedAppURL(wc, url) {
   }
   return wc.loadURL(parsed.toString());
 }
-const urlSafety = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  assertPermittedNavigationURL,
-  assertSafeURL,
-  isSafeNavigationURL,
-  loadInternalDataURL,
-  loadPermittedNavigationURL,
-  loadTrustedAppURL
-}, Symbol.toStringTag, { value: "Module" }));
 const MAX_CUSTOM_HISTORY = 50;
 const READER_MODE_DATA_URL_PREFIX = "data:text/html;charset=utf-8,";
 const logger$B = createLogger("Tab");
@@ -2598,6 +2623,9 @@ class DevToolsSession {
   entryCounter = 0;
   // Track in-flight network requests for matching response data
   pendingRequests = /* @__PURE__ */ new Map();
+  // Notified whenever a captured buffer mutates so the DevTools panel can
+  // refresh independent of agent actions (e.g. while a user browses).
+  onCaptureChange = null;
   // Named handlers so we can remove them on detach/destroy (fixes listener leak)
   onDetach = () => {
     this.attached = false;
@@ -2613,6 +2641,27 @@ class DevToolsSession {
   get isAttached() {
     return this.attached;
   }
+  /**
+   * Register a callback invoked whenever a captured console/network/error
+   * entry is added or updated. Used to push live updates to the DevTools
+   * panel while a user browses (not just when an agent acts).
+   */
+  setOnCaptureChange(cb) {
+    this.onCaptureChange = cb;
+  }
+  /**
+   * Enable all capture domains (console, network, errors) in one call.
+   * Idempotent per-domain. Used by the panel-open path so manual browsing is
+   * captured without requiring an agent tool invocation.
+   */
+  async enableCapture() {
+    await this.ensureConsoleDomain();
+    await this.ensureNetworkDomain();
+    await this.ensureErrorCapture();
+  }
+  notifyCaptureChange() {
+    this.onCaptureChange?.();
+  }
   async ensureAttached() {
     if (this.attached) return;
     if (this.attachingPromise) return this.attachingPromise;
@@ -2663,6 +2712,7 @@ class DevToolsSession {
   }
   destroy() {
     this.detach();
+    this.onCaptureChange = null;
     this.consoleBuffer = [];
     this.networkBuffer = [];
     this.errorBuffer = [];
@@ -3120,6 +3170,7 @@ class DevToolsSession {
     if (this.consoleBuffer.length > MAX_CONSOLE_ENTRIES) {
       this.consoleBuffer = this.consoleBuffer.slice(-MAX_CONSOLE_ENTRIES);
     }
+    this.notifyCaptureChange();
   }
   // --- Network events ---
   onNetworkRequest(params) {
@@ -3148,6 +3199,7 @@ class DevToolsSession {
       if (oldest !== void 0) this.pendingRequests.delete(oldest);
     }
     this.pendingRequests.set(requestId, { entry });
+    this.notifyCaptureChange();
   }
   onNetworkResponse(params) {
     const requestId = params.requestId;
@@ -3163,6 +3215,7 @@ class DevToolsSession {
     if (contentLength) {
       pending.entry.contentLength = parseInt(contentLength, 10) || void 0;
     }
+    this.notifyCaptureChange();
   }
   onNetworkFinished(params) {
     const requestId = params.requestId;
@@ -3177,6 +3230,7 @@ class DevToolsSession {
     }
     pending.entry.contentLength = pending.entry.contentLength ?? (params.encodedDataLength || void 0);
     this.pendingRequests.delete(requestId);
+    this.notifyCaptureChange();
   }
   onNetworkFailed(params) {
     const requestId = params.requestId;
@@ -3191,6 +3245,7 @@ class DevToolsSession {
       );
     }
     this.pendingRequests.delete(requestId);
+    this.notifyCaptureChange();
   }
   // --- Error events ---
   onExceptionThrown(params) {
@@ -3217,6 +3272,7 @@ class DevToolsSession {
     if (this.errorBuffer.length > MAX_ERROR_ENTRIES) {
       this.errorBuffer = this.errorBuffer.slice(-MAX_ERROR_ENTRIES);
     }
+    this.notifyCaptureChange();
   }
 }
 function mapConsoleLevel(level) {
@@ -3940,8 +3996,19 @@ const ContentChannels = {
 };
 const DevToolsChannels = {
   DEVTOOLS_PANEL_TOGGLE: "devtools-panel:toggle",
+  DEVTOOLS_PANEL_CLOSE: "devtools-panel:close",
+  DEVTOOLS_PANEL_OPEN_TAB: "devtools-panel:open-tab",
+  DEVTOOLS_PANEL_SELECT_TAB: "devtools-panel:select-tab",
+  DEVTOOLS_PANEL_STATE_GET: "devtools-panel:state-get",
   DEVTOOLS_PANEL_STATE: "devtools-panel:state",
-  DEVTOOLS_PANEL_RESIZE: "devtools-panel:resize"
+  DEVTOOLS_PANEL_RESIZE_START: "devtools-panel:resize-start",
+  DEVTOOLS_PANEL_RESIZE: "devtools-panel:resize",
+  DEVTOOLS_PANEL_RESIZE_COMMIT: "devtools-panel:resize-commit",
+  DEVTOOLS_PANEL_POPOUT: "devtools-panel:popout",
+  DEVTOOLS_PANEL_DOCK: "devtools-panel:dock",
+  DEVTOOLS_PANEL_HOST_STATE_GET: "devtools-panel:host-state-get",
+  DEVTOOLS_PANEL_HOST_STATE: "devtools-panel:host-state",
+  DEVTOOLS_PAGE_MAP_REVEAL: "devtools-panel:page-map:reveal"
 };
 const DownloadChannels = {
   DOWNLOAD_STARTED: "download:started",
@@ -7215,6 +7282,236 @@ function sendSafe(wc, channel, ...args) {
     }
   }
 }
+function closeDetachedViewWindow(state2, host) {
+  const detachedWindow = host.getWindow(state2);
+  if (!detachedWindow) return false;
+  host.setWindow(state2, null);
+  host.setClosing(state2, true);
+  detachedWindow.once("closed", () => {
+    host.setClosing(state2, false);
+  });
+  detachedWindow.close();
+  return true;
+}
+function moveDetachedViewToMainWindow(state2, host) {
+  const view = host.getView(state2);
+  host.getWindow(state2)?.contentView.removeChildView(view);
+  state2.mainWindow.contentView.addChildView(view);
+}
+function createDetachedViewWindow(state2, host) {
+  const detachedWindow = new electron.BaseWindow(host.createWindowOptions(state2));
+  const view = host.getView(state2);
+  state2.mainWindow.contentView.removeChildView(view);
+  detachedWindow.contentView.addChildView(view);
+  host.setWindow(state2, detachedWindow);
+  detachedWindow.on("resize", () => {
+    host.layoutView(state2);
+    host.persistBounds(state2);
+  });
+  detachedWindow.on("move", () => host.persistBounds(state2));
+  detachedWindow.on("close", (event) => {
+    if (host.isClosing(state2)) return;
+    event.preventDefault();
+    host.onNativeClose(state2);
+  });
+  detachedWindow.on("closed", () => {
+    if (host.getWindow(state2) !== detachedWindow) return;
+    host.onUnexpectedClosed(state2, detachedWindow);
+  });
+  return detachedWindow;
+}
+const devToolsDetachedHost = {
+  getWindow: (state2) => state2.devtoolsPanelWindow,
+  setWindow: (state2, window2) => {
+    state2.devtoolsPanelWindow = window2;
+  },
+  isClosing: (state2) => state2.devtoolsPanelWindowClosing,
+  setClosing: (state2, closing) => {
+    state2.devtoolsPanelWindowClosing = closing;
+  },
+  getView: (state2) => state2.devtoolsPanelView
+};
+function setDevToolsPanelMode(state2, mode) {
+  state2.uiState.devtoolsPanelMode = mode;
+}
+function persistDetachedBounds$1(state2) {
+  const devtoolsWindow = state2.devtoolsPanelWindow;
+  if (!devtoolsWindow || devtoolsWindow.isDestroyed()) return;
+  const bounds = devtoolsWindow.getBounds();
+  state2.uiState.devtoolsPanelDetachedBounds = {
+    x: bounds.x,
+    y: bounds.y,
+    width: bounds.width,
+    height: bounds.height
+  };
+  setSetting(
+    "devtoolsPanelDetachedBounds",
+    state2.uiState.devtoolsPanelDetachedBounds
+  );
+}
+function moveDevToolsToMainWindow(state2) {
+  moveDetachedViewToMainWindow(state2, devToolsDetachedHost);
+}
+function isDevToolsPanelDocked(state2) {
+  return state2.uiState.devtoolsPanelMode === "docked";
+}
+function isDevToolsPanelDetached(state2) {
+  return state2.uiState.devtoolsPanelMode === "detached";
+}
+function getDevToolsPanelHostState(state2) {
+  return {
+    open: state2.uiState.devtoolsPanelMode !== "closed",
+    detached: isDevToolsPanelDetached(state2),
+    height: state2.uiState.devtoolsPanelHeight
+  };
+}
+function emitDevToolsPanelHostState(state2) {
+  const panelState = getDevToolsPanelHostState(state2);
+  sendSafe(
+    state2.chromeView.webContents,
+    Channels.DEVTOOLS_PANEL_HOST_STATE,
+    panelState
+  );
+  sendSafe(
+    state2.devtoolsPanelView.webContents,
+    Channels.DEVTOOLS_PANEL_HOST_STATE,
+    panelState
+  );
+  return panelState;
+}
+function closeDetachedDevToolsPanelWindow(state2) {
+  return closeDetachedViewWindow(state2, devToolsDetachedHost);
+}
+function layoutDetachedDevToolsPanel(state2) {
+  if (!state2.devtoolsPanelWindow) return;
+  const [width, height] = state2.devtoolsPanelWindow.getContentSize();
+  state2.devtoolsPanelView.setBounds({ x: 0, y: 0, width, height });
+}
+function toggleDockedDevToolsPanel(state2, hooks) {
+  if (isDevToolsPanelDetached(state2)) {
+    state2.devtoolsPanelWindow?.focus();
+    return getDevToolsPanelHostState(state2);
+  }
+  setDevToolsPanelMode(
+    state2,
+    isDevToolsPanelDocked(state2) ? "closed" : "docked"
+  );
+  hooks.relayout();
+  return emitDevToolsPanelHostState(state2);
+}
+function resizeDockedDevToolsPanel(state2, height, relayout) {
+  state2.uiState.devtoolsPanelHeight = Math.round(height);
+  if (isDevToolsPanelDocked(state2)) {
+    relayout();
+  }
+  return emitDevToolsPanelHostState(state2);
+}
+function detachDevToolsPanel(state2, hooks) {
+  if (state2.devtoolsPanelWindow) {
+    state2.devtoolsPanelWindow.focus();
+    return getDevToolsPanelHostState(state2);
+  }
+  const detachedBounds = state2.uiState.devtoolsPanelDetachedBounds;
+  const devtoolsWindow = createDetachedViewWindow(state2, {
+    ...devToolsDetachedHost,
+    createWindowOptions: () => ({
+      ...typeof detachedBounds?.x === "number" ? { x: detachedBounds.x } : {},
+      ...typeof detachedBounds?.y === "number" ? { y: detachedBounds.y } : {},
+      width: Math.max(
+        DETACHED_DEVTOOLS_MIN_WIDTH,
+        Math.round(detachedBounds?.width ?? DETACHED_DEVTOOLS_DEFAULT_WIDTH)
+      ),
+      height: Math.max(
+        DETACHED_DEVTOOLS_MIN_HEIGHT,
+        Math.round(detachedBounds?.height ?? DETACHED_DEVTOOLS_DEFAULT_HEIGHT)
+      ),
+      minWidth: DETACHED_DEVTOOLS_MIN_WIDTH,
+      minHeight: DETACHED_DEVTOOLS_MIN_HEIGHT,
+      frame: true,
+      show: false,
+      backgroundColor: "#1a1a1e",
+      title: "Vessel DevTools",
+      icon: hooks.getWindowIconPath()
+    }),
+    layoutView: layoutDetachedDevToolsPanel,
+    persistBounds: persistDetachedBounds$1,
+    onNativeClose: () => dockDevToolsPanel(state2, hooks),
+    onUnexpectedClosed: () => {
+      state2.devtoolsPanelWindow = null;
+      setDevToolsPanelMode(state2, "docked");
+      state2.mainWindow.contentView.addChildView(state2.devtoolsPanelView);
+      hooks.relayout();
+      emitDevToolsPanelHostState(state2);
+    }
+  });
+  setDevToolsPanelMode(state2, "detached");
+  hooks.relayout();
+  layoutDetachedDevToolsPanel(state2);
+  devtoolsWindow.show();
+  devtoolsWindow.focus();
+  return emitDevToolsPanelHostState(state2);
+}
+function dockDevToolsPanel(state2, hooks) {
+  const devtoolsWindow = state2.devtoolsPanelWindow;
+  setDevToolsPanelMode(state2, "docked");
+  if (devtoolsWindow) {
+    moveDevToolsToMainWindow(state2);
+    hooks.relayout();
+    closeDetachedDevToolsPanelWindow(state2);
+    state2.mainWindow.focus();
+  } else {
+    hooks.relayout();
+  }
+  return emitDevToolsPanelHostState(state2);
+}
+function closeDevToolsPanel(state2, hooks) {
+  if (state2.devtoolsPanelWindow) {
+    moveDevToolsToMainWindow(state2);
+    closeDetachedDevToolsPanelWindow(state2);
+  }
+  setDevToolsPanelMode(state2, "closed");
+  hooks.relayout();
+  return emitDevToolsPanelHostState(state2);
+}
+function registerDisabledDevToolsPanelHandlers(ipc) {
+  const disabledDevToolsState = {
+    open: false,
+    detached: false,
+    height: 0
+  };
+  const disabledPanelState = {
+    console: [],
+    network: [],
+    errors: [],
+    activity: [],
+    agentTrace: [],
+    pageMap: null
+  };
+  ipc.handle(Channels.DEVTOOLS_PANEL_TOGGLE, () => disabledDevToolsState);
+  ipc.handle(Channels.DEVTOOLS_PANEL_CLOSE, () => disabledDevToolsState);
+  ipc.handle(Channels.DEVTOOLS_PANEL_OPEN_TAB, () => disabledDevToolsState);
+  ipc.handle(Channels.DEVTOOLS_PANEL_STATE_GET, () => disabledPanelState);
+  ipc.handle(Channels.DEVTOOLS_PANEL_RESIZE_START, () => void 0);
+  ipc.handle(Channels.DEVTOOLS_PANEL_RESIZE, () => 0);
+  ipc.handle(Channels.DEVTOOLS_PANEL_RESIZE_COMMIT, () => void 0);
+  ipc.handle(Channels.DEVTOOLS_PANEL_POPOUT, () => disabledDevToolsState);
+  ipc.handle(Channels.DEVTOOLS_PANEL_DOCK, () => disabledDevToolsState);
+  ipc.handle(
+    Channels.DEVTOOLS_PANEL_HOST_STATE_GET,
+    () => disabledDevToolsState
+  );
+}
+const sidebarDetachedHost = {
+  getWindow: (state2) => state2.sidebarWindow,
+  setWindow: (state2, window2) => {
+    state2.sidebarWindow = window2;
+  },
+  isClosing: (state2) => state2.sidebarWindowClosing,
+  setClosing: (state2, closing) => {
+    state2.sidebarWindowClosing = closing;
+  },
+  getView: (state2) => state2.sidebarView
+};
 function setSidebarPanelMode(state2, mode, reason = "user") {
   state2.uiState.sidebarPanelMode = mode;
   if (reason === "user") {
@@ -7234,19 +7531,10 @@ function persistDetachedBounds(state2) {
   setSetting("sidebarDetachedBounds", state2.uiState.sidebarDetachedBounds);
 }
 function closeDetachedSidebarWindow(state2) {
-  const sidebarWindow = state2.sidebarWindow;
-  if (!sidebarWindow) return false;
-  state2.sidebarWindow = null;
-  state2.sidebarWindowClosing = true;
-  sidebarWindow.once("closed", () => {
-    state2.sidebarWindowClosing = false;
-  });
-  sidebarWindow.close();
-  return true;
+  return closeDetachedViewWindow(state2, sidebarDetachedHost);
 }
 function moveSidebarToMainWindow(state2) {
-  state2.sidebarWindow?.contentView.removeChildView(state2.sidebarView);
-  state2.mainWindow.contentView.addChildView(state2.sidebarView);
+  moveDetachedViewToMainWindow(state2, sidebarDetachedHost);
 }
 function getSidebarPanelState(state2) {
   return {
@@ -7306,41 +7594,33 @@ function detachSidebar(state2, hooks) {
   const detachedBounds = state2.uiState.sidebarDetachedBounds;
   const detachedWidth = detachedBounds?.width ?? Math.max(DETACHED_SIDEBAR_DEFAULT_WIDTH, state2.uiState.sidebarWidth);
   const detachedHeight = detachedBounds?.height ?? DETACHED_SIDEBAR_DEFAULT_HEIGHT;
-  const sidebarWindow = new electron.BaseWindow({
-    ...typeof detachedBounds?.x === "number" ? { x: detachedBounds.x } : {},
-    ...typeof detachedBounds?.y === "number" ? { y: detachedBounds.y } : {},
-    width: Math.max(DETACHED_SIDEBAR_MIN_WIDTH, Math.round(detachedWidth)),
-    height: Math.max(DETACHED_SIDEBAR_MIN_HEIGHT, Math.round(detachedHeight)),
-    minWidth: DETACHED_SIDEBAR_MIN_WIDTH,
-    minHeight: DETACHED_SIDEBAR_MIN_HEIGHT,
-    frame: true,
-    show: false,
-    backgroundColor: "#1a1a1e",
-    title: "Vessel Agent",
-    icon: hooks.getWindowIconPath()
+  const sidebarWindow = createDetachedViewWindow(state2, {
+    ...sidebarDetachedHost,
+    createWindowOptions: () => ({
+      ...typeof detachedBounds?.x === "number" ? { x: detachedBounds.x } : {},
+      ...typeof detachedBounds?.y === "number" ? { y: detachedBounds.y } : {},
+      width: Math.max(DETACHED_SIDEBAR_MIN_WIDTH, Math.round(detachedWidth)),
+      height: Math.max(DETACHED_SIDEBAR_MIN_HEIGHT, Math.round(detachedHeight)),
+      minWidth: DETACHED_SIDEBAR_MIN_WIDTH,
+      minHeight: DETACHED_SIDEBAR_MIN_HEIGHT,
+      frame: true,
+      show: false,
+      backgroundColor: "#1a1a1e",
+      title: "Vessel Agent",
+      icon: hooks.getWindowIconPath()
+    }),
+    layoutView: layoutDetachedSidebar,
+    persistBounds: persistDetachedBounds,
+    onNativeClose: () => dockSidebar(state2, hooks),
+    onUnexpectedClosed: () => {
+      state2.sidebarWindow = null;
+      setSidebarPanelMode(state2, "docked");
+      state2.mainWindow.contentView.addChildView(state2.sidebarView);
+      hooks.relayout();
+      emitSidebarPanelState(state2);
+    }
   });
-  state2.mainWindow.contentView.removeChildView(state2.sidebarView);
-  sidebarWindow.contentView.addChildView(state2.sidebarView);
-  state2.sidebarWindow = sidebarWindow;
   setSidebarPanelMode(state2, "detached");
-  sidebarWindow.on("resize", () => {
-    layoutDetachedSidebar(state2);
-    persistDetachedBounds(state2);
-  });
-  sidebarWindow.on("move", () => persistDetachedBounds(state2));
-  sidebarWindow.on("close", (event) => {
-    if (state2.sidebarWindowClosing) return;
-    event.preventDefault();
-    dockSidebar(state2, hooks);
-  });
-  sidebarWindow.on("closed", () => {
-    if (state2.sidebarWindow !== sidebarWindow) return;
-    state2.sidebarWindow = null;
-    setSidebarPanelMode(state2, "docked");
-    state2.mainWindow.contentView.addChildView(state2.sidebarView);
-    hooks.relayout();
-    emitSidebarPanelState(state2);
-  });
   hooks.relayout();
   layoutDetachedSidebar(state2);
   sidebarWindow.show();
@@ -7563,8 +7843,9 @@ function createMainWindow(onTabStateChange) {
     sidebarDetachedBounds: settings2.sidebarDetachedBounds,
     focusMode: false,
     settingsOpen: false,
-    devtoolsPanelOpen: false,
-    devtoolsPanelHeight: DEFAULT_DEVTOOLS_PANEL_HEIGHT
+    devtoolsPanelMode: "closed",
+    devtoolsPanelHeight: DEFAULT_DEVTOOLS_PANEL_HEIGHT,
+    devtoolsPanelDetachedBounds: settings2.devtoolsPanelDetachedBounds
   };
   const tabManager = new TabManager(mainWindow, onTabStateChange);
   const sendToRendererViews = (channel, ...args) => {
@@ -7580,6 +7861,8 @@ function createMainWindow(onTabStateChange) {
     mainWindow,
     sidebarWindow: null,
     sidebarWindowClosing: false,
+    devtoolsPanelWindow: null,
+    devtoolsPanelWindowClosing: false,
     chromeView,
     sidebarView,
     devtoolsPanelView,
@@ -7591,6 +7874,7 @@ function createMainWindow(onTabStateChange) {
   mainWindow.on("focus", () => layoutViews(state2));
   mainWindow.on("closed", () => {
     closeDetachedSidebarWindow(state2);
+    closeDetachedDevToolsPanelWindow(state2);
   });
   sidebarView.webContents.on("context-menu", (event, params) => {
     event.preventDefault();
@@ -7619,7 +7903,9 @@ function layoutViews(state2) {
   const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
   const sidebarAttached = isSidebarAttached(state2);
   const sidebarWidth = sidebarAttached ? uiState.sidebarWidth : 0;
-  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
+  const devtoolsDocked = isDevToolsPanelDocked(state2);
+  const devtoolsDetached = isDevToolsPanelDetached(state2);
+  const devtoolsHeight = devtoolsDocked ? uiState.devtoolsPanelHeight : 0;
   const chromeNeedsFullHeight = uiState.settingsOpen;
   if (chromeNeedsFullHeight) {
     chromeView.setBounds({ x: 0, y: 0, width, height });
@@ -7637,14 +7923,14 @@ function layoutViews(state2) {
     sidebarView.setBounds({ x: width, y: 0, width: 0, height: 0 });
   }
   const contentWidth = width - sidebarWidth;
-  if (uiState.devtoolsPanelOpen) {
+  if (devtoolsDocked) {
     devtoolsPanelView.setBounds({
       x: 0,
       y: height - devtoolsHeight,
       width: contentWidth,
       height: devtoolsHeight
     });
-  } else {
+  } else if (!devtoolsDetached) {
     devtoolsPanelView.setBounds({ x: 0, y: height, width: 0, height: 0 });
   }
   mainWindow.contentView.removeChildView(chromeView);
@@ -7653,8 +7939,10 @@ function layoutViews(state2) {
     mainWindow.contentView.removeChildView(sidebarView);
     mainWindow.contentView.addChildView(sidebarView);
   }
-  mainWindow.contentView.removeChildView(devtoolsPanelView);
-  mainWindow.contentView.addChildView(devtoolsPanelView);
+  if (!devtoolsDetached) {
+    mainWindow.contentView.removeChildView(devtoolsPanelView);
+    mainWindow.contentView.addChildView(devtoolsPanelView);
+  }
   const activeTab = tabManager.getActiveTab();
   if (activeTab) {
     activeTab.view.setBounds({
@@ -7670,7 +7958,8 @@ function resizeSidebarViews(state2) {
   const [width, height] = mainWindow.getContentSize();
   const chromeHeight = uiState.focusMode ? 0 : CHROME_HEIGHT;
   const sidebarWidth = isSidebarAttached(state2) ? uiState.sidebarWidth : 0;
-  const devtoolsHeight = uiState.devtoolsPanelOpen ? uiState.devtoolsPanelHeight : 0;
+  const devtoolsDocked = isDevToolsPanelDocked(state2);
+  const devtoolsHeight = devtoolsDocked ? uiState.devtoolsPanelHeight : 0;
   const contentWidth = width - sidebarWidth;
   if (uiState.sidebarPanelMode !== "detached") {
     sidebarView.setBounds({
@@ -7680,7 +7969,7 @@ function resizeSidebarViews(state2) {
       height: height - chromeHeight
     });
   }
-  if (uiState.devtoolsPanelOpen) {
+  if (devtoolsDocked) {
     devtoolsPanelView.setBounds({
       x: 0,
       y: height - devtoolsHeight,
@@ -7806,6 +8095,96 @@ function isClickReadLoop(names) {
   }
   return clickReadPairs >= 2;
 }
+const CLICK_READ_LOOP_SUPPRESS_THRESHOLD = 3;
+function classifyClickFailure(output) {
+  if (/Error\[hidden\]/i.test(output)) return "hidden";
+  if (/Error\[stale-index\]/i.test(output)) return "stale";
+  if (/^\s*Error:/i.test(output)) return "other";
+  return null;
+}
+function buildClickReadLoopIntervention(strikes, lastClickFailureKind) {
+  if (strikes <= 0) return null;
+  if (strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+    const lines = [
+      `Error: Suppressed repeated click — you have alternated click and read_page ${strikes} times without making progress and the clicks are not landing.`,
+      `Stop calling click. Instead do one of: scroll (scroll or scroll_to_element) to load more of the page then read_page to refresh, inspect_element on a specific indexed result, or answer from the results already visible in the conversation.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The last click target was hidden / not laid out — scrolling toward it first usually reveals it.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The last click target was stale — refresh page state with read_page and choose a currently listed target before clicking again.`
+      );
+    }
+    return { kind: "suppress", message: lines.join("\n") };
+  }
+  if (strikes >= 2) {
+    const lines = [
+      `[System] You are alternating between click and read_page without advancing the task, and the last click did not complete.`,
+      `The click result already includes a page snapshot, so do not read_page after every click.`
+    ];
+    if (lastClickFailureKind === "hidden") {
+      lines.push(
+        `The click failed on a hidden element — call scroll (scroll or scroll_to_element) to reveal it, then read_page to refresh visible elements, before clicking again.`
+      );
+    } else if (lastClickFailureKind === "stale") {
+      lines.push(
+        `The click failed on a stale element index — call read_page to refresh current indexes before clicking again.`
+      );
+    } else {
+      lines.push(
+        `If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+      );
+    }
+    return { kind: "nudge", message: lines.join("\n") };
+  }
+  return {
+    kind: "nudge",
+    message: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
+  };
+}
+class ClickReadLoopGuard {
+  recentToolNames = [];
+  strikes = 0;
+  lastClickFailureKind = null;
+  beforeTool(toolName) {
+    if (toolName === "click" && this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD && isClickReadLoop(this.recentToolNames)) {
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+  afterToolResult(toolName, output, succeeded) {
+    if (toolName === "click") {
+      this.lastClickFailureKind = succeeded ? null : classifyClickFailure(output);
+    }
+    this.recentToolNames.push(toolName);
+    if (this.recentToolNames.length > 8) this.recentToolNames.shift();
+    if (toolName === "click" && succeeded) {
+      this.strikes = 0;
+      return null;
+    }
+    if (toolName !== "click" && toolName !== "read_page") {
+      this.strikes = 0;
+      return null;
+    }
+    if (isClickReadLoop(this.recentToolNames) && this.lastClickFailureKind) {
+      this.strikes += 1;
+      if (this.strikes >= CLICK_READ_LOOP_SUPPRESS_THRESHOLD) {
+        return null;
+      }
+      return buildClickReadLoopIntervention(
+        this.strikes,
+        this.lastClickFailureKind
+      );
+    }
+    return null;
+  }
+}
 const TERMINAL_TOOL_RESULT = "__VESSEL_TERMINAL_TOOL_RESULT__";
 const logger$w = createLogger("PromptCache");
 function shortHash(value) {
@@ -7966,8 +8345,7 @@ class AnthropicProvider {
     try {
       const maxIterations = getEffectiveMaxIterations();
       let iterationsUsed = 0;
-      const recentToolNames = [];
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         const stream = this.client.messages.stream(
@@ -8074,6 +8452,7 @@ class AnthropicProvider {
           break;
         }
         const toolResults = [];
+        const loopNudges = [];
         for (const tb of toolUseBlocks) {
           if (tb._malformedArgs !== void 0) {
             onChunk(`
@@ -8087,6 +8466,19 @@ class AnthropicProvider {
             });
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tb.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            toolResults.push({
+              type: "tool_result",
+              tool_use_id: tb.id,
+              content: clickLoopPreflight.message,
+              is_error: true
+            });
+            continue;
+          }
           const argSummary = [tb.input.url, tb.input.query, tb.input.text, tb.input.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tb.name}${argSummary ? ":" + argSummary : ""}>>
@@ -8101,6 +8493,7 @@ class AnthropicProvider {
           if (result === TERMINAL_TOOL_RESULT) {
             return;
           }
+          const toolSucceeded = !/^Error:/i.test(result.trim());
           let parsedRich = null;
           try {
             const parsed = JSON.parse(result);
@@ -8132,16 +8525,18 @@ class AnthropicProvider {
               content: result
             });
           }
-          recentToolNames.push(tb.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tb.name,
+            result,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
+            loopNudges.push(clickLoopIntervention.message);
+          }
         }
         messages.push({ role: "user", content: toolResults });
-        if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-          clickReadLoopNudged = true;
-          messages.push({
-            role: "user",
-            content: `You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
-          });
+        for (const nudge of loopNudges) {
+          messages.push({ role: "user", content: nudge });
         }
       }
       if (iterationsUsed >= maxIterations) {
@@ -9432,10 +9827,9 @@ class OpenAICompatProvider {
       let highlightCompletionRecoveryCount = 0;
       let compactCorrectionCount = 0;
       const recentCompactToolSignatures = [];
-      const recentToolNames = [];
       const successfulToolNames = [];
       const searchLoopGuard = new SearchLoopGuard(isSearchContextResettingTool);
-      let clickReadLoopNudged = false;
+      const clickReadLoopGuard = new ClickReadLoopGuard();
       for (let i = 0; i < maxIterations; i++) {
         iterationsUsed = i + 1;
         let textAccum = "";
@@ -9725,6 +10119,19 @@ class OpenAICompatProvider {
             }
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(tc.name);
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            messages.push({
+              role: "tool",
+              tool_call_id: tc.id,
+              content: clickLoopPreflight.message
+            });
+            compactCorrectionCount += 1;
+            continue;
+          }
           const argSummary = [args.url, args.query, args.text, args.direction].map((v) => typeof v === "string" ? v : "").find((v) => v.length > 0) ?? "";
           onChunk(`
 <<tool:${tc.name}${argSummary ? ":" + argSummary : ""}>>
@@ -9762,15 +10169,11 @@ class OpenAICompatProvider {
             searchToolQuery,
             toolSucceeded
           );
-          recentToolNames.push(tc.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
-          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-            clickReadLoopNudged = true;
-            messages.push({
-              role: "user",
-              content: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates — you do not need read_page after every click. If you need detail on a specific element, use inspect_element instead. If you have enough context, proceed with the next action directly.`
-            });
-          }
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            tc.name,
+            toolContent,
+            toolSucceeded
+          );
           compactCorrectionCount = 0;
           iterationToolResultPreviews.push(toolContent);
           messages.push({
@@ -9778,6 +10181,9 @@ class OpenAICompatProvider {
             tool_call_id: tc.id,
             content: toolContent
           });
+          if (clickLoopIntervention?.kind === "nudge") {
+            messages.push({ role: "user", content: clickLoopIntervention.message });
+          }
         }
         const followUpReminder = followUpReminderForProfile(
           this.agentToolProfile,
@@ -10187,9 +10593,18 @@ function summarizeToolArg(args) {
 function normalizeCodexText(text) {
   return text.trim().toLowerCase().replace(/[‘’]/g, "'").replace(/[“”]/g, '"');
 }
-function looksLikeFailedToolOutput(output) {
+function looksLikeFailedToolOutput(output, toolName) {
   const normalized = normalizeCodexText(output);
-  return normalized.startsWith("error") || normalized.startsWith("warning") || normalized.startsWith("target") || normalized.startsWith("no active tab") || normalized.includes("same page — results may have loaded dynamically") || normalized.includes("could not ") || normalized.includes("did not ");
+  const firstLine = normalized.split(/\n+/).map((line) => line.trim()).find(Boolean) ?? "";
+  if (/^(?:error\b|error\[|blocked\b|warning\b|target\b|no active tab\b|cannot\b|can't\b)/.test(
+    firstLine
+  )) {
+    return true;
+  }
+  if (toolName === "click" && (normalized.includes("page did not change after click") || normalized.includes("element may need a different interaction method"))) {
+    return true;
+  }
+  return toolName === "type_text" && /^(?:could not|did not|no focused|no visible)/.test(firstLine);
 }
 function looksLikeTravelFareContext(text) {
   const normalized = normalizeCodexText(text);
@@ -10197,7 +10612,7 @@ function looksLikeTravelFareContext(text) {
 }
 function emitCodexToolChunk(onChunk, name, args, output) {
   const summary = summarizeToolArg(args);
-  const argSummary = looksLikeFailedToolOutput(output) ? ["⚠ failed", summary].filter(Boolean).join(" ") : summary;
+  const argSummary = looksLikeFailedToolOutput(output, name) ? ["⚠ failed", summary].filter(Boolean).join(" ") : summary;
   onChunk(`
 <<tool:${name}${argSummary ? ":" + argSummary : ""}>>
 `);
@@ -10449,12 +10864,25 @@ function buildCodexFlightPriceEvidenceRecoveryInput(userMessage, assistantText,
     ]
   };
 }
-function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1) {
+function buildCodexFailedClickRecoveryInput(attemptedTarget, latestToolResultPreview, failedClickCount = 1, errorOutput = "") {
   const stateReminder = buildLatestStateReminder(latestToolResultPreview);
+  const clickFailureKind = classifyClickFailure(errorOutput);
   const lines = [
-    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`,
-    `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    `[System] The previous click did not complete${attemptedTarget ? ` for ${attemptedTarget}` : ""}.`
   ];
+  if (clickFailureKind === "hidden") {
+    lines.push(
+      `The click target was hidden / not laid out (collapsed, lazy-loaded, or virtual-scroll). Call scroll or scroll_to_element toward it to reveal it, then read_page to refresh visible elements, before clicking again — or inspect_element on the intended index, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else if (clickFailureKind === "stale") {
+    lines.push(
+      `The click target was stale — the page changed since the last snapshot. Call read_page to refresh current indexes, then choose a currently listed target, inspect_element on the intended element, or answer from the results already visible. Do not ask the user to inspect or click the result for you.`
+    );
+  } else {
+    lines.push(
+      `Take the next step yourself: try a different target, refresh the page state with read_page, call inspect_element on the intended element, or answer from the results already visible in the conversation. Do not ask the user to inspect or click the result for you.`
+    );
+  }
   if (failedClickCount >= 2) {
     lines.push(
       `You have already had multiple failed clicks without making page progress. Do not keep clicking similar search result titles. Use the latest read_page/search result text to answer, or inspect a specific indexed result/control only if essential.`
@@ -10665,8 +11093,7 @@ class CodexProvider {
     let flightPriceEvidenceRecoveryCount = 0;
     let correctionCount = 0;
     const recentToolSignatures = [];
-    const recentToolNames = [];
-    let clickReadLoopNudged = false;
+    const clickReadLoopGuard = new ClickReadLoopGuard();
     let latestToolResultPreview = null;
     let failedClickCountSinceProgress = 0;
     const searchLoopGuard = new SearchLoopGuard(isRealProgressTool);
@@ -10822,6 +11249,22 @@ ${latestToolResultPreview || ""}`
             correctionCount += 1;
             continue;
           }
+          const clickLoopPreflight = clickReadLoopGuard.beforeTool(
+            prepared.prepared.name
+          );
+          if (clickLoopPreflight?.kind === "suppress") {
+            onChunk(`
+<<tool:click:↻ loop suppressed>>
+`);
+            const suppressed = createCodexToolOutput(
+              prepared.prepared.callId,
+              clickLoopPreflight.message
+            );
+            currentInput.push(suppressed);
+            latestToolResultPreview = previewToolResult(suppressed.output);
+            correctionCount += 1;
+            continue;
+          }
           const output = await executePreparedCodexFunctionCall(
             prepared.prepared,
             onChunk,
@@ -10834,7 +11277,10 @@ ${latestToolResultPreview || ""}`
           toolHistoryCount += 1;
           latestToolResultPreview = previewToolResult(output.output);
           const outputText = toolResultTextContent(output.output);
-          const toolSucceeded = !looksLikeFailedToolOutput(outputText);
+          const toolSucceeded = !looksLikeFailedToolOutput(
+            outputText,
+            prepared.prepared.name
+          );
           if (toolSucceeded && isRealProgressTool(prepared.prepared.name)) {
             failedClickCountSinceProgress = 0;
           }
@@ -10843,13 +11289,14 @@ ${latestToolResultPreview || ""}`
             searchToolQuery,
             toolSucceeded
           );
-          if (prepared.prepared.name === "click" && looksLikeFailedToolOutput(outputText)) {
+          if (prepared.prepared.name === "click" && looksLikeFailedToolOutput(outputText, prepared.prepared.name)) {
             failedClickCountSinceProgress += 1;
             currentInput.push(
               buildCodexFailedClickRecoveryInput(
                 summarizeToolArg(prepared.prepared.args),
                 latestToolResultPreview,
-                failedClickCountSinceProgress
+                failedClickCountSinceProgress,
+                outputText
               )
             );
           }
@@ -10857,17 +11304,16 @@ ${latestToolResultPreview || ""}`
           if (recentToolSignatures.length > 4) {
             recentToolSignatures.shift();
           }
-          recentToolNames.push(prepared.prepared.name);
-          if (recentToolNames.length > 8) recentToolNames.shift();
-          if (!clickReadLoopNudged && recentToolNames.length >= 6 && isClickReadLoop(recentToolNames)) {
-            clickReadLoopNudged = true;
+          const clickLoopIntervention = clickReadLoopGuard.afterToolResult(
+            prepared.prepared.name,
+            outputText,
+            toolSucceeded
+          );
+          if (clickLoopIntervention?.kind === "nudge") {
             currentInput.push({
               type: "message",
               role: "user",
-              content: [{
-                type: "input_text",
-                text: `[System] You are alternating between click and read_page without advancing the task. The click result already includes a page snapshot when it navigates, so do not read_page after every click. If you need detail on a specific element, use inspect_element. Otherwise continue the original task directly.`
-              }]
+              content: [{ type: "input_text", text: clickLoopIntervention.message }]
             });
           }
           correctionCount = 0;
@@ -12091,8 +12537,7 @@ function pageBusyError(action) {
   return `Error: Page is still busy; ${action} timed out waiting for page scripts. Retry in a moment.`;
 }
 async function loadPermittedUrl(wc, url) {
-  const { assertPermittedNavigationURL: assertPermittedNavigationURL2 } = await Promise.resolve().then(() => urlSafety);
-  assertPermittedNavigationURL2(url);
+  assertPermittedNavigationURL(url);
   await wc.loadURL(url);
 }
 async function executePageScript(wc, script, options) {
@@ -16432,6 +16877,60 @@ async function clickElement(wc, selector) {
         }));
       }
 
+      // Sum offsetTop up the offsetParent chain until reaching "container",
+      // giving the element's vertical position within that scroll container.
+      function offsetTopWithin(el, container) {
+        let top = 0;
+        let node = el;
+        while (node && node !== container) {
+          top += node.offsetTop || 0;
+          node = node.offsetParent;
+        }
+        return top;
+      }
+
+      function nearestScrollableAncestor(el) {
+        let node = el.parentElement;
+        while (node) {
+          if (node instanceof HTMLElement) {
+            const style = window.getComputedStyle(node);
+            if (
+              (style.overflowY === "auto" || style.overflowY === "scroll") &&
+              node.scrollHeight > node.clientHeight
+            ) {
+              return node;
+            }
+          }
+          node = node.parentElement;
+        }
+        return null;
+      }
+
+      // Wait for the element to gain a non-zero layout box, polling for up to
+      // maxFrames animation frames. Lazy / virtual-scroll renderers
+      // (content-visibility, intersection-triggered list items) often lay out
+      // a frame or two after the scroller moves. Falls back to setTimeout when
+      // the window is hidden (requestAnimationFrame does not fire then).
+      function waitForBox(el, maxFrames) {
+        return new Promise((resolve) => {
+          let frames = 0;
+          const rafAvailable =
+            typeof requestAnimationFrame === "function" &&
+            document.visibilityState === "visible";
+          const schedule = rafAvailable
+            ? (cb) => requestAnimationFrame(cb)
+            : (cb) => setTimeout(cb, 16);
+          const check = () => {
+            const r = el.getBoundingClientRect();
+            if (r.width > 0 && r.height > 0) return resolve(true);
+            if (frames >= maxFrames) return resolve(false);
+            frames += 1;
+            schedule(check);
+          };
+          check();
+        });
+      }
+
       const el = document.querySelector(${JSON.stringify(selector)});
       if (!el) return { error: "Error[stale-index]: Element not found — the page may have changed. Call read_page to refresh." };
 
@@ -16439,21 +16938,26 @@ async function clickElement(wc, selector) {
         el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
       }
 
-      await new Promise((resolve) => {
-        let settled = false;
-        const finish = () => {
-          if (settled) return;
-          settled = true;
-          resolve(undefined);
-        };
-        if (
-          typeof requestAnimationFrame === "function" &&
-          document.visibilityState === "visible"
-        ) {
-          requestAnimationFrame(() => finish());
+      // Give the renderer a brief grace to lay the element out after the
+      // initial scroll. Already-visible elements resolve on the first check.
+      let revealed = await waitForBox(el, 4);
+
+      // scrollIntoView is a no-op on zero-rect elements (collapsed, lazy, or
+      // virtual-scroll content). Force the nearest scrollable ancestor to bring
+      // the element's offset position into view, then wait longer for the
+      // renderer to produce a layout box. This recovers many hidden targets
+      // without the model having to scroll manually.
+      if (!revealed) {
+        const scroller = nearestScrollableAncestor(el);
+        if (scroller) {
+          const targetTop = offsetTopWithin(el, scroller) - scroller.clientHeight / 2;
+          scroller.scrollTop = Math.max(0, targetTop);
         }
-        setTimeout(finish, 32);
-      });
+        if (el instanceof HTMLElement) {
+          el.scrollIntoView({ behavior: "instant", block: "center", inline: "center" });
+        }
+        revealed = await waitForBox(el, 24);
+      }
 
       const rect = el.getBoundingClientRect();
       if (rect.width <= 0 || rect.height <= 0) {
@@ -18016,9 +18520,13 @@ Go back and select a different product.`;
   const clickText = `Clicked: ${elInfo.text}${tagLabel}`;
   const clickResult = await clickElement(wc, selector);
   if (clickResult.startsWith("Error:")) return clickResult;
-  await waitForPotentialNavigation$1(wc, beforeUrl);
+  const initialNavigationWaitMs = /DOM activation/i.test(clickResult) && !elInfo.href ? 800 : void 0;
+  await waitForPotentialNavigation$1(wc, beforeUrl, initialNavigationWaitMs);
   const afterUrl = wc.getURL();
   if (afterUrl !== beforeUrl) {
+    if (/DOM activation/i.test(clickResult)) {
+      return `${clickText} -> ${afterUrl} (recovered via DOM activation)`;
+    }
     return `${clickText} -> ${afterUrl}`;
   }
   const overlayHint = await detectPostClickOverlay(wc);
@@ -18045,6 +18553,9 @@ ${overlayHint}`;
     }
     return `${clickText} (${clickResult})${await buildCartSuccessSuffix(wc, beforeUrl)}`;
   }
+  if (/DOM activation/i.test(clickResult) && (!elInfo.href || elInfo.target === "_blank")) {
+    return `${clickText} (${clickResult})`;
+  }
   const activationResult = await activateElement(wc, selector);
   if (!activationResult.startsWith("Error:")) {
     await waitForPotentialNavigation$1(wc, beforeUrl);
@@ -22777,7 +23288,7 @@ function registerPrivateIpcHandlers(state2) {
   });
   ipc.handle(Channels.FOCUS_MODE_TOGGLE, () => false);
   ipc.handle(Channels.SIDEBAR_TOGGLE, () => ({ open: false, width: 0 }));
-  ipc.handle(Channels.DEVTOOLS_PANEL_TOGGLE, () => ({ open: false }));
+  registerDisabledDevToolsPanelHandlers(ipc);
   ipc.handle(
     Channels.FIND_IN_PAGE_START,
     (_e, text, options) => {
@@ -23041,7 +23552,7 @@ function registerSecondaryIpcHandlers(state2) {
   ipc.handle(Channels.SETTINGS_VISIBILITY, () => false);
   ipc.handle(Channels.FOCUS_MODE_TOGGLE, () => false);
   ipc.handle(Channels.SIDEBAR_TOGGLE, () => ({ open: false, width: 0 }));
-  ipc.handle(Channels.DEVTOOLS_PANEL_TOGGLE, () => ({ open: false }));
+  registerDisabledDevToolsPanelHandlers(ipc);
   ipc.handle(
     Channels.FIND_IN_PAGE_START,
     (_e, text, options) => {
@@ -23847,6 +24358,9 @@ All open tabs: ${allTabs.map((t) => `${t.id === activeTabId ? "→ " : ""}${t.ti
         let isError = false;
         try {
           output = await executeAction(name, args, actionCtx);
+          if (/^\s*Error:/i.test(output)) {
+            isError = true;
+          }
           if (provider.agentToolProfile === "compact") {
             runtime2.updateTaskTracker(name, output);
             const trackerCtx = runtime2.getTaskTrackerContext();
@@ -24571,8 +25085,14 @@ const DANGEROUS_DEVTOOLS_ACTIONS = /* @__PURE__ */ new Set([
 ]);
 let stateListener = null;
 const activityLog = [];
+const agentTraceLog = [];
 const MAX_ACTIVITY_ENTRIES = 100;
+const MAX_TRACE_ENTRIES = 200;
 let activityCounter = 0;
+let traceCounter = 0;
+let latestPageMap = null;
+let pageMapRefreshInFlight = false;
+const traceEntriesByActionId = /* @__PURE__ */ new Map();
 function setDevToolsPanelListener(listener) {
   stateListener = listener;
 }
@@ -24582,14 +25102,325 @@ function getDevToolsPanelState(tabId) {
     console: session?.getConsoleLogs() ?? [],
     network: session?.getNetworkLog() ?? [],
     errors: session?.getErrors() ?? [],
-    activity: activityLog
+    activity: activityLog,
+    agentTrace: agentTraceLog,
+    pageMap: latestPageMap
   };
 }
-function broadcastState(tabManager) {
+function broadcastDevToolsPanelState(tabManager) {
   if (!stateListener) return;
   const tabId = tabManager.getActiveTabId();
   stateListener(getDevToolsPanelState(tabId));
 }
+let panelBroadcastScheduled = false;
+let panelBroadcastTabManager = null;
+let panelCapturedTabId = null;
+const panelOwnedCaptureTabs = /* @__PURE__ */ new Set();
+function schedulePanelBroadcast(tabManager) {
+  panelBroadcastTabManager = tabManager;
+  if (panelBroadcastScheduled) return;
+  panelBroadcastScheduled = true;
+  queueMicrotask(() => {
+    panelBroadcastScheduled = false;
+    if (panelBroadcastTabManager) {
+      broadcastDevToolsPanelState(panelBroadcastTabManager);
+    }
+  });
+}
+function releasePanelCaptureForTab(tabId) {
+  const session = getSession(tabId);
+  session?.setOnCaptureChange(null);
+  if (panelCapturedTabId === tabId) {
+    panelCapturedTabId = null;
+  }
+  if (panelOwnedCaptureTabs.delete(tabId)) {
+    destroySession(tabId);
+  }
+}
+function markActiveSessionToolOwned(tabManager) {
+  const tabId = tabManager.getActiveTabId();
+  if (tabId) {
+    panelOwnedCaptureTabs.delete(tabId);
+  }
+}
+async function enableCaptureForTab(tabManager) {
+  const tabId = tabManager.getActiveTabId();
+  if (!tabId) return;
+  if (panelCapturedTabId && panelCapturedTabId !== tabId) {
+    releasePanelCaptureForTab(panelCapturedTabId);
+  }
+  let session = getSession(tabId);
+  const panelCreatedSession = !session;
+  session ??= getOrCreateSession(tabManager);
+  if (panelCreatedSession) {
+    panelOwnedCaptureTabs.add(tabId);
+  }
+  panelCapturedTabId = tabId;
+  session.setOnCaptureChange(() => {
+    if (panelCapturedTabId === tabId) {
+      schedulePanelBroadcast(tabManager);
+    }
+  });
+  await session.enableCapture();
+  if (panelCapturedTabId === tabId) {
+    broadcastDevToolsPanelState(tabManager);
+  }
+}
+function disableCaptureForTab(tabId) {
+  const targetTabId = panelCapturedTabId;
+  if (targetTabId) {
+    releasePanelCaptureForTab(targetTabId);
+  }
+  {
+    for (const ownedTabId of [...panelOwnedCaptureTabs]) {
+      releasePanelCaptureForTab(ownedTabId);
+    }
+    panelBroadcastTabManager = null;
+  }
+}
+function pushTrace(entry) {
+  const traceEntry = {
+    id: ++traceCounter,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...entry
+  };
+  agentTraceLog.push(traceEntry);
+  if (agentTraceLog.length > MAX_TRACE_ENTRIES) {
+    const removed = agentTraceLog.splice(
+      0,
+      agentTraceLog.length - MAX_TRACE_ENTRIES
+    );
+    for (const trace of removed) {
+      if (trace.actionId) traceEntriesByActionId.delete(trace.actionId);
+    }
+  }
+  return traceEntry;
+}
+function formatTraceActionName(name) {
+  return name.replace(/^devtools_/, "").split(/[_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+function traceDetail(event) {
+  const sourcePrefix = event.source === "ai" ? "Agent" : event.source.toUpperCase();
+  return [sourcePrefix, event.detail].filter(Boolean).join(": ").slice(0, 240);
+}
+function recordDevToolsAgentAction(event, tabManager) {
+  const actionName = formatTraceActionName(event.name);
+  if (event.phase === "started") {
+    const entry = pushTrace({
+      actionId: event.actionId,
+      kind: "tool-start",
+      title: `Started ${actionName}`,
+      detail: traceDetail(event),
+      status: "running",
+      tool: event.name
+    });
+    traceEntriesByActionId.set(event.actionId, entry);
+    broadcastDevToolsPanelState(tabManager);
+    return;
+  }
+  const startEntry = traceEntriesByActionId.get(event.actionId);
+  if (startEntry) {
+    startEntry.status = event.phase === "completed" ? "completed" : "failed";
+    startEntry.durationMs = event.durationMs;
+    if (event.phase === "waiting-approval") {
+      startEntry.status = "running";
+      startEntry.detail = traceDetail(event);
+    }
+  }
+  if (event.phase === "waiting-approval") {
+    broadcastDevToolsPanelState(tabManager);
+    return;
+  }
+  pushTrace({
+    actionId: event.actionId,
+    kind: event.phase === "completed" ? "tool-complete" : "tool-error",
+    title: event.phase === "completed" ? `Completed ${actionName}` : `${event.phase === "rejected" ? "Rejected" : "Failed"} ${actionName}`,
+    detail: traceDetail(event),
+    status: event.phase === "completed" ? "completed" : "failed",
+    tool: event.name,
+    durationMs: event.durationMs
+  });
+  traceEntriesByActionId.delete(event.actionId);
+  broadcastDevToolsPanelState(tabManager);
+}
+const PAGE_MAP_SCRIPT = `
+(() => {
+  const INTERACTIVE_SELECTOR = [
+    "a[href]",
+    "button",
+    "input",
+    "select",
+    "textarea",
+    "summary",
+    "[role='button']",
+    "[role='link']",
+    "[role='checkbox']",
+    "[role='radio']",
+    "[role='switch']",
+    "[role='tab']",
+    "[role='menuitem']",
+    "[contenteditable='true']",
+    "[tabindex]:not([tabindex='-1'])"
+  ].join(",");
+
+  function round(value) {
+    return Math.round(value * 10) / 10;
+  }
+
+  function textFor(el) {
+    const direct =
+      el.getAttribute("aria-label") ||
+      el.getAttribute("title") ||
+      el.getAttribute("placeholder") ||
+      el.getAttribute("alt") ||
+      el.value ||
+      el.innerText ||
+      el.textContent ||
+      "";
+    return String(direct).replace(/\\s+/g, " ").trim().slice(0, 140);
+  }
+
+  function selectorFor(el) {
+    if (el.id) return "#" + CSS.escape(el.id);
+    const parts = [];
+    let node = el;
+    while (node && node.nodeType === Node.ELEMENT_NODE && parts.length < 4) {
+      let part = node.localName;
+      const classes = Array.from(node.classList || []).slice(0, 2);
+      if (classes.length) part += "." + classes.map((c) => CSS.escape(c)).join(".");
+      const parent = node.parentElement;
+      if (parent) {
+        const siblings = Array.from(parent.children).filter((child) => child.localName === node.localName);
+        if (siblings.length > 1) part += ":nth-of-type(" + (siblings.indexOf(node) + 1) + ")";
+      }
+      parts.unshift(part);
+      node = parent;
+    }
+    return parts.join(" > ");
+  }
+
+  function isVisible(el, style, rect) {
+    return rect.width > 0 &&
+      rect.height > 0 &&
+      style.display !== "none" &&
+      style.visibility !== "hidden" &&
+      Number(style.opacity || "1") > 0.01;
+  }
+
+  const viewport = {
+    width: window.innerWidth,
+    height: window.innerHeight,
+    scrollX: window.scrollX,
+    scrollY: window.scrollY,
+  };
+
+  const candidates = Array.from(document.querySelectorAll(INTERACTIVE_SELECTOR));
+  const elements = candidates.slice(0, 120).map((el, index) => {
+    const style = window.getComputedStyle(el);
+    const rect = el.getBoundingClientRect();
+    const visible = isVisible(el, style, rect);
+    const disabled = Boolean(el.disabled) || el.getAttribute("aria-disabled") === "true";
+    const inViewport = rect.bottom >= 0 && rect.right >= 0 && rect.top <= viewport.height && rect.left <= viewport.width;
+    let issue = "";
+    let blocked = false;
+    if (!visible) issue = "hidden";
+    else if (!inViewport) issue = "offscreen";
+    else {
+      const centerX = Math.min(Math.max(rect.left + rect.width / 2, 0), viewport.width - 1);
+      const centerY = Math.min(Math.max(rect.top + rect.height / 2, 0), viewport.height - 1);
+      const top = document.elementFromPoint(centerX, centerY);
+      if (top && top !== el && !el.contains(top)) {
+        blocked = true;
+        issue = "covered by " + top.localName;
+      }
+    }
+    return {
+      id: index + 1,
+      tag: el.localName,
+      role: el.getAttribute("role") || undefined,
+      label: textFor(el) || "(unlabeled)",
+      selector: selectorFor(el),
+      href: el.href || undefined,
+      type: el.type || undefined,
+      visible,
+      interactable: visible && inViewport && !disabled && !blocked,
+      disabled,
+      issue: issue || undefined,
+      bounds: {
+        x: round(rect.x),
+        y: round(rect.y),
+        width: round(rect.width),
+        height: round(rect.height),
+      },
+    };
+  });
+
+  const counts = elements.reduce((acc, element) => {
+    acc.total += 1;
+    if (element.visible) acc.visible += 1;
+    if (element.interactable) acc.interactable += 1;
+    if (element.disabled) acc.disabled += 1;
+    if (element.issue && element.issue.startsWith("covered")) acc.blocked += 1;
+    return acc;
+  }, { total: 0, visible: 0, interactable: 0, disabled: 0, blocked: 0 });
+
+  return {
+    timestamp: new Date().toISOString(),
+    pageUrl: location.href,
+    title: document.title || "",
+    viewport,
+    counts,
+    elements,
+    accessIssues: elements.length === 0 ? ["No obvious interactive elements found."] : [],
+  };
+})()
+`;
+async function capturePageMapSnapshot(tabManager) {
+  const tab = tabManager.getActiveTab();
+  if (!tab || tab.view.webContents.isDestroyed()) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: "",
+      title: "No active tab",
+      viewport: { width: 0, height: 0, scrollX: 0, scrollY: 0 },
+      counts: { total: 0, visible: 0, interactable: 0, disabled: 0, blocked: 0 },
+      elements: [],
+      accessIssues: ["No active tab is available."]
+    };
+  }
+  try {
+    return await tab.view.webContents.executeJavaScript(PAGE_MAP_SCRIPT, true);
+  } catch (error) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pageUrl: tab.view.webContents.getURL(),
+      title: "Page map unavailable",
+      viewport: { width: 0, height: 0, scrollX: 0, scrollY: 0 },
+      counts: { total: 0, visible: 0, interactable: 0, disabled: 0, blocked: 0 },
+      elements: [],
+      accessIssues: [
+        error instanceof Error ? error.message : "Could not inspect active page."
+      ]
+    };
+  }
+}
+async function refreshDevToolsPageMap(tabManager) {
+  if (pageMapRefreshInFlight) {
+    return getDevToolsPanelState(tabManager.getActiveTabId());
+  }
+  pageMapRefreshInFlight = true;
+  try {
+    latestPageMap = await capturePageMapSnapshot(tabManager);
+  } finally {
+    pageMapRefreshInFlight = false;
+  }
+  broadcastDevToolsPanelState(tabManager);
+  return getDevToolsPanelState(tabManager.getActiveTabId());
+}
+function broadcastState(tabManager) {
+  broadcastDevToolsPanelState(tabManager);
+  void refreshDevToolsPageMap(tabManager);
+}
 async function withDevToolsAction(runtime2, tabManager, name, args, executor) {
   try {
     assertFeatureUnlocked("devtools", "DevTools");
@@ -24598,6 +25429,7 @@ async function withDevToolsAction(runtime2, tabManager, name, args, executor) {
       `Error: ${error instanceof Error ? error.message : "DevTools require Vessel Premium."}`
     );
   }
+  markActiveSessionToolOwned(tabManager);
   const activityEntry = {
     id: ++activityCounter,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -30216,6 +31048,76 @@ async function togglePictureInPicture(tabManager) {
     return false;
   }
 }
+const REVEAL_SCRIPT = `
+(function () {
+  var selector = __SELECTOR_JSON__;
+  try {
+    var el = document.querySelector(selector);
+  } catch (e) {
+    return "invalid-selector";
+  }
+  if (!el) return "not-found";
+  try {
+    el.scrollIntoView({ block: "center", behavior: "smooth" });
+  } catch (e) {}
+  var rect = el.getBoundingClientRect();
+  var overlay = document.createElement("div");
+  overlay.setAttribute("data-vessel-devtools-reveal", "");
+  overlay.style.cssText = [
+    "position: fixed",
+    "left: " + rect.left + "px",
+    "top: " + rect.top + "px",
+    "width: " + rect.width + "px",
+    "height: " + rect.height + "px",
+    "box-sizing: border-box",
+    "border: 2px solid #4f8cff",
+    "background: rgba(79, 140, 255, 0.18)",
+    "border-radius: 4px",
+    "pointer-events: none",
+    "z-index: 2147483647",
+    "transition: opacity 250ms ease-out",
+    "opacity: 1",
+  ].join("; ");
+  document.documentElement.appendChild(overlay);
+  var start = performance.now();
+  function track(now) {
+    var r = el.getBoundingClientRect();
+    overlay.style.left = r.left + "px";
+    overlay.style.top = r.top + "px";
+    overlay.style.width = r.width + "px";
+    overlay.style.height = r.height + "px";
+    if (now - start < 1000) {
+      requestAnimationFrame(track);
+    } else {
+      overlay.style.opacity = "0";
+      setTimeout(function () {
+        if (overlay.parentNode) overlay.parentNode.removeChild(overlay);
+      }, 300);
+    }
+  }
+  requestAnimationFrame(track);
+  return "revealed";
+})();
+`;
+async function revealPageMapElement(tabManager, selector) {
+  const tab = tabManager.getActiveTab();
+  if (!tab || tab.view.webContents.isDestroyed()) {
+    return "no-active-tab";
+  }
+  try {
+    const script = REVEAL_SCRIPT.replace(
+      "__SELECTOR_JSON__",
+      JSON.stringify(selector)
+    );
+    const result = await tab.view.webContents.executeJavaScript(script, true);
+    if (result === "revealed" || result === "not-found" || result === "invalid-selector") {
+      return result;
+    }
+    return "revealed";
+  } catch {
+    return "invalid-selector";
+  }
+}
 const VALID_KIT_CATEGORIES = /* @__PURE__ */ new Set([
   "research",
   "shopping",
@@ -30736,21 +31638,177 @@ function stopScheduler() {
 const KitIdSchema = zod.z.string().min(1);
 const SkillSourceSchema = zod.z.string().min(1).max(1e5);
 const OriginSchema = zod.z.string().min(1);
+const DevToolsHeightSchema = zod.z.number().finite().min(0).max(2e3);
+const DevToolsPageMapRevealSchema = zod.z.object({
+  selector: zod.z.string().min(1)
+});
+const DevToolsPanelTabSchema = zod.z.enum([
+  "console",
+  "network",
+  "activity",
+  "agentTrace",
+  "pageMap"
+]);
+const RendererViewSchema = zod.z.enum(["chrome", "sidebar", "devtools"]);
 function registerSystemHandlers(windowState, sendToRendererViews) {
   const { tabManager } = windowState;
+  let devToolsResizeRecoveryTimer = null;
+  let devToolsResizeActive = false;
+  const relayout = () => layoutViews(windowState);
+  const clearDevToolsResizeRecoveryTimer = () => {
+    if (!devToolsResizeRecoveryTimer) return;
+    clearTimeout(devToolsResizeRecoveryTimer);
+    devToolsResizeRecoveryTimer = null;
+  };
+  const stopDevToolsResize = () => {
+    devToolsResizeActive = false;
+    clearDevToolsResizeRecoveryTimer();
+  };
+  const restoreDevToolsLayoutAfterResize = () => {
+    clearDevToolsResizeRecoveryTimer();
+    if (!devToolsResizeActive) return;
+    devToolsResizeActive = false;
+    relayout();
+  };
+  const scheduleDevToolsResizeRecovery = () => {
+    clearDevToolsResizeRecoveryTimer();
+    devToolsResizeRecoveryTimer = setTimeout(() => {
+      restoreDevToolsLayoutAfterResize();
+    }, 1200);
+  };
+  const maxDockedDevToolsHeight = () => {
+    const [, windowHeight] = windowState.mainWindow.getContentSize();
+    const chromeHeight = windowState.uiState.focusMode ? 0 : CHROME_HEIGHT;
+    return Math.max(
+      MIN_DEVTOOLS_PANEL,
+      Math.min(MAX_DEVTOOLS_PANEL, windowHeight - chromeHeight - 80)
+    );
+  };
+  windowState.mainWindow.once("closed", stopDevToolsResize);
   electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_TOGGLE, (event) => {
     assertTrustedIpcSender(event);
-    windowState.uiState.devtoolsPanelOpen = !windowState.uiState.devtoolsPanelOpen;
-    layoutViews(windowState);
-    return { open: windowState.uiState.devtoolsPanelOpen };
+    stopDevToolsResize();
+    const hostState = toggleDockedDevToolsPanel(windowState, { relayout });
+    if (hostState.open) {
+      void enableCaptureForTab(tabManager);
+    } else {
+      disableCaptureForTab();
+    }
+    return hostState;
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_CLOSE, (event) => {
+    assertTrustedIpcSender(event);
+    stopDevToolsResize();
+    const hostState = closeDevToolsPanel(windowState, { relayout });
+    disableCaptureForTab();
+    return hostState;
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_OPEN_TAB, (event, tab) => {
+    assertTrustedIpcSender(event);
+    const selectedTab = parseIpc(DevToolsPanelTabSchema, tab, "tab");
+    stopDevToolsResize();
+    const wasOpen = getDevToolsPanelHostState(windowState).open;
+    if (!wasOpen) {
+      toggleDockedDevToolsPanel(windowState, { relayout });
+      void enableCaptureForTab(tabManager);
+    } else if (getDevToolsPanelHostState(windowState).detached) {
+      windowState.devtoolsPanelWindow?.focus();
+    }
+    emitDevToolsPanelHostState(windowState);
+    sendSafe(
+      windowState.devtoolsPanelView.webContents,
+      Channels.DEVTOOLS_PANEL_SELECT_TAB,
+      selectedTab
+    );
+    if (selectedTab === "pageMap") {
+      void refreshDevToolsPageMap(tabManager);
+    }
+    return getDevToolsPanelHostState(windowState);
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_RESIZE_START, (event) => {
+    assertTrustedIpcSender(event);
+    if (!getDevToolsPanelHostState(windowState).open) return;
+    if (getDevToolsPanelHostState(windowState).detached) return;
+    devToolsResizeActive = true;
+    clearDevToolsResizeRecoveryTimer();
+    const [windowWidth, windowHeight] = windowState.mainWindow.getContentSize();
+    const chromeHeight = windowState.uiState.focusMode ? 0 : CHROME_HEIGHT;
+    const sidebarWidth = isSidebarAttached(windowState) ? windowState.uiState.sidebarWidth : 0;
+    windowState.devtoolsPanelView.setBounds({
+      x: 0,
+      y: chromeHeight,
+      width: windowWidth - sidebarWidth,
+      height: windowHeight - chromeHeight
+    });
+    scheduleDevToolsResizeRecovery();
   });
   electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_RESIZE, (event, height) => {
     assertTrustedIpcSender(event);
-    const clamped = Math.max(MIN_DEVTOOLS_PANEL, Math.min(MAX_DEVTOOLS_PANEL, Math.round(height)));
-    windowState.uiState.devtoolsPanelHeight = clamped;
-    layoutViews(windowState);
+    const validatedHeight = parseIpc(DevToolsHeightSchema, height, "height");
+    const clamped = Math.max(
+      MIN_DEVTOOLS_PANEL,
+      Math.min(maxDockedDevToolsHeight(), Math.round(validatedHeight))
+    );
+    if (devToolsResizeActive) {
+      windowState.uiState.devtoolsPanelHeight = clamped;
+      scheduleDevToolsResizeRecovery();
+      emitDevToolsPanelHostState(windowState);
+      return clamped;
+    }
+    resizeDockedDevToolsPanel(windowState, clamped, relayout);
     return clamped;
   });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_RESIZE_COMMIT, (event) => {
+    assertTrustedIpcSender(event);
+    stopDevToolsResize();
+    relayout();
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_POPOUT, (event) => {
+    assertTrustedIpcSender(event);
+    stopDevToolsResize();
+    return detachDevToolsPanel(windowState, {
+      relayout,
+      getWindowIconPath
+    });
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_DOCK, (event) => {
+    assertTrustedIpcSender(event);
+    stopDevToolsResize();
+    return dockDevToolsPanel(windowState, { relayout });
+  });
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_STATE_GET, async (event) => {
+    assertTrustedIpcSender(event);
+    if (getDevToolsPanelHostState(windowState).open) {
+      void enableCaptureForTab(tabManager);
+    }
+    return await refreshDevToolsPageMap(tabManager);
+  });
+  electron.ipcMain.handle(
+    Channels.DEVTOOLS_PAGE_MAP_REVEAL,
+    async (event, payload) => {
+      assertTrustedIpcSender(event);
+      const { selector } = parseIpc(
+        DevToolsPageMapRevealSchema,
+        payload,
+        "payload"
+      );
+      return await revealPageMapElement(tabManager, selector);
+    }
+  );
+  electron.ipcMain.handle(Channels.DEVTOOLS_PANEL_HOST_STATE_GET, (event) => {
+    assertTrustedIpcSender(event);
+    return getDevToolsPanelHostState(windowState);
+  });
+  electron.ipcMain.on(Channels.RENDERER_VIEW_READY, (event, view) => {
+    assertTrustedIpcSender(event);
+    const readyView = parseIpc(RendererViewSchema, view, "view");
+    if (readyView !== "devtools") return;
+    emitDevToolsPanelHostState(windowState);
+    void refreshDevToolsPageMap(tabManager);
+    if (getDevToolsPanelHostState(windowState).open) {
+      void enableCaptureForTab(tabManager);
+    }
+  });
   electron.ipcMain.handle(Channels.AUTOMATION_GET_INSTALLED, async (event) => {
     assertTrustedIpcSender(event);
     assertFeatureUnlocked("automation_kits", "Skills");
@@ -33140,6 +34198,7 @@ class AgentRuntime {
   tabManager;
   state;
   updateListener = null;
+  actionLifecycleListener = null;
   pendingResolvers = /* @__PURE__ */ new Map();
   undoSnapshots = [];
   mcpUnsubscribe = null;
@@ -33149,6 +34208,9 @@ class AgentRuntime {
       listener(this.getState());
     }
   }
+  setActionLifecycleListener(listener) {
+    this.actionLifecycleListener = listener;
+  }
   /**
    * Release all resources, listeners, and pending promises.
    * Call when the window is closing to prevent memory leaks.
@@ -33167,6 +34229,7 @@ class AgentRuntime {
     this.state.flowState = null;
     this.state.taskTracker = null;
     this.updateListener = null;
+    this.actionLifecycleListener = null;
   }
   getState() {
     const snapshot2 = clone(this.state);
@@ -33471,8 +34534,18 @@ ${progress}
       args,
       tabId
     });
+    const actionStartedAt = Date.now();
     const transcriptStreamId = `action:${action.id}`;
     const transcriptTitle = humanizeActionName(name);
+    this.emitActionLifecycle({
+      actionId: action.id,
+      source,
+      name,
+      args,
+      tabId,
+      phase: "started",
+      detail: summarizeArgs(args)
+    });
     this.publishTranscript({
       source,
       kind: "status",
@@ -33483,6 +34556,16 @@ ${progress}
     });
     const approvalReason = this.getApprovalReason(dangerous, requiresApproval);
     if (approvalReason) {
+      this.emitActionLifecycle({
+        actionId: action.id,
+        source,
+        name,
+        args,
+        tabId,
+        phase: "waiting-approval",
+        detail: approvalReason,
+        durationMs: Date.now() - actionStartedAt
+      });
       this.publishTranscript({
         source,
         kind: "status",
@@ -33493,6 +34576,16 @@ ${progress}
       });
       const approved = await this.awaitApproval(action, approvalReason);
       if (!approved) {
+        this.emitActionLifecycle({
+          actionId: action.id,
+          source,
+          name,
+          args,
+          tabId,
+          phase: "rejected",
+          detail: approvalReason,
+          durationMs: Date.now() - actionStartedAt
+        });
         this.publishTranscript({
           source,
           kind: "status",
@@ -33524,6 +34617,16 @@ ${progress}
         this.pushUndoSnapshot(undoSnapshot);
       }
       this.finishAction(action.id, "completed", summarizeText(result));
+      this.emitActionLifecycle({
+        actionId: action.id,
+        source,
+        name,
+        args,
+        tabId,
+        phase: "completed",
+        detail: summarizeText(result),
+        durationMs: Date.now() - actionStartedAt
+      });
       this.publishTranscript({
         source,
         kind: "status",
@@ -33538,6 +34641,16 @@ ${progress}
       const message = error instanceof Error ? error.message : "Unknown action failure";
       this.state.supervisor.lastError = message;
       this.finishAction(action.id, "failed", void 0, message);
+      this.emitActionLifecycle({
+        actionId: action.id,
+        source,
+        name,
+        args,
+        tabId,
+        phase: "failed",
+        detail: summarizeText(message),
+        durationMs: Date.now() - actionStartedAt
+      });
       this.publishTranscript({
         source,
         kind: "status",
@@ -33549,6 +34662,15 @@ ${progress}
       throw error;
     }
   }
+  emitActionLifecycle(event) {
+    try {
+      this.actionLifecycleListener?.(event);
+    } catch (error) {
+      logger$3.warn("Action lifecycle listener failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   createUndoSnapshot(name) {
     return {
       id: crypto$1.randomUUID(),
@@ -34122,6 +35244,10 @@ async function bootstrap() {
     if (meta.persistSession) {
       runtime?.onTabStateChanged();
     }
+    if (windowState.uiState.devtoolsPanelMode !== "closed") {
+      void enableCaptureForTab(windowState.tabManager);
+      void refreshDevToolsPageMap(windowState.tabManager);
+    }
   });
   windowStateForShutdown = windowState;
   let didRevealMainWindow = false;
@@ -34138,6 +35264,9 @@ async function bootstrap() {
   }, 8e3);
   const { chromeView, sidebarView, devtoolsPanelView, tabManager } = windowState;
   runtime = new AgentRuntime(tabManager);
+  runtime.setActionLifecycleListener((event) => {
+    recordDevToolsAgentAction(event, tabManager);
+  });
   installAdBlocking(tabManager);
   setDevToolsPanelListener((state2) => {
     sendSafe(devtoolsPanelView.webContents, Channels.DEVTOOLS_PANEL_STATE, state2);