@rtrvr-ai/rover 1.3.1 → 1.3.3

package/dist/worker/rover-worker.js

@@ -113,6 +113,8 @@ var PLANNER_FUNCTION_CALLS;
   PLANNER_FUNCTION_CALLS2["GOOGLE_SLIDES_GENERATOR"] = "google_slides_generator";
   PLANNER_FUNCTION_CALLS2["PROCESS_TEXT"] = "process_text";
   PLANNER_FUNCTION_CALLS2["CREATE_SHEET_FROM_DATA"] = "create_sheet_from_data";
+  PLANNER_FUNCTION_CALLS2["ROVER_EXTERNAL_READ_CONTEXT"] = "rover_external_read_context";
+  PLANNER_FUNCTION_CALLS2["ROVER_EXTERNAL_ACT_CONTEXT"] = "rover_external_act_context";
   PLANNER_FUNCTION_CALLS2["CONFIGURE_API_KEY"] = "configure_api_key";
   PLANNER_FUNCTION_CALLS2["TASK_COMPLETE"] = "task_complete";
   PLANNER_FUNCTION_CALLS2["ASK_USER"] = "ask_user";
@@ -135,6 +137,8 @@ var FUNCTION_CALLS;
   FUNCTION_CALLS2["GOOGLE_SLIDES_GENERATOR"] = "Google Slides Generator";
   FUNCTION_CALLS2["PROCESS_TEXT"] = "Process Text";
   FUNCTION_CALLS2["CREATE_SHEET_FROM_DATA"] = "Create Sheet From Data";
+  FUNCTION_CALLS2["ROVER_EXTERNAL_READ_CONTEXT"] = "Rover External Read Context";
+  FUNCTION_CALLS2["ROVER_EXTERNAL_ACT_CONTEXT"] = "Rover External Act Context";
   FUNCTION_CALLS2["EXECUTE_MULTIPLE_TOOLS"] = "Execute Multiple User Tools";
   FUNCTION_CALLS2["CONFIGURE_API_KEY"] = "Configure Gemini API Key";
   FUNCTION_CALLS2["QUERY_RTRVR_AI_DOCUMENTATION"] = "query_rtrvr_ai_documentation";
@@ -152,6 +156,8 @@ var plannerFunctionCallValueToFunctionCallValueMap = {
   [PLANNER_FUNCTION_CALLS.GOOGLE_SLIDES_GENERATOR]: FUNCTION_CALLS.GOOGLE_SLIDES_GENERATOR,
   [PLANNER_FUNCTION_CALLS.PROCESS_TEXT]: FUNCTION_CALLS.PROCESS_TEXT,
   [PLANNER_FUNCTION_CALLS.CREATE_SHEET_FROM_DATA]: FUNCTION_CALLS.CREATE_SHEET_FROM_DATA,
+  [PLANNER_FUNCTION_CALLS.ROVER_EXTERNAL_READ_CONTEXT]: FUNCTION_CALLS.ROVER_EXTERNAL_READ_CONTEXT,
+  [PLANNER_FUNCTION_CALLS.ROVER_EXTERNAL_ACT_CONTEXT]: FUNCTION_CALLS.ROVER_EXTERNAL_ACT_CONTEXT,
   [PLANNER_FUNCTION_CALLS.EXECUTE_MULTIPLE_TOOLS]: FUNCTION_CALLS.EXECUTE_MULTIPLE_TOOLS,
   [PLANNER_FUNCTION_CALLS.CONFIGURE_API_KEY]: FUNCTION_CALLS.CONFIGURE_API_KEY,
   [PLANNER_FUNCTION_CALLS.QUERY_RTRVR_AI_DOCUMENTATION]: FUNCTION_CALLS.QUERY_RTRVR_AI_DOCUMENTATION
@@ -161,27 +167,6 @@ 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)
@@ -607,6 +592,18 @@ var isMemorySheetId = (sheetId) => {
 // dist/agent/errors.js
 function inferErrorCode(message) {
   const text = String(message || "").toLowerCase();
+  if (text.includes("stale_seq") || text.includes("stale seq"))
+    return "STALE_SEQ";
+  if (text.includes("stale_epoch") || text.includes("stale epoch"))
+    return "STALE_EPOCH";
+  if (text.includes("session token") && text.includes("expired"))
+    return "SESSION_TOKEN_EXPIRED";
+  if (text.includes("session token") && text.includes("invalid"))
+    return "SESSION_TOKEN_INVALID";
+  if (text.includes("bootstrap") && text.includes("required"))
+    return "BOOTSTRAP_REQUIRED";
+  if (text.includes("navigation handoff"))
+    return "NAVIGATION_HANDOFF_PENDING";
   if ((text.includes("auth token") || text.includes("authentication token")) && (text.includes("missing") || text.includes("required"))) {
     return "MISSING_AUTH_TOKEN";
   }
@@ -630,31 +627,78 @@ function inferErrorCode(message) {
 }
 function defaultNextActionForCode(code) {
   if (code === "MISSING_AUTH" || code === "MISSING_AUTH_TOKEN") {
-    return "Provide the required auth token in tool input or rover.boot(...).";
+    return "Provide a valid rvrsess_* sessionToken from /v1/rover/session/start in rover.boot(...).";
   }
   if (code === "MISSING_API_KEY") {
-    return "Provide apiKey in rover.boot(...) or an Authorization Bearer token.";
+    return "Use a Rover session token (rvrsess_*) from /v1/rover/session/start.";
   }
   if (code === "INVALID_API_KEY") {
-    return "Use a valid active rtrvr_ API key.";
+    return "Use a valid active Rover session token or rotate your site public key.";
+  }
+  if (code === "STALE_SEQ") {
+    return "Sync session projection and retry with latest seq.";
+  }
+  if (code === "STALE_EPOCH") {
+    return "Refresh session token/projection and retry with latest epoch.";
+  }
+  if (code === "SESSION_TOKEN_EXPIRED") {
+    return "Refresh session via /v1/rover/session/start using bootstrap public key (pk_site_*), then retry.";
+  }
+  if (code === "SESSION_TOKEN_INVALID") {
+    return "Initialize a fresh session token via /v1/rover/session/start and retry.";
+  }
+  if (code === "BOOTSTRAP_REQUIRED") {
+    return "Provide a valid pk_site_* key in bootstrapToken/publicKey and retry session start.";
+  }
+  if (code === "NAVIGATION_HANDOFF_PENDING") {
+    return "Wait for post-navigation hydration/projection sync and retry.";
   }
   return void 0;
 }
 function toRoverErrorEnvelope(err, fallbackMessage = "Operation failed") {
+  const rawErrorCode = String(err?.error || "").trim().toLowerCase();
+  if (rawErrorCode === "stale_seq" || rawErrorCode === "stale_epoch" || rawErrorCode === "session_token_expired" || rawErrorCode === "session_token_invalid" || rawErrorCode === "bootstrap_required") {
+    const code2 = rawErrorCode === "stale_epoch" ? "STALE_EPOCH" : rawErrorCode === "session_token_expired" ? "SESSION_TOKEN_EXPIRED" : rawErrorCode === "session_token_invalid" ? "SESSION_TOKEN_INVALID" : rawErrorCode === "bootstrap_required" ? "BOOTSTRAP_REQUIRED" : "STALE_SEQ";
+    const data = err?.data && typeof err.data === "object" ? err.data : {};
+    const message2 = typeof data?.reason === "string" ? data.reason : rawErrorCode === "stale_epoch" ? "Session epoch is stale." : rawErrorCode === "session_token_expired" ? "Session token expired." : rawErrorCode === "session_token_invalid" ? "Session token invalid." : rawErrorCode === "bootstrap_required" ? "Bootstrap token required." : "Run sequence is stale.";
+    return {
+      code: code2,
+      message: message2,
+      next_action: defaultNextActionForCode(code2),
+      retryable: code2 === "STALE_SEQ" || code2 === "STALE_EPOCH" || code2 === "SESSION_TOKEN_EXPIRED",
+      details: err
+    };
+  }
   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) {
+    const candidateCodeRaw = String(candidate.code || "").trim();
+    const normalizedCandidateCode = candidateCodeRaw === "stale_seq" ? "STALE_SEQ" : candidateCodeRaw === "stale_epoch" ? "STALE_EPOCH" : candidateCodeRaw === "session_token_expired" ? "SESSION_TOKEN_EXPIRED" : candidateCodeRaw === "session_token_invalid" ? "SESSION_TOKEN_INVALID" : candidateCodeRaw === "bootstrap_required" ? "BOOTSTRAP_REQUIRED" : candidateCodeRaw === "navigation_handoff_pending" ? "NAVIGATION_HANDOFF_PENDING" : candidateCodeRaw;
+    const normalizedCode = normalizedCandidateCode;
+    const retryable = typeof candidate.retryable === "boolean" ? candidate.retryable : normalizedCode === "STALE_SEQ" || normalizedCode === "STALE_EPOCH" || normalizedCode === "SESSION_TOKEN_EXPIRED" || normalizedCode === "NAVIGATION_HANDOFF_PENDING";
     return {
-      code: candidate.code,
+      code: normalizedCode,
       message: candidate.message,
       requires_api_key: !!candidate.requires_api_key,
       missing: Array.isArray(candidate.missing) ? candidate.missing : void 0,
-      next_action: candidate.next_action,
-      retryable: candidate.retryable,
+      next_action: candidate.next_action || defaultNextActionForCode(normalizedCode),
+      retryable,
       degraded: candidate.degraded,
       details: candidate.details
     };
   }
+  if (typeof err === "string") {
+    const message2 = err || fallbackMessage;
+    const code2 = inferErrorCode(message2);
+    return {
+      code: code2,
+      message: message2,
+      requires_api_key: code2 === "MISSING_API_KEY" || code2 === "INVALID_API_KEY",
+      missing: code2 === "MISSING_AUTH" || code2 === "MISSING_AUTH_TOKEN" ? ["authToken"] : void 0,
+      next_action: defaultNextActionForCode(code2),
+      retryable: code2 === "NETWORK_ERROR" || code2 === "STALE_SEQ" || code2 === "STALE_EPOCH" || code2 === "SESSION_TOKEN_EXPIRED" || code2 === "NAVIGATION_HANDOFF_PENDING"
+    };
+  }
   const message = String(err?.message || err?.error || fallbackMessage);
   const code = inferErrorCode(message);
   const requiresApiKey = code === "MISSING_API_KEY" || code === "INVALID_API_KEY";
@@ -662,9 +706,9 @@ function toRoverErrorEnvelope(err, fallbackMessage = "Operation failed") {
     code,
     message,
     requires_api_key: requiresApiKey,
-    missing: requiresApiKey ? ["apiKey"] : code === "MISSING_AUTH" || code === "MISSING_AUTH_TOKEN" ? ["authToken"] : void 0,
+    missing: requiresApiKey ? ["publicKey"] : code === "MISSING_AUTH" || code === "MISSING_AUTH_TOKEN" ? ["authToken"] : void 0,
     next_action: defaultNextActionForCode(code),
-    retryable: code === "NETWORK_ERROR",
+    retryable: code === "NETWORK_ERROR" || code === "STALE_SEQ" || code === "STALE_EPOCH" || code === "SESSION_TOKEN_EXPIRED" || code === "NAVIGATION_HANDOFF_PENDING",
     details: err
   };
 }
@@ -788,6 +832,30 @@ function normalizeRuntimeExternalTabs(input) {
   }
   return Array.from(deduped.values());
 }
