@rtrvr-ai/rover 1.0.3 → 1.1.0

package/dist/rover.js

@@ -11465,9 +11465,9 @@ var Bridge = class {
   }
   async openUrlInNewTab(targetUrl, options) {
     const external = !isUrlAllowedByDomains(targetUrl, this.allowedDomains);
-    const popup = window.open(targetUrl, "_blank", "noopener,noreferrer");
+    const popupAttempt = this.openVerifiedPopup(targetUrl);
     let logicalTabId;
-    if (this.registerOpenedTab) {
+    if (popupAttempt.opened && this.registerOpenedTab) {
       try {
         const registered = await this.registerOpenedTab({
           url: targetUrl,
@@ -11479,8 +11479,8 @@ var Bridge = class {
       } catch {
       }
     }
-    const registrationFailed = !logicalTabId && !!this.registerOpenedTab;
-    if (!popup) {
+    const registrationFailed = popupAttempt.opened && !logicalTabId && !!this.registerOpenedTab;
+    if (!popupAttempt.opened) {
       const reason = "Browser popup settings blocked opening a new tab.";
       if (options?.policyBlocked) {
         this.emitNavigationGuardrail({
@@ -11516,6 +11516,13 @@ var Bridge = class {
         openedInNewTab: true
       });
     }
+    const warningMessages = [];
+    if (registrationFailed) {
+      warningMessages.push("Tab opened but registration failed; tab may not be targetable.");
+    }
+    if (!popupAttempt.verified) {
+      warningMessages.push("Tab open was triggered, but browser did not return a popup handle.");
+    }
     return {
       success: true,
       output: {
@@ -11523,13 +11530,64 @@ var Bridge = class {
         external,
         logicalTabId,
         openedInNewTab: true,
+        openVerification: popupAttempt.verified ? "verified" : "unverified",
         policyBlocked: !!options?.policyBlocked,
         message,
-        ...registrationFailed && { warning: "Tab opened but registration failed \u2014 tab may not be targetable" }
+        ...warningMessages.length ? { warning: warningMessages.join(" ") } : {}
       },
       allowFallback: true
     };
   }
+  openVerifiedPopup(targetUrl) {
+    const popup = window.open("about:blank", "_blank");
+    if (popup) {
+      try {
+        popup.opener = null;
+      } catch {
+      }
+      try {
+        popup.location.href = targetUrl;
+      } catch {
+      }
+      return { opened: true, verified: true };
+    }
+    try {
+      const directPopup = window.open(targetUrl, "_blank");
+      if (directPopup) {
+        try {
+          directPopup.opener = null;
+        } catch {
+        }
+        return { opened: true, verified: true };
+      }
+    } catch {
+    }
+    try {
+      const noOpenerPopup = window.open(targetUrl, "_blank", "noopener,noreferrer");
+      if (noOpenerPopup) {
+        try {
+          noOpenerPopup.opener = null;
+        } catch {
+        }
+        return { opened: true, verified: true };
+      }
+      return { opened: true, verified: false };
+    } catch {
+    }
+    try {
+      const anchor = document.createElement("a");
+      anchor.href = targetUrl;
+      anchor.target = "_blank";
+      anchor.rel = "noopener noreferrer";
+      anchor.style.display = "none";
+      document.body.appendChild(anchor);
+      anchor.click();
+      anchor.remove();
+      return { opened: true, verified: false };
+    } catch {
+      return { opened: false, verified: false };
+    }
+  }
   async openElementInNewTab(args) {
     const elementId = args.element_id ?? args.source_element_id ?? args.target_element_id ?? args.center_element_id ?? null;
     if (!elementId) {
@@ -11950,6 +12008,7 @@ function bindRpc(port, handlers) {
 }
 
 // ../ui/dist/mount.js
+var DEFAULT_AGENT_NAME = "Rover";
 var DEFAULT_MASCOT_MP4 = "https://www.rtrvr.ai/rover/mascot.mp4";
 var DEFAULT_MASCOT_WEBM = "https://www.rtrvr.ai/rover/mascot.webm";
 var EXPAND_THRESHOLD_OUTPUT = 280;
@@ -11999,6 +12058,22 @@ function deriveTraceKey(event) {
 function sanitizeText(text) {
   return String(text || "").trim();
 }
+function resolveAgentName(input) {
+  const normalized = String(input || "").trim();
+  if (!normalized)
+    return DEFAULT_AGENT_NAME;
+  return normalized.slice(0, 64);
+}
+function deriveAgentInitial(name) {
+  const normalized = String(name || "").trim();
+  if (!normalized)
+    return "R";
+  return normalized[0].toUpperCase();
+}
+function deriveLauncherToken(name) {
+  const compact = String(name || "").replace(/[^a-zA-Z0-9]/g, "").slice(0, 3).toUpperCase();
+  return compact || "RVR";
+}
 function parseStageFromTitle(title) {
   const clean = sanitizeText(title);
   const match = /^(Analyze|Route|Execute|Verify|Complete):\s*(.*)$/i.exec(clean);
@@ -12174,6 +12249,9 @@ function createExpandableRichContent(text, threshold) {
   return wrapper;
 }
 function mountWidget(opts) {
+  const agentName = resolveAgentName(opts.agent?.name);
+  const agentInitial = deriveAgentInitial(agentName);
+  const launcherToken = deriveLauncherToken(agentName);
   const host = document.createElement("div");
   host.id = "rover-widget-root";
   document.documentElement.appendChild(host);
@@ -13220,7 +13298,7 @@ function mountWidget(opts) {
   wrapper.dataset.mood = "idle";
   const launcher = document.createElement("button");
   launcher.className = "launcher";
-  launcher.setAttribute("aria-label", "Open Rover assistant");
+  launcher.setAttribute("aria-label", `Open ${agentName} assistant`);
   const mascotDisabled = opts.mascot?.disabled === true;
   let launcherVideo = null;
   if (!mascotDisabled) {
@@ -13242,7 +13320,7 @@ function mountWidget(opts) {
   }
   const launcherFallback = document.createElement("span");
   launcherFallback.className = "launcherFallback";
-  launcherFallback.textContent = "RVR";
+  launcherFallback.textContent = launcherToken;
   const launcherShine = document.createElement("div");
   launcherShine.className = "launcherShine";
   launcher.appendChild(launcherFallback);
@@ -13260,13 +13338,13 @@ function mountWidget(opts) {
   }
   const avatarFallback = document.createElement("span");
   avatarFallback.className = "avatarFallback";
-  avatarFallback.textContent = "R";
+  avatarFallback.textContent = agentInitial;
   avatar.appendChild(avatarFallback);
   const meta = document.createElement("div");
   meta.className = "meta";
   const titleEl = document.createElement("div");
   titleEl.className = "title";
-  titleEl.textContent = "Rover";
+  titleEl.textContent = agentName;
   const statusEl = document.createElement("div");
   statusEl.className = "status";
   const statusDot = document.createElement("span");
@@ -13399,7 +13477,7 @@ function mountWidget(opts) {
   composer.className = "composer";
   const composerTextarea = document.createElement("textarea");
   composerTextarea.rows = 1;
-  composerTextarea.placeholder = "Ask Rover to act on this website...";
+  composerTextarea.placeholder = `Ask ${agentName} to act on this website...`;
   composer.appendChild(composerTextarea);
   const sendButton = document.createElement("button");
   sendButton.type = "submit";
@@ -13707,7 +13785,7 @@ function mountWidget(opts) {
     if (mode === "controller") {
       modeBadge.textContent = "active";
       menuTakeControl.style.display = "none";
-      inputEl.placeholder = "Ask Rover to act on this website...";
+      inputEl.placeholder = `Ask ${agentName} to act on this website...`;
     } else {
       modeBadge.textContent = "observer";
       if (executionMeta?.canTakeControl !== false) {
@@ -13720,7 +13798,7 @@ function mountWidget(opts) {
       } else if (canComposeInObserver) {
         inputEl.placeholder = "Send to take control and run here.";
       } else if (executionMeta?.activeLogicalTabId && executionMeta?.localLogicalTabId && executionMeta.activeLogicalTabId !== executionMeta.localLogicalTabId) {
-        inputEl.placeholder = `Observing: Rover is acting in tab #${executionMeta.activeLogicalTabId}`;
+        inputEl.placeholder = `Observing: ${agentName} is acting in tab #${executionMeta.activeLogicalTabId}`;
       } else {
         inputEl.placeholder = "Observer mode. Take control to run actions here.";
       }
@@ -13920,6 +13998,9 @@ function mountWidget(opts) {
 var SHARED_VERSION = 2;
 var SHARED_KEY_PREFIX = "rover:shared:";
 var SHARED_CHANNEL_PREFIX = "rover:channel:";
+var STALE_DETACHED_EXTERNAL_TAB_MS = 2 * 6e4;
+var STALE_DETACHED_TAB_MS = 10 * 6e4;
+var STALE_RUNTIME_TAB_MS = 45e3;
 function now() {
   return Date.now();
 }
@@ -14125,6 +14206,36 @@ var SessionCoordinator = class _SessionCoordinator {
   lastNotifiedRole;
   roleChangeTimer = null;
   static ROLE_CHANGE_DEBOUNCE_MS = 200;
+  pruneDetachedTabs(draft, options) {
+    const dropRuntimeDetached = !!options?.dropRuntimeDetached;
+    const dropAllDetachedExternal = !!options?.dropAllDetachedExternal;
+    const nowMs2 = now();
+    const before = draft.tabs.length;
+    draft.tabs = draft.tabs.filter((tab) => {
+      if (tab.runtimeId) {
+        if (tab.runtimeId === this.runtimeId)
+          return true;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_RUNTIME_TAB_MS;
+      }
+      if (dropRuntimeDetached && tab.openerRuntimeId === this.runtimeId) {
+        return false;
+      }
+      if (tab.external) {
+        if (dropAllDetachedExternal)
+          return false;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+      }
+      return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_TAB_MS;
+    });
+    if (before !== draft.tabs.length) {
+      if (draft.activeLogicalTabId && !draft.tabs.some((tab) => tab.logicalTabId === draft.activeLogicalTabId)) {
+        draft.activeLogicalTabId = this.localLogicalTabId || draft.tabs[0]?.logicalTabId;
+      }
+      if (draft.nextLogicalTabId <= (draft.tabs.at(-1)?.logicalTabId ?? 0)) {
+        draft.nextLogicalTabId = draft.tabs.reduce((max, tab) => Math.max(max, tab.logicalTabId), 0) + 1;
+      }
+    }
+  }
   constructor(options) {
     this.siteId = options.siteId;
     this.sessionId = options.sessionId;
@@ -14144,6 +14255,9 @@ var SessionCoordinator = class _SessionCoordinator {
     if (this.started)
       return;
     this.started = true;
+    this.mutate("local", (draft) => {
+      this.pruneDetachedTabs(draft, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
+    });
     this.registerCurrentTab(window.location.href, document.title || void 0);
     this.claimLease(false);
     if (!this.state.task) {
@@ -14278,10 +14392,27 @@ var SessionCoordinator = class _SessionCoordinator {
   }
   hydrateExternalState(raw) {
     const incoming = sanitizeSharedState(raw, this.siteId, this.sessionId);
+    this.pruneDetachedTabs(incoming, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
     const beforeSeq = this.state.seq;
     const beforeUpdatedAt = this.state.updatedAt;
     this.applyIncomingState(incoming);
-    const changed = this.state.seq !== beforeSeq || this.state.updatedAt !== beforeUpdatedAt;
+    let changed = this.state.seq !== beforeSeq || this.state.updatedAt !== beforeUpdatedAt;
+    if (!changed) {
+      const hasDetachedCandidates = this.state.tabs.some((tab) => {
+        if (tab.runtimeId)
+          return false;
+        if (tab.external)
+          return true;
+        return tab.openerRuntimeId === this.runtimeId;
+      });
+      if (hasDetachedCandidates) {
+        const beforeTabCount = this.state.tabs.length;
+        this.mutate("local", (draft) => {
+          this.pruneDetachedTabs(draft, { dropRuntimeDetached: true, dropAllDetachedExternal: true });
+        });
+        changed = this.state.tabs.length !== beforeTabCount;
+      }
+    }
     if (!changed)
       return false;
     this.persistState();
@@ -14291,7 +14422,23 @@ var SessionCoordinator = class _SessionCoordinator {
     return true;
   }
   listTabs() {
-    return [...this.state.tabs];
+    const nowMs2 = now();
+    return this.state.tabs.filter((tab) => {
+      if (tab.runtimeId) {
+        if (tab.runtimeId === this.runtimeId)
+          return true;
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_RUNTIME_TAB_MS;
+      }
+      if (tab.external) {
+        return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_EXTERNAL_TAB_MS;
+      }
+      return nowMs2 - Math.max(tab.updatedAt || 0, tab.openedAt || 0) <= STALE_DETACHED_TAB_MS;
+    });
+  }
+  pruneTabs(options) {
+    this.mutate("local", (draft) => {
+      this.pruneDetachedTabs(draft, options);
+    });
   }
   startNewTask(task) {
     const startedAt = Number(task.startedAt) || now();
@@ -14312,6 +14459,7 @@ var SessionCoordinator = class _SessionCoordinator {
       draft.uiStatus = void 0;
       draft.activeRun = void 0;
       draft.workerContext = void 0;
+      this.pruneDetachedTabs(draft, { dropAllDetachedExternal: true });
     });
     return nextTask;
   }
@@ -14426,9 +14574,6 @@ var SessionCoordinator = class _SessionCoordinator {
     this.mutate("local", (draft) => {
       if (!activeRun) {
         draft.activeRun = void 0;
-        if (draft.task && draft.task.status === "running") {
-          draft.task.status = "completed";
-        }
         return;
       }
       draft.activeRun = {
@@ -14781,6 +14926,7 @@ var SessionCoordinator = class _SessionCoordinator {
       if (draft.workflowLock?.runtimeId === this.runtimeId) {
         draft.workflowLock.expiresAt = now() + this.leaseMs * 5;
       }
+      this.pruneDetachedTabs(draft);
     });
     this.notifyRoleChange();
   }
@@ -14872,6 +15018,7 @@ var SessionCoordinator = class _SessionCoordinator {
       return;
     if (incoming.seq === this.state.seq && incoming.updatedAt <= this.state.updatedAt)
       return;
+    this.pruneDetachedTabs(incoming);
     this.state = incoming;
     this.syncLocalLogicalTabId();
     this.onStateChange?.(this.state, "remote");
@@ -15238,9 +15385,8 @@ var MAX_AUTO_RESUME_AGE_MS = 15 * 6e4;
 var MAX_AUTO_RESUME_ATTEMPTS = 12;
 var VISITOR_COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 365;
 var CHECKPOINT_PAYLOAD_VERSION = 1;
-var DEFAULT_TASK_INACTIVITY_MS = 5 * 6e4;
-var DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD = 0.18;
-var MAX_RECENT_USER_MESSAGES_FOR_TASK_HEURISTIC = 3;
+var ACTIVE_PENDING_RUN_GRACE_MS = 3e3;
+var STALE_PENDING_RUN_MS = 9e4;
 var instance = null;
 var bridge = null;
 var worker = null;
@@ -15482,6 +15628,72 @@ function safeSerialize(value) {
     }
   }
 }
+function resolveEmbeddedDomainLabel(allowedDomains) {
+  const raw = String((allowedDomains || [])[0] || "").trim();
+  if (!raw)
+    return "the configured domain";
+  return raw.replace(/^\*?\./, "").replace(/^=/, "");
+}
+function buildInaccessibleTabPageData(cfg, tab, reason = "tab_not_accessible") {
+  const logicalTabId = Number(tab?.logicalTabId) || void 0;
+  const url = tab?.url || "";
+  const title = tab?.title || (tab?.external ? "External Tab (Inaccessible)" : "Inactive Tab");
+  const embeddedDomain = resolveEmbeddedDomainLabel(cfg.allowedDomains);
+  const normalizedReason = String(reason || "").trim();
+  const reasonLine = normalizedReason ? ` Reason: ${normalizedReason}.` : "";
+  const content = tab?.external ? `Rover is embedded inside ${embeddedDomain}. This tab is outside direct DOM access and only virtual tab context is available.${reasonLine}` : `This tab is currently not attached to an active Rover runtime. Switch to a live tab or reopen it.${reasonLine}`;
+  return {
+    url,
+    title,
+    contentType: "text/html",
+    content,
+    metadata: {
+      inaccessible: true,
+      external: !!tab?.external,
+      accessMode: tab?.external ? "external_placeholder" : "inactive_tab",
+      reason,
+      logicalTabId
+    }
+  };
+}
+function buildTabAccessToolError(cfg, tab, reason = "tab_not_accessible") {
+  const logicalTabId = Number(tab?.logicalTabId) || 0;
+  const blockedUrl = tab?.url || "";
+  const embeddedDomain = resolveEmbeddedDomainLabel(cfg.allowedDomains);
+  const message = tab?.external ? `Tab ${logicalTabId} is outside Rover's embedded domain scope (${embeddedDomain}) and cannot be controlled directly.` : `Tab ${logicalTabId} is not attached to an active Rover runtime.`;
+  const code = tab?.external ? "DOMAIN_SCOPE_BLOCKED" : "TAB_NOT_ACCESSIBLE";
+  return {
+    success: false,
+    error: message,
+    allowFallback: true,
+    output: {
+      success: false,
+      error: {
+        code,
+        message,
+        missing: [],
+        next_action: tab?.external ? "Use open_new_tab for external context or continue on an in-scope tab." : "Switch to an active tab and retry.",
+        retryable: false
+      },
+      blocked_url: blockedUrl || void 0,
+      logical_tab_id: logicalTabId || void 0,
+      external: !!tab?.external,
+      policy_action: tab?.external ? cfg.externalNavigationPolicy || "open_new_tab_notice" : void 0,
+      reason
+    },
+    errorDetails: {
+      code,
+      message,
+      retryable: false,
+      details: {
+        logicalTabId,
+        blockedUrl,
+        external: !!tab?.external,
+        reason
+      }
+    }
+  };
+}
 function normalizeStatusStage(input) {
   if (input === "analyze" || input === "route" || input === "execute" || input === "verify" || input === "complete") {
     return input;
@@ -15557,14 +15769,26 @@ function shouldIgnoreRunScopedWorkerMessage(msg) {
     return false;
   }
   if (type === "run_completed") {
-    if (!pendingRunId)
+    if (!pendingRunId) {
+      const sharedRunId = sessionCoordinator?.getState()?.activeRun?.runId;
+      if (sharedRunId && sharedRunId === messageRunId)
+        return false;
       return true;
+    }
     return pendingRunId !== messageRunId;
   }
   if (!pendingRunId)
     return true;
   return pendingRunId !== messageRunId;
 }
+function normalizeRunCompletionState(msg) {
+  if (!msg || typeof msg !== "object") {
+    return { taskComplete: false, needsUserInput: false };
+  }
+  const needsUserInput = msg.needsUserInput === true;
+  const taskComplete = msg.taskComplete === true && !needsUserInput;
+  return { taskComplete, needsUserInput };
+}
 function getLatestAssistantText(runId) {
   if (runId && latestAssistantByRunId.has(runId)) {
     return latestAssistantByRunId.get(runId);
@@ -15828,6 +16052,33 @@ function markTaskActivity(role, timestamp = Date.now()) {
     task.endedAt = void 0;
   }
 }
+function markTaskRunning(reason = "worker_task_active", timestamp = Date.now()) {
+  if (!runtimeState)
+    return;
+  const task = ensureActiveTask(reason);
+  if (!task)
+    return;
+  task.status = "running";
+  task.endedAt = void 0;
+  task.boundaryReason = reason;
+  if (!task.lastUserAt && !task.lastAssistantAt) {
+    task.lastAssistantAt = timestamp;
+  }
+  sessionCoordinator?.syncTask({ ...task }, runtimeState.taskEpoch);
+  persistRuntimeState();
+}
+function markTaskCompleted(reason = "worker_task_complete", timestamp = Date.now()) {
+  if (!runtimeState)
+    return;
+  const task = ensureActiveTask(reason);
+  if (!task)
+    return;
+  task.status = "completed";
+  task.endedAt = timestamp;
+  task.boundaryReason = reason;
+  sessionCoordinator?.syncTask({ ...task }, runtimeState.taskEpoch);
+  persistRuntimeState();
+}
 function hideTaskSuggestion() {
   pendingTaskSuggestion = null;
   ui?.setTaskSuggestion({ visible: false });
@@ -15837,53 +16088,37 @@ function clearTaskUiState() {
   ui?.clearTimeline();
   hideTaskSuggestion();
 }
-function collectRecentUserTextsForHeuristic() {
-  if (!runtimeState)
-    return [];
-  const userMessages = runtimeState.uiMessages.filter((message) => message.role === "user");
-  return userMessages.slice(-MAX_RECENT_USER_MESSAGES_FOR_TASK_HEURISTIC).map((message) => message.text.trim()).filter(Boolean);
-}
-function tokenizeForSimilarity(input) {
-  return new Set(String(input || "").toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).map((token) => token.trim()).filter((token) => token.length > 2));
-}
-function computeSemanticOverlap(a, b) {
-  const ta = tokenizeForSimilarity(a);
-  const tb = tokenizeForSimilarity(b);
-  if (!ta.size || !tb.size)
-    return 0;
-  let intersection = 0;
-  for (const token of ta) {
-    if (tb.has(token))
-      intersection += 1;
+function isPendingRunLikelyActive() {
+  const pending = runtimeState?.pendingRun;
+  if (!pending)
+    return false;
+  if (!sessionCoordinator)
+    return true;
+  const sharedActiveRun = sessionCoordinator?.getState()?.activeRun;
+  if (sharedActiveRun?.runId && sharedActiveRun.runId === pending.id) {
+    return true;
+  }
+  if (sharedActiveRun?.runtimeId && sharedActiveRun.runtimeId !== runtimeId) {
+    return true;
   }
-  return intersection / Math.max(ta.size, tb.size);
+  const ageMs = Date.now() - Number(pending.startedAt || 0);
+  return ageMs >= 0 && ageMs <= ACTIVE_PENDING_RUN_GRACE_MS;
 }
-function shouldSuggestResetForPrompt(text) {
-  if (!runtimeState || !currentConfig)
-    return { suggest: false };
-  const suggestEnabled = currentConfig.taskContext?.suggestReset !== false;
-  if (!suggestEnabled)
-    return { suggest: false };
-  if (runtimeState.pendingRun)
-    return { suggest: false };
-  const task = ensureActiveTask("implicit");
-  if (!task || task.status === "ended")
-    return { suggest: false };
-  const inactivityMs = Math.max(6e4, Number(currentConfig.taskContext?.inactivityMs) || DEFAULT_TASK_INACTIVITY_MS);
-  const now2 = Date.now();
-  const latestActivity = Math.max(task.lastUserAt || 0, task.lastAssistantAt || 0, task.startedAt || 0);
-  if (!latestActivity || now2 - latestActivity < inactivityMs)
-    return { suggest: false };
-  const recent = collectRecentUserTextsForHeuristic();
-  if (!recent.length)
-    return { suggest: true, reason: "inactivity_only" };
-  const baseline = recent.join(" ");
-  const overlap = computeSemanticOverlap(baseline, text);
-  const threshold = Math.max(0.05, Math.min(0.9, Number(currentConfig.taskContext?.semanticSimilarityThreshold) || DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD));
-  if (overlap < threshold) {
-    return { suggest: true, reason: `low_similarity_${overlap.toFixed(2)}` };
-  }
-  return { suggest: false };
+function maybeClearStalePendingRun() {
+  if (!runtimeState?.pendingRun)
+    return;
+  if (isPendingRunLikelyActive())
+    return;
+  if (!sessionCoordinator)
+    return;
+  const pending = runtimeState.pendingRun;
+  const ageMs = Date.now() - Number(pending.startedAt || 0);
+  if (!Number.isFinite(ageMs) || ageMs < STALE_PENDING_RUN_MS)
+    return;
+  setPendingRun(void 0);
+  sessionCoordinator?.clearActiveRunRuntimeId(pending.id);
+  sessionCoordinator?.releaseWorkflowLock(pending.id);
+  sessionCoordinator?.setActiveRun(void 0);
 }
 function appendUiMessage(role, text, persist = true, options) {
   const clean = truncateText2(String(text || ""));
@@ -16068,28 +16303,16 @@ function dispatchUserPrompt(text, options) {
   const trimmed = String(text || "").trim();
   if (!trimmed)
     return;
-  if (options?.startNewTask) {
-    newTask({ reason: options.reason || "suggested_new_task", clearUi: true });
-  } else if (!options?.bypassSuggestion) {
-    const decision = shouldSuggestResetForPrompt(trimmed);
-    if (decision.suggest) {
-      pendingTaskSuggestion = {
-        text: trimmed,
-        reason: decision.reason || "heuristic",
-        createdAt: Date.now()
-      };
-      ui?.setTaskSuggestion({
-        visible: true,
-        text: "This looks like a different request. Start a new task or continue this one?",
-        primaryLabel: "Start new",
-        secondaryLabel: "Continue"
-      });
-      emit("task_suggested_reset", {
-        text: trimmed,
-        reason: pendingTaskSuggestion.reason
-      });
-      return;
-    }
+  maybeClearStalePendingRun();
+  const activeTaskStatus = runtimeState?.activeTask?.status;
+  const shouldStartFreshTask = !!options?.startNewTask || activeTaskStatus === "completed" || activeTaskStatus === "ended";
+  sessionCoordinator?.pruneTabs({
+    dropRuntimeDetached: true,
+    dropAllDetachedExternal: shouldStartFreshTask
+  });
+  if (shouldStartFreshTask) {
+    const autoReason = options?.reason || (activeTaskStatus === "completed" ? "auto_after_task_complete" : "auto_after_task_end");
+    newTask({ reason: autoReason, clearUi: true });
   }
   hideTaskSuggestion();
   postRun(trimmed, { appendUserMessage: true, resume: false, autoResume: true });
@@ -16727,6 +16950,7 @@ function handleWorkerMessage(msg) {
     }
     sessionCoordinator?.setActiveRun(void 0);
     if (!msg.ok && msg.error) {
+      markTaskRunning("worker_run_failed");
       setUiStatus(`Task failed: ${String(msg.error)}`);
       latestAssistantByRunId.delete(String(msg.runId || ""));
       appendTimelineEvent({
@@ -16736,8 +16960,23 @@ function handleWorkerMessage(msg) {
         status: "error"
       });
     } else if (msg.ok) {
-      setUiStatus("Execution completed");
-      finalizeSuccessfulRunTimeline(typeof msg.runId === "string" ? msg.runId : void 0);
+      const completionState = normalizeRunCompletionState(msg);
+      const taskComplete = completionState.taskComplete;
+      const needsUserInput = completionState.needsUserInput;
+      if (taskComplete) {
+        markTaskCompleted("worker_task_complete");
+        setUiStatus("Task completed");
+        finalizeSuccessfulRunTimeline(typeof msg.runId === "string" ? msg.runId : void 0);
+      } else {
+        markTaskRunning(needsUserInput ? "worker_waiting_for_input" : "worker_continuation");
+        setUiStatus(needsUserInput ? "Need more input to continue" : "Execution finished. Continue when ready.");
+        appendTimelineEvent({
+          kind: "status",
+          title: needsUserInput ? "Waiting for your input" : "Continuation available",
+          detail: needsUserInput ? "Planner requested more information before marking the task complete." : "Task is still active and will continue with your next message.",
+          status: "info"
+        });
+      }
       if (typeof msg.runId === "string" && msg.runId) {
         latestAssistantByRunId.delete(msg.runId);
       }
@@ -16815,26 +17054,34 @@ function createRuntime(cfg) {
   bindRpc(channel.port1, {
     getSnapshot: () => bridge.getSnapshot(),
     getPageData: async (params) => {
-      const tabId = params?.tabId;
+      const runtimeCfg = currentConfig || cfg;
+      const tabId = Number(params?.tabId);
       const localTabId = sessionCoordinator?.getLocalLogicalTabId();
-      if (!tabId || tabId === localTabId || !sessionCoordinator) {
+      if (!Number.isFinite(tabId) || tabId <= 0 || tabId === localTabId || !sessionCoordinator) {
         return bridge.getPageData(params);
       }
       const tabs = sessionCoordinator.listTabs();
       const targetTab = tabs.find((t) => t.logicalTabId === tabId);
-      if (!targetTab || targetTab.runtimeId === runtimeId) {
+      if (!targetTab) {
+        return buildInaccessibleTabPageData(runtimeCfg, { logicalTabId: tabId, external: true }, "target_tab_missing");
+      }
+      if (targetTab.runtimeId === runtimeId) {
         return bridge.getPageData(params);
       }
+      if (targetTab.external && runtimeCfg.externalNavigationPolicy !== "allow") {
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "external_domain_inaccessible");
+      }
       if (!targetTab.runtimeId || !sessionCoordinator.isTabAlive(tabId)) {
-        return bridge.getPageData(params);
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "target_tab_inactive");
       }
       try {
         return await sessionCoordinator.sendCrossTabRpc(targetTab.runtimeId, "getPageData", params, 15e3);
       } catch {
-        return bridge.getPageData(params);
+        return buildInaccessibleTabPageData(runtimeCfg, targetTab, "cross_tab_rpc_failed");
       }
     },
     executeTool: async (params) => {
+      const runtimeCfg = currentConfig || cfg;
       const activeTabId = sessionCoordinator?.getActiveLogicalTabId();
       const localTabId = sessionCoordinator?.getLocalLogicalTabId();
       if (!activeTabId || activeTabId === localTabId || !sessionCoordinator) {
@@ -16842,16 +17089,22 @@ function createRuntime(cfg) {
       }
       const tabs = sessionCoordinator.listTabs();
       const targetTab = tabs.find((t) => t.logicalTabId === activeTabId);
-      if (!targetTab?.runtimeId || targetTab.runtimeId === runtimeId) {
-        return bridge.executeTool(params.call, params.payload);
+      if (!targetTab) {
+        return buildTabAccessToolError(runtimeCfg, { logicalTabId: activeTabId, external: true }, "target_tab_missing");
+      }
+      if (targetTab.external && runtimeCfg.externalNavigationPolicy !== "allow") {
+        return buildTabAccessToolError(runtimeCfg, targetTab, "external_tab_action_blocked");
       }
-      if (!sessionCoordinator.isTabAlive(activeTabId)) {
+      if (targetTab.runtimeId === runtimeId) {
         return bridge.executeTool(params.call, params.payload);
       }
+      if (!targetTab.runtimeId || !sessionCoordinator.isTabAlive(activeTabId)) {
+        return buildTabAccessToolError(runtimeCfg, targetTab, "target_tab_inactive");
+      }
       try {
         return await sessionCoordinator.sendCrossTabRpc(targetTab.runtimeId, "executeTool", params, 2e4);
       } catch {
-        return bridge.executeTool(params.call, params.payload);
+        return buildTabAccessToolError(runtimeCfg, targetTab, "cross_tab_execute_failed");
       }
     },
     executeClientTool: (params) => bridge.executeClientTool(params.name, params.args),
@@ -16938,6 +17191,9 @@ function createRuntime(cfg) {
     },
     showTaskControls: cfg.ui?.showTaskControls !== false,
     muted: cfg.ui?.muted,
+    agent: {
+      name: cfg.ui?.agent?.name
+    },
     mascot: {
       disabled: cfg.ui?.mascot?.disabled,
       mp4Url: cfg.ui?.mascot?.mp4Url,
@@ -17052,9 +17308,7 @@ function boot(cfg) {
       plannerOnActError: cfg.taskRouting?.plannerOnActError
     },
     taskContext: {
-      inactivityMs: cfg.taskContext?.inactivityMs ?? DEFAULT_TASK_INACTIVITY_MS,
-      suggestReset: cfg.taskContext?.suggestReset ?? true,
-      semanticSimilarityThreshold: cfg.taskContext?.semanticSimilarityThreshold ?? DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD
+      ...cfg.taskContext
     }
   };
   runtimeState.sessionId = currentConfig.sessionId;
@@ -17115,17 +17369,29 @@ function update(cfg) {
       ...cfg.taskRouting
     },
     taskContext: {
-      inactivityMs: cfg.taskContext?.inactivityMs ?? currentConfig.taskContext?.inactivityMs ?? DEFAULT_TASK_INACTIVITY_MS,
-      suggestReset: cfg.taskContext?.suggestReset ?? currentConfig.taskContext?.suggestReset ?? true,
-      semanticSimilarityThreshold: cfg.taskContext?.semanticSimilarityThreshold ?? currentConfig.taskContext?.semanticSimilarityThreshold ?? DEFAULT_SEMANTIC_SIMILARITY_THRESHOLD
+      ...currentConfig.taskContext,
+      ...cfg.taskContext
     },
     ui: {
       ...currentConfig.ui,
       ...cfg.ui,
+      agent: {
+        ...currentConfig.ui?.agent,
+        ...cfg.ui?.agent
+      },
       panel: {
         ...currentConfig.ui?.panel,
         ...cfg.ui?.panel
       }
+    },
+    tools: {
+      ...currentConfig.tools,
+      ...cfg.tools,
+      client: cfg.tools?.client ?? currentConfig.tools?.client,
+      web: {
+        ...currentConfig.tools?.web,
+        ...cfg.tools?.web
+      }
     }
   };
   resolvedVisitorId = resolveVisitorId(currentConfig);