@rtrvr-ai/rover 1.0.3 → 1.1.1

package/dist/rover.js

@@ -11107,7 +11107,7 @@ var Bridge = class {
     this.runtimeId = opts.runtimeId;
     this.domainScopeMode = normalizeDomainScopeMode(opts.domainScopeMode);
     this.allowedDomains = normalizeAllowedDomains(opts.allowedDomains, window.location.hostname, this.domainScopeMode);
-    this.externalNavigationPolicy = normalizeExternalNavigationPolicy(opts.externalNavigationPolicy, opts.crossDomainPolicy);
+    this.externalNavigationPolicy = normalizeExternalNavigationPolicy(opts.externalNavigationPolicy);
     this.registerOpenedTab = opts.registerOpenedTab;
     this.listKnownTabs = opts.listKnownTabs;
     this.switchToLogicalTab = opts.switchToLogicalTab;
@@ -11137,8 +11137,8 @@ var Bridge = class {
     if (options.allowedDomains) {
       this.allowedDomains = normalizeAllowedDomains(options.allowedDomains, window.location.hostname, this.domainScopeMode);
     }
-    if (options.externalNavigationPolicy || options.crossDomainPolicy) {
-      this.externalNavigationPolicy = normalizeExternalNavigationPolicy(options.externalNavigationPolicy, options.crossDomainPolicy);
+    if (options.externalNavigationPolicy) {
+      this.externalNavigationPolicy = normalizeExternalNavigationPolicy(options.externalNavigationPolicy);
     }
   }
   async getSnapshot() {
@@ -11465,9 +11465,10 @@ var Bridge = class {
   }
   async openUrlInNewTab(targetUrl, options) {
     const external = !isUrlAllowedByDomains(targetUrl, this.allowedDomains);
-    const popup = window.open(targetUrl, "_blank", "noopener,noreferrer");
+    const knownTabIdsBeforeOpen = this.snapshotKnownTabIds();
+    let popupAttempt = this.openVerifiedPopup(targetUrl);
     let logicalTabId;
-    if (this.registerOpenedTab) {
+    if (popupAttempt.opened && this.registerOpenedTab) {
       try {
         const registered = await this.registerOpenedTab({
           url: targetUrl,
@@ -11479,8 +11480,18 @@ var Bridge = class {
       } catch {
       }
     }
-    const registrationFailed = !logicalTabId && !!this.registerOpenedTab;
-    if (!popup) {
+    if (popupAttempt.opened && !logicalTabId) {
+      logicalTabId = await this.reconcileOpenedTab(targetUrl, knownTabIdsBeforeOpen);
+    }
+    if (!popupAttempt.opened) {
+      const reconciledTabId = await this.reconcileOpenedTab(targetUrl, knownTabIdsBeforeOpen);
+      if (reconciledTabId) {
+        popupAttempt = { opened: true, verified: false };
+        logicalTabId = logicalTabId || reconciledTabId;
+      }
+    }
+    const registrationFailed = popupAttempt.opened && !logicalTabId && !!this.registerOpenedTab;
+    if (!popupAttempt.opened) {
       const reason = "Browser popup settings blocked opening a new tab.";
       if (options?.policyBlocked) {
         this.emitNavigationGuardrail({
@@ -11516,6 +11527,13 @@ var Bridge = class {
         openedInNewTab: true
       });
     }
+    const warningMessages = [];
+    if (registrationFailed) {
+      warningMessages.push("Tab opened but registration failed; tab may not be targetable.");
+    }
+    if (!popupAttempt.verified) {
+      warningMessages.push("Tab open was triggered, but browser did not return a popup handle.");
+    }
     return {
       success: true,
       output: {
@@ -11523,13 +11541,109 @@ var Bridge = class {
         external,
         logicalTabId,
         openedInNewTab: true,
+        openVerification: popupAttempt.verified ? "verified" : "unverified",
         policyBlocked: !!options?.policyBlocked,
         message,
-        ...registrationFailed && { warning: "Tab opened but registration failed \u2014 tab may not be targetable" }
+        ...warningMessages.length ? { warning: warningMessages.join(" ") } : {}
       },
       allowFallback: true
     };
   }
+  openVerifiedPopup(targetUrl) {
+    const popup = window.open("about:blank", "_blank");
+    if (popup) {
+      try {
+        popup.opener = null;
+      } catch {
+      }
+      try {
+        popup.location.href = targetUrl;
+      } catch {
+      }
+      return { opened: true, verified: true };
+    }
+    try {
+      const directPopup = window.open(targetUrl, "_blank");
+      if (directPopup) {
+        try {
+          directPopup.opener = null;
+        } catch {
+        }
+        return { opened: true, verified: true };
+      }
+    } catch {
+    }
+    try {
+      const noOpenerPopup = window.open(targetUrl, "_blank", "noopener,noreferrer");
+      if (noOpenerPopup) {
+        try {
+          noOpenerPopup.opener = null;
+        } catch {
+        }
+        return { opened: true, verified: true };
+      }
+      return { opened: true, verified: false };
+    } catch {
+    }
+    try {
+      const anchor = document.createElement("a");
+      anchor.href = targetUrl;
+      anchor.target = "_blank";
+      anchor.rel = "noopener noreferrer";
+      anchor.style.display = "none";
+      document.body.appendChild(anchor);
+      anchor.click();
+      anchor.remove();
+      return { opened: true, verified: false };
+    } catch {
+      return { opened: false, verified: false };
+    }
+  }
+  snapshotKnownTabIds() {
+    const ids = /* @__PURE__ */ new Set();
+    if (!this.listKnownTabs)
+      return ids;
+    try {
+      const tabs = this.listKnownTabs();
+      for (const tab of tabs) {
+        const logicalTabId = Number(tab?.logicalTabId);
+        if (!Number.isFinite(logicalTabId) || logicalTabId <= 0)
+          continue;
+        ids.add(logicalTabId);
+      }
+    } catch {
+      return ids;
+    }
+    return ids;
+  }
+  async reconcileOpenedTab(targetUrl, beforeIds) {
+    if (!this.listKnownTabs)
+      return void 0;
+    const targetHost = extractHostname(targetUrl);
+    const deadline = Date.now() + 2e3;
+    while (Date.now() < deadline) {
+      try {
+        const knownTabs = this.listKnownTabs();
+        for (const tab of knownTabs) {
+          const logicalTabId = Number(tab?.logicalTabId);
+          if (!Number.isFinite(logicalTabId) || logicalTabId <= 0)
+            continue;
+          if (beforeIds.has(logicalTabId))
+            continue;
+          const knownUrl = String(tab?.url || "").trim();
+          if (!knownUrl)
+            return logicalTabId;
+          const knownHost = extractHostname(knownUrl);
+          if (!targetHost || !knownHost || knownHost === targetHost) {
+            return logicalTabId;
+          }
+        }
+      } catch {
+      }
+      await new Promise((resolve) => setTimeout(resolve, 120));
+    }
+    return void 0;
+  }
   async openElementInNewTab(args) {
     const elementId = args.element_id ?? args.source_element_id ?? args.target_element_id ?? args.center_element_id ?? null;
     if (!elementId) {
@@ -11663,18 +11777,11 @@ function normalizeToolName(name) {
 function normalizeDomainScopeMode(mode) {
   return mode === "host_only" ? "host_only" : "registrable_domain";
 }
-function mapLegacyCrossDomainPolicy(policy) {
-  if (policy === "allow")
-    return "allow";
-  if (policy === "block_new_tab")
-    return "open_new_tab_notice";
-  return void 0;
-}
-function normalizeExternalNavigationPolicy(policy, legacy) {
+function normalizeExternalNavigationPolicy(policy) {
   if (policy === "allow" || policy === "block" || policy === "open_new_tab_notice") {
     return policy;
   }
-  return mapLegacyCrossDomainPolicy(legacy) || "open_new_tab_notice";
+  return "open_new_tab_notice";
 }
 function normalizeAllowedDomains(input, currentHost, scopeMode) {
   const candidates = Array.isArray(input) ? input : [];
@@ -11950,6 +12057,7 @@ function bindRpc(port, handlers) {
 }
 
 // ../ui/dist/mount.js
+var DEFAULT_AGENT_NAME = "Rover";
 var DEFAULT_MASCOT_MP4 = "https://www.rtrvr.ai/rover/mascot.mp4";
 var DEFAULT_MASCOT_WEBM = "https://www.rtrvr.ai/rover/mascot.webm";
 var EXPAND_THRESHOLD_OUTPUT = 280;
@@ -11999,6 +12107,22 @@ function deriveTraceKey(event) {
 function sanitizeText(text) {
   return String(text || "").trim();
 }
+function resolveAgentName(input) {
+  const normalized = String(input || "").trim();
+  if (!normalized)
+    return DEFAULT_AGENT_NAME;
+  return normalized.slice(0, 64);
+}
+function deriveAgentInitial(name) {
+  const normalized = String(name || "").trim();
+  if (!normalized)
+    return "R";
+  return normalized[0].toUpperCase();
+}
+function deriveLauncherToken(name) {
+  const compact = String(name || "").replace(/[^a-zA-Z0-9]/g, "").slice(0, 3).toUpperCase();
+  return compact || "RVR";
+}
 function parseStageFromTitle(title) {
   const clean = sanitizeText(title);
   const match = /^(Analyze|Route|Execute|Verify|Complete):\s*(.*)$/i.exec(clean);
@@ -12174,6 +12298,9 @@ function createExpandableRichContent(text, threshold) {
   return wrapper;
 }
 function mountWidget(opts) {
+  const agentName = resolveAgentName(opts.agent?.name);
+  const agentInitial = deriveAgentInitial(agentName);
+  const launcherToken = deriveLauncherToken(agentName);
   const host = document.createElement("div");
   host.id = "rover-widget-root";
   document.documentElement.appendChild(host);
@@ -13220,7 +13347,7 @@ function mountWidget(opts) {
   wrapper.dataset.mood = "idle";
   const launcher = document.createElement("button");
   launcher.className = "launcher";
-  launcher.setAttribute("aria-label", "Open Rover assistant");
+  launcher.setAttribute("aria-label", `Open ${agentName} assistant`);
   const mascotDisabled = opts.mascot?.disabled === true;
   let launcherVideo = null;
   if (!mascotDisabled) {
@@ -13242,7 +13369,7 @@ function mountWidget(opts) {
   }
   const launcherFallback = document.createElement("span");
   launcherFallback.className = "launcherFallback";
-  launcherFallback.textContent = "RVR";
+  launcherFallback.textContent = launcherToken;
   const launcherShine = document.createElement("div");
   launcherShine.className = "launcherShine";
   launcher.appendChild(launcherFallback);
@@ -13260,13 +13387,13 @@ function mountWidget(opts) {
   }
   const avatarFallback = document.createElement("span");
   avatarFallback.className = "avatarFallback";
-  avatarFallback.textContent = "R";
+  avatarFallback.textContent = agentInitial;
   avatar.appendChild(avatarFallback);
   const meta = document.createElement("div");
   meta.className = "meta";
   const titleEl = document.createElement("div");
   titleEl.className = "title";
-  titleEl.textContent = "Rover";
+  titleEl.textContent = agentName;
   const statusEl = document.createElement("div");
   statusEl.className = "status";
   const statusDot = document.createElement("span");
@@ -13399,7 +13526,7 @@ function mountWidget(opts) {
   composer.className = "composer";
   const composerTextarea = document.createElement("textarea");
   composerTextarea.rows = 1;
-  composerTextarea.placeholder = "Ask Rover to act on this website...";
+  composerTextarea.placeholder = `Ask ${agentName} to act on this website...`;
   composer.appendChild(composerTextarea);
   const sendButton = document.createElement("button");
   sendButton.type = "submit";
@@ -13707,7 +13834,7 @@ function mountWidget(opts) {
     if (mode === "controller") {
       modeBadge.textContent = "active";
       menuTakeControl.style.display = "none";
-      inputEl.placeholder = "Ask Rover to act on this website...";
+      inputEl.placeholder = `Ask ${agentName} to act on this website...`;
     } else {
       modeBadge.textContent = "observer";
       if (executionMeta?.canTakeControl !== false) {
@@ -13720,7 +13847,7 @@ function mountWidget(opts) {
       } else if (canComposeInObserver) {
         inputEl.placeholder = "Send to take control and run here.";
       } else if (executionMeta?.activeLogicalTabId && executionMeta?.localLogicalTabId && executionMeta.activeLogicalTabId !== executionMeta.localLogicalTabId) {
-        inputEl.placeholder = `Observing: Rover is acting in tab #${executionMeta.activeLogicalTabId}`;
+        inputEl.placeholder = `Observing: ${agentName} is acting in tab #${executionMeta.activeLogicalTabId}`;
       } else {
         inputEl.placeholder = "Observer mode. Take control to run actions here.";
       }
@@ -13920,6 +14047,9 @@ function mountWidget(opts) {
 var SHARED_VERSION = 2;
 var SHARED_KEY_PREFIX = "rover:shared:";
 var SHARED_CHANNEL_PREFIX = "rover:channel:";
+var STALE_DETACHED_EXTERNAL_TAB_MS = 2 * 6e4;
+var STALE_DETACHED_TAB_MS = 10 * 6e4;
+var STALE_RUNTIME_TAB_MS = 45e3;
 function now() {
   return Date.now();
 }
@@ -14125,6 +14255,36 @@ var SessionCoordinator = class _SessionCoordinator {
   lastNotifiedRole;
   roleChangeTimer = null;
   static ROLE_CHANGE_DEBOUNCE_MS = 200;
+  pruneDetachedTabs(draft, options) {
+    const dropRuntimeDetached = !!options?.dropRuntimeDetached;
+    const dropAllDetachedExternal = !!options?.dropAllDetachedExternal;
+    const nowMs2 = now();
+    const before = draft.tabs.length;
+    draft.tabs = draft.tabs.filter((tab) => {
+      if (tab.runtimeId) {
+        if (tab.runtimeId === this.runtimeId)
+          return true;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_RUNTIME_TAB_MS;
+      }
+      if (dropRuntimeDetached && tab.openerRuntimeId === this.runtimeId) {
+        return false;
+      }
+      if (tab.external) {
+        if (dropAllDetachedExternal)
+          return false;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+      }
+      return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_TAB_MS;
+    });
+    if (before !== draft.tabs.length) {
+      if (draft.activeLogicalTabId && !draft.tabs.some((tab) => tab.logicalTabId === draft.activeLogicalTabId)) {
+        draft.activeLogicalTabId = this.localLogicalTabId || draft.tabs[0]?.logicalTabId;
+      }
+      if (draft.nextLogicalTabId <= (draft.tabs.at(-1)?.logicalTabId ?? 0)) {
+        draft.nextLogicalTabId = draft.tabs.reduce((max, tab) => Math.max(max, tab.logicalTabId), 0) + 1;
+      }
+    }
+  }
   constructor(options) {
     this.siteId = options.siteId;
     this.sessionId = options.sessionId;
@@ -14144,6 +14304,9 @@ var SessionCoordinator = class _SessionCoordinator {
     if (this.started)
       return;
     this.started = true;
+    this.mutate("local", (draft) => {
+      this.pruneDetachedTabs(draft, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
+    });
     this.registerCurrentTab(window.location.href, document.title || void 0);
     this.claimLease(false);
     if (!this.state.task) {
@@ -14278,10 +14441,27 @@ var SessionCoordinator = class _SessionCoordinator {
   }
   hydrateExternalState(raw) {
     const incoming = sanitizeSharedState(raw, this.siteId, this.sessionId);
+    this.pruneDetachedTabs(incoming, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
     const beforeSeq = this.state.seq;
     const beforeUpdatedAt = this.state.updatedAt;
     this.applyIncomingState(incoming);
-    const changed = this.state.seq !== beforeSeq || this.state.updatedAt !== beforeUpdatedAt;
+    let changed = this.state.seq !== beforeSeq || this.state.updatedAt !== beforeUpdatedAt;
+    if (!changed) {
+      const hasDetachedCandidates = this.state.tabs.some((tab) => {
+        if (tab.runtimeId)
+          return false;
+        if (tab.external)
+          return true;
+        return tab.openerRuntimeId === this.runtimeId;
+      });
+      if (hasDetachedCandidates) {
+        const beforeTabCount = this.state.tabs.length;
+        this.mutate("local", (draft) => {
+          this.pruneDetachedTabs(draft, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
+        });
+        changed = this.state.tabs.length !== beforeTabCount;
+      }
+    }
     if (!changed)
       return false;
     this.persistState();
@@ -14291,7 +14471,23 @@ var SessionCoordinator = class _SessionCoordinator {
     return true;
   }
   listTabs() {
-    return [...this.state.tabs];
+    const nowMs2 = now();
+    return this.state.tabs.filter((tab) => {
+      if (tab.runtimeId) {
+        if (tab.runtimeId === this.runtimeId)
+          return true;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_RUNTIME_TAB_MS;
+      }
+      if (tab.external) {
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+      }
+      return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_TAB_MS;
+    });
+  }
+  pruneTabs(options) {
+    this.mutate("local", (draft) => {
+      this.pruneDetachedTabs(draft, options);
+    });
   }
   startNewTask(task) {
     const startedAt = Number(task.startedAt) || now();
@@ -14312,6 +14508,7 @@ var SessionCoordinator = class _SessionCoordinator {
       draft.uiStatus = void 0;
       draft.activeRun = void 0;
       draft.workerContext = void 0;
+      this.pruneDetachedTabs(draft, { dropAllDetachedExternal: true });
     });
     return nextTask;
   }
@@ -14426,9 +14623,6 @@ var SessionCoordinator = class _SessionCoordinator {
     this.mutate("local", (draft) => {
       if (!activeRun) {
         draft.activeRun = void 0;
-        if (draft.task && draft.task.status === "running") {
-          draft.task.status = "completed";
-        }
         return;
       }
       draft.activeRun = {
@@ -14494,6 +14688,14 @@ var SessionCoordinator = class _SessionCoordinator {
     const normalizedUrl = normalizeUrl2(payload.url);
     let logicalTabId = 0;
     this.mutate("local", (draft) => {
+      const existing = draft.tabs.find((tab) => !tab.runtimeId && !!tab.external && tab.url === normalizedUrl);
+      if (existing) {
+        existing.title = payload.title || existing.title;
+        existing.updatedAt = now();
+        existing.openerRuntimeId = payload.openerRuntimeId || existing.openerRuntimeId;
+        logicalTabId = existing.logicalTabId;
+        return;
+      }
       logicalTabId = draft.nextLogicalTabId++;
       draft.tabs.push({
         logicalTabId,
@@ -14781,6 +14983,7 @@ var SessionCoordinator = class _SessionCoordinator {
       if (draft.workflowLock?.runtimeId === this.runtimeId) {
         draft.workflowLock.expiresAt = now() + this.leaseMs * 5;
       }
+      this.pruneDetachedTabs(draft);
     });
     this.notifyRoleChange();
   }
@@ -14872,6 +15075,7 @@ var SessionCoordinator = class _SessionCoordinator {
       return;
     if (incoming.seq === this.state.seq && incoming.updatedAt <= this.state.updatedAt)
       return;
+    this.pruneDetachedTabs(incoming);
     this.state = incoming;
     this.syncLocalLogicalTabId();
     this.onStateChange?.(this.state, "remote");
@@ -14944,6 +15148,7 @@ var RoverCloudCheckpointClient = class {
   shouldWrite;
   buildCheckpoint;
   onCheckpoint;
+  onStateChange;
   onError;
   started = false;
   dirty = false;
@@ -14955,8 +15160,9 @@ var RoverCloudCheckpointClient = class {
   lastAppliedRemoteUpdatedAt = 0;
   pushInFlight = false;
   pullInFlight = false;
+  state = "active";
   constructor(options) {
-    const token = String(options.apiKey || options.authToken || "").trim();
+    const token = String(options.authToken || options.apiKey || "").trim();
     if (!token) {
       throw toError("Rover cloud checkpoint requires apiKey or authToken.");
     }
@@ -14971,12 +15177,14 @@ var RoverCloudCheckpointClient = class {
     this.shouldWrite = options.shouldWrite || (() => true);
     this.buildCheckpoint = options.buildCheckpoint;
     this.onCheckpoint = options.onCheckpoint;
+    this.onStateChange = options.onStateChange;
     this.onError = options.onError;
   }
   start() {
     if (this.started)
       return;
     this.started = true;
+    this.setState("active");
     this.flushTimer = window.setInterval(() => {
       void this.flush(false);
     }, this.flushIntervalMs);
@@ -15009,6 +15217,8 @@ var RoverCloudCheckpointClient = class {
   async flush(force) {
     if (this.pushInFlight)
       return;
+    if (this.state === "paused_auth")
+      return;
     if (!this.dirty && !force)
       return;
     if (!this.shouldWrite())
@@ -15042,8 +15252,9 @@ var RoverCloudCheckpointClient = class {
         this.applyRemoteCheckpoint(response.checkpoint, "push_stale");
         this.dirty = false;
       }
+      this.setState("active");
     } catch (error) {
-      this.onError?.(error);
+      this.handleCheckpointError(error, "roverSessionCheckpointUpsert");
     } finally {
       this.pushInFlight = false;
     }
@@ -15051,6 +15262,8 @@ var RoverCloudCheckpointClient = class {
   async pull(force) {
     if (this.pullInFlight)
       return;
+    if (this.state === "paused_auth")
+      return;
     if (!force && Date.now() - this.lastPullAt < this.pullIntervalMs)
       return;
     this.pullInFlight = true;
@@ -15063,8 +15276,9 @@ var RoverCloudCheckpointClient = class {
       if (!response?.found || !response?.checkpoint || typeof response.checkpoint !== "object")
         return;
       this.applyRemoteCheckpoint(response.checkpoint, "pull");
+      this.setState("active");
     } catch (error) {
-      this.onError?.(error);
+      this.handleCheckpointError(error, "roverSessionCheckpointGet");
     } finally {
       this.pullInFlight = false;
     }
@@ -15093,14 +15307,68 @@ var RoverCloudCheckpointClient = class {
         const text = await response.text().catch(() => "");
         payload2 = text ? { error: truncateText(text, 2e3) } : void 0;
       }
-      throw toError(`Checkpoint HTTP ${response.status}`, payload2);
+      throw toError(`Checkpoint HTTP ${response.status}`, {
+        action,
+        status: response.status,
+        payload: payload2
+      });
     }
     const payload = await response.json();
     if (payload?.success === false) {
-      throw toError("Checkpoint extensionRouter returned success=false", payload);
+      throw toError("Checkpoint extensionRouter returned success=false", {
+        action,
+        status: response.status,
+        payload
+      });
     }
     return payload?.data;
   }
+  setState(next, context) {
+    if (this.state === next)
+      return;
+    this.state = next;
+    this.onStateChange?.(next, context || {});
+  }
+  handleCheckpointError(error, action) {
+    const details = this.normalizeCheckpointError(error);
+    const isAuthFailure = this.isAuthFailure(details);
+    if (isAuthFailure) {
+      this.setState("paused_auth", {
+        reason: "auth_failed",
+        action,
+        code: details.code,
+        message: details.message
+      });
+    }
+    this.onError?.(error, {
+      action,
+      state: this.state,
+      code: details.code,
+      message: details.message,
+      status: details.status,
+      paused: isAuthFailure
+    });
+  }
+  normalizeCheckpointError(error) {
+    const anyError = error;
+    const details = anyError?.details;
+    const payload = details?.payload || details?.response || details;
+    const candidateCode = payload?.errorCode || payload?.errorDetails?.code || payload?.error?.code || payload?.code;
+    const candidateMessage = payload?.error || payload?.errorDetails?.message || payload?.error?.message || anyError?.message || "Checkpoint request failed";
+    const status = Number(details?.status);
+    return {
+      code: typeof candidateCode === "string" ? candidateCode : void 0,
+      message: truncateText(candidateMessage, 1e3),
+      status: Number.isFinite(status) ? status : void 0
+    };
+  }
+  isAuthFailure(details) {
+    const code = String(details.code || "").toUpperCase();
+    if (code === "INVALID_API_KEY" || code === "MISSING_API_KEY" || code === "UNAUTHENTICATED" || code === "PERMISSION_DENIED") {
+      return true;
+    }
+    return details.status === 401 || details.status === 403;
+  }
 };
 
 // dist/runtimeStorage.js
@@ -15238,9 +15506,11 @@ var MAX_AUTO_RESUME_AGE_MS = 15 * 6e4;
 var MAX_AUTO_RESUME_ATTEMPTS = 12;
 var VISITOR_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 365;
 var CHECKPOINT_PAYLOAD_VERSION = 1;
-var DEFAULT_TASK_INACTIVITY_MS = 5 * 6e4;
-var DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD = 0.18;
-var MAX_RECENT_USER_MESSAGES_FOR_TASK_HEURISTIC = 3;
+var ACTIVE_PENDING_RUN_GRACE_MS = 3e3;
+var STALE_PENDING_RUN_MS = 9e4;
+var TELEMETRY_DEFAULT_FLUSH_INTERVAL_MS = 12e3;
+var TELEMETRY_DEFAULT_MAX_BATCH_SIZE = 30;
+var TELEMETRY_MAX_BUFFER_SIZE = 240;
 var instance = null;
 var bridge = null;
 var worker = null;
@@ -15252,6 +15522,11 @@ var runtimeStateStore = null;
 var runtimeId = "";
 var sessionCoordinator = null;
 var cloudCheckpointClient = null;
+var telemetryFlushTimer = null;
+var telemetryBuffer = [];
+var telemetryInFlight = false;
+var telemetryPausedAuth = false;
+var telemetrySeq = 0;
 var resolvedVisitorId = void 0;
 var suppressCheckpointSync = false;
 var currentMode = "controller";
@@ -15277,6 +15552,7 @@ var RUN_SCOPED_WORKER_MESSAGE_TYPES = /* @__PURE__ */ new Set([
 var pendingToolRegistrations = [];
 var eventHandlers = /* @__PURE__ */ new Map();
 function emit(event, payload) {
+  recordTelemetryEvent(event, payload);
   const handlers = eventHandlers.get(event);
   if (!handlers)
     return;
@@ -15482,6 +15758,240 @@ function safeSerialize(value) {
     }
   }
 }
+function normalizeTelemetryConfig(cfg) {
+  const raw = cfg?.telemetry;
+  const sampleRateRaw = Number(raw?.sampleRate);
+  const sampleRate = Number.isFinite(sampleRateRaw) ? Math.min(1, Math.max(0, sampleRateRaw)) : 1;
+  const flushRaw = Number(raw?.flushIntervalMs);
+  const flushIntervalMs = Number.isFinite(flushRaw) ? Math.min(6e4, Math.max(2e3, Math.floor(flushRaw))) : TELEMETRY_DEFAULT_FLUSH_INTERVAL_MS;
+  const batchRaw = Number(raw?.maxBatchSize);
+  const maxBatchSize = Number.isFinite(batchRaw) ? Math.min(80, Math.max(1, Math.floor(batchRaw))) : TELEMETRY_DEFAULT_MAX_BATCH_SIZE;
+  return {
+    enabled: raw?.enabled !== false,
+    sampleRate,
+    flushIntervalMs,
+    maxBatchSize,
+    includePayloads: raw?.includePayloads === true
+  };
+}
+function canUseTelemetry(cfg) {
+  if (!cfg)
+    return false;
+  const telemetry = normalizeTelemetryConfig(cfg);
+  if (!telemetry.enabled)
+    return false;
+  if (!(cfg.authToken || cfg.apiKey))
+    return false;
+  return true;
+}
+function summarizeTelemetryPayload(payload) {
+  if (payload == null)
+    return void 0;
+  if (typeof payload === "string")
+    return truncateText2(payload, 260);
+  if (typeof payload === "number" || typeof payload === "boolean")
+    return payload;
+  if (Array.isArray(payload)) {
+    return { type: "array", length: payload.length };
+  }
+  if (typeof payload === "object") {
+    const keys = Object.keys(payload).slice(0, 20);
+    const summary = { type: "object", keys };
+    const preferredKeys = ["code", "message", "stage", "status", "reason", "taskId", "runId", "policyAction"];
+    for (const key of preferredKeys) {
+      const value = payload?.[key];
+      if (value == null)
+        continue;
+      if (typeof value === "string")
+        summary[key] = truncateText2(value, 180);
+      else if (typeof value === "number" || typeof value === "boolean")
+        summary[key] = value;
+    }
+    return summary;
+  }
+  return void 0;
+}
+function buildTelemetryPayload(payload, includePayloads) {
+  if (!includePayloads) {
+    return summarizeTelemetryPayload(payload);
+  }
+  const cloned = cloneUnknown2(payload);
+  if (cloned == null)
+    return void 0;
+  if (typeof cloned === "string")
+    return truncateText2(cloned, 1e3);
+  if (typeof cloned === "number" || typeof cloned === "boolean")
+    return cloned;
+  if (Array.isArray(cloned))
+    return { type: "array", length: cloned.length };
+  if (typeof cloned === "object")
+    return cloned;
+  return summarizeTelemetryPayload(payload);
+}
+function stopTelemetry() {
+  if (telemetryFlushTimer) {
+    clearInterval(telemetryFlushTimer);
+    telemetryFlushTimer = null;
+  }
+}
+function getTelemetryEndpoint(cfg) {
+  const base = (cfg.apiBase || "https://us-central1-rtrvr-extension-functions.cloudfunctions.net").replace(/\/$/, "");
+  return base.endsWith("/extensionRouter") ? base : `${base}/extensionRouter`;
+}
+async function flushTelemetry(force = false) {
+  if (telemetryInFlight)
+    return;
+  if (telemetryPausedAuth)
+    return;
+  if (!currentConfig || !canUseTelemetry(currentConfig)) {
+    telemetryBuffer = [];
+    return;
+  }
+  if (!telemetryBuffer.length)
+    return;
+  const telemetry = normalizeTelemetryConfig(currentConfig);
+  const token = String(currentConfig.authToken || currentConfig.apiKey || "").trim();
+  if (!token)
+    return;
+  const batch = telemetryBuffer.splice(0, telemetry.maxBatchSize);
+  if (!batch.length)
+    return;
+  telemetryInFlight = true;
+  try {
+    const response = await fetch(getTelemetryEndpoint(currentConfig), {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        action: "roverTelemetryIngest",
+        data: {
+          siteId: currentConfig.siteId,
+          runtimeId,
+          sessionId: runtimeState?.sessionId,
+          visitorId: resolvedVisitorId,
+          flushReason: force ? "manual" : "interval",
+          sdkVersion: "rover_sdk_v1",
+          pageUrl: window.location.href,
+          userAgent: navigator.userAgent,
+          sampleRate: telemetry.sampleRate,
+          events: batch
+        }
+      })
+    });
+    if (!response.ok) {
+      if (response.status === 401 || response.status === 403) {
+        telemetryPausedAuth = true;
+      } else {
+        telemetryBuffer = [...batch, ...telemetryBuffer].slice(-TELEMETRY_MAX_BUFFER_SIZE);
+      }
+      return;
+    }
+    const payload = await response.json().catch(() => void 0);
+    if (payload?.success === false) {
+      const code = String(payload?.errorCode || payload?.errorDetails?.code || "").toUpperCase();
+      if (code === "INVALID_API_KEY" || code === "MISSING_API_KEY" || code === "UNAUTHENTICATED" || code === "PERMISSION_DENIED") {
+        telemetryPausedAuth = true;
+      }
+      return;
+    }
+  } catch {
+    telemetryBuffer = [...batch, ...telemetryBuffer].slice(-TELEMETRY_MAX_BUFFER_SIZE);
+  } finally {
+    telemetryInFlight = false;
+  }
+}
+function setupTelemetry(cfg) {
+  stopTelemetry();
+  telemetryPausedAuth = false;
+  if (!canUseTelemetry(cfg)) {
+    telemetryBuffer = [];
+    return;
+  }
+  const telemetry = normalizeTelemetryConfig(cfg);
+  telemetryFlushTimer = setInterval(() => {
+    void flushTelemetry(false);
+  }, telemetry.flushIntervalMs);
+}
+function recordTelemetryEvent(event, payload) {
+  if (!canUseTelemetry(currentConfig) || telemetryPausedAuth)
+    return;
+  const telemetry = normalizeTelemetryConfig(currentConfig);
+  if (telemetry.sampleRate < 1 && Math.random() > telemetry.sampleRate)
+    return;
+  const next = {
+    name: event,
+    ts: Date.now(),
+    seq: ++telemetrySeq,
+    payload: buildTelemetryPayload(payload, telemetry.includePayloads)
+  };
+  telemetryBuffer.push(next);
+  if (telemetryBuffer.length > TELEMETRY_MAX_BUFFER_SIZE) {
+    telemetryBuffer = telemetryBuffer.slice(-TELEMETRY_MAX_BUFFER_SIZE);
+  }
+  if (telemetryBuffer.length >= telemetry.maxBatchSize) {
+    void flushTelemetry(false);
+  }
+}
+function buildInaccessibleTabPageData(_cfg, tab, reason = "tab_not_accessible") {
+  const logicalTabId = Number(tab?.logicalTabId) || void 0;
+  const url = tab?.url || "";
+  const title = tab?.title || (tab?.external ? "External Tab (Inaccessible)" : "Inactive Tab");
+  const normalizedReason = String(reason || "").trim();
+  const reasonLine = normalizedReason ? ` Reason: ${normalizedReason}.` : "";
+  const content = tab?.external ? `This external tab is tracked in virtual mode only. Live DOM control and accessibility-tree access are unavailable here.${reasonLine}` : `This tab is currently not attached to an active Rover runtime. Switch to a live tab or reopen it.${reasonLine}`;
+  return {
+    url,
+    title,
+    contentType: "text/html",
+    content,
+    metadata: {
+      inaccessible: true,
+      external: !!tab?.external,
+      accessMode: tab?.external ? "external_placeholder" : "inactive_tab",
+      reason,
+      logicalTabId
+    }
+  };
+}
+function buildTabAccessToolError(cfg, tab, reason = "tab_not_accessible") {
+  const logicalTabId = Number(tab?.logicalTabId) || 0;
+  const blockedUrl = tab?.url || "";
+  const message = tab?.external ? `Tab ${logicalTabId} is external to the active runtime and cannot be controlled directly.` : `Tab ${logicalTabId} is not attached to an active Rover runtime.`;
+  const code = tab?.external ? "DOMAIN_SCOPE_BLOCKED" : "TAB_NOT_ACCESSIBLE";
+  return {
+    success: false,
+    error: message,
+    allowFallback: true,
+    output: {
+      success: false,
+      error: {
+        code,
+        message,
+        missing: [],
+        next_action: tab?.external ? "Use open_new_tab for external context or continue on an in-scope tab." : "Switch to an active tab and retry.",
+        retryable: false
+      },
+      blocked_url: blockedUrl || void 0,
+      logical_tab_id: logicalTabId || void 0,
+      external: !!tab?.external,
+      policy_action: tab?.external ? cfg.externalNavigationPolicy || "open_new_tab_notice" : void 0,
+      reason
+    },
+    errorDetails: {
+      code,
+      message,
+      retryable: false,
+      details: {
+        logicalTabId,
+        blockedUrl,
+        external: !!tab?.external,
+        reason
+      }
+    }
+  };
+}
 function normalizeStatusStage(input) {
   if (input === "analyze" || input === "route" || input === "execute" || input === "verify" || input === "complete") {
     return input;
@@ -15557,14 +16067,26 @@ function shouldIgnoreRunScopedWorkerMessage(msg) {
     return false;
   }
   if (type === "run_completed") {
-    if (!pendingRunId)
+    if (!pendingRunId) {
+      const sharedRunId = sessionCoordinator?.getState()?.activeRun?.runId;
+      if (sharedRunId && sharedRunId === messageRunId)
+        return false;
       return true;
+    }
     return pendingRunId !== messageRunId;
   }
   if (!pendingRunId)
     return true;
   return pendingRunId !== messageRunId;
 }
+function normalizeRunCompletionState(msg) {
+  if (!msg || typeof msg !== "object") {
+    return { taskComplete: false, needsUserInput: false };
+  }
+  const needsUserInput = msg.needsUserInput === true;
+  const taskComplete = msg.taskComplete === true && !needsUserInput;
+  return { taskComplete, needsUserInput };
+}
 function getLatestAssistantText(runId) {
   if (runId && latestAssistantByRunId.has(runId)) {
     return latestAssistantByRunId.get(runId);
@@ -15786,6 +16308,8 @@ function ensureUnloadHandler() {
       sessionCoordinator?.releaseWorkflowLock(runtimeState.pendingRun.id);
     }
     persistRuntimeState();
+    void flushTelemetry(true);
+    stopTelemetry();
     cloudCheckpointClient?.markDirty();
     cloudCheckpointClient?.syncNow();
     cloudCheckpointClient?.stop();
@@ -15801,6 +16325,9 @@ function ensureUnloadHandler() {
       sessionCoordinator.claimLease(false);
     }
     autoResumeAttempted = false;
+    if (currentConfig) {
+      setupTelemetry(currentConfig);
+    }
   };
   window.addEventListener("pageshow", onPageShow);
 }
@@ -15828,6 +16355,33 @@ function markTaskActivity(role, timestamp = Date.now()) {
     task.endedAt = void 0;
   }
 }
+function markTaskRunning(reason = "worker_task_active", timestamp = Date.now()) {
+  if (!runtimeState)
+    return;
+  const task = ensureActiveTask(reason);
+  if (!task)
+    return;
+  task.status = "running";
+  task.endedAt = void 0;
+  task.boundaryReason = reason;
+  if (!task.lastUserAt && !task.lastAssistantAt) {
+    task.lastAssistantAt = timestamp;
+  }
+  sessionCoordinator?.syncTask({ ...task }, runtimeState.taskEpoch);
+  persistRuntimeState();
+}
+function markTaskCompleted(reason = "worker_task_complete", timestamp = Date.now()) {
+  if (!runtimeState)
+    return;
+  const task = ensureActiveTask(reason);
+  if (!task)
+    return;
+  task.status = "completed";
+  task.endedAt = timestamp;
+  task.boundaryReason = reason;
+  sessionCoordinator?.syncTask({ ...task }, runtimeState.taskEpoch);
+  persistRuntimeState();
+}
 function hideTaskSuggestion() {
   pendingTaskSuggestion = null;
   ui?.setTaskSuggestion({ visible: false });
@@ -15837,53 +16391,37 @@ function clearTaskUiState() {
   ui?.clearTimeline();
   hideTaskSuggestion();
 }
-function collectRecentUserTextsForHeuristic() {
-  if (!runtimeState)
-    return [];
-  const userMessages = runtimeState.uiMessages.filter((message) => message.role === "user");
-  return userMessages.slice(-MAX_RECENT_USER_MESSAGES_FOR_TASK_HEURISTIC).map((message) => message.text.trim()).filter(Boolean);
-}
-function tokenizeForSimilarity(input) {
-  return new Set(String(input || "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 2));
-}
-function computeSemanticOverlap(a, b) {
-  const ta = tokenizeForSimilarity(a);
-  const tb = tokenizeForSimilarity(b);
-  if (!ta.size || !tb.size)
-    return 0;
-  let intersection = 0;
-  for (const token of ta) {
-    if (tb.has(token))
-      intersection += 1;
+function isPendingRunLikelyActive() {
+  const pending = runtimeState?.pendingRun;
+  if (!pending)
+    return false;
+  if (!sessionCoordinator)
+    return true;
+  const sharedActiveRun = sessionCoordinator?.getState()?.activeRun;
+  if (sharedActiveRun?.runId && sharedActiveRun.runId === pending.id) {
+    return true;
+  }
+  if (sharedActiveRun?.runtimeId && sharedActiveRun.runtimeId !== runtimeId) {
+    return true;
   }
-  return intersection / Math.max(ta.size, tb.size);
+  const ageMs = Date.now() - Number(pending.startedAt || 0);
+  return ageMs >= 0 && ageMs <= ACTIVE_PENDING_RUN_GRACE_MS;
 }
-function shouldSuggestResetForPrompt(text) {
-  if (!runtimeState || !currentConfig)
-    return { suggest: false };
-  const suggestEnabled = currentConfig.taskContext?.suggestReset !== false;
-  if (!suggestEnabled)
-    return { suggest: false };
-  if (runtimeState.pendingRun)
-    return { suggest: false };
-  const task = ensureActiveTask("implicit");
-  if (!task || task.status === "ended")
-    return { suggest: false };
-  const inactivityMs = Math.max(6e4, Number(currentConfig.taskContext?.inactivityMs) || DEFAULT_TASK_INACTIVITY_MS);
-  const now2 = Date.now();
-  const latestActivity = Math.max(task.lastUserAt || 0, task.lastAssistantAt || 0, task.startedAt || 0);
-  if (!latestActivity || now2 - latestActivity < inactivityMs)
-    return { suggest: false };
-  const recent = collectRecentUserTextsForHeuristic();
-  if (!recent.length)
-    return { suggest: true, reason: "inactivity_only" };
-  const baseline = recent.join(" ");
-  const overlap = computeSemanticOverlap(baseline, text);
-  const threshold = Math.max(0.05, Math.min(0.9, Number(currentConfig.taskContext?.semanticSimilarityThreshold) || DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD));
-  if (overlap < threshold) {
-    return { suggest: true, reason: `low_similarity_${overlap.toFixed(2)}` };
-  }
-  return { suggest: false };
+function maybeClearStalePendingRun() {
+  if (!runtimeState?.pendingRun)
+    return;
+  if (isPendingRunLikelyActive())
+    return;
+  if (!sessionCoordinator)
+    return;
+  const pending = runtimeState.pendingRun;
+  const ageMs = Date.now() - Number(pending.startedAt || 0);
+  if (!Number.isFinite(ageMs) || ageMs < STALE_PENDING_RUN_MS)
+    return;
+  setPendingRun(void 0);
+  sessionCoordinator?.clearActiveRunRuntimeId(pending.id);
+  sessionCoordinator?.releaseWorkflowLock(pending.id);
+  sessionCoordinator?.setActiveRun(void 0);
 }
 function appendUiMessage(role, text, persist = true, options) {
   const clean = truncateText2(String(text || ""));
@@ -16068,28 +16606,16 @@ function dispatchUserPrompt(text, options) {
   const trimmed = String(text || "").trim();
   if (!trimmed)
     return;
-  if (options?.startNewTask) {
-    newTask({ reason: options.reason || "suggested_new_task", clearUi: true });
-  } else if (!options?.bypassSuggestion) {
-    const decision = shouldSuggestResetForPrompt(trimmed);
-    if (decision.suggest) {
-      pendingTaskSuggestion = {
-        text: trimmed,
-        reason: decision.reason || "heuristic",
-        createdAt: Date.now()
-      };
-      ui?.setTaskSuggestion({
-        visible: true,
-        text: "This looks like a different request. Start a new task or continue this one?",
-        primaryLabel: "Start new",
-        secondaryLabel: "Continue"
-      });
-      emit("task_suggested_reset", {
-        text: trimmed,
-        reason: pendingTaskSuggestion.reason
-      });
-      return;
-    }
+  maybeClearStalePendingRun();
+  const activeTaskStatus = runtimeState?.activeTask?.status;
+  const shouldStartFreshTask = !!options?.startNewTask || activeTaskStatus === "completed" || activeTaskStatus === "ended";
+  sessionCoordinator?.pruneTabs({
+    dropRuntimeDetached: true,
+    dropAllDetachedExternal: shouldStartFreshTask
+  });
+  if (shouldStartFreshTask) {
+    const autoReason = options?.reason || (activeTaskStatus === "completed" ? "auto_after_task_complete" : "auto_after_task_end");
+    newTask({ reason: autoReason, clearUi: true });
   }
   hideTaskSuggestion();
   postRun(trimmed, { appendUserMessage: true, resume: false, autoResume: true });
@@ -16418,6 +16944,10 @@ function setupCloudCheckpointing(cfg) {
   if (!resolvedVisitorId)
     return;
   try {
+    const emitCheckpointState = (payload) => {
+      emit("checkpoint_state", payload);
+      cfg.checkpointing?.onStateChange?.(payload);
+    };
     cloudCheckpointClient = new RoverCloudCheckpointClient({
       apiBase: cfg.apiBase,
       apiKey: cfg.apiKey,
@@ -16433,7 +16963,36 @@ function setupCloudCheckpointing(cfg) {
       onCheckpoint: (payload) => {
         applyCloudCheckpointPayload(payload);
       },
-      onError: () => {
+      onStateChange: (state, context) => {
+        emitCheckpointState({
+          state,
+          reason: context.reason,
+          action: context.action,
+          code: context.code,
+          message: context.message
+        });
+        if (state === "paused_auth") {
+          emit("checkpoint_error", {
+            action: context.action,
+            code: context.code || "INVALID_API_KEY",
+            message: context.message || "Checkpoint sync paused due to auth failure.",
+            disabled: true,
+            reason: context.reason || "auth_failed"
+          });
+        }
+      },
+      onError: (_error, context) => {
+        cfg.checkpointing?.onError?.(context);
+        if (!context.paused) {
+          emit("checkpoint_error", {
+            action: context.action,
+            code: context.code,
+            message: context.message,
+            status: context.status,
+            disabled: false,
+            reason: "transient_failure"
+          });
+        }
       }
     });
     cloudCheckpointClient.start();
@@ -16727,6 +17286,7 @@ function handleWorkerMessage(msg) {
     }
     sessionCoordinator?.setActiveRun(void 0);
     if (!msg.ok && msg.error) {
+      markTaskRunning("worker_run_failed");
       setUiStatus(`Task failed: ${String(msg.error)}`);
       latestAssistantByRunId.delete(String(msg.runId || ""));
       appendTimelineEvent({
@@ -16736,8 +17296,27 @@ function handleWorkerMessage(msg) {
         status: "error"
       });
     } else if (msg.ok) {
-      setUiStatus("Execution completed");
-      finalizeSuccessfulRunTimeline(typeof msg.runId === "string" ? msg.runId : void 0);
+      const completionState = normalizeRunCompletionState(msg);
+      const taskComplete = completionState.taskComplete;
+      const needsUserInput = completionState.needsUserInput;
+      if (taskComplete) {
+        markTaskCompleted("worker_task_complete");
+        sessionCoordinator?.pruneTabs({
+          dropRuntimeDetached: true,
+          dropAllDetachedExternal: true
+        });
+        setUiStatus("Task completed");
+        finalizeSuccessfulRunTimeline(typeof msg.runId === "string" ? msg.runId : void 0);
+      } else {
+        markTaskRunning(needsUserInput ? "worker_waiting_for_input" : "worker_continuation");
+        setUiStatus(needsUserInput ? "Need more input to continue" : "Execution finished. Continue when ready.");
+        appendTimelineEvent({
+          kind: "status",
+          title: needsUserInput ? "Waiting for your input" : "Continuation available",
+          detail: needsUserInput ? "Planner requested more information before marking the task complete." : "Task is still active and will continue with your next message.",
+          status: "info"
+        });
+      }
       if (typeof msg.runId === "string" && msg.runId) {
         latestAssistantByRunId.delete(msg.runId);
       }
@@ -16783,6 +17362,7 @@ function createRuntime(cfg) {
     }
   }
   setupCloudCheckpointing(cfg);
+  setupTelemetry(cfg);
   const initialAllowActions = (cfg.allowActions ?? true) && (sessionCoordinator ? sessionCoordinator.isController() : true);
   bridge = new Bridge({
     allowActions: initialAllowActions,
@@ -16790,7 +17370,6 @@ function createRuntime(cfg) {
     allowedDomains: cfg.allowedDomains,
     domainScopeMode: cfg.domainScopeMode,
     externalNavigationPolicy: cfg.externalNavigationPolicy,
-    crossDomainPolicy: cfg.crossDomainPolicy,
     registerOpenedTab: (payload) => sessionCoordinator?.registerOpenedTab(payload),
     switchToLogicalTab: (logicalTabId) => sessionCoordinator?.switchToLogicalTab(logicalTabId) || { ok: false, reason: "No session coordinator" },
     listKnownTabs: () => (sessionCoordinator?.listTabs() || []).map((tab) => ({
@@ -16815,26 +17394,34 @@ function createRuntime(cfg) {
   bindRpc(channel.port1, {
     getSnapshot: () => bridge.getSnapshot(),
     getPageData: async (params) => {
-      const tabId = params?.tabId;
+      const runtimeCfg = currentConfig || cfg;
+      const tabId = Number(params?.tabId);
       const localTabId = sessionCoordinator?.getLocalLogicalTabId();
-      if (!tabId || tabId === localTabId || !sessionCoordinator) {
+      if (!Number.isFinite(tabId) || tabId <= 0 || tabId === localTabId || !sessionCoordinator) {
         return bridge.getPageData(params);
       }
       const tabs = sessionCoordinator.listTabs();
       const targetTab = tabs.find((t) => t.logicalTabId === tabId);
-      if (!targetTab || targetTab.runtimeId === runtimeId) {
+      if (!targetTab) {
+        return buildInaccessibleTabPageData(runtimeCfg, { logicalTabId: tabId, external: true }, "target_tab_missing");
+      }
+      if (targetTab.runtimeId === runtimeId) {
         return bridge.getPageData(params);
       }
+      if (targetTab.external && runtimeCfg.externalNavigationPolicy !== "allow") {
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "external_domain_inaccessible");
+      }
       if (!targetTab.runtimeId || !sessionCoordinator.isTabAlive(tabId)) {
-        return bridge.getPageData(params);
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "target_tab_inactive");
       }
       try {
         return await sessionCoordinator.sendCrossTabRpc(targetTab.runtimeId, "getPageData", params, 15e3);
       } catch {
-        return bridge.getPageData(params);
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "cross_tab_rpc_failed");
       }
     },
     executeTool: async (params) => {
+      const runtimeCfg = currentConfig || cfg;
       const activeTabId = sessionCoordinator?.getActiveLogicalTabId();
       const localTabId = sessionCoordinator?.getLocalLogicalTabId();
       if (!activeTabId || activeTabId === localTabId || !sessionCoordinator) {
@@ -16842,16 +17429,22 @@ function createRuntime(cfg) {
       }
       const tabs = sessionCoordinator.listTabs();
       const targetTab = tabs.find((t) => t.logicalTabId === activeTabId);
-      if (!targetTab?.runtimeId || targetTab.runtimeId === runtimeId) {
-        return bridge.executeTool(params.call, params.payload);
+      if (!targetTab) {
+        return buildTabAccessToolError(runtimeCfg, { logicalTabId: activeTabId, external: true }, "target_tab_missing");
       }
-      if (!sessionCoordinator.isTabAlive(activeTabId)) {
+      if (targetTab.external && runtimeCfg.externalNavigationPolicy !== "allow") {
+        return buildTabAccessToolError(runtimeCfg, targetTab, "external_tab_action_blocked");
+      }
+      if (targetTab.runtimeId === runtimeId) {
         return bridge.executeTool(params.call, params.payload);
       }
+      if (!targetTab.runtimeId || !sessionCoordinator.isTabAlive(activeTabId)) {
+        return buildTabAccessToolError(runtimeCfg, targetTab, "target_tab_inactive");
+      }
       try {
         return await sessionCoordinator.sendCrossTabRpc(targetTab.runtimeId, "executeTool", params, 2e4);
       } catch {
-        return bridge.executeTool(params.call, params.payload);
+        return buildTabAccessToolError(runtimeCfg, targetTab, "cross_tab_execute_failed");
       }
     },
     executeClientTool: (params) => bridge.executeClientTool(params.name, params.args),
@@ -16938,6 +17531,9 @@ function createRuntime(cfg) {
     },
     showTaskControls: cfg.ui?.showTaskControls !== false,
     muted: cfg.ui?.muted,
+    agent: {
+      name: cfg.ui?.agent?.name
+    },
     mascot: {
       disabled: cfg.ui?.mascot?.disabled,
       mp4Url: cfg.ui?.mascot?.mp4Url,
@@ -17052,9 +17648,7 @@ function boot(cfg) {
       plannerOnActError: cfg.taskRouting?.plannerOnActError
     },
     taskContext: {
-      inactivityMs: cfg.taskContext?.inactivityMs ?? DEFAULT_TASK_INACTIVITY_MS,
-      suggestReset: cfg.taskContext?.suggestReset ?? true,
-      semanticSimilarityThreshold: cfg.taskContext?.semanticSimilarityThreshold ?? DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD
+      ...cfg.taskContext
     }
   };
   runtimeState.sessionId = currentConfig.sessionId;
@@ -17115,17 +17709,29 @@ function update(cfg) {
       ...cfg.taskRouting
     },
     taskContext: {
-      inactivityMs: cfg.taskContext?.inactivityMs ?? currentConfig.taskContext?.inactivityMs ?? DEFAULT_TASK_INACTIVITY_MS,
-      suggestReset: cfg.taskContext?.suggestReset ?? currentConfig.taskContext?.suggestReset ?? true,
-      semanticSimilarityThreshold: cfg.taskContext?.semanticSimilarityThreshold ?? currentConfig.taskContext?.semanticSimilarityThreshold ?? DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD
+      ...currentConfig.taskContext,
+      ...cfg.taskContext
     },
     ui: {
       ...currentConfig.ui,
       ...cfg.ui,
+      agent: {
+        ...currentConfig.ui?.agent,
+        ...cfg.ui?.agent
+      },
       panel: {
         ...currentConfig.ui?.panel,
         ...cfg.ui?.panel
       }
+    },
+    tools: {
+      ...currentConfig.tools,
+      ...cfg.tools,
+      client: cfg.tools?.client ?? currentConfig.tools?.client,
+      web: {
+        ...currentConfig.tools?.web,
+        ...cfg.tools?.web
+      }
     }
   };
   resolvedVisitorId = resolveVisitorId(currentConfig);
@@ -17140,16 +17746,16 @@ function update(cfg) {
     setupSessionCoordinator(currentConfig);
   }
   setupCloudCheckpointing(currentConfig);
+  setupTelemetry(currentConfig);
   if (bridge) {
     if (typeof cfg.allowActions === "boolean") {
       bridge.setAllowActions(cfg.allowActions && currentMode === "controller");
     }
-    if (cfg.allowedDomains || cfg.crossDomainPolicy || cfg.domainScopeMode || cfg.externalNavigationPolicy) {
+    if (cfg.allowedDomains || cfg.domainScopeMode || cfg.externalNavigationPolicy) {
       bridge.setNavigationPolicy({
         allowedDomains: cfg.allowedDomains,
         domainScopeMode: cfg.domainScopeMode,
-        externalNavigationPolicy: cfg.externalNavigationPolicy,
-        crossDomainPolicy: cfg.crossDomainPolicy
+        externalNavigationPolicy: cfg.externalNavigationPolicy
       });
     }
   }
@@ -17164,6 +17770,8 @@ function update(cfg) {
 function shutdown() {
   hideTaskSuggestion();
   persistRuntimeState();
+  void flushTelemetry(true);
+  stopTelemetry();
   cloudCheckpointClient?.markDirty();
   cloudCheckpointClient?.syncNow();
   cloudCheckpointClient?.stop();
@@ -17181,6 +17789,10 @@ function shutdown() {
   runtimeId = "";
   resolvedVisitorId = void 0;
   suppressCheckpointSync = false;
+  telemetryInFlight = false;
+  telemetryPausedAuth = false;
+  telemetryBuffer = [];
+  telemetrySeq = 0;
   currentMode = "controller";
   pendingTaskSuggestion = null;
   runtimeStateStore = null;