+function selectExternalIntent(requestedIntent, message) {
+  if (requestedIntent === "act")
+    return "act";
+  if (requestedIntent === "read_context")
+    return "read_context";
+  if (requestedIntent === "open_only")
+    return "open_only";
+  const normalized = String(message || "").toLowerCase();
+  if (!normalized.trim())
+    return "read_context";
+  const mutationSignals = /\b(fill|submit|book|buy|purchase|apply|sign up|signup|log in|login|register|delete|update|create|post|send|checkout|pay)\b/i;
+  const navigationSignals = /\b(open|navigate|go to|visit|take me to|bring me to)\b/i;
+  const readSignals = /\b(read|summarize|extract|inspect|analyze|check|find|lookup|list|show|compare|review)\b/i;
+  if (mutationSignals.test(normalized) && !/\b(do not|don't)\b/i.test(normalized)) {
+    return "act";
+  }
+  if (navigationSignals.test(normalized) && !readSignals.test(normalized)) {
+    return "read_context";
+  }
+  if (readSignals.test(normalized)) {
+    return "read_context";
+  }
+  return "read_context";
+}
 function resolveExtensionRouterEndpoint(apiBase) {
   const fallback = DEFAULT_EXTENSION_ROUTER_BASE;
   const base = String(apiBase || fallback).trim().replace(/\/+$/, "");
@@ -806,6 +874,24 @@ function resolveExtensionRouterEndpoint(apiBase) {
   }
   return `${base}/extensionRouter`;
 }
+function resolveRoverV1Endpoint(apiBase) {
+  const fallback = DEFAULT_EXTENSION_ROUTER_BASE;
+  const base = String(apiBase || fallback).trim().replace(/\/+$/, "");
+  if (!base)
+    return `${fallback}/v1/rover`;
+  if (base.endsWith("/extensionRouter")) {
+    return `${base.slice(0, -"/extensionRouter".length)}/v1/rover`;
+  }
+  if (base.endsWith("/v1/rover"))
+    return base;
+  return `${base}/v1/rover`;
+}
+function createRequestNonce() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
 function buildRoverRuntimeContext(config2) {
   const runtimeContext = config2.runtimeContext;
   if (!runtimeContext || runtimeContext.mode !== "rover_embed")
@@ -854,7 +940,7 @@ function getUserFriendlyTimestamp() {
 }
 function createAgentContext(config2, bridgeRpc2, tabularStore2) {
   const userTimestamp = getUserFriendlyTimestamp();
-  const apiMode = typeof config2.apiMode === "boolean" ? config2.apiMode : !!config2.apiKey;
+  const apiMode = typeof config2.apiMode === "boolean" ? config2.apiMode : !!String(config2.sessionToken || config2.authToken || "").trim();
   const llmIntegration = {
     model: config2.llmIntegration?.model || config2.model || DEFAULT_GEMINI_MODEL
   };
@@ -870,6 +956,7 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     llmIntegration.enableGoogleAiStudioApiKey = true;
   }
   const endpoint = resolveExtensionRouterEndpoint(config2.apiBase);
+  const roverV1Endpoint = resolveRoverV1Endpoint(config2.apiBase);
   const runtimeContext = buildRoverRuntimeContext(config2);
   const externalWebConfig = normalizeExternalWebConfig(config2.tools?.web);
   const externalPageDataCache = /* @__PURE__ */ new Map();
@@ -882,13 +969,21 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
   const ACTIVE_TAB_CACHE_TTL_MS = 250;
   const EXTERNAL_PAGE_CACHE_TTL_MS = 45e3;
   const callExtensionRouter = async (action, data) => {
-    const token = config2.authToken || config2.apiKey;
-    if (!token) {
+    let sessionToken = String(config2.sessionToken || config2.authToken || "").trim();
+    if (!sessionToken || !sessionToken.startsWith("rvrsess_")) {
+      for (let wait = 0; wait < 3; wait++) {
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        sessionToken = String(config2.sessionToken || config2.authToken || "").trim();
+        if (sessionToken && sessionToken.startsWith("rvrsess_"))
+          break;
+      }
+    }
+    if (!sessionToken || !sessionToken.startsWith("rvrsess_")) {
       throw createRoverError({
-        code: "MISSING_API_KEY",
-        message: "Rover API key is required to call extensionRouter.",
-        requires_api_key: true,
-        next_action: "Provide apiKey in rover.boot(...) or an Authorization Bearer token.",
+        code: "MISSING_AUTH_TOKEN",
+        message: "Rover session token is required to call backend action routes.",
+        requires_api_key: false,
+        next_action: "Initialize Rover session via /v1/rover/session/start and pass sessionToken to rover.boot(...).",
         retryable: false
       });
     }
@@ -900,15 +995,24 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
       const response = await fetch(endpoint, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${token}`,
           "Content-Type": "application/json"
         },
         body: JSON.stringify({
           action,
           data: data && typeof data === "object" ? {
             ...data,
+            sessionToken,
+            sessionId: String(config2.sessionId || "").trim() || void 0,
+            runId: String(config2.activeRunId || "").trim() || void 0,
+            requestNonce: createRequestNonce(),
             ...!data.runtimeContext && runtimeContext ? { runtimeContext } : {}
-          } : data
+          } : {
+            payload: data,
+            sessionToken,
+            sessionId: String(config2.sessionId || "").trim() || void 0,
+            runId: String(config2.activeRunId || "").trim() || void 0,
+            requestNonce: createRequestNonce()
+          }
         }),
         signal: config2.signal
       });
@@ -967,7 +1071,9 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     if (!normalizedUrl)
       throw new Error("external page data requires url");
     const cacheTabId = Number(options?.tabId) || 0;
-    const cacheKey = `${cacheTabId}:${normalizedUrl}`;
+    const source = options?.source || "direct_url";
+    const intent = options?.intent === "act" ? "act" : options?.intent === "open_only" ? "open_only" : "read_context";
+    const cacheKey = `${cacheTabId}:${intent}:${source}:${normalizedUrl}`;
     const nowMs = Date.now();
     const cachedData = externalPageDataCache.get(cacheKey);
     if (cachedData && nowMs - cachedData.ts <= EXTERNAL_PAGE_CACHE_TTL_MS) {
@@ -982,19 +1088,49 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     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
-      }
-    };
+    const sessionToken = String(config2.sessionToken || "").trim();
+    if (!sessionToken.startsWith("rvrsess_")) {
+      throw createRoverError({
+        code: "MISSING_AUTH_TOKEN",
+        message: "External context requires a Rover session token.",
+        next_action: "Initialize Rover v1 session/start before requesting external context.",
+        retryable: false
+      });
+    }
     try {
-      const response = await callExtensionRouter(SUB_AGENTS.roverExternalPageData, payload);
-      const pageData = response?.data || response;
+      const v1Resp = await fetch(`${roverV1Endpoint}/context/external`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          requestNonce: createRequestNonce(),
+          sessionToken,
+          sessionId: String(config2.sessionId || "").trim() || void 0,
+          runId: String(options?.runId || config2.activeRunId || "").trim() || void 0,
+          expectedEpoch: Number.isFinite(Number(config2.sessionEpoch)) ? Number(config2.sessionEpoch) : void 0,
+          expectedSeq: Number.isFinite(Number(config2.sessionSeq)) ? Number(config2.sessionSeq) : void 0,
+          logicalTabId: Number(options?.tabId) > 0 ? String(Math.trunc(Number(options?.tabId))) : void 0,
+          intent,
+          url: normalizedUrl,
+          source,
+          message: options?.message
+        }),
+        signal: config2.signal
+      });
+      const payload = await v1Resp.json().catch(() => void 0);
+      if (!v1Resp.ok || payload?.success === false) {
+        const envelope = toRoverErrorEnvelope(payload, payload?.error || `external context request failed (${v1Resp.status})`);
+        throw createRoverError({
+          ...envelope,
+          details: {
+            endpoint: `${roverV1Endpoint}/context/external`,
+            status: v1Resp.status,
+            response: payload
+          }
+        });
+      }
+      const pageData = payload?.data?.pageData || payload?.data;
       externalPageDataCache.set(cacheKey, { data: pageData, ts: nowMs });
       return pageData;
     } catch (error) {
@@ -1028,7 +1164,10 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     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 requestedExternalIntent = rawOptions?.__roverExternalIntent === "act" || rawOptions?.__roverExternalIntent === "open_only" || rawOptions?.__roverExternalIntent === "read_context" || rawOptions?.__roverExternalIntent === "auto" ? rawOptions.__roverExternalIntent : "auto";
+    const externalMessage = typeof rawOptions?.__roverExternalMessage === "string" ? String(rawOptions.__roverExternalMessage) : void 0;
+    const externalIntent = selectExternalIntent(requestedExternalIntent, externalMessage);
+    const pageConfig = rawOptions && typeof rawOptions === "object" ? Object.fromEntries(Object.entries(rawOptions).filter(([key]) => key !== "__roverAllowExternalFetch" && key !== "__roverExternalIntent" && key !== "__roverExternalMessage")) : 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 || {};
@@ -1070,8 +1209,13 @@ function createAgentContext(config2, bridgeRpc2, tabularStore2) {
     try {
       const cloudData = await getExternalPageData(pageUrl, {
         tabId: numericTabId,
-        source: pageUrl.includes("google.com/search") ? "google_search" : "direct_url"
+        source: pageUrl.includes("google.com/search") ? "google_search" : "direct_url",
+        intent: externalIntent,
+        message: externalMessage
       });
+      if (externalIntent === "open_only") {
+        return localPageData;
+      }
       if (cloudData && typeof cloudData === "object") {
         return {
           ...cloudData,
@@ -1315,6 +1459,27 @@ 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_AGENTS2["roverExternalPageData"] = "roverExternalPageData";
+})(SUB_AGENTS || (SUB_AGENTS = {}));
+
 // ../shared/dist/lib/system-tools/tools.js
 var SystemToolNames;
 (function(SystemToolNames2) {
@@ -1350,6 +1515,8 @@ var SystemToolNames;
   SystemToolNames2["describe_images"] = "describe_images";
   SystemToolNames2["google_search"] = "google_search";
   SystemToolNames2["network_run_recipe"] = "network_run_recipe";
+  SystemToolNames2["rover_external_read_context"] = "rover_external_read_context";
+  SystemToolNames2["rover_external_act_context"] = "rover_external_act_context";
   SystemToolNames2["copy_text"] = "copy_text";
   SystemToolNames2["paste_text"] = "paste_text";
   SystemToolNames2["wait_action"] = "wait_action";
@@ -1367,6 +1534,7 @@ var NAVIGATION_TOOLS = /* @__PURE__ */ new Set([
   SystemToolNames.go_back,
   SystemToolNames.go_forward,
   SystemToolNames.refresh_page,
+  SystemToolNames.open_new_tab,
   SystemToolNames.switch_tab,
   SystemToolNames.close_tab
 ]);
@@ -1381,12 +1549,26 @@ var VIEWPORT_SENSITIVE_TOOLS = /* @__PURE__ */ new Set([
   SystemToolNames.focus_element
 ]);
 var ACTION_DELAY_MS = 600;
-async function executeSystemToolCallsSequentially({ calls, bridgeRpc: bridgeRpc2 }) {
+var NAVIGATION_OUTCOMES = /* @__PURE__ */ new Set([
+  "same_tab_scheduled",
+  "new_tab_opened",
+  "blocked",
+  "switch_tab"
+]);
+function throwIfCancelled(isCancelled) {
+  if (!isCancelled?.())
+    return;
+  throw new DOMException("Run cancelled", "AbortError");
+}
+async function executeSystemToolCallsSequentially({ calls, bridgeRpc: bridgeRpc2, isCancelled }) {
   const results = [];
   let sawViewportSensitiveToolSuccess = false;
   let navigationOccurred = false;
   let navigationTool;
+  let navigationOutcome;
+  let logicalTabId;
   for (const call of calls) {
+    throwIfCancelled(isCancelled);
     const name = call.name;
     const args = call.args || {};
     if (navigationOccurred) {
@@ -1405,8 +1587,10 @@ async function executeSystemToolCallsSequentially({ calls, bridgeRpc: bridgeRpc2
     }
     let response;
     try {
+      throwIfCancelled(isCancelled);
       response = await bridgeRpc2("executeTool", { call });
     } catch (err) {
+      throwIfCancelled(isCancelled);
       response = { success: false, error: err?.message || String(err), allowFallback: true };
     }
     const llmResponse = {
@@ -1418,20 +1602,51 @@ async function executeSystemToolCallsSequentially({ calls, bridgeRpc: bridgeRpc2
     const resolvedResult = { name: name || "unknown", args, response: llmResponse };
     results.push(resolvedResult);
     if (response?.success) {
-      if (NAVIGATION_TOOLS.has(name)) {
+      const output = response?.output && typeof response.output === "object" ? response.output : void 0;
+      const outputNavigationOutcomeRaw = String(output?.navigationOutcome || "").trim().toLowerCase();
+      const outputNavigationOutcome = NAVIGATION_OUTCOMES.has(outputNavigationOutcomeRaw) ? outputNavigationOutcomeRaw : void 0;
+      const outputNavigationPending = output?.navigationPending === true;
+      const outputOpenedInNewTab = output?.openedInNewTab === true;
+      const inferredNavigation = !!outputNavigationOutcome || outputNavigationPending || outputOpenedInNewTab;
+      if (NAVIGATION_TOOLS.has(name) || inferredNavigation) {
         navigationOccurred = true;
         navigationTool = name;
         sawViewportSensitiveToolSuccess = false;
+        if (outputNavigationOutcome) {
+          navigationOutcome = outputNavigationOutcome;
+        } else if (outputOpenedInNewTab) {
+          navigationOutcome = "new_tab_opened";
+        } else if (name === SystemToolNames.switch_tab) {
+          navigationOutcome = "switch_tab";
+        } else if (name === SystemToolNames.open_new_tab) {
+          navigationOutcome = "new_tab_opened";
+        } else if (outputNavigationPending) {
+          navigationOutcome = "same_tab_scheduled";
+        } else {
+          navigationOutcome = "same_tab_scheduled";
+        }
+        const outputLogicalTabId = Number(output?.logicalTabId ?? output?.logical_tab_id ?? output?.tabId ?? output?.tab_id ?? args?.logical_tab_id ?? args?.tab_id);
+        if (Number.isFinite(outputLogicalTabId) && outputLogicalTabId > 0) {
+          logicalTabId = outputLogicalTabId;
+        }
       } else if (VIEWPORT_SENSITIVE_TOOLS.has(name)) {
         sawViewportSensitiveToolSuccess = true;
       }
     }
     if (ACTION_DELAY_MS > 0) {
       await new Promise((resolve) => setTimeout(resolve, ACTION_DELAY_MS));
+      throwIfCancelled(isCancelled);
     }
   }
   const disableAutoScroll = sawViewportSensitiveToolSuccess && !navigationOccurred;
-  return { results, disableAutoScroll, navigationOccurred, navigationTool };
+  return {
+    results,
+    disableAutoScroll,
+    navigationOccurred,
+    navigationTool,
+    navigationOutcome,
+    logicalTabId
+  };
 }
 
 // dist/agent/utils.js
@@ -1445,7 +1660,22 @@ async function waitWhilePaused(executionRef) {
     await new Promise((resolve) => setTimeout(resolve, 100));
   }
 }
-async function processActionResponse({ request, response, tabId, prevSteps, thought, bridgeRpc: bridgeRpc2, userFunctionDeclarations, onStatusUpdate, onPrevStepsUpdate }) {
+function buildWorkerStopSignal(params) {
+  if (params.isCancelled) {
+    return {
+      state: "cancel_requested",
+      reason: params.reason || "worker_cancelled"
+    };
+  }
+  return { state: "continue" };
+}
+async function processActionResponse({ request, response, tabId, prevSteps, thought, bridgeRpc: bridgeRpc2, isCancelled, userFunctionDeclarations, onStatusUpdate, onPrevStepsUpdate }) {
+  const throwIfCancelled2 = () => {
+    if (!isCancelled?.())
+      return;
+    throw new DOMException("Run cancelled", "AbortError");
+  };
+  throwIfCancelled2();
   const { functionCalls, modelParts, data, accTreeId } = response || {};
   let disableAutoScroll = false;
   if (data && Array.isArray(data) && data.length > 0) {
@@ -1548,6 +1778,7 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
       }
     }
     if (externalCalls.length > 0) {
+      throwIfCancelled2();
       if (userFunctionDeclarations?.length) {
         for (const funcCall of externalCalls) {
           const found = userFunctionDeclarations.find((decl) => decl.name === funcCall.name);
@@ -1575,6 +1806,7 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
       return { needsRetry: false, functionCalls: externalCalls };
     }
     if (systemCalls.length > 0) {
+      throwIfCancelled2();
       onStatusUpdate?.(`Executing browser actions: ${systemCalls.map((c) => c.name).join(", ")}`, thought, "execute");
       prevSteps.push({
         accTreeId,
@@ -1589,11 +1821,13 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
       limitPrevSteps(prevSteps);
       onPrevStepsUpdate?.(prevSteps);
       const stepIndex = prevSteps.length - 1;
-      const { results, disableAutoScroll: isScroll } = await executeSystemToolCallsSequentially({
+      const { results, disableAutoScroll: isScroll, navigationOccurred, navigationTool, navigationOutcome, logicalTabId } = await executeSystemToolCallsSequentially({
         calls: systemCalls,
-        bridgeRpc: bridgeRpc2
+        bridgeRpc: bridgeRpc2,
+        isCancelled
       });
       disableAutoScroll = isScroll;
+      throwIfCancelled2();
       if (stepIndex >= 0 && stepIndex < prevSteps.length) {
         prevSteps[stepIndex].functions = results;
         const failedCount = results.filter((r) => r.response.status === "Failure").length;
@@ -1603,7 +1837,14 @@ async function processActionResponse({ request, response, tabId, prevSteps, thou
       }
       limitPrevSteps(prevSteps);
       onPrevStepsUpdate?.(prevSteps);
-      return { needsRetry: false, disableAutoScroll };
+      return {
+        needsRetry: false,
+        disableAutoScroll,
+        navigationOccurred,
+        navigationTool,
+        navigationOutcome,
+        logicalTabId
+      };
     }
   }
   prevSteps.push({ accTreeId, thought, modelParts, fail: "Empty or unusable response" });
@@ -1757,81 +1998,192 @@ function normalizeListedTabs(input) {
     };
   }).filter((tab) => !!tab);
 }
+function preferScopedOrder(scopedOrder, activeTabId, maxContextTabs) {
+  const deduped = dedupePositiveTabIds(scopedOrder);
+  if (!deduped.length)
+    return [];
+  const activeInScope = deduped.includes(activeTabId);
+  const resolvedActive = activeInScope ? activeTabId : deduped[0];
+  const ordered = [
+    resolvedActive,
+    ...deduped.filter((tabId) => tabId !== resolvedActive)
+  ];
+  return ordered.slice(0, maxContextTabs);
+}
+function filterTabIdsToScope(tabIds, scopedTabIds2) {
+  if (!scopedTabIds2.length)
+    return dedupePositiveTabIds(tabIds);
+  const scoped = new Set(scopedTabIds2);
+  return dedupePositiveTabIds(tabIds).filter((tabId) => scoped.has(tabId));
+}
 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 scopedTabIds2 = dedupePositiveTabIds(options?.scopedTabIds || []);
+  const hasExplicitScope = scopedTabIds2.length > 0;
+  const scopedOrder = [...scopedTabIds2];
+  const scopedTabSet = new Set(scopedOrder);
   const fallbackSnapshots = normalizeFallbackTabs(fallbackTabs);
-  const fallbackTabIds = dedupePositiveTabIds(fallbackSnapshots.map((tab) => tab.id));
+  const fallbackTabIds = dedupePositiveTabIds((scopedTabIds2.length > 0 ? fallbackSnapshots.filter((tab) => scopedTabIds2.includes(tab.id)) : fallbackSnapshots).map((tab) => tab.id));
   let tabIds = [...fallbackTabIds];
   let listedTabs = [];
+  let listedTabIds = [];
+  const isTabInScope = (tabId) => {
+    if (!hasExplicitScope)
+      return true;
+    return scopedTabSet.has(tabId);
+  };
   if (bridgeRpc2) {
     try {
-      listedTabs = normalizeListedTabs(await bridgeRpc2("listSessionTabs"));
-      const listedIds = dedupePositiveTabIds(listedTabs.map((tab) => tab.id));
-      if (listedIds.length > 0) {
-        tabIds = listedIds;
+      const listed = await bridgeRpc2("listSessionTabs");
+      listedTabs = normalizeListedTabs(Array.isArray(listed) ? listed : []);
+      listedTabIds = dedupePositiveTabIds(listedTabs.map((tab) => tab.id));
+      if (listedTabIds.length > 0) {
+        tabIds = hasExplicitScope ? filterTabIdsToScope(listedTabIds, scopedOrder) : listedTabIds;
+      } else if (hasExplicitScope) {
+        tabIds = [...scopedOrder];
       }
     } catch {
     }
   }
-  let activeTabId = tabIds[0] || fallbackTabIds[0] || 1;
+  if (hasExplicitScope) {
+    tabIds = dedupePositiveTabIds(tabIds).filter((tabId) => isTabInScope(tabId));
+    if (!tabIds.length && scopedOrder.length) {
+      tabIds = [...scopedOrder];
+    }
+  }
+  let activeTabId = Number(options?.seedTabId) > 0 ? Number(options?.seedTabId) : 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) {
+      if (Number.isFinite(candidate) && candidate > 0 && isTabInScope(candidate)) {
         activeTabId = candidate;
       }
     } catch {
     }
   }
-  if (!tabIds.length) {
-    tabIds = [activeTabId];
-  } else if (!tabIds.includes(activeTabId)) {
-    tabIds = [activeTabId, ...tabIds];
+  if (hasExplicitScope && !isTabInScope(activeTabId) && scopedOrder.length > 0) {
+    activeTabId = scopedOrder[0];
   }
   const nowMs = Date.now();
   const listedById = /* @__PURE__ */ new Map();
   for (const tab of listedTabs)
     listedById.set(tab.id, tab);
-  const prioritized = tabIds.filter((tabId) => {
+  const freshRuntimeListedIds = listedTabs.filter((tab) => !!tab.runtimeId && nowMs - (tab.updatedAt || 0) <= staleRuntimeTabMaxAgeMs).map((tab) => tab.id);
+  if (freshRuntimeListedIds.length > 0 && !freshRuntimeListedIds.includes(activeTabId)) {
+    const freshestRuntimeTabId = [...freshRuntimeListedIds].sort((a, b) => Number(listedById.get(b)?.updatedAt || 0) - Number(listedById.get(a)?.updatedAt || 0))[0];
+    if (Number.isFinite(freshestRuntimeTabId) && freshestRuntimeTabId > 0 && isTabInScope(freshestRuntimeTabId)) {
+      activeTabId = freshestRuntimeTabId;
+    }
+  }
+  if (!tabIds.length) {
+    tabIds = hasExplicitScope ? scopedOrder.length > 0 ? [...scopedOrder] : [activeTabId] : [activeTabId];
+  } else if (!tabIds.includes(activeTabId)) {
+    if (hasExplicitScope) {
+      tabIds = scopedOrder.length > 0 ? [...scopedOrder] : tabIds;
+    } else if (listedTabs.length > 0) {
+      activeTabId = tabIds[0];
+    } else {
+      tabIds = [activeTabId, ...tabIds];
+    }
+  }
+  const baseOrder = hasExplicitScope ? [...scopedOrder] : listedTabs.length > 0 ? dedupePositiveTabIds(listedTabs.map((tab) => tab.id)) : [...tabIds];
+  const prioritized = baseOrder.filter((tabId) => {
     if (tabId === activeTabId)
       return true;
     const listed = listedById.get(tabId);
-    if (!listed)
-      return true;
+    if (!listed) {
+      return hasExplicitScope;
+    }
     if (listed.runtimeId) {
       return nowMs - (listed.updatedAt || 0) <= staleRuntimeTabMaxAgeMs;
     }
-    if (!listed.external)
-      return true;
-    return nowMs - (listed.updatedAt || 0) <= detachedExternalTabMaxAgeMs;
+    if (listed.external) {
+      return nowMs - (listed.updatedAt || 0) <= detachedExternalTabMaxAgeMs;
+    }
+    return nowMs - (listed.updatedAt || 0) <= staleRuntimeTabMaxAgeMs;
   });
-  let tabOrder = (prioritized.length ? prioritized : tabIds).slice(0, maxContextTabs);
-  if (!tabOrder.includes(activeTabId)) {
-    tabOrder = [activeTabId, ...tabOrder].slice(0, maxContextTabs);
+  let tabOrder = hasExplicitScope ? preferScopedOrder(scopedOrder, activeTabId, maxContextTabs) : [...new Set(prioritized.length ? prioritized : baseOrder.length ? baseOrder : tabIds)];
+  if (!hasExplicitScope) {
+    if (tabOrder.includes(activeTabId)) {
+      tabOrder = [activeTabId, ...tabOrder.filter((tabId) => tabId !== activeTabId)];
+    } else {
+      tabOrder = [activeTabId, ...tabOrder];
+    }
+    tabOrder = tabOrder.slice(0, maxContextTabs);
   }
   if (!tabOrder.length) {
-    tabOrder = [activeTabId || 1];
+    tabOrder = hasExplicitScope ? scopedOrder.length > 0 ? preferScopedOrder(scopedOrder, activeTabId || scopedOrder[0], maxContextTabs) : [activeTabId || 1] : [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 scopedOrder) {
+    if (!tabMetaById[tabId]) {
+      tabMetaById[tabId] = {
+        id: tabId,
+        accessMode: "live_dom",
+        inaccessibleReason: "detached_runtime_placeholder"
+      };
+    }
+  }
   for (const tabId of tabOrder) {
-    if (!tabMetaById[tabId])
-      tabMetaById[tabId] = { id: tabId };
+    if (!tabMetaById[tabId]) {
+      tabMetaById[tabId] = {
+        id: tabId,
+        accessMode: "live_dom",
+        inaccessibleReason: "detached_runtime_placeholder"
+      };
+    }
+  }
+  const diagnostics = {
+    hasExplicitScope,
+    scopedTabIdsInput: scopedTabIds2,
+    listedTabIds,
+    keptScopedTabIds: scopedOrder,
+    resolvedTabOrder: tabOrder
+  };
+  if (hasExplicitScope) {
+    if (scopedOrder.length && !scopedTabSet.has(activeTabId)) {
+      activeTabId = scopedOrder[0];
+    }
+    tabOrder = preferScopedOrder(scopedOrder, activeTabId, maxContextTabs);
+    const scopedMeta = {};
+    for (const tabId of scopedOrder) {
+      scopedMeta[tabId] = tabMetaById[tabId] || { id: tabId };
+    }
+    options?.onDiagnostics?.({
+      ...diagnostics,
+      resolvedTabOrder: tabOrder
+    });
+    return { tabOrder, activeTabId, tabMetaById: scopedMeta };
   }
+  options?.onDiagnostics?.(diagnostics);
   return { tabOrder, activeTabId, tabMetaById };
 }
 
 // dist/agent/actAgent.js
 var MAX_RETRIES = 3;
-var MAX_ITERATIONS = 25;
+function dedupePositiveTabIds2(input) {
+  if (!Array.isArray(input))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of input) {
+    const tabId = Number(value);
+    if (!Number.isFinite(tabId) || tabId <= 0 || seen.has(tabId))
+      continue;
+    seen.add(tabId);
+    out.push(tabId);
+  }
+  return out;
+}
 async function executeAgenticSeek(options) {
-  const { tabOrder, userInput, schema, previousSteps = [], plannerPrevSteps = [], files = [], chatLog = [], recordingContext, trajectoryId: trajectoryId2, onStatusUpdate, functionDeclarations, bridgeRpc: bridgeRpc2, ctx, onPrevStepsUpdate } = options;
+  const { tabOrder, scopedTabIds: scopedTabIds2, seedTabId, onScopedTabIdsTouched, userInput, schema, previousSteps = [], plannerPrevSteps = [], files = [], chatLog = [], recordingContext, trajectoryId, onStatusUpdate, functionDeclarations, bridgeRpc: bridgeRpc2, ctx, onPrevStepsUpdate } = options;
   if (!tabOrder?.length) {
     return { error: "No tabs available for processing", warnings: ["No active tab found"] };
   }
@@ -1839,26 +2191,48 @@ async function executeAgenticSeek(options) {
   const allWarnings = [];
   const accumulatedPrevSteps = Array.isArray(previousSteps) ? previousSteps : [];
   const fallbackTabs = tabOrder.map((id) => ({ id }));
+  let runtimeScopedTabIds = dedupePositiveTabIds2(scopedTabIds2 || []);
+  if (Number(seedTabId) > 0 && !runtimeScopedTabIds.includes(Number(seedTabId))) {
+    runtimeScopedTabIds.unshift(Number(seedTabId));
+  }
+  const touchScopedTabIds = (tabIds) => {
+    const touched = dedupePositiveTabIds2(tabIds);
+    if (!touched.length)
+      return;
+    const nextScoped = dedupePositiveTabIds2([...runtimeScopedTabIds, ...touched]);
+    if (nextScoped.length === runtimeScopedTabIds.length && nextScoped.every((id, index) => id === runtimeScopedTabIds[index])) {
+      return;
+    }
+    runtimeScopedTabIds = nextScoped;
+    onScopedTabIdsTouched?.(nextScoped);
+  };
   let retry = 0;
-  let iterations = 0;
   let pageDataOptions;
   while (retry < MAX_RETRIES) {
-    if (iterations++ >= MAX_ITERATIONS) {
-      return { error: "Max action iterations reached", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
-    }
     if (ctx.isCancelled?.()) {
       return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
     }
     try {
       await waitWhilePaused(void 0);
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+      }
       onStatusUpdate?.("Analyzing page content...", "Calling seek workflow", "analyze");
-      const { tabOrder: runtimeTabOrder, activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+      const { tabOrder: runtimeTabOrder, activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs, {
+        scopedTabIds: runtimeScopedTabIds,
+        seedTabId
+      });
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+      }
       const scopedTabOrder = runtimeTabOrder.length ? runtimeTabOrder : tabOrder;
       const webPageMap = {};
       try {
         webPageMap[activeTabId] = await ctx.getPageData(activeTabId, {
           ...pageDataOptions || {},
-          __roverAllowExternalFetch: true
+          __roverAllowExternalFetch: true,
+          __roverExternalIntent: "auto",
+          __roverExternalMessage: userInput
         });
       } catch {
         retry++;
@@ -1873,6 +2247,9 @@ async function executeAgenticSeek(options) {
           return { tabId: currentTabId, pageData: void 0 };
         }
       }));
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+      }
       for (const result of backgroundResults) {
         if (result.pageData) {
           webPageMap[result.tabId] = result.pageData;
@@ -1902,12 +2279,22 @@ async function executeAgenticSeek(options) {
         functionDeclarations,
         authToken: void 0,
         timestamp: ctx.userTimestamp,
-        trajectoryId: trajectoryId2,
-        userProfile: ctx.userProfile
+        trajectoryId,
+        userProfile: ctx.userProfile,
+        stop: buildWorkerStopSignal({
+          isCancelled: !!ctx.isCancelled?.()
+        })
       };
       const response = await ctx.callExtensionRouter(SUB_AGENTS.processTabWorkflows, request);
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+      }
       if (!response?.success) {
-        return { error: response?.error || "Failed to process tab workflows", creditsUsed: totalCreditsUsed };
+        return {
+          error: response?.error || "Failed to process tab workflows",
+          errorDetails: response?.errorDetails || void 0,
+          creditsUsed: totalCreditsUsed
+        };
       }
       const data = response.data;
       totalCreditsUsed += data?.creditsUsed || 0;
@@ -1918,6 +2305,10 @@ async function executeAgenticSeek(options) {
       }
       if (tabResponse?.warnings?.length)
         allWarnings.push(...tabResponse.warnings);
+      if (tabResponse?.stopState && tabResponse.stopState !== "continue") {
+        const stopReason = String(tabResponse.stopReason || tabResponse.error || "").trim() || `Execution stopped (${tabResponse.stopState})`;
+        return { error: stopReason, prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed, warnings: allWarnings };
+      }
       if (tabResponse?.error) {
         retry++;
         continue;
@@ -1929,15 +2320,58 @@ async function executeAgenticSeek(options) {
         prevSteps: accumulatedPrevSteps,
         thought: tabResponse.thought,
         bridgeRpc: bridgeRpc2,
+        isCancelled: ctx.isCancelled,
         userFunctionDeclarations: functionDeclarations,
         onStatusUpdate,
         onPrevStepsUpdate
       });
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+      }
       if (processResult.needsRetry) {
         pageDataOptions = processResult.disableAutoScroll ? { disableAutoScroll: true } : void 0;
         retry++;
         continue;
       }
+      if (processResult.navigationOccurred) {
+        const navigationOutcome = processResult.navigationOutcome;
+        const logicalTabId = Number(processResult.logicalTabId);
+        if (Number.isFinite(logicalTabId) && logicalTabId > 0) {
+          touchScopedTabIds([logicalTabId]);
+        }
+        if (navigationOutcome === "new_tab_opened" || navigationOutcome === "switch_tab") {
+          if (Number.isFinite(logicalTabId) && logicalTabId > 0) {
+            try {
+              await bridgeRpc2("executeTool", {
+                call: {
+                  name: "switch_tab",
+                  args: {
+                    logical_tab_id: logicalTabId,
+                    tab_id: logicalTabId
+                  }
+                },
+                payload: {
+                  reason: "act_loop_navigation_continue"
+                }
+              });
+            } catch {
+            }
+          }
+          pageDataOptions = processResult.disableAutoScroll ? { disableAutoScroll: true } : void 0;
+          continue;
+        }
+        managePrevStepsSize(accumulatedPrevSteps);
+        onPrevStepsUpdate?.(accumulatedPrevSteps);
+        return {
+          prevSteps: accumulatedPrevSteps,
+          creditsUsed: totalCreditsUsed,
+          warnings: allWarnings,
+          navigationPending: true,
+          navigationTool: processResult.navigationTool,
+          navigationOutcome: processResult.navigationOutcome,
+          logicalTabId: processResult.logicalTabId
+        };
+      }
       if (processResult.data) {
         managePrevStepsSize(accumulatedPrevSteps);
         onPrevStepsUpdate?.(accumulatedPrevSteps);
@@ -1966,10 +2400,19 @@ async function executeAgenticSeek(options) {
         }));
         const functionResults = {};
         for (const fc of functionCallsWithIds) {
+          if (ctx.isCancelled?.()) {
+            return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+          }
           try {
             const result = await bridgeRpc2("executeClientTool", { name: fc.name, args: fc.args });
+            if (ctx.isCancelled?.()) {
+              return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+            }
             functionResults[fc.callId] = { success: true, result };
           } catch (error) {
+            if (ctx.isCancelled?.()) {
+              return { error: "Run cancelled", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+            }
             functionResults[fc.callId] = { success: false, error: { message: error?.message || String(error) } };
           }
         }
@@ -1984,7 +2427,12 @@ async function executeAgenticSeek(options) {
       }
       retry++;
       if (retry >= MAX_RETRIES) {
-        return { error: error?.message || "Agentic seek failed", prevSteps: accumulatedPrevSteps, creditsUsed: totalCreditsUsed };
+        return {
+          error: error?.message || "Agentic seek failed",
+          errorDetails: error?.roverError || void 0,
+          prevSteps: accumulatedPrevSteps,
+          creditsUsed: totalCreditsUsed
+        };
       }
       await new Promise((resolve) => setTimeout(resolve, 500 * retry));
     }
@@ -1994,19 +2442,57 @@ async function executeAgenticSeek(options) {
 
 // dist/agent/extractAgent.js
 var MAX_RETRIES2 = 3;
+function dedupePositiveTabIds3(input) {
+  if (!Array.isArray(input))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of input) {
+    const tabId = Number(value);
+    if (!Number.isFinite(tabId) || tabId <= 0 || seen.has(tabId))
+      continue;
+    seen.add(tabId);
+    out.push(tabId);
+  }
+  return out;
+}
 async function executeExtract(options) {
-  const { tabOrder, userInput, schema, outputDestination, trajectoryId: trajectoryId2, recordingContext, plannerPrevSteps = [], files = [], onStatusUpdate, schemaHeaderSheetInfo, returnDataOnly, previousSteps = [], bridgeRpc: bridgeRpc2, ctx, onPrevStepsUpdate } = options;
+  const { tabOrder, scopedTabIds: scopedTabIds2, seedTabId, onScopedTabIdsTouched, userInput, schema, outputDestination, trajectoryId, recordingContext, plannerPrevSteps = [], files = [], onStatusUpdate, schemaHeaderSheetInfo, returnDataOnly, previousSteps = [], bridgeRpc: bridgeRpc2, ctx, onPrevStepsUpdate } = options;
   if (!tabOrder?.length) {
     return { error: "No tabs available for extraction", warnings: ["No active tab found"] };
   }
   let totalCreditsUsed = 0;
   const warnings = [];
   const fallbackTabs = tabOrder.map((id) => ({ id }));
+  let runtimeScopedTabIds = dedupePositiveTabIds3(scopedTabIds2 || []);
+  if (Number(seedTabId) > 0 && !runtimeScopedTabIds.includes(Number(seedTabId))) {
+    runtimeScopedTabIds.unshift(Number(seedTabId));
+  }
+  const touchScopedTabIds = (tabIds) => {
+    const touched = dedupePositiveTabIds3(tabIds);
+    if (!touched.length)
+      return;
+    const nextScoped = dedupePositiveTabIds3([...runtimeScopedTabIds, ...touched]);
+    if (nextScoped.length === runtimeScopedTabIds.length && nextScoped.every((id, index) => id === runtimeScopedTabIds[index])) {
+      return;
+    }
+    runtimeScopedTabIds = nextScoped;
+    onScopedTabIdsTouched?.(nextScoped);
+  };
   const prevSteps = Array.isArray(previousSteps) ? previousSteps : [];
   let pageDataOptions;
   for (let retry = 0; retry < MAX_RETRIES2; retry++) {
     await waitWhilePaused(void 0);
-    const { activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+    if (ctx.isCancelled?.()) {
+      return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+    }
+    const { activeTabId } = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs, {
+      scopedTabIds: runtimeScopedTabIds,
+      seedTabId
+    });
+    if (ctx.isCancelled?.()) {
+      return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+    }
     const tabId = activeTabId;
     let pageData;
     try {
@@ -2029,14 +2515,20 @@ async function executeExtract(options) {
       apiToolsConfig: ctx.apiToolsConfig,
       authToken: void 0,
       timestamp: ctx.userTimestamp,
-      trajectoryId: trajectoryId2,
+      trajectoryId,
       userProfile: ctx.userProfile,
       recordingContext,
       files,
-      returnDataOnly
+      returnDataOnly,
+      stop: buildWorkerStopSignal({
+        isCancelled: !!ctx.isCancelled?.()
+      })
     };
     onStatusUpdate?.("Extracting data...", "Calling extract sub-agent", "execute");
     const response = await ctx.callExtensionRouter(SUB_AGENTS.extract, request);
+    if (ctx.isCancelled?.()) {
+      return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+    }
     if (!response?.success) {
       return { error: response?.error || "Extract request failed", creditsUsed: totalCreditsUsed };
     }
@@ -2055,6 +2547,10 @@ async function executeExtract(options) {
     }
     const tabResponse = data?.tabResponses?.[activeTabId];
     if (tabResponse) {
+      if (tabResponse?.stopState && tabResponse.stopState !== "continue") {
+        const stopReason = String(tabResponse.stopReason || tabResponse.error || "").trim() || `Execution stopped (${tabResponse.stopState})`;
+        return { error: stopReason, prevSteps, creditsUsed: totalCreditsUsed, warnings };
+      }
       const processResult = await processActionResponse({
         request,
         response: tabResponse,
@@ -2062,12 +2558,22 @@ async function executeExtract(options) {
         prevSteps,
         thought: tabResponse.thought,
         bridgeRpc: bridgeRpc2,
+        isCancelled: ctx.isCancelled,
         onPrevStepsUpdate
       });
+      if (ctx.isCancelled?.()) {
+        return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+      }
       if (processResult.needsRetry) {
         pageDataOptions = processResult.disableAutoScroll ? { disableAutoScroll: true } : void 0;
         continue;
       }
+      if (processResult.navigationOccurred) {
+        const logicalTabId = Number(processResult.logicalTabId);
+        if (Number.isFinite(logicalTabId) && logicalTabId > 0) {
+          touchScopedTabIds([logicalTabId]);
+        }
+      }
       pageDataOptions = processResult.disableAutoScroll ? { disableAutoScroll: true } : void 0;
       if (processResult.data) {
         return {
@@ -2080,9 +2586,18 @@ async function executeExtract(options) {
       }
       if (processResult.functionCalls?.length) {
         for (const fc of processResult.functionCalls) {
+          if (ctx.isCancelled?.()) {
+            return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+          }
           try {
             await bridgeRpc2("executeClientTool", { name: fc.name, args: fc.args });
+            if (ctx.isCancelled?.()) {
+              return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+            }
           } catch {
+            if (ctx.isCancelled?.()) {
+              return { error: "Run cancelled", prevSteps, creditsUsed: totalCreditsUsed, warnings };
+            }
           }
         }
       }
@@ -2258,8 +2773,14 @@ function attachSheetData(store, sheetInfo) {
 
 // dist/agent/sheetsWorkflowAgent.js
 async function executeSheetsWorkflow(options) {
-  const { workflow, userInput, trajectoryId: trajectoryId2, plannerPrevSteps, agentLog, files, onStatusUpdate, ctx, bridgeRpc: bridgeRpc2, driveAuthToken } = options;
+  const { workflow, userInput, trajectoryId, plannerPrevSteps, agentLog, files, onStatusUpdate, ctx, bridgeRpc: bridgeRpc2, driveAuthToken } = options;
+  const throwIfCancelled2 = () => {
+    if (!ctx.isCancelled?.())
+      return;
+    throw new DOMException("Run cancelled", "AbortError");
+  };
   try {
+    throwIfCancelled2();
     const sourceSheetInfo = workflow.sourceSheetFromHistory ? resolveHistorySheetInfo(workflow.sourceSheetFromHistory, plannerPrevSteps) : void 0;
     let sheetId = sourceSheetInfo?.sheetId || workflow.sheetId;
     let sheetTabTitle = sourceSheetInfo?.sheetTab || workflow.sheetTabTitle;
@@ -2293,6 +2814,7 @@ async function executeSheetsWorkflow(options) {
       if (!sheetTabTitle) {
         return { error: "Could not resolve sheet tab title for workflow." };
       }
+      throwIfCancelled2();
       onStatusUpdate?.("Loading sheet rows...", sheetTabTitle, "analyze");
       grid = await fetchWorkflowSheetTabDataSmart(sheetId, sheetTabTitle, getAuthToken) || [];
     }
@@ -2311,6 +2833,7 @@ async function executeSheetsWorkflow(options) {
     const outputRows = [];
     const newTabOutputs = {};
     for (let rowIdx = startRow; rowIdx < endRow; rowIdx++) {
+      throwIfCancelled2();
       const row = dataRows[rowIdx] || [];
       const rowData = buildRowData(header, row);
       const context = buildContextData(header, row, contextIndices);
@@ -2323,11 +2846,13 @@ async function executeSheetsWorkflow(options) {
       const stepOutputs = {};
       const rowOutputValues = [];
       for (const step of workflow.workflowSteps) {
+        throwIfCancelled2();
         const stepName = step.stepName || step.tool;
         const resolvedUserInput = resolveTemplate(step.userInputTemplate || userInput, rowContext, stepOutputs);
         if (step.tabManagement?.urlTemplate) {
           const targetUrl = resolveTemplate(step.tabManagement.urlTemplate, rowContext, stepOutputs);
           if (targetUrl) {
+            throwIfCancelled2();
             await bridgeRpc2("executeTool", { call: { name: "goto_url", args: { tab_id: 0, url: targetUrl } } });
           }
         }
@@ -2335,7 +2860,7 @@ async function executeSheetsWorkflow(options) {
         const stepResult = await executeWorkflowStep({
           step,
           userInput: resolvedUserInput,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           plannerPrevSteps,
           agentLog,
           files,
@@ -2346,6 +2871,7 @@ async function executeSheetsWorkflow(options) {
           toolArgs: resolvedToolArgs
         });
         stepOutputs[stepName] = stepResult;
+        throwIfCancelled2();
         if (step.outputMapping === SheetOutputFormat.CONTEXT) {
           continue;
         }
@@ -2364,6 +2890,7 @@ async function executeSheetsWorkflow(options) {
       outputRows.push(rowOutputValues);
     }
     if (useMemory) {
+      throwIfCancelled2();
       const store = ctx.tabularStore;
       const baseTab = sheetTabId !== void 0 ? store.getTab(sheetId, sheetTabId) : store.getTabByTitle(sheetId, sheetTabTitle) || store.getTab(sheetId, 0);
       if (outputColumnHeaders.length) {
@@ -2402,6 +2929,7 @@ async function executeSheetsWorkflow(options) {
       };
     }
     if (outputColumnHeaders.length) {
+      throwIfCancelled2();
       await appendColumnsToSheet({
         sheetId,
         sheetTabTitle,
@@ -2413,6 +2941,7 @@ async function executeSheetsWorkflow(options) {
       });
     }
     for (const [stepName, rows] of Object.entries(newTabOutputs)) {
+      throwIfCancelled2();
       const title = truncateTabTitle(stepName);
       const newTitle = await createSheetTab(sheetId, title, getAuthToken);
       const headerRowValues = buildNewTabHeader(rows);
@@ -2443,7 +2972,10 @@ async function executeSheetsWorkflow(options) {
     return { error: error?.message || String(error) };
   }
 }
-async function executeWorkflowStep({ step, userInput, trajectoryId: trajectoryId2, plannerPrevSteps, agentLog, files, onStatusUpdate, ctx, bridgeRpc: bridgeRpc2, driveAuthToken, toolArgs }) {
+async function executeWorkflowStep({ step, userInput, trajectoryId, plannerPrevSteps, agentLog, files, onStatusUpdate, ctx, bridgeRpc: bridgeRpc2, driveAuthToken, toolArgs }) {
+  if (ctx.isCancelled?.()) {
+    throw new DOMException("Run cancelled", "AbortError");
+  }
   const toolName = step.tool;
   if (toolName === PLANNER_FUNCTION_CALLS.PROCESS_TEXT) {
     const result = await executeToolFromPlan({
@@ -2455,7 +2987,7 @@ async function executeWorkflowStep({ step, userInput, trajectoryId: trajectoryId
       },
       userInput,
       tabs: [{ id: 1 }],
-      trajectoryId: trajectoryId2,
+      trajectoryId,
       plannerPrevSteps,
       agentLog,
       files,
@@ -2480,7 +3012,7 @@ async function executeWorkflowStep({ step, userInput, trajectoryId: trajectoryId
       },
       userInput,
       tabs: [{ id: 1 }],
-      trajectoryId: trajectoryId2,
+      trajectoryId,
       plannerPrevSteps,
       agentLog,
       files,
@@ -2495,7 +3027,13 @@ async function executeWorkflowStep({ step, userInput, trajectoryId: trajectoryId
     return result.output ?? result;
   }
   if (toolArgs || step.toolArgs || typeof toolName === "string") {
+    if (ctx.isCancelled?.()) {
+      throw new DOMException("Run cancelled", "AbortError");
+    }
     const result = await bridgeRpc2("executeClientTool", { name: toolName, args: toolArgs || step.toolArgs || {} });
+    if (ctx.isCancelled?.()) {
+      throw new DOMException("Run cancelled", "AbortError");
+    }
     return result;
   }
   return { error: `Unsupported step tool: ${toolName}` };
@@ -2757,28 +3295,98 @@ function normalizeAgentLog(agentLog) {
       continue;
     dedupedChatLog.push(entry);
   }
-  const firstUser = dedupedChatLog.find((entry) => entry.role === "user");
-  const tailBudget = firstUser ? Math.max(1, MAX_AGENT_CHATLOG_ENTRIES - 1) : MAX_AGENT_CHATLOG_ENTRIES;
-  let chatLog = dedupedChatLog.slice(-tailBudget);
-  if (firstUser) {
-    const hasAnchor = chatLog.some((entry) => entry.role === "user" && entry.message === firstUser.message);
-    if (!hasAnchor) {
-      chatLog = [firstUser, ...chatLog];
-    }
+  let chatLog = dedupedChatLog.slice(-MAX_AGENT_CHATLOG_ENTRIES);
+  const seen = /* @__PURE__ */ new Set();
+  const compactedReverse = [];
+  for (let i = chatLog.length - 1; i >= 0; i -= 1) {
+    const entry = chatLog[i];
+    const key = `${entry.role}::${entry.message.toLowerCase()}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    compactedReverse.push(entry);
   }
+  chatLog = compactedReverse.reverse();
   if (chatLog.length > MAX_AGENT_CHATLOG_ENTRIES) {
     chatLog = chatLog.slice(-MAX_AGENT_CHATLOG_ENTRIES);
   }
   return { prevSteps, chatLog };
 }
+function isExecutionCancelled(ctx) {
+  if (!ctx?.isCancelled)
+    return false;
+  try {
+    return !!ctx.isCancelled();
+  } catch {
+    return false;
+  }
+}
+function throwIfExecutionCancelled(ctx) {
+  if (!isExecutionCancelled(ctx))
+    return;
+  throw new DOMException("Run cancelled", "AbortError");
+}
+function cancelledToolResult() {
+  return { error: "Run cancelled" };
+}
+async function executeRoverExternalContextPlannerTool(params) {
+  const bridge = params.bridgeRpc;
+  if (!bridge) {
+    return { error: `Bridge RPC unavailable for ${params.toolName}` };
+  }
+  const message = String(params.toolArgs?.message || params.toolArgs?.user_input || params.toolArgs?.task_instruction || params.userInput || "").trim();
+  params.onStatusUpdate?.(params.toolName === PLANNER_FUNCTION_CALLS.ROVER_EXTERNAL_ACT_CONTEXT ? "Fetching external action context..." : "Fetching external context...", `Calling ${params.toolName}`, "execute");
+  const routedResponse = await bridge("executeTool", {
+    call: {
+      name: params.toolName,
+      args: {
+        ...params.toolArgs,
+        ...message ? { message } : {}
+      }
+    }
+  });
+  const success = routedResponse?.success === true;
+  if (!success) {
+    const errorMessage = String(routedResponse?.output?.error?.message || routedResponse?.error || `${params.toolName} failed`);
+    return {
+      error: errorMessage,
+      output: routedResponse?.output,
+      warnings: errorMessage ? [errorMessage] : void 0
+    };
+  }
+  return {
+    output: routedResponse?.output,
+    warnings: Array.isArray(routedResponse?.output?.warnings) ? routedResponse.output.warnings : void 0
+  };
+}
+async function callExtensionRouterWithCancel(ctx, action, request) {
+  throwIfExecutionCancelled(ctx);
+  const response = await ctx.callExtensionRouter(action, request);
+  throwIfExecutionCancelled(ctx);
+  return response;
+}
 async function executeToolFromPlan(context) {
-  const { toolName, toolArgs, userInput, tabs, trajectoryId: trajectoryId2, plannerPrevSteps, files, onStatusUpdate, recordingContext, toolFunctions, bridgeRpc: bridgeRpc2, ctx, functionDeclarations, driveAuthToken, agentLog, onPrevStepsUpdate } = context;
+  const { toolName, toolArgs, userInput, tabs, scopedTabIds: scopedTabIds2, seedTabId, getScopedTabRuntimeContext, onScopedTabIdsTouched, trajectoryId, plannerPrevSteps, files, onStatusUpdate, recordingContext, toolFunctions, bridgeRpc: bridgeRpc2, ctx, functionDeclarations, driveAuthToken, agentLog, onPrevStepsUpdate } = context;
   const effectiveCtx = ctx;
   if (!effectiveCtx) {
     return { error: "Agent context unavailable" };
   }
+  if (isExecutionCancelled(effectiveCtx)) {
+    return cancelledToolResult();
+  }
   const fallbackTabs = Array.isArray(tabs) && tabs.length ? tabs : [{ id: 1 }];
-  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+  const runtimeScope = getScopedTabRuntimeContext?.() || {};
+  const scopedTabIdsInput = runtimeScope.scopedTabIds ?? scopedTabIds2;
+  const seedTabIdInput = runtimeScope.seedTabId ?? seedTabId;
+  const resolvedScopedTabIds = Array.isArray(scopedTabIdsInput) && scopedTabIdsInput.length ? Array.from(new Set(scopedTabIdsInput.map((tabId) => Number(tabId)).filter((tabId) => Number.isFinite(tabId) && tabId > 0))) : Array.from(new Set(fallbackTabs.map((tab) => Number(tab?.id)).filter((tabId) => Number.isFinite(tabId) && tabId > 0)));
+  const resolvedSeedTabId = Number(seedTabIdInput) > 0 ? Number(seedTabIdInput) : resolvedScopedTabIds[0];
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs, {
+    scopedTabIds: resolvedScopedTabIds,
+    seedTabId: resolvedSeedTabId
+  });
+  if (isExecutionCancelled(effectiveCtx)) {
+    return cancelledToolResult();
+  }
   const tabOrder = resolvedTabs.tabOrder.length ? resolvedTabs.tabOrder : fallbackTabs.map((tab) => tab.id);
   const effectiveAgentLog = normalizeAgentLog(agentLog);
   try {
@@ -2787,6 +3395,9 @@ async function executeToolFromPlan(context) {
         const prompt = toolArgs?.user_input || toolArgs?.prompt || toolArgs?.task_instruction || userInput;
         const actResult = await executeAgenticSeek({
           tabOrder,
+          scopedTabIds: resolvedScopedTabIds,
+          seedTabId: resolvedSeedTabId,
+          onScopedTabIdsTouched,
           userInput: prompt,
           schema: toolArgs?.schema,
           previousSteps: effectiveAgentLog.prevSteps,
@@ -2794,7 +3405,7 @@ async function executeToolFromPlan(context) {
           files,
           chatLog: effectiveAgentLog.chatLog,
           recordingContext,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           functionDeclarations,
           bridgeRpc: bridgeRpc2,
@@ -2805,6 +3416,13 @@ async function executeToolFromPlan(context) {
           status: "waiting_input",
           needsUserInput: true,
           questions: Array.isArray(actResult.questions) ? actResult.questions : []
+        } : actResult.navigationPending ? {
+          status: "in_progress",
+          taskStatus: "in_progress",
+          navigationPending: true,
+          navigationTool: actResult.navigationTool,
+          navigationOutcome: actResult.navigationOutcome,
+          logicalTabId: actResult.logicalTabId
         } : void 0);
         return { ...actResult, output: actOutput };
       }
@@ -2816,6 +3434,9 @@ async function executeToolFromPlan(context) {
         const returnDataOnly = toolArgs?.return_data_only ?? toolArgs?.returnDataOnly ?? shouldMemory;
         const extractResult = await executeExtract({
           tabOrder,
+          scopedTabIds: resolvedScopedTabIds,
+          seedTabId: resolvedSeedTabId,
+          onScopedTabIdsTouched,
           userInput: prompt,
           schema: toolArgs?.schema,
           outputDestination,
@@ -2824,7 +3445,7 @@ async function executeToolFromPlan(context) {
           files,
           recordingContext,
           previousSteps: effectiveAgentLog.prevSteps,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           returnDataOnly,
           onStatusUpdate,
           bridgeRpc: bridgeRpc2,
@@ -2871,7 +3492,7 @@ async function executeToolFromPlan(context) {
           files,
           recordingContext,
           previousSteps: effectiveAgentLog.prevSteps,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           returnDataOnly,
           bridgeRpc: bridgeRpc2,
@@ -2913,13 +3534,23 @@ async function executeToolFromPlan(context) {
           schema: toolArgs?.schema,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
           driveAuthToken: toolArgs?.authToken || toolArgs?.driveAuthToken || driveAuthToken
         });
       }
+      case PLANNER_FUNCTION_CALLS.ROVER_EXTERNAL_READ_CONTEXT:
+      case PLANNER_FUNCTION_CALLS.ROVER_EXTERNAL_ACT_CONTEXT: {
+        return executeRoverExternalContextPlannerTool({
+          toolName,
+          toolArgs: toolArgs || {},
+          userInput,
+          bridgeRpc: bridgeRpc2,
+          onStatusUpdate
+        });
+      }
       case PLANNER_FUNCTION_CALLS.CREATE_SHEET_FROM_DATA: {
         const dataInputs = toolArgs?.data_inputs || toolArgs?.dataInputs || [];
         const taskInstruction = toolArgs?.task_instruction || toolArgs?.taskInstruction || userInput;
@@ -2930,7 +3561,7 @@ async function executeToolFromPlan(context) {
           outputSheetParameters: toolArgs?.output_sheet_parameters || toolArgs?.outputSheetParameters,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
@@ -2942,7 +3573,7 @@ async function executeToolFromPlan(context) {
           toolArgs,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
@@ -2951,7 +3582,7 @@ async function executeToolFromPlan(context) {
       }
       case PLANNER_FUNCTION_CALLS.QUERY_RTRVR_AI_DOCUMENTATION: {
         const userQuestion = toolArgs?.user_question || toolArgs?.userQuestion || userInput;
-        return executeQueryDocs({ userQuestion, trajectoryId: trajectoryId2, plannerPrevSteps, onStatusUpdate, agentLog: effectiveAgentLog, ctx: effectiveCtx });
+        return executeQueryDocs({ userQuestion, trajectoryId, plannerPrevSteps, onStatusUpdate, agentLog: effectiveAgentLog, ctx: effectiveCtx });
       }
       case PLANNER_FUNCTION_CALLS.GOOGLE_DOC_GENERATOR: {
         const prompt = toolArgs?.user_input || toolArgs?.prompt || toolArgs?.task_instruction || userInput;
@@ -2961,7 +3592,7 @@ async function executeToolFromPlan(context) {
           tabOrder,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
@@ -2976,7 +3607,7 @@ async function executeToolFromPlan(context) {
           tabOrder,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
@@ -2991,7 +3622,7 @@ async function executeToolFromPlan(context) {
           tabOrder,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx
@@ -3005,7 +3636,7 @@ async function executeToolFromPlan(context) {
           tabOrder,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx,
@@ -3018,7 +3649,7 @@ async function executeToolFromPlan(context) {
           userInput: prompt,
           plannerPrevSteps,
           files,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           onStatusUpdate,
           agentLog: effectiveAgentLog,
           ctx: effectiveCtx
@@ -3029,7 +3660,7 @@ async function executeToolFromPlan(context) {
         return executeSheetsWorkflow({
           workflow,
           userInput,
-          trajectoryId: trajectoryId2,
+          trajectoryId,
           plannerPrevSteps,
           files,
           onStatusUpdate,
@@ -3047,6 +3678,9 @@ async function executeToolFromPlan(context) {
         const results = [];
         if (Array.isArray(toolCalls)) {
           for (const call of toolCalls) {
+            if (isExecutionCancelled(effectiveCtx)) {
+              return { error: "Run cancelled", output: results };
+            }
             const name = call.tool_name || call.name;
             const args = call.tool_args || call.args || {};
             try {
@@ -3056,8 +3690,14 @@ async function executeToolFromPlan(context) {
               } else {
                 res = await bridgeRpc2?.("executeClientTool", { name, args });
               }
+              if (isExecutionCancelled(effectiveCtx)) {
+                return { error: "Run cancelled", output: results };
+              }
               results.push({ name, result: res, success: true });
             } catch (error) {
+              if (isExecutionCancelled(effectiveCtx)) {
+                return { error: "Run cancelled", output: results };
+              }
               results.push({ name, error: error?.message || String(error), success: false });
             }
           }
@@ -3065,12 +3705,18 @@ async function executeToolFromPlan(context) {
         return { output: results };
       }
       case PLANNER_FUNCTION_CALLS.CONFIGURE_API_KEY: {
-        return unsupportedToolResult(PLANNER_FUNCTION_CALLS.CONFIGURE_API_KEY, "configure_api_key is not supported in rover embed mode. Provide apiKey via rover.boot(...) or rover.update(...).");
+        return unsupportedToolResult(PLANNER_FUNCTION_CALLS.CONFIGURE_API_KEY, "configure_api_key is not supported in rover embed mode. Provide publicKey (pk_site_*) via rover.boot(...) or an rvrsess_* sessionToken.");
       }
       default: {
         if (toolFunctions && toolFunctions[toolName]) {
           try {
+            if (isExecutionCancelled(effectiveCtx)) {
+              return cancelledToolResult();
+            }
             const result = await bridgeRpc2?.("executeClientTool", { name: toolName, args: toolArgs });
+            if (isExecutionCancelled(effectiveCtx)) {
+              return cancelledToolResult();
+            }
             return { output: result };
           } catch (error) {
             return { error: error?.message || String(error) };
@@ -3091,7 +3737,7 @@ async function executeToolFromPlan(context) {
     };
   }
 }
-async function executeProcessText({ textInputs, taskInstruction, schema, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executeProcessText({ textInputs, taskInstruction, schema, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Processing text...", "Calling process_text", "execute");
   const request = {
     siteId: ctx.siteId,
@@ -3108,11 +3754,11 @@ async function executeProcessText({ textInputs, taskInstruction, schema, planner
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.processText, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.processText, request);
   if (!response?.success)
     return { error: response?.error || "process_text failed" };
   return {
@@ -3123,7 +3769,7 @@ async function executeProcessText({ textInputs, taskInstruction, schema, planner
     warnings: response.data?.warnings
   };
 }
-async function executeCreateSheetFromData({ dataInputs, taskInstruction, schema, outputSheetParameters, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executeCreateSheetFromData({ dataInputs, taskInstruction, schema, outputSheetParameters, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Creating sheet...", "Calling create_sheet_from_data", "execute");
   const memoryTarget = resolveMemoryTarget(outputSheetParameters, plannerPrevSteps);
   const useMemory = ctx.apiMode || !driveAuthToken || memoryTarget.sheetId && isMemorySheetId(memoryTarget.sheetId);
@@ -3143,12 +3789,12 @@ async function executeCreateSheetFromData({ dataInputs, taskInstruction, schema,
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files,
     returnDataOnly: useMemory
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.createSheetFromData, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.createSheetFromData, request);
   if (!response?.success)
     return { error: response?.error || "create_sheet_from_data failed" };
   if (useMemory) {
@@ -3189,7 +3835,7 @@ async function executeCreateSheetFromData({ dataInputs, taskInstruction, schema,
     schemaHeaderSheetInfo: response.data?.schemaHeaderSheetInfo
   };
 }
-async function executeInferSheetData({ toolArgs, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executeInferSheetData({ toolArgs, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Inferring sheet data...", "Calling infer_sheet_data", "execute");
   const sourceSheetRef = toolArgs?.source_sheet_from_history || toolArgs?.sourceSheetFromHistory;
   const resolvedSheetInfo = sourceSheetRef ? resolveHistorySheetInfo(sourceSheetRef, plannerPrevSteps) : void 0;
@@ -3224,11 +3870,11 @@ async function executeInferSheetData({ toolArgs, plannerPrevSteps, files, trajec
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.infer, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.infer, request);
   if (!response?.success)
     return { error: response?.error || "infer_sheet_data failed" };
   const inferredItems = Array.isArray(response.data?.data) ? response.data.data : [];
@@ -3307,7 +3953,7 @@ async function executeInferSheetData({ toolArgs, plannerPrevSteps, files, trajec
     warnings: response.data?.warnings
   };
 }
-async function executeQueryDocs({ userQuestion, trajectoryId: trajectoryId2, plannerPrevSteps, onStatusUpdate, agentLog, ctx }) {
+async function executeQueryDocs({ userQuestion, trajectoryId, plannerPrevSteps, onStatusUpdate, agentLog, ctx }) {
   onStatusUpdate?.("Querying docs...", "Calling query_rtrvr_docs", "execute");
   const request = {
     siteId: ctx.siteId,
@@ -3322,10 +3968,10 @@ async function executeQueryDocs({ userQuestion, trajectoryId: trajectoryId2, pla
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.queryRtrvrDocs, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.queryRtrvrDocs, request);
   if (!response?.success)
     return { error: response?.error || "query_rtrvr_docs failed" };
   return {
@@ -3382,7 +4028,7 @@ Slide 3: Summary`;
     warnings: [warning]
   };
 }
-async function executeDocGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executeDocGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Generating doc...", "Calling google_doc_generator", "execute");
   if (!driveAuthToken) {
     return buildMissingAuthToolResult("google_doc_generator", ["authToken"]);
@@ -3404,13 +4050,13 @@ async function executeDocGenerator({ userInput, toolArgs, tabOrder, plannerPrevS
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files
   };
   let response;
   try {
-    response = await ctx.callExtensionRouter(SUB_AGENTS.googleDocGenerator, request);
+    response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.googleDocGenerator, request);
   } catch (err) {
     if (shouldFallbackToMemoryArtifact(err)) {
       const envelope2 = toRoverErrorEnvelope(err);
@@ -3433,7 +4079,7 @@ async function executeDocGenerator({ userInput, toolArgs, tabOrder, plannerPrevS
     warnings: response.data?.warnings
   };
 }
-async function executeSlidesGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executeSlidesGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Generating slides...", "Calling google_slides_generator", "execute");
   if (!driveAuthToken) {
     return buildMissingAuthToolResult("google_slides_generator", ["authToken"]);
@@ -3455,13 +4101,13 @@ async function executeSlidesGenerator({ userInput, toolArgs, tabOrder, plannerPr
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files
   };
   let response;
   try {
-    response = await ctx.callExtensionRouter(SUB_AGENTS.googleSlidesGenerator, request);
+    response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.googleSlidesGenerator, request);
   } catch (err) {
     if (shouldFallbackToMemoryArtifact(err)) {
       const envelope2 = toRoverErrorEnvelope(err);
@@ -3484,7 +4130,7 @@ async function executeSlidesGenerator({ userInput, toolArgs, tabOrder, plannerPr
     warnings: response.data?.warnings
   };
 }
-async function executeWebpageGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx }) {
+async function executeWebpageGenerator({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx }) {
   onStatusUpdate?.("Generating webpage...", "Calling webpage_generator", "execute");
   const pageData = await ctx.getPageData(tabOrder[0]);
   const request = {
@@ -3502,12 +4148,12 @@ async function executeWebpageGenerator({ userInput, toolArgs, tabOrder, plannerP
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files,
     outputDestination: toolArgs?.output_destination || toolArgs?.outputDestination
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.webpageGenerator, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.webpageGenerator, request);
   if (!response?.success)
     return { error: response?.error || "webpage_generator failed" };
   return {
@@ -3519,7 +4165,7 @@ async function executeWebpageGenerator({ userInput, toolArgs, tabOrder, plannerP
     warnings: response.data?.warnings
   };
 }
-async function executePdfFiller({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
+async function executePdfFiller({ userInput, toolArgs, tabOrder, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx, driveAuthToken }) {
   onStatusUpdate?.("Filling PDF...", "Calling pdf_filler", "execute");
   if (!driveAuthToken) {
     return buildMissingAuthToolResult("pdf_filler", ["authToken"]);
@@ -3540,12 +4186,12 @@ async function executePdfFiller({ userInput, toolArgs, tabOrder, plannerPrevStep
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files,
     outputDestination: toolArgs?.output_destination || toolArgs?.outputDestination
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.pdfFiller, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.pdfFiller, request);
   if (!response?.success)
     return { error: response?.error || "pdf_filler failed" };
   return {
@@ -3557,7 +4203,7 @@ async function executePdfFiller({ userInput, toolArgs, tabOrder, plannerPrevStep
     warnings: response.data?.warnings
   };
 }
-async function executeCustomToolGenerator({ userInput, plannerPrevSteps, files, trajectoryId: trajectoryId2, onStatusUpdate, agentLog, ctx }) {
+async function executeCustomToolGenerator({ userInput, plannerPrevSteps, files, trajectoryId, onStatusUpdate, agentLog, ctx }) {
   onStatusUpdate?.("Generating custom tool...", "Calling custom_tool_generator", "execute");
   const request = {
     siteId: ctx.siteId,
@@ -3572,11 +4218,11 @@ async function executeCustomToolGenerator({ userInput, plannerPrevSteps, files,
     apiToolsConfig: ctx.apiToolsConfig,
     authToken: "",
     timestamp: ctx.userTimestamp,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile,
     files
   };
-  const response = await ctx.callExtensionRouter(SUB_AGENTS.customToolGenerator, request);
+  const response = await callExtensionRouterWithCancel(ctx, SUB_AGENTS.customToolGenerator, request);
   if (!response?.success)
     return { error: response?.error || "custom_tool_generator failed" };
   return {
@@ -3606,24 +4252,33 @@ function normalizeChatLog(entries) {
       continue;
     deduped.push(entry);
   }
-  const firstUser = deduped.find((entry) => entry.role === "user");
-  const tailBudget = firstUser ? Math.max(1, MAX_CHATLOG_ENTRIES - 1) : MAX_CHATLOG_ENTRIES;
-  let selected = deduped.slice(-tailBudget);
-  if (firstUser) {
-    const hasAnchor = selected.some((entry) => entry.role === "user" && entry.message === firstUser.message);
-    if (!hasAnchor) {
-      selected = [firstUser, ...selected];
-    }
+  let selected = deduped.slice(-MAX_CHATLOG_ENTRIES);
+  const seen = /* @__PURE__ */ new Set();
+  const compactedReverse = [];
+  for (let i = selected.length - 1; i >= 0; i -= 1) {
+    const entry = selected[i];
+    const key = `${entry.role}::${entry.message.toLowerCase()}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    compactedReverse.push(entry);
   }
+  selected = compactedReverse.reverse();
   if (selected.length > MAX_CHATLOG_ENTRIES) {
     selected = selected.slice(-MAX_CHATLOG_ENTRIES);
   }
   return selected;
 }
 async function executePlanner(options) {
-  const { userInput, tabs, previousMessages = [], trajectoryId: trajectoryId2, previousSteps = [], files, continuePlanning = false, recordingContext, driveAuthToken, agentLog, lastToolPreviousSteps, ctx, bridgeRpc: bridgeRpc2, functionDeclarations } = options;
+  const { userInput, tabs, scopedTabIds: scopedTabIds2, seedTabId, getScopedTabRuntimeContext, previousMessages = [], trajectoryId, previousSteps = [], files, continuePlanning = false, recordingContext, driveAuthToken, agentLog, lastToolPreviousSteps, ctx, bridgeRpc: bridgeRpc2, functionDeclarations } = options;
+  const runtimeScope = getScopedTabRuntimeContext?.() || {};
+  const scopedTabIdsInput = runtimeScope.scopedTabIds ?? scopedTabIds2;
+  const seedTabIdInput = runtimeScope.seedTabId ?? seedTabId;
   const fallbackTabs = Array.isArray(tabs) && tabs.length ? tabs : [{ id: 1 }];
-  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs);
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc2, fallbackTabs, {
+    scopedTabIds: scopedTabIdsInput,
+    seedTabId: seedTabIdInput
+  });
   const tabOrder = resolvedTabs.tabOrder.length ? resolvedTabs.tabOrder : fallbackTabs.map((tab) => tab.id);
   const activeTabId = resolvedTabs.activeTabId;
   const tabMetaById = resolvedTabs.tabMetaById;
@@ -3632,7 +4287,9 @@ async function executePlanner(options) {
     try {
       return await ctx.getPageData(tabId, {
         onlyTextContent: false,
-        ...options2?.allowExternalFetch ? { __roverAllowExternalFetch: true } : {}
+        ...options2?.allowExternalFetch ? { __roverAllowExternalFetch: true } : {},
+        ...options2?.allowExternalFetch ? { __roverExternalIntent: "auto" } : {},
+        ...options2?.allowExternalFetch ? { __roverExternalMessage: userInput } : {}
       });
     } catch {
       const tab = tabMetaById[tabId];
@@ -3668,7 +4325,7 @@ async function executePlanner(options) {
     authToken: driveAuthToken || "",
     timestamp: ctx.userTimestamp,
     continuePlanning,
-    trajectoryId: trajectoryId2,
+    trajectoryId,
     userProfile: ctx.userProfile
   };
   const response = await ctx.callExtensionRouter(SUB_AGENTS.plan, request);
@@ -4087,55 +4744,130 @@ function convertParametersToTypes(parameters, functionDef) {
 
 // dist/agent/messageOrchestrator.js
 var COMPLEX_TASK_HINTS = [
-  "plan",
-  "research",
-  "compare",
-  "summarize",
-  "table",
-  "spreadsheet",
-  "sheet",
   "extract",
-  "crawl",
-  "workflow",
+  "compare",
+  "list",
   "across",
-  "multi",
   "multiple",
-  "then",
-  "after",
-  "finally",
-  "slides",
+  "many",
+  "report",
   "document",
-  "website",
-  "webpage",
-  "pdf"
+  "spreadsheet",
+  "sheet",
+  "table",
+  "csv",
+  "json",
+  "pdf",
+  "slides"
 ];
+var MULTI_LABEL_TLDS = /* @__PURE__ */ new Set([
+  "co.uk",
+  "org.uk",
+  "gov.uk",
+  "ac.uk",
+  "com.au",
+  "net.au",
+  "org.au",
+  "co.jp",
+  "com.br",
+  "com.mx",
+  "com.sg",
+  "co.in"
+]);
+function extractHostFromUrl(input) {
+  const raw = String(input || "").trim();
+  if (!raw)
+    return "";
+  try {
+    return new URL(raw).hostname.toLowerCase();
+  } catch {
+    return "";
+  }
+}
+function registrableDomain(host) {
+  const clean = String(host || "").trim().toLowerCase().replace(/^\.+/, "");
+  if (!clean)
+    return "";
+  if (clean === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(clean))
+    return clean;
+  const parts = clean.split(".").filter(Boolean);
+  if (parts.length < 2)
+    return clean;
+  const tail2 = `${parts[parts.length - 2]}.${parts[parts.length - 1]}`;
+  if (parts.length >= 3 && MULTI_LABEL_TLDS.has(tail2)) {
+    return `${parts[parts.length - 3]}.${tail2}`;
+  }
+  return tail2;
+}
+function hasCrossDomainPlanDependency(userInput, tabs) {
+  const currentUrl = String(tabs?.find((tab) => typeof tab?.url === "string" && String(tab.url || "").trim())?.url || "");
+  const currentDomain = registrableDomain(extractHostFromUrl(currentUrl));
+  if (!currentDomain)
+    return false;
+  const urls = String(userInput || "").match(/https?:\/\/[^\s)]+/g) || [];
+  if (!urls.length)
+    return false;
+  return urls.some((url) => {
+    const targetDomain = registrableDomain(extractHostFromUrl(url));
+    return !!targetDomain && targetDomain !== currentDomain;
+  });
+}
+function countCrossDomainNavigationDependencies(userInput, tabs) {
+  const currentUrl = String(tabs?.find((tab) => typeof tab?.url === "string" && String(tab.url || "").trim())?.url || "");
+  const currentDomain = registrableDomain(extractHostFromUrl(currentUrl));
+  const urls = String(userInput || "").match(/https?:\/\/[^\s)]+/g) || [];
+  if (!urls.length || !currentDomain)
+    return 0;
+  const distinct = /* @__PURE__ */ new Set();
+  for (const url of urls) {
+    const targetDomain = registrableDomain(extractHostFromUrl(url));
+    if (!targetDomain || targetDomain === currentDomain)
+      continue;
+    distinct.add(targetDomain);
+  }
+  return distinct.size;
+}
+function hasMultiStepDependencyMarkers(text) {
+  const input = String(text || "").toLowerCase();
+  if (!input)
+    return false;
+  const sequenceMarkers = (input.match(/\b(first|second|third|then|after that|next|finally)\b/g) || []).length;
+  if (sequenceMarkers >= 2)
+    return true;
+  if ((input.match(/\bstep\s*[1-9]\b/g) || []).length >= 2)
+    return true;
+  if ((input.match(/\b\d+\.\s+/g) || []).length >= 2)
+    return true;
+  return false;
+}
 function computeComplexityScore(text) {
   const input = String(text || "").toLowerCase().trim();
   if (!input)
     return 0;
   let score = 0;
-  const words = input.split(/\s+/).filter(Boolean);
-  if (words.length >= 14)
-    score += 1;
-  if (words.length >= 26)
+  const actionVerbs = new Set((input.match(/\b(click|open|go|navigate|fill|type|submit|extract|find|search|compare|summarize|collect|download|upload|create|generate|report)\b/g) || []).map((v) => v.toLowerCase()));
+  if (input.length > 120)
     score += 1;
-  if ((input.match(/\b(and then|then|after that|next|finally)\b/g) || []).length >= 1)
-    score += 1;
-  if ((input.match(/[;,]/g) || []).length >= 2)
+  if (actionVerbs.size >= 2)
     score += 1;
+  if ((input.match(/\b(and then|then|after|next|finally|first|second|third)\b/g) || []).length >= 1)
+    score += 2;
+  if ((input.match(/\b(extract|compare|list|all|each|every|across|multiple|many)\b/g) || []).length >= 2)
+    score += 2;
   if (/https?:\/\/|www\./.test(input))
-    score += 1;
-  if (/\b(json|csv|table|schema|columns?)\b/.test(input))
-    score += 1;
+    score += 2;
+  if ((input.match(/\b(report|document|doc|spreadsheet|sheet|table|csv|json|pdf|slides|summary)\b/g) || []).length >= 1)
+    score += 2;
   for (const hint of COMPLEX_TASK_HINTS) {
     if (input.includes(hint)) {
-      score += 1;
+      score += 0.25;
     }
   }
+  const words = input.split(/\s+/).filter(Boolean);
   if (/^(click|type|fill|open|go to|scroll|press|select)\b/.test(input) && words.length <= 10) {
     score = Math.max(0, score - 2);
   }
-  return score;
+  return Math.max(0, Math.min(10, Math.round(score)));
 }
 function decideRouting(message, options) {
   const mode = options.taskRouting?.mode || "act";
@@ -4145,21 +4877,97 @@ function decideRouting(message, options) {
   if (mode === "act") {
     return { mode: "act", reason: "Configured act mode" };
   }
-  const threshold = Math.max(1, Number(options.taskRouting?.actHeuristicThreshold) || 5);
+  const hasAwaitingUserChain = Array.isArray(options.previousSteps) && options.previousSteps.some((step) => Array.isArray(step?.questionsAsked) && step.questionsAsked.length > 0 && !(step?.userAnswers && Object.keys(step.userAnswers).length > 0));
+  if (hasAwaitingUserChain) {
+    const score2 = computeComplexityScore(message);
+    return {
+      mode: "planner",
+      score: score2,
+      reason: "Forced planner due to awaiting_user continuation chain."
+    };
+  }
+  if (hasMultiStepDependencyMarkers(message)) {
+    const score2 = computeComplexityScore(message);
+    return {
+      mode: "planner",
+      score: score2,
+      reason: "Forced planner due to multi-step dependency markers in prompt."
+    };
+  }
+  const crossDomainDependencies = countCrossDomainNavigationDependencies(message, options.tabs || []);
+  if (crossDomainDependencies > 1) {
+    const score2 = computeComplexityScore(message);
+    return {
+      mode: "planner",
+      score: score2,
+      reason: `Forced planner due to ${crossDomainDependencies} cross-domain dependencies.`
+    };
+  }
   const score = computeComplexityScore(message);
-  if (score >= threshold) {
+  const plannerThreshold = Math.max(3, Math.min(10, Number(options.taskRouting?.actHeuristicThreshold) || 7));
+  if (score >= plannerThreshold) {
     return {
       mode: "planner",
       score,
-      reason: `Complexity score ${score} >= threshold ${threshold}`
+      reason: `Complexity score ${score} >= ${plannerThreshold}`
     };
   }
   return {
     mode: "act",
     score,
-    reason: `Complexity score ${score} < threshold ${threshold}`
+    reason: `Complexity score ${score} < ${plannerThreshold}`
   };
 }
+function hasUsableActOutcome(actResult) {
+  if (!actResult || typeof actResult !== "object")
+    return false;
+  if (actResult.error)
+    return false;
+  const hasNonEmptyValue = (value) => {
+    if (Array.isArray(value))
+      return value.length > 0;
+    if (value && typeof value === "object")
+      return Object.keys(value).length > 0;
+    if (typeof value === "string")
+      return value.trim().length > 0;
+    return value !== void 0 && value !== null;
+  };
+  if (hasNonEmptyValue(actResult.data))
+    return true;
+  if (actResult.navigationPending === true)
+    return true;
+  if (actResult.needsUserInput === true)
+    return true;
+  const output = actResult.output;
+  if (!output)
+    return false;
+  if (typeof output === "string")
+    return output.trim().length > 0;
+  if (typeof output !== "object")
+    return hasNonEmptyValue(output);
+  if (output.success === false || output.error)
+    return false;
+  const navigationOutcome = String(output.navigationOutcome || "").trim().toLowerCase();
+  if (navigationOutcome === "same_tab_scheduled" || navigationOutcome === "new_tab_opened")
+    return true;
+  if (output.navigationPending === true)
+    return true;
+  if (output.needsUserInput === true || output.waitingForUserInput === true)
+    return true;
+  if (Array.isArray(output.questions) && output.questions.length > 0)
+    return true;
+  if (String(output.taskStatus || "").trim().toLowerCase() === "in_progress")
+    return true;
+  if (output.taskComplete === true)
+    return true;
+  if (hasNonEmptyValue(output.data))
+    return true;
+  if (typeof output.response === "string" && String(output.response || "").trim())
+    return true;
+  if (hasNonEmptyValue(output))
+    return true;
+  return false;
+}
 async function processMessageWithFunctions(options) {
   const { message, toolFunctions } = options;
   const parsed = parseMessage(message);
@@ -4255,6 +5063,7 @@ async function handleSendMessageWithFunctions(userInput, context) {
     let routedAgentPrevSteps = context.agentLog?.prevSteps;
     if (routing.mode === "act") {
       context.onStatusUpdate?.("Executing action plan", "Using ACT tool loop", "execute");
+      const actStartedAt = Date.now();
       const actResult = await executeToolFromPlan({
         ...context,
         toolName: PLANNER_FUNCTION_CALLS.ACT,
@@ -4273,7 +5082,17 @@ async function handleSendMessageWithFunctions(userInput, context) {
         routedAgentPrevSteps = actResult.prevSteps;
         context.onPrevStepsUpdate?.(routedAgentPrevSteps);
       }
-      const shouldEscalateToPlanner = !!actResult.error && (context.taskRouting?.plannerOnActError ?? true) && context.taskRouting?.mode !== "act";
+      const actElapsedMs = Date.now() - actStartedAt;
+      const actFunctionCount = Array.isArray(actResult.prevSteps?.[actResult.prevSteps.length - 1]?.functions) ? actResult.prevSteps[actResult.prevSteps.length - 1].functions.length : 0;
+      const recoverableFailures = Array.isArray(actResult.prevSteps) ? actResult.prevSteps.reduce((count, step) => {
+        const failures = Array.isArray(step.functions) ? step.functions.filter((fn) => fn?.response?.status === "Failure").length : 0;
+        return count + failures;
+      }, 0) : 0;
+      const crossDomainPlanDependency = hasCrossDomainPlanDependency(userInput, context.tabs || []);
+      const crossDomainDependencyCount = countCrossDomainNavigationDependencies(userInput, context.tabs || []);
+      const multiStepDependency = hasMultiStepDependencyMarkers(userInput);
+      const actProducedUsableOutcome = hasUsableActOutcome(actResult);
+      const shouldEscalateToPlanner = !actProducedUsableOutcome && (!!actResult.error && (context.taskRouting?.plannerOnActError ?? true) && context.taskRouting?.mode !== "act" || actElapsedMs > 8e3 || actFunctionCount > 3 || recoverableFailures >= 2 || crossDomainDependencyCount > 1 || crossDomainPlanDependency || multiStepDependency);
       if (!shouldEscalateToPlanner) {
         return {
           success: !actResult.error,
@@ -4311,6 +5130,19 @@ async function handleSendMessageWithFunctions(userInput, context) {
   return { success: true, processedMessage: result.processedMessage };
 }
 
+// dist/runHistoryGuards.js
+function shouldClearHistoryForRun(params) {
+  return !params.resume && !params.preserveHistory;
+}
+function shouldBuildResumeCueChatLog(params) {
+  return !!(params.resume || params.preserveHistory) && params.resumeFollowupMode === "deterministic_cues";
+}
+function shouldUseFollowupChatLog(params) {
+  if (params.resume)
+    return false;
+  return Number(params.followupChatLogLength) > 0;
+}
+
 // dist/worker.js
 var history = [];
 var config = null;
@@ -4319,7 +5151,12 @@ var toolRegistry = new ToolRegistry();
 var plannerHistory = [];
 var agentPrevSteps = [];
 var pendingAskUser;
-var trajectoryId = crypto.randomUUID();
+var rootUserInput = "";
+var workerSessionId = "";
+var taskTrajectoryId = crypto.randomUUID();
+var taskBoundaryId = crypto.randomUUID();
+var scopedTabIds = [];
+var scopedSeedTabId;
 var tabularStore = null;
 var PLANNER_TOOL_NAME_SET = new Set(Object.values(PLANNER_FUNCTION_CALLS));
 var activeRun = null;
@@ -4327,10 +5164,12 @@ var cancelledRunIds = /* @__PURE__ */ new Set();
 var activeAbortController = null;
 var lastStatusKey = "";
 var seenStatusKeys = /* @__PURE__ */ new Set();
+var lastRuntimeTabsDiagnosticsKey = "";
 var terminalRuns = /* @__PURE__ */ new Map();
 var RPC_TIMEOUT_MS = 3e4;
 var DETACHED_EXTERNAL_TAB_MAX_AGE_MS = 9e4;
-var MAX_CHATLOG_ENTRIES2 = 12;
+var PENDING_ATTACH_TAB_MAX_AGE_MS = 2e4;
+var MAX_RESUME_CUE_TURNS = 2;
 function resolveAgentName(config2) {
   const raw = String(config2?.ui?.agent?.name || "").trim();
   if (!raw)
@@ -4379,6 +5218,7 @@ function buildRoverRuntimeContext2(params) {
     agentName: params.agentName,
     externalNavigationPolicy: params.externalNavigationPolicy,
     tabIdContract: "tree_index_mapped_by_tab_order",
+    taskBoundaryId: params.taskBoundaryId,
     ...externalTabs.length ? { externalTabs } : {}
   };
 }
@@ -4483,6 +5323,8 @@ async function getKnownTabs() {
           id,
           runtimeId: typeof tab?.runtimeId === "string" ? tab.runtimeId : void 0,
           updatedAt: Number(tab?.updatedAt) || 0,
+          detachedAt: Number(tab?.detachedAt) || 0,
+          detachedReason: typeof tab?.detachedReason === "string" ? tab.detachedReason : void 0,
           url: typeof tab?.url === "string" ? tab.url : void 0,
           title: typeof tab?.title === "string" ? tab.title : void 0,
           external,
@@ -4490,9 +5332,15 @@ async function getKnownTabs() {
           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)
+        const freshness = Math.max(Number(tab.updatedAt) || 0, Number(tab.detachedAt) || 0);
+        if (tab.runtimeId)
           return true;
-        return nowMs - (tab.updatedAt || 0) <= DETACHED_EXTERNAL_TAB_MAX_AGE_MS;
+        if (tab.external)
+          return nowMs - freshness <= DETACHED_EXTERNAL_TAB_MAX_AGE_MS;
+        if (tab.detachedReason === "opened_pending_attach") {
+          return nowMs - freshness <= PENDING_ATTACH_TAB_MAX_AGE_MS;
+        }
+        return false;
       }).map((tab) => ({
         id: tab.id,
         url: tab.url,
@@ -4534,6 +5382,8 @@ function postStatus(message, thought, stage) {
   const resolvedStage = inferStatusStage(message, thought, stage);
   const compact = compactThought(message, thought);
   const runId = activeRun?.runId || "no-run";
+  if (runId !== "no-run" && cancelledRunIds.has(runId))
+    return;
   const key = `${runId}|${resolvedStage}|${String(message || "").trim().toLowerCase()}|${compact.toLowerCase()}`;
   if (key === lastStatusKey || seenStatusKeys.has(key))
     return;
@@ -4546,6 +5396,27 @@ function postStatus(message, thought, stage) {
   self.postMessage({ type: "status", message, thought, stage: resolvedStage, compactThought: compact, runId: activeRun?.runId });
   postStateSnapshot();
 }
+function postRuntimeTabsDiagnostics(payload) {
+  const runId = activeRun?.runId || "no-run";
+  if (runId !== "no-run" && cancelledRunIds.has(runId))
+    return;
+  const signature = [
+    runId,
+    payload.hasExplicitScope ? "1" : "0",
+    payload.scopedTabIdsInput.join(","),
+    payload.listedTabIds.join(","),
+    payload.keptScopedTabIds.join(","),
+    payload.resolvedTabOrder.join(",")
+  ].join("|");
+  if (signature === lastRuntimeTabsDiagnosticsKey)
+    return;
+  lastRuntimeTabsDiagnosticsKey = signature;
+  self.postMessage({
+    type: "runtime_tabs_diagnostics",
+    runId: activeRun?.runId,
+    diagnostics: payload
+  });
+}
 function cloneUnknown(value) {
   if (value == null)
     return value;
@@ -4562,8 +5433,8 @@ function cloneUnknown(value) {
   }
 }
 function sanitizeHistoryForPersist(input) {
-  return input.slice(-80).map((message) => ({
-    ...message,
+  return input.filter((message) => message?.role === "user").slice(-20).map((message) => ({
+    role: "user",
     content: String(message?.content ?? "")
   }));
 }
@@ -4631,6 +5502,7 @@ function questionToDisplayText(question) {
 function normalizeAskUserAnswerMeta(raw, questions, fallbackText) {
   const validKeys = new Set(questions.map((question) => question.key));
   const answersByKey = {};
+  const submittedKeys = Array.isArray(raw?.keys) ? raw.keys.map((key) => String(key || "").trim()).filter((key) => !!key && validKeys.has(key)) : [];
   if (raw?.answersByKey && typeof raw.answersByKey === "object") {
     for (const [key, value] of Object.entries(raw.answersByKey)) {
       if (!validKeys.has(key))
@@ -4660,8 +5532,14 @@ function normalizeAskUserAnswerMeta(raw, questions, fallbackText) {
     }
   }
   const rawText = String(raw?.rawText || fallback || "").trim();
-  if (!rawText && Object.keys(answersByKey).length === 0)
-    return void 0;
+  if (!rawText && Object.keys(answersByKey).length === 0) {
+    if (!submittedKeys.length)
+      return void 0;
+    return {
+      answersByKey,
+      rawText: submittedKeys.map((key) => `${key}: (no answer provided)`).join("\n")
+    };
+  }
   return { answersByKey, rawText };
 }
 function buildAskUserAnswerContext(questions, answers) {
@@ -4676,10 +5554,256 @@ function buildAskUserAnswerContext(questions, answers) {
   }
   return lines.join("\n");
 }
+function normalizeRootUserInput(input) {
+  const normalized = String(input || "").trim();
+  return normalized || void 0;
+}
+function normalizeFollowupChatLog(input) {
+  if (!Array.isArray(input))
+    return [];
+  const normalized = input.map((entry) => ({
+    role: entry?.role === "user" ? "user" : "model",
+    message: String(entry?.message || "").replace(/\s+/g, " ").trim()
+  })).filter((entry) => !!entry.message);
+  if (!normalized.length)
+    return [];
+  const deduped = [];
+  for (const entry of normalized) {
+    const previous = deduped[deduped.length - 1];
+    if (previous && previous.role === entry.role && previous.message === entry.message)
+      continue;
+    deduped.push(entry);
+  }
+  return deduped.slice(-12);
+}
+function dedupePositiveTabIds4(input) {
+  if (!Array.isArray(input))
+    return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of input) {
+    const tabId = Number(value);
+    if (!Number.isFinite(tabId) || tabId <= 0 || seen.has(tabId))
+      continue;
+    seen.add(tabId);
+    out.push(tabId);
+  }
+  return out;
+}
+function resolveScopedTabConfig(partial) {
+  const directScoped = dedupePositiveTabIds4(partial?.scopedTabIds);
+  const scope = partial?.taskTabScope;
+  const scopedFromScope = dedupePositiveTabIds4(scope?.touchedTabIds);
+  const seedCandidate = Number(scope?.seedTabId);
+  const seedTabId = Number.isFinite(seedCandidate) && seedCandidate > 0 ? seedCandidate : void 0;
+  const scoped = dedupePositiveTabIds4(directScoped.length > 0 ? directScoped : scopedFromScope.length > 0 ? scopedFromScope : seedTabId ? [seedTabId] : []);
+  if (seedTabId && !scoped.includes(seedTabId)) {
+    scoped.unshift(seedTabId);
+  }
+  return { scoped, seedTabId };
+}
+function applyScopedTabConfig(partial) {
+  if (!partial || typeof partial !== "object")
+    return;
+  const hasScopedTabIds = Object.prototype.hasOwnProperty.call(partial, "scopedTabIds");
+  const hasTaskTabScope = Object.prototype.hasOwnProperty.call(partial, "taskTabScope");
+  if (!hasScopedTabIds && !hasTaskTabScope)
+    return;
+  const next = resolveScopedTabConfig(partial);
+  scopedTabIds = next.scoped;
+  scopedSeedTabId = next.seedTabId;
+}
+function touchRunScopedTabIds(tabIds) {
+  const touched = dedupePositiveTabIds4(Array.isArray(tabIds) ? tabIds : [tabIds]);
+  if (!touched.length)
+    return scopedTabIds;
+  const next = dedupePositiveTabIds4([
+    ...Number(scopedSeedTabId) > 0 ? [Number(scopedSeedTabId)] : [],
+    ...scopedTabIds,
+    ...touched
+  ]);
+  if (next.length === scopedTabIds.length && next.every((tabId, index) => tabId === scopedTabIds[index])) {
+    return scopedTabIds;
+  }
+  scopedTabIds = next;
+  return scopedTabIds;
+}
+function getRootUserInputFallbackFromHistory() {
+  for (const message of history) {
+    if (message.role !== "user")
+      continue;
+    const content = normalizeRootUserInput(String(message.content || ""));
+    if (content)
+      return content;
+  }
+  return void 0;
+}
+function buildContinuePlanningInput(focus, lastToolName, lastToolOutput) {
+  const safeToolName = String(lastToolName || "").trim();
+  const safeFocus = String(focus || "").trim();
+  const lines = [
+    safeToolName ? `The tool \`${safeToolName}\` just finished executing.` : "No tool was issued previously.",
+    `Please analyze the progress based on the complete history and determine the single next best step required to fulfill the overall request: ${safeFocus || "(none)"}.`,
+    `If the request is complete, invoke tool \`${PLANNER_FUNCTION_CALLS.TASK_COMPLETE}\` via \`tool_code\`. If not, invoke the appropriate tool.`
+  ];
+  const output = String(lastToolOutput || "").trim();
+  if (output) {
+    lines.push("[LAST_TOOL_OUTPUT]");
+    lines.push(output);
+  }
+  return lines.join("\n");
+}
+function findLatestAskUserFunctionStep(steps) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    return void 0;
+  for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex -= 1) {
+    const step = steps[stepIndex];
+    const functions = Array.isArray(step?.functions) ? step.functions : [];
+    for (let functionIndex = functions.length - 1; functionIndex >= 0; functionIndex -= 1) {
+      const fn = functions[functionIndex];
+      if (String(fn?.name || "").trim().toLowerCase() === "ask_user") {
+        return { stepIndex, functionIndex };
+      }
+    }
+  }
+  return void 0;
+}
+function resolveAskUserStepRef(steps, prompt) {
+  const explicit = prompt?.stepRef;
+  if (explicit && prompt?.boundaryId && prompt.boundaryId === taskBoundaryId && Number.isFinite(explicit.stepIndex) && explicit.stepIndex >= 0 && Number.isFinite(explicit.functionIndex) && explicit.functionIndex >= 0 && explicit.stepIndex < steps.length) {
+    const step = steps[explicit.stepIndex];
+    const functions = Array.isArray(step?.functions) ? step.functions : [];
+    const fn = functions[explicit.functionIndex];
+    if (String(fn?.name || "").trim().toLowerCase() === "ask_user") {
+      return {
+        stepIndex: explicit.stepIndex,
+        functionIndex: explicit.functionIndex
+      };
+    }
+  }
+  const refs = [];
+  for (let stepIndex = 0; stepIndex < steps.length; stepIndex += 1) {
+    const step = steps[stepIndex];
+    const functions = Array.isArray(step?.functions) ? step.functions : [];
+    for (let functionIndex = 0; functionIndex < functions.length; functionIndex += 1) {
+      const fn = functions[functionIndex];
+      if (String(fn?.name || "").trim().toLowerCase() === "ask_user") {
+        refs.push({ stepIndex, functionIndex });
+      }
+    }
+  }
+  if (refs.length === 1)
+    return refs[0];
+  if (refs.length > 1)
+    return refs[refs.length - 1];
+  return void 0;
+}
+function captureLatestAskUserStepRef(steps) {
+  const ref = findLatestAskUserFunctionStep(steps);
+  if (!ref)
+    return void 0;
+  const step = steps[ref.stepIndex];
+  return {
+    stepIndex: ref.stepIndex,
+    functionIndex: ref.functionIndex,
+    ...typeof step?.accTreeId === "string" && String(step.accTreeId).trim() ? { accTreeId: String(step.accTreeId).trim() } : {}
+  };
+}
+function buildPendingAskUserPrompt(source, questions) {
+  const stepRef = captureLatestAskUserStepRef(agentPrevSteps);
+  return {
+    questions,
+    source,
+    askedAt: Date.now(),
+    boundaryId: taskBoundaryId,
+    ...stepRef ? { stepRef } : {}
+  };
+}
+function mergeAskUserAnswerIntoPrevSteps(inputSteps, prompt, answers) {
+  const next = sanitizeAgentPrevStepsForPersist(Array.isArray(inputSteps) ? inputSteps : []);
+  const questions = normalizePlannerQuestions(prompt?.questions);
+  if (!questions.length)
+    return next;
+  const askUserRef = resolveAskUserStepRef(next, prompt);
+  const questionPayload = normalizePlannerQuestions(questions).map((question) => ({
+    key: question.key,
+    query: question.query,
+    ...question.required === false ? { required: false } : {}
+  }));
+  const buildOutputPayload = (previousOutput2) => {
+    const prev = previousOutput2 && typeof previousOutput2 === "object" && !Array.isArray(previousOutput2) ? previousOutput2 : {};
+    const prevQuestions = normalizePlannerQuestions(prev.questions);
+    const resolvedQuestions = prevQuestions.length ? prevQuestions : normalizePlannerQuestions(questions);
+    return {
+      ...prev,
+      status: "answered",
+      needsUserInput: false,
+      ...resolvedQuestions.length ? { questions: resolvedQuestions } : {},
+      ask_user_answers: { ...answers.answersByKey },
+      ...answers.rawText ? { raw_user_reply: answers.rawText } : {},
+      answeredAt: Date.now()
+    };
+  };
+  if (!askUserRef) {
+    return next;
+  }
+  const step = next[askUserRef.stepIndex];
+  if (!Array.isArray(step.functions))
+    step.functions = [];
+  const existingFn = step.functions[askUserRef.functionIndex];
+  const previousOutput = existingFn?.response?.output;
+  step.functions[askUserRef.functionIndex] = {
+    name: "ask_user",
+    args: {
+      questions_to_ask: questionPayload
+    },
+    response: {
+      status: "Success",
+      output: buildOutputPayload(previousOutput)
+    }
+  };
+  return next;
+}
+function mergeAskUserAnswersIntoPlannerHistory(input, questions, answersByKey) {
+  const next = sanitizePlannerHistoryForPersist(Array.isArray(input) ? input : []);
+  for (let i = next.length - 1; i >= 0; i -= 1) {
+    const step = next[i];
+    if (!step || typeof step !== "object")
+      continue;
+    const asked = normalizePlannerQuestions(step.questionsAsked);
+    if (!asked.length)
+      continue;
+    const askedKeys = new Set(asked.map((question) => question.key.toLowerCase()));
+    const overlaps = questions.some((question) => askedKeys.has(String(question.key || "").toLowerCase()));
+    if (!overlaps)
+      continue;
+    const existingAnswers = step.userAnswers && typeof step.userAnswers === "object" && !Array.isArray(step.userAnswers) ? step.userAnswers : {};
+    step.userAnswers = {
+      ...existingAnswers,
+      ...answersByKey
+    };
+    return sanitizePlannerHistoryForPersist(next);
+  }
+  next.push({
+    thought: "User provided clarification answers.",
+    questionsAsked: questions,
+    userAnswers: answersByKey
+  });
+  return sanitizePlannerHistoryForPersist(next);
+}
 function buildPersistedState() {
   const safePrevSteps = sanitizeAgentPrevStepsForPersist(Array.isArray(agentPrevSteps) ? agentPrevSteps : []);
+  const normalizedRootUserInput = normalizeRootUserInput(rootUserInput);
+  const pendingStepRef = pendingAskUser?.stepRef;
+  const safePendingStepRef = pendingStepRef && Number.isFinite(pendingStepRef.stepIndex) && pendingStepRef.stepIndex >= 0 && Number.isFinite(pendingStepRef.functionIndex) && pendingStepRef.functionIndex >= 0 ? {
+    stepIndex: pendingStepRef.stepIndex,
+    functionIndex: pendingStepRef.functionIndex,
+    ...typeof pendingStepRef.accTreeId === "string" && pendingStepRef.accTreeId.trim() ? { accTreeId: pendingStepRef.accTreeId.trim() } : {}
+  } : void 0;
   return {
-    trajectoryId,
+    trajectoryId: taskTrajectoryId,
+    taskBoundaryId,
+    ...normalizedRootUserInput ? { rootUserInput: normalizedRootUserInput } : {},
     history: sanitizeHistoryForPersist(history),
     plannerHistory: sanitizePlannerHistoryForPersist(Array.isArray(plannerHistory) ? plannerHistory : []),
     agentPrevSteps: safePrevSteps,
@@ -4687,7 +5811,9 @@ function buildPersistedState() {
     pendingAskUser: pendingAskUser ? {
       questions: normalizePlannerQuestions(pendingAskUser.questions),
       source: pendingAskUser.source,
-      askedAt: Number(pendingAskUser.askedAt) || Date.now()
+      askedAt: Number(pendingAskUser.askedAt) || Date.now(),
+      ...typeof pendingAskUser.boundaryId === "string" && pendingAskUser.boundaryId.trim() ? { boundaryId: pendingAskUser.boundaryId.trim() } : {},
+      ...safePendingStepRef ? { stepRef: safePendingStepRef } : {}
     } : void 0
   };
 }
@@ -4722,20 +5848,33 @@ function hydrateState(raw) {
     agentPrevSteps = sanitizeAgentPrevStepsForPersist(snapshot.lastToolPreviousSteps);
   }
   const hydratedQuestions = normalizePlannerQuestions(snapshot.pendingAskUser?.questions);
+  const hydratedStepRefRaw = snapshot.pendingAskUser?.stepRef;
+  const hydratedStepRef = hydratedStepRefRaw && Number.isFinite(Number(hydratedStepRefRaw.stepIndex)) && Number(hydratedStepRefRaw.stepIndex) >= 0 && Number.isFinite(Number(hydratedStepRefRaw.functionIndex)) && Number(hydratedStepRefRaw.functionIndex) >= 0 ? {
+    stepIndex: Number(hydratedStepRefRaw.stepIndex),
+    functionIndex: Number(hydratedStepRefRaw.functionIndex),
+    ...typeof hydratedStepRefRaw.accTreeId === "string" && hydratedStepRefRaw.accTreeId.trim() ? { accTreeId: hydratedStepRefRaw.accTreeId.trim() } : {}
+  } : void 0;
   if (hydratedQuestions.length > 0) {
     pendingAskUser = {
       questions: hydratedQuestions,
       source: snapshot.pendingAskUser?.source === "planner" ? "planner" : "act",
-      askedAt: Number(snapshot.pendingAskUser?.askedAt) || Date.now()
+      askedAt: Number(snapshot.pendingAskUser?.askedAt) || Date.now(),
+      boundaryId: typeof snapshot.pendingAskUser?.boundaryId === "string" ? String(snapshot.pendingAskUser.boundaryId).trim() || void 0 : void 0,
+      ...hydratedStepRef ? { stepRef: hydratedStepRef } : {}
     };
   } else {
     pendingAskUser = void 0;
   }
   if (typeof snapshot.trajectoryId === "string" && snapshot.trajectoryId.trim()) {
-    trajectoryId = snapshot.trajectoryId.trim();
+    taskTrajectoryId = snapshot.trajectoryId.trim();
   }
+  if (typeof snapshot.taskBoundaryId === "string" && String(snapshot.taskBoundaryId).trim()) {
+    taskBoundaryId = String(snapshot.taskBoundaryId).trim();
+  }
+  const hydratedRootUserInput = normalizeRootUserInput(snapshot.rootUserInput);
+  rootUserInput = hydratedRootUserInput || normalizeRootUserInput(getRootUserInputFallbackFromHistory()) || "";
   if (!tabularStore) {
-    tabularStore = new TabularStore(`rover-${trajectoryId}`);
+    tabularStore = new TabularStore(`rover-${taskTrajectoryId}`);
   }
   postStateSnapshot();
 }
@@ -4757,7 +5896,7 @@ function sanitizeAssistantBlocks(input) {
     if (type === "tool_output" || type === "json") {
       out.push({
         type,
-        data: cloneUnknown(raw.data),
+        data: normalizeRuntimeToolOutput(raw.data),
         label: typeof raw.label === "string" ? raw.label : void 0,
         toolName: typeof raw.toolName === "string" ? raw.toolName : void 0
       });
@@ -4765,6 +5904,21 @@ function sanitizeAssistantBlocks(input) {
   }
   return out.length ? out : void 0;
 }
+function normalizeRuntimeToolOutput(value) {
+  const cloned = cloneUnknown(value);
+  if (cloned == null)
+    return null;
+  if (typeof cloned === "string" || typeof cloned === "number" || typeof cloned === "boolean") {
+    return cloned;
+  }
+  if (Array.isArray(cloned)) {
+    return cloned;
+  }
+  if (typeof cloned === "object") {
+    return cloned;
+  }
+  return String(cloned);
+}
 function summarizeOutputText(output) {
   if (output == null)
     return void 0;
@@ -4786,7 +5940,7 @@ function summarizeOutputText(output) {
     }
     if (lines.length)
       return lines.join("\n");
-    return `Received ${output.length} item(s).`;
+    return void 0;
   }
   if (typeof output === "object") {
     const preferredKeys = ["response", "message", "summary", "text", "content", "result", "description"];
@@ -4796,10 +5950,7 @@ function summarizeOutputText(output) {
         return value.trim();
       }
     }
-    const keys = Object.keys(output);
-    if (!keys.length)
-      return void 0;
-    return `Received ${keys.length} field(s).`;
+    return void 0;
   }
   return void 0;
 }
@@ -4844,14 +5995,14 @@ function shouldAttachStructuredBlock(output, summaryText) {
 }
 function buildAssistantPayloadFromToolOutput(output, options) {
   const summaryText = summarizeOutputText(output);
-  const text = summaryText || options?.fallbackText || "Done.";
+  const text = summaryText || options?.fallbackText || "";
   const blocks = [];
   if (shouldAttachStructuredBlock(output, summaryText)) {
     blocks.push({
       type: "tool_output",
       label: options?.label,
       toolName: options?.toolName,
-      data: cloneUnknown(output)
+      data: normalizeRuntimeToolOutput(output)
     });
   }
   return { text, blocks: blocks.length ? blocks : void 0 };
@@ -4861,8 +6012,15 @@ function postAssistantMessage(payload) {
   const blocks = typeof payload === "string" ? void 0 : sanitizeAssistantBlocks(payload.blocks);
   const firstTextBlock = blocks?.find((block) => block.type === "text");
   const firstStructuredBlock = blocks?.find((block) => block.type === "tool_output" || block.type === "json");
-  const resolvedText = text || firstTextBlock?.text || summarizeOutputText(firstStructuredBlock?.data) || "Done.";
-  self.postMessage({ type: "assistant", text: resolvedText, blocks, runId: activeRun?.runId });
+  const resolvedText = text || firstTextBlock?.text || summarizeOutputText(firstStructuredBlock?.data) || "";
+  if (!resolvedText && (!blocks || blocks.length === 0)) {
+    return "";
+  }
+  const runId = activeRun?.runId;
+  if (runId && cancelledRunIds.has(runId)) {
+    return resolvedText;
+  }
+  self.postMessage({ type: "assistant", text: resolvedText, blocks, runId });
   return resolvedText;
 }
 function dedupeFunctionDeclarations(declarations) {
@@ -4880,9 +6038,20 @@ function removePlannerNameCollisions(declarations) {
   return declarations.filter((decl) => !!decl?.name && !PLANNER_TOOL_NAME_SET.has(decl.name));
 }
 function postAuthRequired(err) {
+  const runId = activeRun?.runId;
+  if (runId && cancelledRunIds.has(runId))
+    return;
   const envelope = err && typeof err === "object" && err.code && err.message ? toRoverErrorEnvelope({ errorDetails: err }, "Rover API key is required.") : toRoverErrorEnvelope(err, "Rover API key is required.");
-  self.postMessage({ type: "auth_required", error: envelope, runId: activeRun?.runId });
-}
+  self.postMessage({ type: "auth_required", error: envelope, runId });
+}
+var NAVIGATION_TOOL_NAME_SET = /* @__PURE__ */ new Set([
+  "goto_url",
+  "google_search",
+  "go_back",
+  "go_forward",
+  "refresh_page",
+  "open_new_tab"
+]);
 function toStructuredErrorPayload(err, fallbackMessage = "Operation failed") {
   const envelope = toRoverErrorEnvelope(err, fallbackMessage);
   const payload = {
@@ -4923,6 +6092,58 @@ function extractStructuredErrorFromToolResult(result) {
   }
   return void 0;
 }
+function sawRecentSuccessfulNavigationStep(steps) {
+  if (!Array.isArray(steps) || steps.length === 0)
+    return false;
+  let inspectedStepCount = 0;
+  for (let stepIndex = steps.length - 1; stepIndex >= 0; stepIndex -= 1) {
+    const step = steps[stepIndex];
+    const functions = Array.isArray(step?.functions) ? step.functions : [];
+    if (!functions.length)
+      continue;
+    inspectedStepCount += 1;
+    for (let fnIndex = functions.length - 1; fnIndex >= 0; fnIndex -= 1) {
+      const fn = functions[fnIndex];
+      const toolName = String(fn?.name || fn?.toolName || fn?.functionName || "").trim();
+      if (!toolName || !NAVIGATION_TOOL_NAME_SET.has(toolName))
+        continue;
+      const status = String(fn?.response?.status || fn?.status || "").trim().toLowerCase();
+      if (status === "success") {
+        return true;
+      }
+    }
+    if (inspectedStepCount >= 2)
+      break;
+  }
+  return false;
+}
+var NAVIGATION_TRANSIENT_CODES = /* @__PURE__ */ new Set([
+  "UNKNOWN_ERROR",
+  "MISSING_AUTH_TOKEN",
+  "MISSING_AUTH",
+  "SESSION_TOKEN_EXPIRED",
+  "SESSION_TOKEN_INVALID",
+  "BOOTSTRAP_REQUIRED"
+]);
+function normalizeLifecycleHandoffError(payload, steps) {
+  const code = String(payload?.error?.code || "").trim().toUpperCase();
+  if (code && !NAVIGATION_TRANSIENT_CODES.has(code))
+    return payload;
+  if (!sawRecentSuccessfulNavigationStep(steps))
+    return payload;
+  return {
+    ...payload,
+    error: {
+      ...payload.error,
+      code: "NAVIGATION_HANDOFF_PENDING",
+      message: payload.error?.message || "Navigation handoff is in progress.",
+      retryable: true,
+      next_action: "Wait for post-navigation resume and continue the task."
+    },
+    retryable: true,
+    next_action: "Wait for post-navigation resume and continue the task."
+  };
+}
 function maybePostNavigationGuardrailFromToolResult(toolResult) {
   if (!toolResult || typeof toolResult !== "object")
     return;
@@ -4942,52 +6163,71 @@ function maybePostNavigationGuardrailFromToolResult(toolResult) {
     allowedDomains: output?.allowed_domains || details?.details?.allowedDomains
   });
 }
-function buildChatLogFromHistory(input, currentUserInput) {
-  const sanitizeChatText = (raw) => {
-    return String(raw || "").replace(/\s+/g, " ").trim();
-  };
-  const normalizedCurrentUserInput = currentUserInput ? sanitizeChatText(currentUserInput) : "";
+function assessAdversarialInput(rawText) {
+  const text = String(rawText || "").toLowerCase();
+  if (!text.trim())
+    return { blocked: false, score: 0, reasons: [] };
+  const signals = [
+    { reason: "prompt_injection", pattern: /\b(ignore|bypass|override)\b.{0,40}\b(instruction|policy|guardrail|system|developer)\b/i, weight: 2 },
+    { reason: "secret_exfiltration", pattern: /\b(token|cookie|password|secret|api key|session key)\b.{0,40}\b(extract|dump|reveal|steal|exfiltrat)/i, weight: 3 },
+    { reason: "credential_harvest", pattern: /\b(phish|credential|login prompt|social engineering)\b/i, weight: 3 },
+    { reason: "policy_evasion", pattern: /\b(do not tell|without asking|silently|hidden|covert)\b/i, weight: 1 }
+  ];
+  const reasons = [];
+  let score = 0;
+  for (const signal of signals) {
+    if (!signal.pattern.test(text))
+      continue;
+    reasons.push(signal.reason);
+    score += signal.weight;
+  }
+  const blocked = score >= 3;
+  return { blocked, score, reasons };
+}
+function buildChatLogFromHistory(input, currentUserInput, maxTurns = MAX_RESUME_CUE_TURNS) {
+  const normalize = (value) => String(value || "").replace(/\s+/g, " ").trim();
+  const normalizedCurrent = normalize(String(currentUserInput || ""));
+  if (!normalizedCurrent)
+    return [];
   const entries = input.filter((message) => message.role === "user" || message.role === "assistant").map((message) => ({
     role: message.role,
-    content: sanitizeChatText(String(message.content || ""))
-  })).filter((message) => !!message.content);
-  if (normalizedCurrentUserInput) {
-    for (let i = entries.length - 1; i >= 0; i -= 1) {
-      if (entries[i].role === "user" && entries[i].content === normalizedCurrentUserInput) {
-        entries.splice(i, 1);
-        break;
-      }
-    }
-  }
-  const deduped = [];
+    content: normalize(String(message.content || ""))
+  })).filter((message) => !!message.content).filter((message) => {
+    const lowered = message.content.toLowerCase();
+    if (lowered.includes("[ask_user_answers]"))
+      return false;
+    if (lowered.includes("[raw_user_reply]"))
+      return false;
+    if (lowered.includes("[continue_planning]"))
+      return false;
+    return true;
+  });
+  const turns = [];
   for (const entry of entries) {
-    const previous = deduped[deduped.length - 1];
-    if (previous && previous.role === entry.role && previous.content === entry.content)
+    if (entry.role === "user") {
+      turns.push({ user: entry.content });
       continue;
-    deduped.push(entry);
-  }
-  const firstUser = deduped.find((message) => message.role === "user");
-  const tailBudget = firstUser ? Math.max(1, MAX_CHATLOG_ENTRIES2 - 1) : MAX_CHATLOG_ENTRIES2;
-  let selected = deduped.slice(-tailBudget);
-  if (firstUser) {
-    const hasAnchor = selected.some((message) => message.role === "user" && message.content === firstUser.content);
-    if (!hasAnchor) {
-      selected = [firstUser, ...selected];
+    }
+    if (!turns.length)
+      continue;
+    const latest = turns[turns.length - 1];
+    if (!latest.assistant) {
+      latest.assistant = entry.content;
     }
   }
-  if (selected.length > MAX_CHATLOG_ENTRIES2) {
-    selected = selected.slice(-MAX_CHATLOG_ENTRIES2);
-  }
-  if (selected.length > 1 && selected[0]?.role !== "user") {
-    const firstUserIndex = selected.findIndex((message) => message.role === "user");
-    if (firstUserIndex > 0) {
-      selected = selected.slice(firstUserIndex);
+  if (!turns.length)
+    return [];
+  const cappedTurns = turns.slice(-Math.max(1, Math.min(4, Math.floor(maxTurns))));
+  const messages = [];
+  for (const turn of cappedTurns) {
+    if (turn.user && turn.user !== normalizedCurrent) {
+      messages.push({ role: "user", message: turn.user });
+    }
+    if (turn.assistant) {
+      messages.push({ role: "model", message: turn.assistant });
     }
   }
-  return selected.map((message) => ({
-    role: message.role === "user" ? "user" : "model",
-    message: message.content
-  }));
+  return messages;
 }
 function applyAgentPrevSteps(next, options) {
   if (!Array.isArray(next) || !next.length)
@@ -5049,14 +6289,14 @@ function buildPlannerToolResultBlocks(toolResults) {
         type: "tool_output",
         label: result.toolName ? `${stepLabel}: ${result.toolName}` : stepLabel,
         toolName: typeof result.toolName === "string" ? result.toolName : void 0,
-        data: cloneUnknown(output)
+        data: normalizeRuntimeToolOutput(output)
       });
     }
     if (result.error || result.errorDetails) {
       blocks.push({
         type: "json",
         label: `${stepLabel} error`,
-        data: cloneUnknown({
+        data: normalizeRuntimeToolOutput({
           error: result.error,
           errorDetails: result.errorDetails
         })
@@ -5142,6 +6382,24 @@ function detectOpenedTabFromToolResult(result) {
   }
   return void 0;
 }
+function extractTouchedTabIdsFromToolResult(result) {
+  if (!result || typeof result !== "object")
+    return [];
+  const output = result.output && typeof result.output === "object" ? result.output : void 0;
+  const candidates = [
+    Number(result.logicalTabId ?? result.logical_tab_id ?? result.tabId ?? result.tab_id),
+    Number(output?.logicalTabId ?? output?.logical_tab_id ?? output?.tabId ?? output?.tab_id)
+  ];
+  const unique = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of candidates) {
+    if (!Number.isFinite(value) || value <= 0 || unique.has(value))
+      continue;
+    unique.add(value);
+    out.push(value);
+  }
+  return out;
+}
 function extractQuestionsFromResult(result) {
   if (!result || typeof result !== "object")
     return void 0;
@@ -5149,7 +6407,7 @@ function extractQuestionsFromResult(result) {
   if (topLevel.length)
     return topLevel;
   const output = result.output;
-  const outputQuestions = normalizePlannerQuestions(output?.questions);
+  const outputQuestions = normalizePlannerQuestions(output && typeof output === "object" ? output.questions : void 0);
   if (outputQuestions.length)
     return outputQuestions;
   return void 0;
@@ -5173,77 +6431,170 @@ function extractPlannerQuestionsFromToolResults(toolResults) {
   }
   return combined.slice(0, 6);
 }
-function deriveDirectToolRunOutcome(result) {
-  if (!result || typeof result !== "object") {
-    return { taskComplete: false };
+function inferPlannerContinuation(toolResults) {
+  if (!Array.isArray(toolResults) || toolResults.length === 0) {
+    return {
+      failed: false,
+      needsUserInput: false,
+      navigationPending: false,
+      sameTabNavigationPending: false
+    };
   }
-  const questions = extractQuestionsFromResult(result);
-  const topLevelStatus = String(result.status || "").trim().toLowerCase();
-  if (topLevelStatus === "failure" || topLevelStatus === "failed" || topLevelStatus === "error") {
-    return { taskComplete: false };
+  let failed = false;
+  let needsUserInput = false;
+  let navigationPending = false;
+  let sameTabNavigationPending = false;
+  for (const result of toolResults) {
+    if (!result || typeof result !== "object")
+      continue;
+    if (result.error || result.errorDetails) {
+      failed = true;
+      continue;
+    }
+    const output = result.output && typeof result.output === "object" ? result.output : void 0;
+    if (!output)
+      continue;
+    const navigationOutcome = String(output.navigationOutcome || "").trim().toLowerCase();
+    if (output.navigationPending === true || navigationOutcome === "same_tab_scheduled" || navigationOutcome === "new_tab_opened") {
+      navigationPending = true;
+      if (navigationOutcome === "same_tab_scheduled") {
+        sameTabNavigationPending = true;
+      }
+    }
+    const status = String(output.taskStatus || output.status || "").trim().toLowerCase();
+    if (status === "failure" || status === "failed" || status === "error") {
+      failed = true;
+    }
+    if (status === "waiting_input" || status === "needs_input" || status === "pending_user_input") {
+      needsUserInput = true;
+    }
+    if (output.needsUserInput === true || output.waitingForUserInput === true) {
+      needsUserInput = true;
+    }
+    const questions = normalizePlannerQuestions(output.questions);
+    if (questions.length > 0) {
+      needsUserInput = true;
+    }
   }
-  if (topLevelStatus === "waiting_input" || topLevelStatus === "needs_input" || topLevelStatus === "pending_user_input") {
-    return { taskComplete: false, needsUserInput: true, questions };
+  return { failed, needsUserInput, navigationPending, sameTabNavigationPending };
+}
+function deriveDirectToolRunOutcome(result) {
+  if (!result || typeof result !== "object") {
+    return {
+      taskComplete: true,
+      terminalState: "completed",
+      contextResetRecommended: true
+    };
   }
-  if (result.error) {
-    return { taskComplete: false };
+  const topLevelNavigationOutcome = String(result.navigationOutcome || "").trim().toLowerCase();
+  if (result.navigationPending === true) {
+    const isSameTabHandoff = topLevelNavigationOutcome === "same_tab_scheduled";
+    return {
+      taskComplete: false,
+      terminalState: "in_progress",
+      navigationPending: isSameTabHandoff,
+      continuationReason: isSameTabHandoff ? "same_tab_navigation_handoff" : "loop_continue"
+    };
   }
+  const questions = extractQuestionsFromResult(result);
+  if (result.error)
+    return { taskComplete: false, terminalState: "failed" };
   const output = result.output;
   if (output && typeof output === "object") {
-    if (Array.isArray(output)) {
-      return { taskComplete: true };
+    const outputRecord = output;
+    const topLevelStatus = String(result.status || "").trim().toLowerCase();
+    if (topLevelStatus === "failure" || topLevelStatus === "failed" || topLevelStatus === "error") {
+      return { taskComplete: false, terminalState: "failed" };
     }
-    if (output.needsUserInput === true || output.waitingForUserInput === true) {
-      return { taskComplete: false, needsUserInput: true, questions };
+    if (topLevelStatus === "waiting_input" || topLevelStatus === "needs_input" || topLevelStatus === "pending_user_input") {
+      return {
+        taskComplete: false,
+        needsUserInput: true,
+        questions,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
+      };
     }
-    if (Array.isArray(output.questions) && output.questions.length > 0) {
-      return { taskComplete: false, needsUserInput: true, questions };
+    const navigationOutcome = String(outputRecord.navigationOutcome || "").trim().toLowerCase();
+    const navigationMode = String(outputRecord.navigation || "").trim().toLowerCase();
+    if (outputRecord.navigationPending === true || navigationOutcome === "same_tab_scheduled" || navigationOutcome === "new_tab_opened" || navigationMode === "same_tab") {
+      const sameTabHandoff = navigationOutcome === "same_tab_scheduled" || navigationMode === "same_tab";
+      return {
+        taskComplete: false,
+        terminalState: "in_progress",
+        navigationPending: sameTabHandoff,
+        continuationReason: sameTabHandoff ? "same_tab_navigation_handoff" : "loop_continue",
+        contextResetRecommended: false
+      };
     }
-    if (output.error) {
-      return { taskComplete: false };
+    if (outputRecord.needsUserInput === true || outputRecord.waitingForUserInput === true) {
+      return {
+        taskComplete: false,
+        needsUserInput: true,
+        questions,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
+      };
     }
-    if (typeof output.taskComplete === "boolean") {
-      return { taskComplete: !!output.taskComplete };
+    if (Array.isArray(outputRecord.questions) && outputRecord.questions.length > 0) {
+      return {
+        taskComplete: false,
+        needsUserInput: true,
+        questions,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
+      };
     }
-    const taskStatus = String(output.taskStatus || output.status || "").toLowerCase();
+    if (outputRecord.error || outputRecord.success === false)
+      return { taskComplete: false, terminalState: "failed" };
+    const taskStatus = String(outputRecord.taskStatus || outputRecord.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 };
+        return {
+          taskComplete: false,
+          needsUserInput: true,
+          terminalState: "waiting_input",
+          continuationReason: "awaiting_user"
+        };
       }
       if (taskStatus === "failure" || taskStatus === "failed" || taskStatus === "error") {
-        return { taskComplete: false };
+        return { taskComplete: false, terminalState: "failed" };
       }
     }
-    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: true };
+  return {
+    taskComplete: true,
+    terminalState: "completed",
+    contextResetRecommended: true
+  };
 }
 function normalizeRunOutcome(outcome) {
   if (!outcome || typeof outcome !== "object") {
-    return { taskComplete: false, needsUserInput: false };
+    return {
+      taskComplete: true,
+      needsUserInput: false,
+      terminalState: "completed",
+      continuationReason: void 0,
+      contextResetRecommended: true
+    };
   }
-  const needsUserInput = outcome.needsUserInput === true;
-  const taskComplete = outcome.taskComplete === true && !needsUserInput;
+  const inferredNeedsUserInput = outcome.needsUserInput === true;
+  const incomingTerminalState = String(outcome.terminalState || "").trim().toLowerCase();
+  const terminalState = incomingTerminalState === "waiting_input" || incomingTerminalState === "in_progress" || incomingTerminalState === "completed" || incomingTerminalState === "failed" ? incomingTerminalState : inferredNeedsUserInput ? "waiting_input" : outcome.taskComplete === true ? "completed" : outcome.taskComplete === false ? "in_progress" : "completed";
+  const needsUserInput = terminalState === "waiting_input" || inferredNeedsUserInput;
+  const taskComplete = terminalState === "completed" || outcome.taskComplete === true && !needsUserInput;
   const questions = normalizePlannerQuestions(outcome.questions);
+  const continuationCandidate = String(outcome.continuationReason || "").trim().toLowerCase();
+  const continuationReason = continuationCandidate === "loop_continue" || continuationCandidate === "same_tab_navigation_handoff" || continuationCandidate === "awaiting_user" ? continuationCandidate : needsUserInput ? "awaiting_user" : outcome.navigationPending === true ? "same_tab_navigation_handoff" : terminalState === "in_progress" && !taskComplete ? "loop_continue" : void 0;
+  const contextResetRecommended = outcome.contextResetRecommended === true || terminalState === "completed" || terminalState === "failed";
   return {
     route: outcome.route,
     taskComplete,
     needsUserInput,
-    questions: questions.length ? questions : void 0
+    questions: questions.length ? questions : void 0,
+    terminalState,
+    continuationReason,
+    contextResetRecommended
   };
 }
 function rememberTerminalRun(runId, result) {
@@ -5264,11 +6615,19 @@ function rememberCancelledRun(runId) {
     cancelledRunIds.delete(oldest);
   }
 }
-function clearTaskScopedContextAfterCompletion() {
+function throwIfCancelledRun(runId) {
+  if (!runId)
+    return;
+  if (cancelledRunIds.has(runId)) {
+    throw new DOMException("Run cancelled", "AbortError");
+  }
+}
+function clearTaskScopedContextAfterBoundary(_reason) {
   history.length = 0;
   plannerHistory = [];
   agentPrevSteps = [];
   pendingAskUser = void 0;
+  rootUserInput = "";
 }
 async function maybeWaitForNewTab(result) {
   const openedTab = detectOpenedTabFromToolResult(result);
@@ -5284,52 +6643,66 @@ async function handleUserMessage(text, options) {
     throw new Error("Worker not initialized");
   if (!bridgeRpc)
     throw new Error("Bridge RPC not initialized");
+  const activeRunId = activeRun?.runId;
+  throwIfCancelledRun(activeRunId);
   postStatus("Analyzing request", text, "analyze");
   const shouldSkipUserPush = options?.resume && history.length > 0 && history[history.length - 1]?.role === "user" && history[history.length - 1]?.content === text;
-  if (!shouldSkipUserPush) {
-    history.push({ role: "user", content: text });
-    postStateSnapshot();
+  const normalizedIncomingText = String(text || "").trim();
+  if (config.external?.adversarialGate === "pre_tool_block") {
+    const adversarial = assessAdversarialInput(normalizedIncomingText);
+    if (adversarial.blocked) {
+      const blockedMessage = "I can\u2019t run that request because it appears adversarial. Please rephrase with a safe, task-focused instruction.";
+      postAssistantMessage(blockedMessage);
+      postStatus("Blocked unsafe request", adversarial.reasons.join(", ") || "adversarial_input", "complete");
+      postStateSnapshot();
+      return {
+        taskComplete: false,
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: true
+      };
+    }
+  }
+  const pendingAskUserSnapshot = pendingAskUser && pendingAskUser.boundaryId && pendingAskUser.boundaryId !== taskBoundaryId ? void 0 : pendingAskUser;
+  if (!pendingAskUserSnapshot && pendingAskUser) {
+    pendingAskUser = void 0;
+  }
+  const fallbackRootInput = normalizeRootUserInput(getRootUserInputFallbackFromHistory());
+  const existingRootInput = normalizeRootUserInput(rootUserInput) || fallbackRootInput;
+  if (existingRootInput) {
+    rootUserInput = existingRootInput;
+  }
+  if (!pendingAskUserSnapshot?.questions?.length && normalizedIncomingText && !options?.resume) {
+    rootUserInput = normalizedIncomingText;
   }
   let effectiveUserInput = text;
-  if (pendingAskUser?.questions?.length) {
-    const normalizedAnswers = normalizeAskUserAnswerMeta(options?.askUserAnswers, pendingAskUser.questions, text);
+  let chatLogCurrentInputForDedupe = text;
+  let consumedAsAskUserAnswer = false;
+  if (pendingAskUserSnapshot?.questions?.length) {
+    const normalizedAnswers = normalizeAskUserAnswerMeta(options?.askUserAnswers, pendingAskUserSnapshot.questions, text);
     if (normalizedAnswers) {
-      const answerContext = buildAskUserAnswerContext(pendingAskUser.questions, normalizedAnswers);
-      effectiveUserInput = answerContext;
-      plannerHistory = sanitizePlannerHistoryForPersist([
-        ...plannerHistory,
-        {
-          thought: "User provided clarification answers.",
-          questionsAsked: pendingAskUser.questions,
-          userAnswers: normalizedAnswers.answersByKey
-        }
-      ]);
-      applyAgentPrevSteps([
-        ...agentPrevSteps,
-        {
-          functions: [{
-            name: "ask_user",
-            args: {
-              questions_to_ask: pendingAskUser.questions.map((q) => ({
-                key: q.key,
-                query: q.query
-              }))
-            },
-            response: {
-              status: "Success",
-              output: {
-                ask_user_answers: normalizedAnswers.answersByKey,
-                raw_user_reply: normalizedAnswers.rawText
-              }
-            }
-          }]
-        }
-      ], { snapshot: false });
+      consumedAsAskUserAnswer = true;
+      const answerContext = buildAskUserAnswerContext(pendingAskUserSnapshot.questions, normalizedAnswers);
+      const focusInput = normalizeRootUserInput(rootUserInput) || normalizedIncomingText || fallbackRootInput || "";
+      if (focusInput)
+        rootUserInput = focusInput;
+      effectiveUserInput = buildContinuePlanningInput(focusInput, "ask_user", answerContext);
+      chatLogCurrentInputForDedupe = focusInput || text;
+      if (pendingAskUserSnapshot.source === "planner") {
+        plannerHistory = mergeAskUserAnswersIntoPlannerHistory(plannerHistory, pendingAskUserSnapshot.questions, normalizedAnswers.answersByKey);
+      }
+      applyAgentPrevSteps(mergeAskUserAnswerIntoPrevSteps(agentPrevSteps, pendingAskUserSnapshot, normalizedAnswers), { snapshot: false });
       pendingAskUser = void 0;
       postStateSnapshot();
     }
   }
+  if (!shouldSkipUserPush && !consumedAsAskUserAnswer) {
+    history.push({ role: "user", content: text });
+    postStateSnapshot();
+  }
+  throwIfCancelledRun(activeRunId);
   const tabs = await getKnownTabs();
+  throwIfCancelledRun(activeRunId);
   const fallbackTabs = tabs.length > 0 ? tabs : [
     {
       id: 1,
@@ -5337,7 +6710,14 @@ async function handleUserMessage(text, options) {
       accessMode: "live_dom"
     }
   ];
-  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc, fallbackTabs);
+  const resolvedTabs = await resolveRuntimeTabs(bridgeRpc, fallbackTabs, {
+    scopedTabIds,
+    seedTabId: scopedSeedTabId,
+    onDiagnostics: (payload) => {
+      postRuntimeTabsDiagnostics(payload);
+    }
+  });
+  throwIfCancelledRun(activeRunId);
   const tabsById = new Map(tabs.map((tab) => [tab.id, tab]));
   const orderedTabs = resolvedTabs.tabOrder.map((tabId) => {
     const knownTab = tabsById.get(tabId);
@@ -5357,28 +6737,42 @@ async function handleUserMessage(text, options) {
     };
   }).filter((tab) => Number.isFinite(tab.id) && tab.id > 0);
   const tabsForRun = orderedTabs.length > 0 ? orderedTabs : fallbackTabs;
+  if (orderedTabs.length === 0) {
+    postStatus("Using fallback tab mapping", `active=${resolvedTabs.activeTabId}; order=${resolvedTabs.tabOrder.join(",") || "none"}`, "analyze");
+  }
   if (!tabularStore) {
-    tabularStore = new TabularStore(`rover-${trajectoryId}`);
+    tabularStore = new TabularStore(`rover-${taskTrajectoryId}`);
   }
   const agentName = resolveAgentName(config);
   const runtimeContext = buildRoverRuntimeContext2({
     tabs: tabsForRun,
     agentName,
-    externalNavigationPolicy: resolveRuntimeExternalNavigationPolicy(config)
+    externalNavigationPolicy: resolveRuntimeExternalNavigationPolicy(config),
+    taskBoundaryId
   });
   const ctx = createAgentContext({
     ...config,
     signal: activeAbortController?.signal,
+    sessionId: workerSessionId || config.sessionId || taskTrajectoryId,
+    activeRunId,
     runtimeContext,
     tools: {
       web: extractWebToolsConfig(config)
     }
   }, bridgeRpc, tabularStore);
-  const currentRunId = activeRun?.runId;
-  ctx.isCancelled = () => !!(currentRunId && cancelledRunIds.has(currentRunId));
+  ctx.isCancelled = () => !!(activeRunId && cancelledRunIds.has(activeRunId));
   const functionDeclarations = dedupeFunctionDeclarations(removePlannerNameCollisions(toolRegistry.getFunctionDeclarations()));
   const toolFunctions = toolRegistry.getToolFunctions();
-  const chatLog = buildChatLogFromHistory(history, text);
+  const resumeFollowupTurns = Math.max(1, Math.min(4, Math.floor(Number(config.chat?.resumeFollowup?.maxTurns) || MAX_RESUME_CUE_TURNS)));
+  const normalizedFollowupChatLog = normalizeFollowupChatLog(options?.followupChatLog);
+  const chatLog = shouldBuildResumeCueChatLog({
+    resume: options?.resume,
+    preserveHistory: options?.preserveHistory,
+    resumeFollowupMode: config.chat?.resumeFollowup?.mode
+  }) ? buildChatLogFromHistory(history, chatLogCurrentInputForDedupe, resumeFollowupTurns) : shouldUseFollowupChatLog({
+    resume: options?.resume,
+    followupChatLogLength: normalizedFollowupChatLog.length
+  }) ? normalizedFollowupChatLog : [];
   const onPrevStepsUpdate = (steps) => {
     applyAgentPrevSteps(steps, { snapshot: true });
   };
@@ -5386,10 +6780,22 @@ async function handleUserMessage(text, options) {
     plannerHistory = sanitizePlannerHistoryForPersist(Array.isArray(steps) ? steps : []);
     postStateSnapshot();
   };
+  const getScopedTabRuntimeContext = () => ({
+    scopedTabIds: [...scopedTabIds],
+    seedTabId: scopedSeedTabId
+  });
+  const onScopedTabIdsTouched = (tabIds) => {
+    touchRunScopedTabIds(tabIds);
+  };
+  throwIfCancelledRun(activeRunId);
   const result = await handleSendMessageWithFunctions(effectiveUserInput, {
     tabs: tabsForRun,
+    scopedTabIds,
+    seedTabId: scopedSeedTabId,
+    getScopedTabRuntimeContext,
+    onScopedTabIdsTouched,
     previousMessages: history,
-    trajectoryId,
+    trajectoryId: taskTrajectoryId,
     files: [],
     recordingContext: config.recordingContext,
     previousSteps: plannerHistory,
@@ -5407,25 +6813,49 @@ async function handleUserMessage(text, options) {
     onPrevStepsUpdate,
     onPlannerHistoryUpdate
   });
+  throwIfCancelledRun(activeRunId);
+  if (result.directToolResult) {
+    touchRunScopedTabIds(extractTouchedTabIdsFromToolResult(result.directToolResult));
+  }
+  if (Array.isArray(result.executedFunctions) && result.executedFunctions.length > 0) {
+    for (const executed of result.executedFunctions) {
+      touchRunScopedTabIds(extractTouchedTabIdsFromToolResult(executed?.result));
+    }
+  }
   if (!result.success) {
-    const errorPayload = toStructuredErrorPayload(result.error, "Something went wrong.");
+    const rawErrorPayload = toStructuredErrorPayload(result.error, "Something went wrong.");
+    const errorPayload = normalizeLifecycleHandoffError(rawErrorPayload, agentPrevSteps);
+    const errorCode = String(errorPayload.error.code || "").trim().toUpperCase();
+    const isRetryableLifecycleError = !!errorPayload.error.retryable || errorCode === "STALE_SEQ" || errorCode === "STALE_EPOCH" || errorCode === "SESSION_TOKEN_EXPIRED" || errorCode === "NAVIGATION_HANDOFF_PENDING";
+    if (isRetryableLifecycleError) {
+      const retryMessage = `${errorPayload.error.code}: ${errorPayload.error.message}`;
+      postAssistantMessage(retryMessage);
+      postStatus("Waiting for navigation/session sync", errorPayload.error.message, "verify");
+      postStateSnapshot();
+      return {
+        route: result.route,
+        taskComplete: false,
+        terminalState: "in_progress",
+        continuationReason: "loop_continue",
+        contextResetRecommended: false
+      };
+    }
     if (errorPayload.error.requires_api_key) {
       postAuthRequired(errorPayload.error);
     }
-    const errorMsg = postAssistantMessage({
+    postAssistantMessage({
       text: `${errorPayload.error.code}: ${errorPayload.error.message}`,
       blocks: [
         {
           type: "json",
           label: "Error details",
-          data: cloneUnknown(errorPayload)
+          data: normalizeRuntimeToolOutput(errorPayload)
         }
       ]
     });
-    history.push({ role: "assistant", content: errorMsg });
     postStatus("Execution failed", errorPayload.error.message, "complete");
     postStateSnapshot();
-    return { route: result.route, taskComplete: false };
+    return { route: result.route, taskComplete: false, terminalState: "failed" };
   }
   if (result.executedFunctions?.length) {
     for (const fn of result.executedFunctions) {
@@ -5433,6 +6863,12 @@ async function handleUserMessage(text, options) {
     }
     const blocks = [];
     const lines = [];
+    let inferredFailed = false;
+    let inferredCompleted = false;
+    let inferredNavigationPending = false;
+    let inferredSameTabPending = false;
+    let inferredNeedsUserInput = false;
+    let inferredQuestions = [];
     for (const fn of result.executedFunctions) {
       const summary = summarizeOutputText(fn.result);
       if (fn.result !== void 0 && shouldAttachStructuredBlock(fn.result, summary)) {
@@ -5440,28 +6876,100 @@ async function handleUserMessage(text, options) {
           type: "tool_output",
           toolName: fn.name,
           label: `${fn.name} output`,
-          data: cloneUnknown(fn.result)
+          data: normalizeRuntimeToolOutput(fn.result)
         });
       }
       if (fn.error) {
         blocks.push({
           type: "json",
           label: `${fn.name} error`,
-          data: cloneUnknown({ error: fn.error })
+          data: normalizeRuntimeToolOutput({ error: fn.error })
         });
       }
       lines.push(summary ? `@${fn.name}: ${summary}` : `@${fn.name}: ${fn.error || "ok"}`);
+      if (fn.error) {
+        inferredFailed = true;
+        continue;
+      }
+      const rawResult = fn.result;
+      if (!rawResult || typeof rawResult !== "object")
+        continue;
+      const normalized = Array.isArray(rawResult) ? rawResult.find((item) => item && typeof item === "object") : rawResult;
+      if (!normalized)
+        continue;
+      const taskComplete = normalized.taskComplete;
+      if (typeof taskComplete === "boolean" && taskComplete) {
+        inferredCompleted = true;
+      }
+      const navigationPending = normalized.navigationPending === true;
+      const navigationOutcome = String(normalized.navigationOutcome || "").trim().toLowerCase();
+      if (navigationPending || navigationOutcome === "same_tab_scheduled" || navigationOutcome === "new_tab_opened") {
+        inferredNavigationPending = true;
+        if (navigationOutcome === "same_tab_scheduled") {
+          inferredSameTabPending = true;
+        }
+      }
+      const statusRaw = String(normalized.taskStatus || normalized.status || "").trim().toLowerCase();
+      if (statusRaw === "failed" || statusRaw === "error" || statusRaw === "failure") {
+        inferredFailed = true;
+      }
+      if (statusRaw === "waiting_input" || statusRaw === "needs_input" || statusRaw === "pending_user_input") {
+        inferredNeedsUserInput = true;
+      }
+      if (statusRaw === "completed" || statusRaw === "complete" || statusRaw === "done" || statusRaw === "success") {
+        inferredCompleted = true;
+      }
+      if (normalized.needsUserInput === true || normalized.waitingForUserInput === true) {
+        inferredNeedsUserInput = true;
+      }
+      const q = extractQuestionsFromResult(normalized);
+      if (q?.length) {
+        inferredNeedsUserInput = true;
+        inferredQuestions = normalizePlannerQuestions([...inferredQuestions, ...q]);
+      }
     }
-    const msg = postAssistantMessage({
-      text: lines.join("\n") || "Done.",
+    postAssistantMessage({
+      text: lines.join("\n"),
       blocks
     });
-    history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", "Function calls finished", "complete");
     postStateSnapshot();
-    return { route: result.route, taskComplete: true };
+    if (inferredFailed) {
+      return {
+        route: result.route,
+        taskComplete: false,
+        terminalState: "failed"
+      };
+    }
+    if (inferredNavigationPending) {
+      return {
+        route: result.route,
+        taskComplete: false,
+        terminalState: "in_progress",
+        continuationReason: inferredSameTabPending ? "same_tab_navigation_handoff" : "loop_continue",
+        contextResetRecommended: false
+      };
+    }
+    if (inferredNeedsUserInput) {
+      return {
+        route: result.route,
+        taskComplete: false,
+        needsUserInput: true,
+        questions: inferredQuestions.length ? inferredQuestions : void 0,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
+      };
+    }
+    return {
+      route: result.route,
+      taskComplete: true,
+      terminalState: "completed",
+      continuationReason: void 0,
+      contextResetRecommended: true
+    };
   }
   if (result.directToolResult) {
+    throwIfCancelledRun(activeRunId);
     const newTabWait = await maybeWaitForNewTab(result.directToolResult);
     if (newTabWait.openedTab && newTabWait.readyState && !newTabWait.readyState.ready && !newTabWait.readyState.external) {
       const fallbackUrl = String(newTabWait.openedTab.url || "").trim();
@@ -5507,9 +7015,7 @@ async function handleUserMessage(text, options) {
     const questions = normalizePlannerQuestions(outcome.questions);
     if (outcome.needsUserInput && questions.length > 0) {
       pendingAskUser = {
-        questions,
-        source: "act",
-        askedAt: Date.now()
+        ...buildPendingAskUserPrompt("act", questions)
       };
       plannerHistory = sanitizePlannerHistoryForPersist([
         ...plannerHistory,
@@ -5519,16 +7025,17 @@ async function handleUserMessage(text, options) {
         }
       ]);
       const qText = questions.map((question) => `- ${question.key}: ${questionToDisplayText(question)}`).join("\n");
-      const msg2 = postAssistantMessage(`I need a bit more info before continuing:
+      postAssistantMessage(`I need a bit more info before continuing:
 ${qText}`);
-      history.push({ role: "assistant", content: msg2 });
       postStatus("Need more input to continue", void 0, "verify");
       postStateSnapshot();
       return {
         route: result.route,
         taskComplete: false,
         needsUserInput: true,
-        questions
+        questions,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
       };
     }
     pendingAskUser = void 0;
@@ -5537,27 +7044,28 @@ ${qText}`);
     if (structuredError?.error.requires_api_key) {
       postAuthRequired(structuredError.error);
     }
-    const msg = structuredError ? postAssistantMessage({
+    structuredError ? postAssistantMessage({
       text: `${structuredError.error.code}: ${structuredError.error.message}`,
       blocks: [
         {
           type: "json",
           label: "Error details",
-          data: cloneUnknown(structuredError)
+          data: normalizeRuntimeToolOutput(structuredError)
         }
       ]
     }) : postAssistantMessage(buildAssistantPayloadFromToolOutput(output, {
-      label: "Tool output",
-      fallbackText: "Done."
+      label: "Tool output"
     }));
-    history.push({ role: "assistant", content: msg });
     postStatus("Execution completed", structuredError?.error.message, "complete");
     postStateSnapshot();
     return {
       route: result.route,
       taskComplete: outcome.taskComplete,
       needsUserInput: outcome.needsUserInput,
-      questions: normalizePlannerQuestions(outcome.questions)
+      questions: normalizePlannerQuestions(outcome.questions),
+      terminalState: outcome.terminalState,
+      continuationReason: outcome.continuationReason,
+      contextResetRecommended: outcome.contextResetRecommended
     };
   }
   if (result.plannerResponse) {
@@ -5575,23 +7083,19 @@ ${qText}`);
     const plannerQuestions = responseQuestions.length ? responseQuestions : fallbackQuestions;
     if (plannerQuestions.length) {
       const questions = plannerQuestions;
-      pendingAskUser = questions.length ? {
-        questions,
-        source: "planner",
-        askedAt: Date.now()
-      } : void 0;
+      pendingAskUser = questions.length ? buildPendingAskUserPrompt("planner", questions) : void 0;
       const qText = questions.map((question) => `- ${question.key}: ${questionToDisplayText(question)}`).join("\n");
-      const msg2 = `I need a bit more info:
-${qText}`;
-      postAssistantMessage(msg2);
-      history.push({ role: "assistant", content: msg2 });
+      postAssistantMessage(`I need a bit more info:
+${qText}`);
       postStatus("Planner needs user input", void 0, "verify");
       postStateSnapshot();
       return {
         route: result.route,
         taskComplete: false,
         needsUserInput: true,
-        questions
+        questions,
+        terminalState: "waiting_input",
+        continuationReason: "awaiting_user"
       };
     }
     pendingAskUser = void 0;
@@ -5601,37 +7105,44 @@ ${qText}`;
     }
     const toolBlocks = buildPlannerToolResultBlocks(toolResults);
     const responseError = response.error || response.errorDetails ? toStructuredErrorPayload(response.errorDetails || { message: response.error }, "Planner failed") : void 0;
+    const plannerContinuation = inferPlannerContinuation(toolResults);
     if (responseError?.error.requires_api_key) {
       postAuthRequired(responseError.error);
     }
-    const msg = responseError ? postAssistantMessage({
+    responseError ? postAssistantMessage({
       text: `${responseError.error.code}: ${responseError.error.message}`,
       blocks: [
         {
           type: "json",
           label: "Planner error",
-          data: cloneUnknown(responseError)
+          data: normalizeRuntimeToolOutput(responseError)
         },
         ...toolBlocks || []
       ]
     }) : postAssistantMessage({
-      text: String(response.overallThought || summarizePlannerToolResults(toolResults) || "Done."),
+      text: String(response.overallThought || summarizePlannerToolResults(toolResults) || ""),
       blocks: toolBlocks
     });
-    history.push({ role: "assistant", content: msg });
     postStatus("Planner execution completed", response.overallThought, "complete");
     postStateSnapshot();
+    const plannerComplete = !!response.taskComplete && !responseError && !plannerContinuation.needsUserInput && !plannerContinuation.navigationPending;
     return {
       route: result.route,
-      taskComplete: !!response.taskComplete && !responseError,
-      needsUserInput: false
+      taskComplete: plannerComplete,
+      needsUserInput: plannerContinuation.needsUserInput,
+      terminalState: responseError ? "failed" : plannerContinuation.needsUserInput ? "waiting_input" : plannerContinuation.navigationPending ? "in_progress" : "completed",
+      continuationReason: responseError ? void 0 : plannerContinuation.needsUserInput ? "awaiting_user" : plannerContinuation.navigationPending ? plannerContinuation.sameTabNavigationPending ? "same_tab_navigation_handoff" : "loop_continue" : void 0,
+      contextResetRecommended: !responseError && plannerComplete
     };
   }
-  const doneMsg = postAssistantMessage("Done.");
-  history.push({ role: "assistant", content: doneMsg });
   postStatus("Completed", void 0, "complete");
   postStateSnapshot();
-  return { route: result.route, taskComplete: true };
+  return {
+    route: result.route,
+    taskComplete: true,
+    terminalState: "completed",
+    contextResetRecommended: true
+  };
 }
 async function runUserMessage(text, meta) {
   const runId = meta?.runId || crypto.randomUUID();
@@ -5642,20 +7153,27 @@ async function runUserMessage(text, meta) {
       self.postMessage({
         type: "run_completed",
         runId,
+        taskBoundaryId: terminal.taskBoundaryId,
         ok: true,
         route: cachedOutcome.route,
         taskComplete: cachedOutcome.taskComplete,
         needsUserInput: cachedOutcome.needsUserInput,
-        questions: cachedOutcome.questions
+        questions: cachedOutcome.questions,
+        terminalState: cachedOutcome.terminalState,
+        continuationReason: cachedOutcome.continuationReason,
+        contextResetRecommended: cachedOutcome.contextResetRecommended
       });
     } else {
       self.postMessage({
         type: "run_completed",
         runId,
+        taskBoundaryId: terminal.taskBoundaryId,
         ok: false,
         error: terminal.error,
         taskComplete: false,
-        needsUserInput: false
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: terminal.contextResetRecommended
       });
     }
     return;
@@ -5664,32 +7182,58 @@ async function runUserMessage(text, meta) {
     return;
   }
   const resume = !!meta?.resume;
+  const preserveHistory = !!meta?.preserveHistory;
+  const runTaskBoundaryId = taskBoundaryId;
   lastStatusKey = "";
   seenStatusKeys = /* @__PURE__ */ new Set();
+  lastRuntimeTabsDiagnosticsKey = "";
   cancelledRunIds.delete(runId);
   activeAbortController = new AbortController();
-  activeRun = { runId, text, startedAt: Date.now(), resume };
-  self.postMessage({ type: "run_started", runId, text, resume });
+  activeRun = { runId, text, startedAt: Date.now(), resume, preserveHistory };
+  self.postMessage({ type: "run_started", runId, text, resume, taskBoundaryId: runTaskBoundaryId });
+  if (shouldClearHistoryForRun({ resume, preserveHistory })) {
+    history.length = 0;
+  }
   postStateSnapshot();
   try {
     const outcome = normalizeRunOutcome(await handleUserMessage(text, {
       resume,
+      preserveHistory,
+      followupChatLog: normalizeFollowupChatLog(meta?.followupChatLog),
       routing: meta?.routing,
       askUserAnswers: meta?.askUserAnswers
     }));
-    rememberTerminalRun(runId, { ok: true, outcome });
-    self.postMessage({
-      type: "run_completed",
-      runId,
-      ok: true,
-      route: outcome.route,
-      taskComplete: outcome.taskComplete,
-      needsUserInput: outcome.needsUserInput,
-      questions: outcome.questions
-    });
-    if (outcome.taskComplete && !outcome.needsUserInput) {
-      clearTaskScopedContextAfterCompletion();
-      postStateSnapshot();
+    const isTerminalOutcome = outcome.terminalState === "completed" || outcome.terminalState === "failed";
+    if (isTerminalOutcome) {
+      rememberTerminalRun(runId, { ok: true, outcome, taskBoundaryId: runTaskBoundaryId });
+      self.postMessage({
+        type: "run_completed",
+        runId,
+        taskBoundaryId: runTaskBoundaryId,
+        ok: true,
+        route: outcome.route,
+        taskComplete: outcome.taskComplete,
+        needsUserInput: outcome.needsUserInput,
+        questions: outcome.questions,
+        terminalState: outcome.terminalState,
+        continuationReason: outcome.continuationReason,
+        contextResetRecommended: outcome.contextResetRecommended
+      });
+    } else {
+      terminalRuns.delete(runId);
+      self.postMessage({
+        type: "run_state_transition",
+        runId,
+        taskBoundaryId: runTaskBoundaryId,
+        ok: true,
+        route: outcome.route,
+        taskComplete: outcome.taskComplete,
+        needsUserInput: outcome.needsUserInput,
+        questions: outcome.questions,
+        terminalState: outcome.terminalState,
+        continuationReason: outcome.continuationReason,
+        contextResetRecommended: outcome.contextResetRecommended
+      });
     }
   } catch (error) {
     if (error?.name === "AbortError") {
@@ -5697,30 +7241,42 @@ async function runUserMessage(text, meta) {
         ok: false,
         error: "Run cancelled",
         taskComplete: false,
-        needsUserInput: false
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: false,
+        taskBoundaryId: runTaskBoundaryId
       });
       self.postMessage({
         type: "run_completed",
         runId,
+        taskBoundaryId: runTaskBoundaryId,
         ok: false,
         error: "Run cancelled",
         taskComplete: false,
-        needsUserInput: false
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: false
       });
     } else {
       rememberTerminalRun(runId, {
         ok: false,
         error: error?.message || String(error),
         taskComplete: false,
-        needsUserInput: false
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: true,
+        taskBoundaryId: runTaskBoundaryId
       });
       self.postMessage({
         type: "run_completed",
         runId,
+        taskBoundaryId: runTaskBoundaryId,
         ok: false,
         error: error?.message || String(error),
         taskComplete: false,
-        needsUserInput: false
+        needsUserInput: false,
+        terminalState: "failed",
+        contextResetRecommended: true
       });
       throw error;
     }
@@ -5735,9 +7291,14 @@ self.onmessage = async (ev) => {
   try {
     if (data.type === "init") {
       config = data.config;
-      trajectoryId = config.sessionId || crypto.randomUUID();
+      workerSessionId = typeof config.sessionId === "string" && config.sessionId.trim() ? config.sessionId.trim() : workerSessionId || crypto.randomUUID();
+      taskBoundaryId = typeof config.taskBoundaryId === "string" && config.taskBoundaryId.trim() ? config.taskBoundaryId.trim() : taskBoundaryId;
+      applyScopedTabConfig(config);
+      if (config?.timing?.actionTimeoutMs) {
+        RPC_TIMEOUT_MS = Math.max(5e3, Math.min(12e4, Number(config.timing.actionTimeoutMs)));
+      }
       if (!tabularStore) {
-        tabularStore = new TabularStore(`rover-${trajectoryId}`);
+        tabularStore = new TabularStore(`rover-${taskTrajectoryId}`);
       }
       if (data.port) {
         bridgeRpc = createRpcClient(data.port);
@@ -5770,15 +7331,16 @@ self.onmessage = async (ev) => {
         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 = [];
-        agentPrevSteps = [];
-        pendingAskUser = void 0;
-        terminalRuns.clear();
-        cancelledRunIds.clear();
-        tabularStore = new TabularStore(`rover-${trajectoryId}`);
+      if (typeof partial.sessionId === "string" && partial.sessionId.trim()) {
+        workerSessionId = partial.sessionId.trim();
+      }
+      if (partial?.timing?.actionTimeoutMs) {
+        RPC_TIMEOUT_MS = Math.max(5e3, Math.min(12e4, Number(partial.timing.actionTimeoutMs)));
       }
+      if (typeof partial.taskBoundaryId === "string" && partial.taskBoundaryId.trim()) {
+        taskBoundaryId = partial.taskBoundaryId.trim();
+      }
+      applyScopedTabConfig(partial);
       const tools = partial.tools;
       if (Array.isArray(tools)) {
         for (const def of tools)
@@ -5800,15 +7362,15 @@ self.onmessage = async (ev) => {
       if (!config)
         throw new Error("Worker not initialized");
       const nextTaskId = typeof data.taskId === "string" && data.taskId.trim() ? data.taskId.trim() : crypto.randomUUID();
+      const nextTaskBoundaryId = typeof data.taskBoundaryId === "string" && data.taskBoundaryId.trim() ? data.taskBoundaryId.trim() : crypto.randomUUID();
       activeAbortController?.abort();
-      history.length = 0;
-      plannerHistory = [];
-      agentPrevSteps = [];
-      pendingAskUser = void 0;
+      clearTaskScopedContextAfterBoundary("new_task");
       terminalRuns.clear();
       cancelledRunIds.clear();
-      trajectoryId = nextTaskId;
-      tabularStore = new TabularStore(`rover-${trajectoryId}`);
+      taskTrajectoryId = nextTaskId;
+      taskBoundaryId = nextTaskBoundaryId;
+      applyScopedTabConfig(data);
+      tabularStore = new TabularStore(`rover-${taskTrajectoryId}`);
       activeRun = null;
       activeAbortController = null;
       postStateSnapshot();
@@ -5820,14 +7382,17 @@ self.onmessage = async (ev) => {
         rememberCancelledRun(data.runId);
         activeAbortController?.abort();
       }
-      pendingAskUser = void 0;
+      clearTaskScopedContextAfterBoundary("cancel");
       postStateSnapshot();
       return;
     }
     if (data.type === "run") {
+      applyScopedTabConfig(data);
       await runUserMessage(String(data.text || ""), {
         runId: data.runId,
         resume: !!data.resume,
+        preserveHistory: !!data.preserveHistory,
+        followupChatLog: normalizeFollowupChatLog(data.followupChatLog),
         routing: data.routing,
         askUserAnswers: data.askUserAnswers
       });
@@ -5837,6 +7402,8 @@ self.onmessage = async (ev) => {
       await runUserMessage(String(data.text || ""), {
         runId: data.runId,
         resume: !!data.resume,
+        preserveHistory: !!data.preserveHistory,
+        followupChatLog: normalizeFollowupChatLog(data.followupChatLog),
         askUserAnswers: data.askUserAnswers
       });
       return;