@rtrvr-ai/rover 1.0.3 → 1.1.1

package/dist/worker/rover-worker.js

@@ -161,6 +161,27 @@ var DEFAULT_GEMINI_MODEL = GEMINI_MODEL.FLASH;
 var PLANNER = FUNCTION_CALLS.PLANNER;
 var maxFileSizeInBytes = 20 * 1024 * 1024;
 
+// ../shared/dist/lib/types/agent-types.js
+var SUB_AGENTS;
+(function(SUB_AGENTS2) {
+  SUB_AGENTS2["enhance"] = "enhance";
+  SUB_AGENTS2["plan"] = "plan";
+  SUB_AGENTS2["actOnTabs"] = "actOnTabs";
+  SUB_AGENTS2["extract"] = "extract";
+  SUB_AGENTS2["infer"] = "infer";
+  SUB_AGENTS2["processTabWorkflows"] = "processTabWorkflows";
+  SUB_AGENTS2["processText"] = "processText";
+  SUB_AGENTS2["createSheetFromData"] = "createSheetFromData";
+  SUB_AGENTS2["queryRtrvrDocs"] = "queryRtrvrDocs";
+  SUB_AGENTS2["googleDocGenerator"] = "googleDocGenerator";
+  SUB_AGENTS2["googleSlidesGenerator"] = "googleSlidesGenerator";
+  SUB_AGENTS2["webpageGenerator"] = "webpageGenerator";
+  SUB_AGENTS2["pdfFiller"] = "pdfFiller";
+  SUB_AGENTS2["customToolGenerator"] = "customToolGenerator";
+  SUB_AGENTS2["getPageData"] = "getPageData";
+  SUB_AGENTS2["roverExternalPageData"] = "roverExternalPageData";
+})(SUB_AGENTS || (SUB_AGENTS = {}));
+
 // dist/tabular-memory/tabular-store.js
 var makeId = () => {
   if (typeof crypto !== "undefined" && "randomUUID" in crypto)
@@ -620,7 +641,8 @@ function defaultNextActionForCode(code) {
   return void 0;
 }
 function toRoverErrorEnvelope(err, fallbackMessage = "Operation failed") {
-  const candidate = err?.roverError || err?.errorDetails || (typeof err?.error === "object" ? err.error : void 0);
+  const directCandidate = err && typeof err === "object" && typeof err.code === "string" && typeof err.message === "string" ? err : void 0;
+  const candidate = err?.roverError || err?.errorDetails || (typeof err?.error === "object" ? err.error : void 0) || directCandidate;
   if (candidate && typeof candidate === "object" && candidate.code && candidate.message) {
     return {
       code: candidate.code,
@@ -664,6 +686,10 @@ var LEGACY_ADDITIONAL_TOOL_ALIASES = {
   pdf_filling: "generate_docs",
   generate_web_pages: "generate_websites"
 };
+var DEFAULT_EXTERNAL_WEB_CONFIG = {
+  enableExternalWebContext: false,
+  scrapeMode: "off"
+};
 function normalizeApiToolsConfig(input) {
   if (!input)
     return void 0;
@@ -680,6 +706,121 @@ function normalizeApiToolsConfig(input) {
     enableAdditionalTools: normalizedAdditional
   };
 }
+function normalizeDomainRules(input) {
+  if (!Array.isArray(input))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const raw of input) {
+    const next = String(raw || "").trim().toLowerCase().replace(/^\./, "");
+    if (!next || seen.has(next))
+      continue;
+    seen.add(next);
+    out.push(next);
+  }
+  return out;
+}
+function normalizeAgentName(input) {
+  const normalized = String(input || "").trim();
+  if (!normalized)
+    return void 0;
+  return normalized.slice(0, 64);
+}
+function hostFromUrl(url) {
+  try {
+    return new URL(String(url || "")).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function matchesDomainRule(host, rule) {
+  const clean = String(rule || "").trim().toLowerCase();
+  if (!clean)
+    return false;
+  if (clean === "*")
+    return true;
+  if (clean.startsWith("*.")) {
+    const base = clean.slice(2);
+    return !!base && (host === base || host.endsWith(`.${base}`));
+  }
+  return host === clean || host.endsWith(`.${clean}`);
+}
+function normalizeExternalWebConfig(input) {
+  return {
+    enableExternalWebContext: input?.enableExternalWebContext ?? DEFAULT_EXTERNAL_WEB_CONFIG.enableExternalWebContext,
+    scrapeMode: input?.scrapeMode === "on_demand" ? "on_demand" : DEFAULT_EXTERNAL_WEB_CONFIG.scrapeMode,
+    allowDomains: normalizeDomainRules(input?.allowDomains),
+    denyDomains: normalizeDomainRules(input?.denyDomains)
+  };
+}
+function isAllowedByRules(url, rules) {
+  const host = hostFromUrl(url);
+  if (!host)
+    return { allowed: false, reason: "invalid_url" };
+  if (rules.denyDomains.some((rule) => matchesDomainRule(host, rule))) {
+    return { allowed: false, reason: `deny_rule:${host}` };
+  }
+  if (!rules.allowDomains.length)
+    return { allowed: true };
+  if (rules.allowDomains.some((rule) => matchesDomainRule(host, rule)))
+    return { allowed: true };
+  return { allowed: false, reason: `not_in_allowlist:${host}` };
+}
+function normalizeRuntimeExternalTabs(input) {
+  if (!Array.isArray(input))
+    return [];
+  const deduped = /* @__PURE__ */ new Map();
+  for (const tab of input) {
+    const tabId = Number(tab?.tabId);
+    if (!Number.isFinite(tabId))
+      continue;
+    const accessMode = tab?.accessMode === "external_scraped" ? "external_scraped" : "external_placeholder";
+    const host = String(tab?.host || "").trim() || void 0;
+    const title = String(tab?.title || "").trim() || void 0;
+    const reason = String(tab?.reason || "").trim() || void 0;
+    deduped.set(tabId, {
+      tabId,
+      accessMode,
+      host,
+      title,
+      reason
+    });
+  }
+  return Array.from(deduped.values());
+}
+function buildRoverRuntimeContext(config2) {
+  const runtimeContext = config2.runtimeContext;
+  if (!runtimeContext || runtimeContext.mode !== "rover_embed")
+    return void 0;
+  const compactExternalTabs = normalizeRuntimeExternalTabs(runtimeContext.externalTabs).slice(0, 8);
+  return {
+    mode: "rover_embed",
+    agentName: normalizeAgentName(runtimeContext.agentName) || "Rover",
+    externalNavigationPolicy: runtimeContext.externalNavigationPolicy || config2.externalNavigationPolicy,
+    tabIdContract: runtimeContext.tabIdContract || "tree_index_mapped_by_tab_order",
+    ...compactExternalTabs.length ? { externalTabs: compactExternalTabs } : {}
+  };
+}
+function buildExternalPlaceholderPageData(params) {
+  const agentName = normalizeAgentName(params.agentName) || "Rover";
+  const reason = params.reason || "external_domain_inaccessible";
+  const title = params.title || "External Tab (Inaccessible)";
+  const url = params.url || "";
+  const reasonLine = reason ? ` Reason: ${reason}.` : "";
+  return {
+    url,
+    title,
+    contentType: "text/html",
+    content: `${agentName} is running in virtual external-tab mode. Live DOM control and accessibility-tree access are unavailable here.${reasonLine}`,
+    metadata: {
+      inaccessible: true,
+      external: true,
+      accessMode: "external_placeholder",
+      reason,
+      logicalTabId: params.tabId
+    }
+  };
+}
 function getUserFriendlyTimestamp() {
   const now = /* @__PURE__ */ new Date();
   const year = now.getFullYear();
@@ -712,10 +853,19 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
   }
   const base = (config2.apiBase || DEFAULT_CLOUD_FUNCTIONS_BASE).replace(/\/$/, "");
   const endpoint = base.endsWith("/extensionRouter") ? base : `${base}/extensionRouter`;
+  const runtimeContext = buildRoverRuntimeContext(config2);
+  const externalWebConfig = normalizeExternalWebConfig(config2.tools?.web);
+  const externalPageDataCache = /* @__PURE__ */ new Map();
+  const externalPageDataErrorCache = /* @__PURE__ */ new Map();
+  let externalPageDataDisabledReason;
+  let cachedActiveTabId = 0;
+  let cachedActiveTabTs = 0;
   const RETRY_DELAYS = [1e3, 3e3];
   const MAX_RETRIES3 = RETRY_DELAYS.length;
+  const ACTIVE_TAB_CACHE_TTL_MS = 250;
+  const EXTERNAL_PAGE_CACHE_TTL_MS = 45e3;
   const callExtensionRouter = async (action, data) => {
-    const token = config2.apiKey || config2.authToken;
+    const token = config2.authToken || config2.apiKey;
     if (!token) {
       throw createRoverError({
         code: "MISSING_API_KEY",
@@ -736,7 +886,13 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
           Authorization: `Bearer ${token}`,
           "Content-Type": "application/json"
         },
-        body: JSON.stringify({ action, data }),
+        body: JSON.stringify({
+          action,
+          data: data && typeof data === "object" ? {
+            ...data,
+            ...!data.runtimeContext && runtimeContext ? { runtimeContext } : {}
+          } : data
+        }),
         signal: config2.signal
       });
       if (!response.ok) {
@@ -789,11 +945,138 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     }
     throw lastError || new Error("callExtensionRouter: unexpected retry exhaustion");
   };
+  const getExternalPageData = async (url, options) => {
+    const normalizedUrl = String(url || "").trim();
+    if (!normalizedUrl)
+      throw new Error("external page data requires url");
+    const cacheTabId = Number(options?.tabId) || 0;
+    const cacheKey = `${cacheTabId}:${normalizedUrl}`;
+    const nowMs = Date.now();
+    const cachedData = externalPageDataCache.get(cacheKey);
+    if (cachedData && nowMs - cachedData.ts <= EXTERNAL_PAGE_CACHE_TTL_MS) {
+      return cachedData.data;
+    }
+    externalPageDataCache.delete(cacheKey);
+    const cachedError = externalPageDataErrorCache.get(cacheKey);
+    if (cachedError && nowMs - cachedError.ts <= EXTERNAL_PAGE_CACHE_TTL_MS) {
+      throw new Error(cachedError.message || "external page data fetch failed");
+    }
+    externalPageDataErrorCache.delete(cacheKey);
+    if (externalPageDataDisabledReason) {
+      throw new Error(externalPageDataDisabledReason);
+    }
+    const source = options?.source || "direct_url";
+    const payload = {
+      url: normalizedUrl,
+      source,
+      siteId: config2.siteId,
+      roverPolicy: {
+        allowDomains: externalWebConfig.allowDomains,
+        denyDomains: externalWebConfig.denyDomains
+      }
+    };
+    try {
+      const response = await callExtensionRouter(SUB_AGENTS.roverExternalPageData, payload);
+      const pageData = response?.data || response;
+      externalPageDataCache.set(cacheKey, { data: pageData, ts: nowMs });
+      return pageData;
+    } catch (error) {
+      const envelope = toRoverErrorEnvelope(error, "external page data fetch failed");
+      const normalizedMessage = envelope?.message || "external page data fetch failed";
+      externalPageDataErrorCache.set(cacheKey, { message: normalizedMessage, ts: nowMs });
+      if (envelope.code === "PERMISSION_DENIED" || envelope.code === "MISSING_API_KEY" || envelope.code === "INVALID_API_KEY") {
+        externalPageDataDisabledReason = `${envelope.code}: ${normalizedMessage}`;
+      }
+      throw error;
+    }
+  };
+  const getActiveLogicalTabId = async () => {
+    const nowMs = Date.now();
+    if (cachedActiveTabId > 0 && nowMs - cachedActiveTabTs <= ACTIVE_TAB_CACHE_TTL_MS) {
+      return cachedActiveTabId;
+    }
+    try {
+      const context = await bridgeRpc2("getTabContext");
+      const active = Number(context?.activeLogicalTabId || context?.logicalTabId || context?.id);
+      if (Number.isFinite(active) && active > 0) {
+        cachedActiveTabId = active;
+        cachedActiveTabTs = nowMs;
+        return active;
+      }
+    } catch {
+    }
+    return void 0;
+  };
   const getPageData = async (tabId, options) => {
-    if (options) {
-      return bridgeRpc2("getPageData", { pageConfig: options, tabId });
+    const numericTabId = Number(tabId);
+    const rawOptions = options && typeof options === "object" ? options : void 0;
+    const allowExternalFetch = rawOptions?.__roverAllowExternalFetch === true;
+    const pageConfig = rawOptions && typeof rawOptions === "object" ? Object.fromEntries(Object.entries(rawOptions).filter(([key]) => key !== "__roverAllowExternalFetch")) : void 0;
+    const hasPageConfig = !!pageConfig && Object.keys(pageConfig).length > 0;
+    const localPageData = rawOptions ? await bridgeRpc2("getPageData", hasPageConfig ? { pageConfig, tabId: numericTabId } : { tabId: numericTabId }) : await bridgeRpc2("getPageData", { tabId: numericTabId });
+    const metadata = localPageData?.metadata || {};
+    const isExternal = !!metadata?.external || metadata?.accessMode === "external_placeholder" || metadata?.accessMode === "external_scraped";
+    if (!isExternal) {
+      return localPageData;
+    }
+    const pageUrl = typeof localPageData?.url === "string" ? localPageData.url.trim() : "";
+    if (!externalWebConfig.enableExternalWebContext || externalWebConfig.scrapeMode === "off" || !pageUrl) {
+      return localPageData;
+    }
+    if (externalPageDataDisabledReason) {
+      return buildExternalPlaceholderPageData({
+        tabId: numericTabId,
+        url: pageUrl,
+        title: localPageData?.title,
+        agentName: runtimeContext?.agentName,
+        reason: `cloud_fetch_disabled:${externalPageDataDisabledReason}`
+      });
+    }
+    const ruleCheck = isAllowedByRules(pageUrl, {
+      allowDomains: externalWebConfig.allowDomains,
+      denyDomains: externalWebConfig.denyDomains
+    });
+    if (!ruleCheck.allowed) {
+      return buildExternalPlaceholderPageData({
+        tabId: numericTabId,
+        url: pageUrl,
+        title: localPageData?.title,
+        agentName: runtimeContext?.agentName,
+        reason: `policy_blocked:${ruleCheck.reason || "blocked"}`
+      });
+    }
+    const activeTabId = await getActiveLogicalTabId();
+    const shouldFetchExternalContext = allowExternalFetch || (activeTabId ? activeTabId === numericTabId : false);
+    if (!shouldFetchExternalContext) {
+      return localPageData;
+    }
+    try {
+      const cloudData = await getExternalPageData(pageUrl, {
+        tabId: numericTabId,
+        source: pageUrl.includes("google.com/search") ? "google_search" : "direct_url"
+      });
+      if (cloudData && typeof cloudData === "object") {
+        return {
+          ...cloudData,
+          metadata: {
+            ...cloudData.metadata || {},
+            external: true,
+            accessMode: "external_scraped",
+            logicalTabId: numericTabId
+          }
+        };
+      }
+      return localPageData;
+    } catch (error) {
+      const envelope = toRoverErrorEnvelope(error, "external page data fetch failed");
+      return buildExternalPlaceholderPageData({
+        tabId: numericTabId,
+        url: pageUrl,
+        title: localPageData?.title,
+        agentName: runtimeContext?.agentName,
+        reason: `cloud_fetch_failed:${envelope?.code || "unknown"}`
+      });
     }
-    return bridgeRpc2("getPageData", { tabId });
   };
   const userProfile = config2.userProfile || (config2.userContext ? { userContext: config2.userContext } : void 0);
   const defaultApiToolsConfig = apiMode ? {
@@ -806,6 +1089,7 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     llmIntegration,
     userProfile,
     getPageData,
+    getExternalPageData,
     callExtensionRouter,
     apiMode,
     apiToolsConfig: normalizeApiToolsConfig(config2.apiToolsConfig ?? defaultApiToolsConfig),
@@ -1014,26 +1298,6 @@ var GeminiModel;
   GeminiModel2["PRO"] = "Gemini Pro";
 })(GeminiModel || (GeminiModel = {}));
 
-// ../shared/dist/lib/types/agent-types.js
-var SUB_AGENTS;
-(function(SUB_AGENTS2) {
-  SUB_AGENTS2["enhance"] = "enhance";
-  SUB_AGENTS2["plan"] = "plan";
-  SUB_AGENTS2["actOnTabs"] = "actOnTabs";
-  SUB_AGENTS2["extract"] = "extract";
-  SUB_AGENTS2["infer"] = "infer";
-  SUB_AGENTS2["processTabWorkflows"] = "processTabWorkflows";
-  SUB_AGENTS2["processText"] = "processText";
-  SUB_AGENTS2["createSheetFromData"] = "createSheetFromData";
-  SUB_AGENTS2["queryRtrvrDocs"] = "queryRtrvrDocs";
-  SUB_AGENTS2["googleDocGenerator"] = "googleDocGenerator";
-  SUB_AGENTS2["googleSlidesGenerator"] = "googleSlidesGenerator";
-  SUB_AGENTS2["webpageGenerator"] = "webpageGenerator";
-  SUB_AGENTS2["pdfFiller"] = "pdfFiller";
-  SUB_AGENTS2["customToolGenerator"] = "customToolGenerator";
-  SUB_AGENTS2["getPageData"] = "getPageData";
-})(SUB_AGENTS || (SUB_AGENTS = {}));
-
 // ../shared/dist/lib/system-tools/tools.js
 var SystemToolNames;
 (function(SystemToolNames2) {
@@ -1315,6 +1579,127 @@ function formatFunctionResultsIntoPrevSteps(results, functionCalls) {
   return steps;
 }
 
+// dist/agent/runtimeTabs.js
+var DEFAULT_MAX_CONTEXT_TABS = 8;
+var DEFAULT_DETACHED_EXTERNAL_TAB_MAX_AGE_MS = 9e4;
+var DEFAULT_STALE_RUNTIME_TAB_MAX_AGE_MS = 45e3;
+function dedupePositiveTabIds(input) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of input) {
+    const next = Number(value);
+    if (!Number.isFinite(next) || next <= 0 || seen.has(next))
+      continue;
+    seen.add(next);
+    out.push(next);
+  }
+  return out;
+}
+function normalizeAccessMode(value, external) {
+  if (value === "external_scraped" || value === "external_placeholder" || value === "live_dom")
+    return value;
+  return external ? "external_placeholder" : "live_dom";
+}
+function normalizeFallbackTabs(input) {
+  return input.map((tab) => ({
+    id: Number(tab?.id),
+    url: typeof tab?.url === "string" ? tab.url : void 0,
+    title: typeof tab?.title === "string" ? tab.title : void 0,
+    external: !!tab?.external,
+    accessMode: normalizeAccessMode(tab?.accessMode, !!tab?.external),
+    inaccessibleReason: typeof tab?.inaccessibleReason === "string" ? tab.inaccessibleReason : void 0
+  })).filter((tab) => Number.isFinite(tab.id) && tab.id > 0);
+}
+function normalizeListedTabs(input) {
+  if (!Array.isArray(input))
+    return [];
+  return input.map((tab) => {
+    const id = Number(tab?.logicalTabId || tab?.id);
+    if (!Number.isFinite(id) || id <= 0)
+      return void 0;
+    const external = !!tab?.external;
+    return {
+      id,
+      runtimeId: typeof tab?.runtimeId === "string" ? tab.runtimeId : void 0,
+      url: typeof tab?.url === "string" ? tab.url : void 0,
+      title: typeof tab?.title === "string" ? tab.title : void 0,
+      external,
+      accessMode: normalizeAccessMode(tab?.accessMode, external),
+      inaccessibleReason: typeof tab?.inaccessibleReason === "string" ? tab.inaccessibleReason : void 0,
+      updatedAt: Number(tab?.updatedAt) || 0
+    };
+  }).filter((tab) => !!tab);
+}
+async function resolveRuntimeTabs(bridgeRpc2, fallbackTabs, options) {
+  const maxContextTabs = Math.max(1, Number(options?.maxContextTabs) || DEFAULT_MAX_CONTEXT_TABS);
+  const detachedExternalTabMaxAgeMs = Math.max(5e3, Number(options?.detachedExternalTabMaxAgeMs) || DEFAULT_DETACHED_EXTERNAL_TAB_MAX_AGE_MS);
+  const staleRuntimeTabMaxAgeMs = Math.max(1e4, Number(options?.staleRuntimeTabMaxAgeMs) || DEFAULT_STALE_RUNTIME_TAB_MAX_AGE_MS);
+  const fallbackSnapshots = normalizeFallbackTabs(fallbackTabs);
+  const fallbackTabIds = dedupePositiveTabIds(fallbackSnapshots.map((tab) => tab.id));
+  let tabIds = [...fallbackTabIds];
+  let listedTabs = [];
+  if (bridgeRpc2) {
+    try {
+      listedTabs = normalizeListedTabs(await bridgeRpc2("listSessionTabs"));
+      const listedIds = dedupePositiveTabIds(listedTabs.map((tab) => tab.id));
+      if (listedIds.length > 0) {
+        tabIds = listedIds;
+      }
+    } catch {
+    }
+  }
+  let activeTabId = tabIds[0] || fallbackTabIds[0] || 1;
+  if (bridgeRpc2) {
+    try {
+      const context = await bridgeRpc2("getTabContext");
+      const candidate = Number(context?.activeLogicalTabId || context?.logicalTabId || context?.id);
+      if (Number.isFinite(candidate) && candidate > 0) {
+        activeTabId = candidate;
+      }
+    } catch {
+    }
+  }
+  if (!tabIds.length) {
+    tabIds = [activeTabId];
+  } else if (!tabIds.includes(activeTabId)) {
+    tabIds = [activeTabId, ...tabIds];
+  }
+  const nowMs = Date.now();
+  const listedById = /* @__PURE__ */ new Map();
+  for (const tab of listedTabs)
+    listedById.set(tab.id, tab);
+  const prioritized = tabIds.filter((tabId) => {
+    if (tabId === activeTabId)
+      return true;
+    const listed = listedById.get(tabId);
+    if (!listed)
+      return true;
+    if (listed.runtimeId) {
+      return nowMs - (listed.updatedAt || 0) <= staleRuntimeTabMaxAgeMs;
+    }
+    if (!listed.external)
+      return true;
+    return nowMs - (listed.updatedAt || 0) <= detachedExternalTabMaxAgeMs;
+  });
+  let tabOrder = (prioritized.length ? prioritized : tabIds).slice(0, maxContextTabs);
+  if (!tabOrder.includes(activeTabId)) {
+    tabOrder = [activeTabId, ...tabOrder].slice(0, maxContextTabs);
+  }
+  if (!tabOrder.length) {
+    tabOrder = [activeTabId || 1];
+  }
+  const tabMetaById = {};
+  for (const tab of fallbackSnapshots)
+    tabMetaById[tab.id] = tab;
+  for (const tab of listedTabs)
+    tabMetaById[tab.id] = { ...tabMetaById[tab.id] || {}, ...tab };
+  for (const tabId of tabOrder) {
+    if (!tabMetaById[tabId])
+      tabMetaById[tabId] = { id: tabId };
+  }
+  return { tabOrder, activeTabId, tabMetaById };
+}
+
 // dist/agent/actAgent.js
 var MAX_RETRIES = 3;
 var MAX_ITERATIONS = 25;
@@ -1326,10 +1711,10 @@ async function executeAgenticSeek(options) {
   let totalCreditsUsed = 0;
   const allWarnings = [];
   const accumulatedPrevSteps = Array.isArray(previousSteps) ? previousSteps : [];
+  const fallbackTabs = tabOrder.map((id) => ({ id }));
   let retry = 0;
   let iterations = 0;
   let pageDataOptions;
-  const tabId = tabOrder[0];
   while (retry < MAX_RETRIES) {
     if (iterations++ >= MAX_ITERATIONS) {
       return { error: "Max action iterations reached", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
@@ -1340,13 +1725,44 @@ async function executeAgenticSeek(options) {
     try {
       await waitWhilePaused(void 0);
       onStatusUpdate?.("Analyzing page content...", "Calling seek workflow", "analyze");
-      const pageData = await ctx.getPageData(tabId, pageDataOptions);
+      const { tabOrder: runtimeTabOrder, activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+      const scopedTabOrder = runtimeTabOrder.length ? runtimeTabOrder : tabOrder;
+      const webPageMap = {};
+      try {
+        webPageMap[activeTabId] = await ctx.getPageData(activeTabId, {
+          ...pageDataOptions || {},
+          __roverAllowExternalFetch: true
+        });
+      } catch {
+        retry++;
+        continue;
+      }
+      const backgroundTabIds = scopedTabOrder.filter((currentTabId) => currentTabId !== activeTabId);
+      const backgroundResults = await Promise.all(backgroundTabIds.map(async (currentTabId) => {
+        try {
+          const pageData = await ctx.getPageData(currentTabId);
+          return { tabId: currentTabId, pageData };
+        } catch {
+          return { tabId: currentTabId, pageData: void 0 };
+        }
+      }));
+      for (const result of backgroundResults) {
+        if (result.pageData) {
+          webPageMap[result.tabId] = result.pageData;
+        } else {
+          allWarnings.push(`Could not load page data for tab ${result.tabId}; continuing with remaining tabs.`);
+        }
+      }
+      if (!webPageMap[activeTabId]) {
+        retry++;
+        continue;
+      }
       const request = {
         siteId: ctx.siteId,
         customTabWorkflow: "Seek",
-        webPageMap: { [tabId]: pageData },
-        tabOrder: [tabId],
-        activeTabId: tabId,
+        webPageMap,
+        tabOrder: scopedTabOrder,
+        activeTabId,
         userInput,
         dataJsonSchema: schema,
         files,
@@ -1368,7 +1784,7 @@ async function executeAgenticSeek(options) {
       }
       const data = response.data;
       totalCreditsUsed += data?.creditsUsed || 0;
-      const tabResponse = data?.tabResponses?.[tabId];
+      const tabResponse = data?.tabResponses?.[activeTabId];
       if (!tabResponse) {
         retry++;
         continue;
@@ -1382,7 +1798,7 @@ async function executeAgenticSeek(options) {
       const processResult = await processActionResponse({
         request,
         response: tabResponse,
-        tabId,
+        tabId: activeTabId,
         prevSteps: accumulatedPrevSteps,
         thought: tabResponse.thought,
         bridgeRpc: bridgeRpc2,
@@ -1447,20 +1863,28 @@ async function executeExtract(options) {
   }
   let totalCreditsUsed = 0;
   const warnings = [];
-  const tabId = tabOrder[0];
+  const fallbackTabs = tabOrder.map((id) => ({ id }));
   const prevSteps = Array.isArray(previousSteps) ? previousSteps : [];
   let pageDataOptions;
   for (let retry = 0; retry < MAX_RETRIES2; retry++) {
     await waitWhilePaused(void 0);
-    const pageData = await ctx.getPageData(tabId, pageDataOptions);
+    const { activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+    const tabId = activeTabId;
+    let pageData;
+    try {
+      pageData = await ctx.getPageData(tabId, pageDataOptions);
+    } catch {
+      warnings.push(`Could not load page data for tab ${tabId}; retrying.`);
+      continue;
+    }
     const request = {
       siteId: ctx.siteId,
       userInput,
       schema,
       outputDestination,
       schemaHeaderSheetInfo,
-      webPageMap: { [tabId]: pageData },
-      tabOrder: [tabId],
+      webPageMap: { [activeTabId]: pageData },
+      tabOrder: [activeTabId],
       plannerPrevSteps,
       llmIntegration: ctx.llmIntegration,
       apiMode: ctx.apiMode,
@@ -1491,12 +1915,12 @@ async function executeExtract(options) {
         warnings
       };
     }
-    const tabResponse = data?.tabResponses?.[tabId];
+    const tabResponse = data?.tabResponses?.[activeTabId];
     if (tabResponse) {
       const processResult = await processActionResponse({
         request,
         response: tabResponse,
-        tabId,
+        tabId: activeTabId,
         prevSteps,
         thought: tabResponse.thought,
         bridgeRpc: bridgeRpc2,
@@ -2151,6 +2575,8 @@ function resolvePath(obj, path) {
 }
 
 // dist/agent/toolExecutor.js
+var MAX_AGENT_CHATLOG_ENTRIES = 24;
+var MAX_AGENT_CHATLOG_MESSAGE_CHARS = 1e3;
 function unsupportedToolResult(toolName, message) {
   return {
     error: message,
@@ -2180,10 +2606,18 @@ function buildStructuredErrorOutput(envelope) {
 }
 function normalizeAgentLog(agentLog) {
   const prevSteps = Array.isArray(agentLog?.prevSteps) ? agentLog.prevSteps : [];
+  const sanitizeMessage = (value) => {
+    const normalized = String(value || "").replace(/\s+/g, " ").trim();
+    if (!normalized)
+      return "";
+    if (normalized.length <= MAX_AGENT_CHATLOG_MESSAGE_CHARS)
+      return normalized;
+    return `${normalized.slice(0, MAX_AGENT_CHATLOG_MESSAGE_CHARS - 1)}\u2026`;
+  };
   const chatLog = Array.isArray(agentLog?.chatLog) ? agentLog.chatLog.map((entry) => ({
     role: entry?.role === "user" ? "user" : "model",
-    message: typeof entry?.message === "string" ? entry.message : ""
-  })).filter((entry) => !!entry.message) : [];
+    message: typeof entry?.message === "string" ? sanitizeMessage(entry.message) : ""
+  })).filter((entry) => !!entry.message).slice(-MAX_AGENT_CHATLOG_ENTRIES) : [];
   return { prevSteps, chatLog };
 }
 async function executeToolFromPlan(context) {
@@ -2192,7 +2626,9 @@ async function executeToolFromPlan(context) {
   if (!effectiveCtx) {
     return { error: "Agent context unavailable" };
   }
-  const tabOrder = tabs?.length ? tabs.map((t) => t.id) : [1];
+  const fallbackTabs = Array.isArray(tabs) && tabs.length ? tabs : [{ id: 1 }];
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+  const tabOrder = resolvedTabs.tabOrder.length ? resolvedTabs.tabOrder : fallbackTabs.map((tab) => tab.id);
   const effectiveAgentLog = normalizeAgentLog(agentLog);
   try {
     switch (toolName) {
@@ -2999,18 +3435,50 @@ async function executeCustomToolGenerator({ userInput, plannerPrevSteps, files,
 
 // dist/agent/plannerAgent.js
 var MAX_PLANNER_DEPTH = 15;
+var MAX_CHATLOG_ENTRIES = 24;
+var MAX_CHATLOG_MESSAGE_CHARS = 1e3;
+function normalizeChatLog(entries) {
+  if (!Array.isArray(entries) || !entries.length)
+    return [];
+  return entries.map((entry) => ({
+    role: entry?.role === "user" ? "user" : "model",
+    message: String(entry?.message || "").replace(/\s+/g, " ").trim()
+  })).filter((entry) => !!entry.message).map((entry) => ({
+    role: entry.role,
+    message: entry.message.length > MAX_CHATLOG_MESSAGE_CHARS ? `${entry.message.slice(0, MAX_CHATLOG_MESSAGE_CHARS - 1)}\u2026` : entry.message
+  })).slice(-MAX_CHATLOG_ENTRIES);
+}
 async function executePlanner(options) {
-  const { userInput, tabs, previousMessages = [], trajectoryId: trajectoryId2, previousSteps = [], files, continuePlanning = false, recordingContext, driveAuthToken, agentLog, lastToolPreviousSteps, ctx, functionDeclarations } = options;
-  const tabOrder = tabs.map((t) => t.id);
+  const { userInput, tabs, previousMessages = [], trajectoryId: trajectoryId2, previousSteps = [], files, continuePlanning = false, recordingContext, driveAuthToken, agentLog, lastToolPreviousSteps, ctx, bridgeRpc: bridgeRpc2, functionDeclarations } = options;
+  const fallbackTabs = Array.isArray(tabs) && tabs.length ? tabs : [{ id: 1 }];
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+  const tabOrder = resolvedTabs.tabOrder.length ? resolvedTabs.tabOrder : fallbackTabs.map((tab) => tab.id);
+  const activeTabId = resolvedTabs.activeTabId;
+  const tabMetaById = resolvedTabs.tabMetaById;
   const webPageMap = {};
-  for (const tab of tabs) {
+  const loadPageData = async (tabId, options2) => {
     try {
-      webPageMap[tab.id] = await ctx.getPageData(tab.id, { onlyTextContent: false });
+      return await ctx.getPageData(tabId, {
+        onlyTextContent: false,
+        ...options2?.allowExternalFetch ? { __roverAllowExternalFetch: true } : {}
+      });
     } catch {
-      webPageMap[tab.id] = { url: tab.url || "", title: tab.title || "", content: "", contentType: "text/html" };
+      const tab = tabMetaById[tabId];
+      return {
+        url: tab?.url || "",
+        title: tab?.title || (tab?.external ? "External Tab (Inaccessible)" : ""),
+        content: "",
+        contentType: "text/html"
+      };
     }
+  };
+  webPageMap[activeTabId] = await loadPageData(activeTabId, { allowExternalFetch: true });
+  const backgroundTabIds = tabOrder.filter((tabId) => tabId !== activeTabId);
+  const backgroundResults = await Promise.all(backgroundTabIds.map(async (tabId) => ({ tabId, pageData: await loadPageData(tabId) })));
+  for (const { tabId, pageData } of backgroundResults) {
+    webPageMap[tabId] = pageData;
   }
-  const chatLog = agentLog?.chatLog?.length ? agentLog.chatLog : previousMessages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role === "user" ? "user" : "model", message: m.content }));
+  const chatLog = agentLog?.chatLog?.length ? normalizeChatLog(agentLog.chatLog) : normalizeChatLog(previousMessages.filter((m) => m.role === "user" || m.role === "assistant").map((m) => ({ role: m.role === "user" ? "user" : "model", message: m.content })));
   const request = {
     siteId: ctx.siteId,
     userInput,
@@ -3687,7 +4155,98 @@ var activeAbortController = null;
 var lastStatusKey = "";
 var seenStatusKeys = /* @__PURE__ */ new Set();
 var completedRunIds = /* @__PURE__ */ new Set();
+var completedRunOutcomes = /* @__PURE__ */ new Map();
 var RPC_TIMEOUT_MS = 3e4;
+var DETACHED_EXTERNAL_TAB_MAX_AGE_MS = 9e4;
+var MAX_CHATLOG_ENTRIES2 = 24;
+var MAX_CHATLOG_MESSAGE_CHARS2 = 1e3;
+function resolveAgentName(config2) {
+  const raw = String(config2?.ui?.agent?.name || "").trim();
+  if (!raw)
+    return "Rover";
+  return raw.slice(0, 64);
+}
+function hostFromUrl2(url) {
+  const raw = String(url || "").trim();
+  if (!raw)
+    return void 0;
+  try {
+    return new URL(raw).hostname.toLowerCase();
+  } catch {
+    return void 0;
+  }
+}
+function extractWebToolsConfig(config2) {
+  if (!config2?.tools || Array.isArray(config2.tools))
+    return void 0;
+  return config2.tools.web;
+}
+function resolveRuntimeExternalNavigationPolicy(config2) {
+  if (!config2)
+    return void 0;
+  if (config2.externalNavigationPolicy === "open_new_tab_notice" || config2.externalNavigationPolicy === "block" || config2.externalNavigationPolicy === "allow") {
+    return config2.externalNavigationPolicy;
+  }
+  return void 0;
+}
+function buildRoverRuntimeContext2(params) {
+  const externalTabs = params.tabs.map((tab, index) => {
+    if (!tab.external && tab.accessMode !== "external_placeholder" && tab.accessMode !== "external_scraped") {
+      return void 0;
+    }
+    const accessMode = tab.accessMode === "external_scraped" ? "external_scraped" : "external_placeholder";
+    return {
+      tabId: index,
+      host: hostFromUrl2(tab.url),
+      title: String(tab.title || "").trim() || void 0,
+      accessMode,
+      reason: String(tab.inaccessibleReason || "").trim() || void 0
+    };
+  }).filter((tab) => !!tab).slice(0, 8);
+  return {
+    mode: "rover_embed",
+    agentName: params.agentName,
+    externalNavigationPolicy: params.externalNavigationPolicy,
+    tabIdContract: "tree_index_mapped_by_tab_order",
+    ...externalTabs.length ? { externalTabs } : {}
+  };
+}
+function mergeWorkerTools(current, incoming) {
+  if (incoming === void 0)
+    return current;
+  if (Array.isArray(incoming))
+    return incoming;
+  if (Array.isArray(current)) {
+    return {
+      ...incoming,
+      client: incoming.client ?? current,
+      web: {
+        ...incoming.web || {}
+      }
+    };
+  }
+  return {
+    ...current,
+    ...incoming,
+    client: incoming.client ?? current?.client,
+    web: {
+      ...current?.web || {},
+      ...incoming.web || {}
+    }
+  };
+}
+function mergeWorkerUi(current, incoming) {
+  if (!incoming)
+    return current;
+  return {
+    ...current,
+    ...incoming,
+    agent: {
+      ...current?.agent || {},
+      ...incoming.agent || {}
+    }
+  };
+}
 function createRpcClient(port) {
   const pending = /* @__PURE__ */ new Map();
   port.onmessage = (ev) => {
@@ -3725,16 +4284,18 @@ async function getCurrentTab() {
       return {
         id: Number(tabContext.logicalTabId || tabContext.id || 1),
         url: tabContext.url,
-        title: tabContext.title
+        title: tabContext.title,
+        external: false,
+        accessMode: "live_dom"
       };
     }
   } catch {
   }
   try {
     const pageData = await bridgeRpc("getPageData");
-    return { id: 1, url: pageData?.url, title: pageData?.title };
+    return { id: 1, url: pageData?.url, title: pageData?.title, external: false, accessMode: "live_dom" };
   } catch {
-    return { id: 1 };
+    return { id: 1, external: false, accessMode: "live_dom" };
   }
 }
 async function getKnownTabs() {
@@ -3743,11 +4304,32 @@ async function getKnownTabs() {
   try {
     const listed = await bridgeRpc("listSessionTabs");
     if (Array.isArray(listed) && listed.length > 0) {
-      const mapped = listed.map((tab) => ({
-        id: Number(tab?.logicalTabId || tab?.id || 0),
-        url: typeof tab?.url === "string" ? tab.url : void 0,
-        title: typeof tab?.title === "string" ? tab.title : void 0
-      })).filter((tab) => Number.isFinite(tab.id) && tab.id > 0);
+      const nowMs = Date.now();
+      const mapped = listed.map((tab) => {
+        const id = Number(tab?.logicalTabId || tab?.id || 0);
+        const external = !!tab?.external;
+        return {
+          id,
+          runtimeId: typeof tab?.runtimeId === "string" ? tab.runtimeId : void 0,
+          updatedAt: Number(tab?.updatedAt) || 0,
+          url: typeof tab?.url === "string" ? tab.url : void 0,
+          title: typeof tab?.title === "string" ? tab.title : void 0,
+          external,
+          accessMode: tab?.accessMode === "external_scraped" || tab?.accessMode === "external_placeholder" ? tab.accessMode : external ? "external_placeholder" : "live_dom",
+          inaccessibleReason: typeof tab?.inaccessibleReason === "string" ? tab.inaccessibleReason : void 0
+        };
+      }).filter((tab) => Number.isFinite(tab.id) && tab.id > 0).filter((tab) => {
+        if (!tab.external || tab.runtimeId)
+          return true;
+        return nowMs - (tab.updatedAt || 0) <= DETACHED_EXTERNAL_TAB_MAX_AGE_MS;
+      }).map((tab) => ({
+        id: tab.id,
+        url: tab.url,
+        title: tab.title,
+        external: tab.external,
+        accessMode: tab.accessMode,
+        inaccessibleReason: tab.inaccessibleReason
+      }));
       if (mapped.length)
         return mapped;
     }
@@ -4112,19 +4694,46 @@ function maybePostNavigationGuardrailFromToolResult(toolResult) {
   });
 }
 function buildChatLogFromHistory(input, currentUserInput) {
+  const sanitizeChatText = (raw, role) => {
+    let text = String(raw || "").replace(/\s+/g, " ").trim();
+    if (!text)
+      return "";
+    if (role === "assistant") {
+      if (/^\w[\w_]*:\s*\{/.test(text) || /^\[error\]/i.test(text) || /"success":\s*false/.test(text)) {
+        const firstSentence = text.split(/(?<=\.)\s+/)[0] || text;
+        text = firstSentence.trim();
+      }
+    }
+    if (text.length > MAX_CHATLOG_MESSAGE_CHARS2) {
+      text = `${text.slice(0, MAX_CHATLOG_MESSAGE_CHARS2 - 1)}\u2026`;
+    }
+    return text;
+  };
+  const normalizedCurrentUserInput = currentUserInput ? sanitizeChatText(currentUserInput, "user") : "";
   const entries = input.filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
     role: message.role,
-    content: String(message.content || "")
-  }));
-  if (currentUserInput) {
+    content: sanitizeChatText(String(message.content || ""), message.role)
+  })).filter((message) => !!message.content);
+  if (normalizedCurrentUserInput) {
     for (let i = entries.length - 1; i >= 0; i -= 1) {
-      if (entries[i].role === "user" && entries[i].content === currentUserInput) {
+      if (entries[i].role === "user" && entries[i].content === normalizedCurrentUserInput) {
         entries.splice(i, 1);
         break;
       }
     }
   }
-  return entries.slice(-40).map((message) => ({
+  const deduped = [];
+  for (const entry of entries) {
+    const previous = deduped[deduped.length - 1];
+    if (previous && previous.role === entry.role && previous.content === entry.content)
+      continue;
+    deduped.push(entry);
+  }
+  const tail = deduped.slice(-MAX_CHATLOG_ENTRIES2);
+  while (tail.length > 1 && tail[0]?.role !== "user") {
+    tail.shift();
+  }
+  return tail.map((message) => ({
     role: message.role === "user" ? "user" : "model",
     message: message.content
   }));
@@ -4222,6 +4831,9 @@ async function waitForNewTabReady(logicalTabId, timeoutMs = 1e4) {
       const tabs = await bridgeRpc("listSessionTabs");
       if (Array.isArray(tabs)) {
         const target = tabs.find((t) => Number(t?.logicalTabId) === logicalTabId);
+        if (target?.external) {
+          return true;
+        }
         if (target?.runtimeId) {
           await new Promise((resolve) => setTimeout(resolve, 1e3));
           return true;
@@ -4242,6 +4854,81 @@ function detectOpenedTabFromToolResult(result) {
   }
   return void 0;
 }
+function deriveDirectToolRunOutcome(result) {
+  if (!result || typeof result !== "object") {
+    return { taskComplete: false };
+  }
+  const topLevelStatus = String(result.status || "").trim().toLowerCase();
+  if (topLevelStatus === "failure" || topLevelStatus === "failed" || topLevelStatus === "error") {
+    return { taskComplete: false };
+  }
+  if (topLevelStatus === "waiting_input" || topLevelStatus === "needs_input" || topLevelStatus === "pending_user_input") {
+    return { taskComplete: false, needsUserInput: true };
+  }
+  if (result.error) {
+    return { taskComplete: false };
+  }
+  const output = result.output;
+  if (output && typeof output === "object") {
+    if (Array.isArray(output)) {
+      return { taskComplete: true };
+    }
+    if (output.needsUserInput === true || output.waitingForUserInput === true) {
+      return { taskComplete: false, needsUserInput: true };
+    }
+    if (Array.isArray(output.questions) && output.questions.length > 0) {
+      return { taskComplete: false, needsUserInput: true };
+    }
+    if (output.error) {
+      return { taskComplete: false };
+    }
+    if (typeof output.taskComplete === "boolean") {
+      return { taskComplete: !!output.taskComplete };
+    }
+    const taskStatus = String(output.taskStatus || output.status || "").toLowerCase();
+    if (taskStatus) {
+      if (taskStatus === "waiting_input" || taskStatus === "needs_input" || taskStatus === "pending_user_input") {
+        return { taskComplete: false, needsUserInput: true };
+      }
+      if (taskStatus === "running" || taskStatus === "in_progress" || taskStatus === "pending") {
+        return { taskComplete: false };
+      }
+      if (taskStatus === "completed" || taskStatus === "complete" || taskStatus === "done" || taskStatus === "success") {
+        return { taskComplete: true };
+      }
+      if (taskStatus === "failure" || taskStatus === "failed" || taskStatus === "error") {
+        return { taskComplete: false };
+      }
+    }
+    if (output.success === false) {
+      return { taskComplete: false };
+    }
+    if (String(output.status || "").trim().toLowerCase() === "failure") {
+      return { taskComplete: false };
+    }
+  }
+  if (output != null) {
+    return { taskComplete: true };
+  }
+  return { taskComplete: false };
+}
+function normalizeRunOutcome(outcome) {
+  if (!outcome || typeof outcome !== "object") {
+    return { taskComplete: false, needsUserInput: false };
+  }
+  const needsUserInput = outcome.needsUserInput === true;
+  const taskComplete = outcome.taskComplete === true && !needsUserInput;
+  return {
+    route: outcome.route,
+    taskComplete,
+    needsUserInput
+  };
+}
+function clearTaskScopedContextAfterCompletion() {
+  history.length = 0;
+  plannerHistory = [];
+  agentPrevSteps = [];
+}
 async function maybeWaitForNewTab(result) {
   const logicalTabId = detectOpenedTabFromToolResult(result);
   if (logicalTabId) {
@@ -4261,10 +4948,50 @@ async function handleUserMessage(text, options) {
     postStateSnapshot();
   }
   const tabs = await getKnownTabs();
+  const fallbackTabs = tabs.length > 0 ? tabs : [
+    {
+      id: 1,
+      external: false,
+      accessMode: "live_dom"
+    }
+  ];
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc, fallbackTabs);
+  const tabsById = new Map(tabs.map((tab) => [tab.id, tab]));
+  const orderedTabs = resolvedTabs.tabOrder.map((tabId) => {
+    const knownTab = tabsById.get(tabId);
+    if (knownTab)
+      return knownTab;
+    const tabMeta = resolvedTabs.tabMetaById[tabId];
+    if (!tabMeta)
+      return { id: tabId };
+    const external = !!tabMeta.external;
+    return {
+      id: tabId,
+      url: tabMeta.url,
+      title: tabMeta.title,
+      external,
+      accessMode: tabMeta.accessMode || (external ? "external_placeholder" : "live_dom"),
+      inaccessibleReason: tabMeta.inaccessibleReason
+    };
+  }).filter((tab) => Number.isFinite(tab.id) && tab.id > 0);
+  const tabsForRun = orderedTabs.length > 0 ? orderedTabs : fallbackTabs;
   if (!tabularStore) {
     tabularStore = new TabularStore(`rover-${trajectoryId}`);
   }
-  const ctx = createAgentContext({ ...config, signal: activeAbortController?.signal }, bridgeRpc, tabularStore);
+  const agentName = resolveAgentName(config);
+  const runtimeContext = buildRoverRuntimeContext2({
+    tabs: tabsForRun,
+    agentName,
+    externalNavigationPolicy: resolveRuntimeExternalNavigationPolicy(config)
+  });
+  const ctx = createAgentContext({
+    ...config,
+    signal: activeAbortController?.signal,
+    runtimeContext,
+    tools: {
+      web: extractWebToolsConfig(config)
+    }
+  }, bridgeRpc, tabularStore);
   const currentRunId = activeRun?.runId;
   ctx.isCancelled = () => cancelledRunId === currentRunId;
   const functionDeclarations = dedupeFunctionDeclarations(removePlannerNameCollisions(toolRegistry.getFunctionDeclarations()));
@@ -4278,7 +5005,7 @@ async function handleUserMessage(text, options) {
     postStateSnapshot();
   };
   const result = await handleSendMessageWithFunctions(text, {
-    tabs,
+    tabs: tabsForRun,
     previousMessages: history,
     trajectoryId,
     files: [],
@@ -4308,7 +5035,7 @@ async function handleUserMessage(text, options) {
     history.push({ role: "assistant", content: errorMsg });
     postStatus("Execution failed", errorPayload.error.message, "complete");
     postStateSnapshot();
-    return result.route;
+    return { route: result.route, taskComplete: false };
   }
   if (result.executedFunctions?.length) {
     for (const fn of result.executedFunctions) {
@@ -4323,7 +5050,7 @@ async function handleUserMessage(text, options) {
     history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", "Function calls finished", "complete");
     postStateSnapshot();
-    return result.route;
+    return { route: result.route, taskComplete: true };
   }
   if (result.directToolResult) {
     await maybeWaitForNewTab(result.directToolResult);
@@ -4341,7 +5068,12 @@ async function handleUserMessage(text, options) {
     history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", structuredError?.error.message, "complete");
     postStateSnapshot();
-    return result.route;
+    const outcome = deriveDirectToolRunOutcome(result.directToolResult);
+    return {
+      route: result.route,
+      taskComplete: outcome.taskComplete,
+      needsUserInput: outcome.needsUserInput
+    };
   }
   if (result.plannerResponse) {
     postStatus("Verifying planner output", void 0, "verify");
@@ -4360,7 +5092,7 @@ ${qText}`;
       history.push({ role: "assistant", content: msg2 });
       postStatus("Planner needs user input", void 0, "verify");
       postStateSnapshot();
-      return result.route;
+      return { route: result.route, taskComplete: false, needsUserInput: true };
     }
     const toolResults = result.plannerResponse.toolResults || [];
     for (const toolResult of toolResults) {
@@ -4377,18 +5109,30 @@ ${qText}`;
     history.push({ role: "assistant", content: msg });
     postStatus("Planner execution completed", response.overallThought, "complete");
     postStateSnapshot();
-    return result.route;
+    return {
+      route: result.route,
+      taskComplete: !!response.taskComplete && !responseError,
+      needsUserInput: false
+    };
   }
   postAssistantMessage("Done.");
   history.push({ role: "assistant", content: "Done." });
   postStatus("Completed", void 0, "complete");
   postStateSnapshot();
-  return result.route;
+  return { route: result.route, taskComplete: true };
 }
 async function runUserMessage(text, meta) {
   const runId = meta?.runId || crypto.randomUUID();
   if (completedRunIds.has(runId)) {
-    self.postMessage({ type: "run_completed", runId, ok: true, route: void 0 });
+    const cachedOutcome = normalizeRunOutcome(completedRunOutcomes.get(runId));
+    self.postMessage({
+      type: "run_completed",
+      runId,
+      ok: true,
+      route: cachedOutcome.route,
+      taskComplete: cachedOutcome.taskComplete,
+      needsUserInput: cachedOutcome.needsUserInput
+    });
     return;
   }
   if (activeRun && activeRun.runId === runId) {
@@ -4402,13 +5146,39 @@ async function runUserMessage(text, meta) {
   self.postMessage({ type: "run_started", runId, text, resume });
   postStateSnapshot();
   try {
-    const route = await handleUserMessage(text, { resume });
-    self.postMessage({ type: "run_completed", runId, ok: true, route });
+    const outcome = normalizeRunOutcome(await handleUserMessage(text, { resume }));
+    completedRunOutcomes.set(runId, outcome);
+    self.postMessage({
+      type: "run_completed",
+      runId,
+      ok: true,
+      route: outcome.route,
+      taskComplete: outcome.taskComplete,
+      needsUserInput: outcome.needsUserInput
+    });
+    if (outcome.taskComplete && !outcome.needsUserInput) {
+      clearTaskScopedContextAfterCompletion();
+      postStateSnapshot();
+    }
   } catch (error) {
     if (error?.name === "AbortError") {
-      self.postMessage({ type: "run_completed", runId, ok: false, error: "Run cancelled" });
+      self.postMessage({
+        type: "run_completed",
+        runId,
+        ok: false,
+        error: "Run cancelled",
+        taskComplete: false,
+        needsUserInput: false
+      });
     } else {
-      self.postMessage({ type: "run_completed", runId, ok: false, error: error?.message || String(error) });
+      self.postMessage({
+        type: "run_completed",
+        runId,
+        ok: false,
+        error: error?.message || String(error),
+        taskComplete: false,
+        needsUserInput: false
+      });
       throw error;
     }
   } finally {
@@ -4417,8 +5187,10 @@ async function runUserMessage(text, meta) {
     completedRunIds.add(runId);
     if (completedRunIds.size > 50) {
       const oldest = completedRunIds.values().next().value;
-      if (oldest)
+      if (oldest) {
         completedRunIds.delete(oldest);
+        completedRunOutcomes.delete(oldest);
+      }
     }
     postStateSnapshot();
   }
@@ -4457,7 +5229,12 @@ self.onmessage = async (ev) => {
       if (!config)
         throw new Error("Worker not initialized");
       const partial = data.config || {};
-      config = { ...config, ...partial };
+      config = {
+        ...config,
+        ...partial,
+        ui: mergeWorkerUi(config.ui, partial.ui),
+        tools: mergeWorkerTools(config.tools, partial.tools)
+      };
       if (typeof partial.sessionId === "string" && partial.sessionId.trim() && partial.sessionId.trim() !== trajectoryId) {
         trajectoryId = partial.sessionId.trim();
         plannerHistory = [];